/*
- * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
- * Copyright (C) 2013 - Raphaël Beamonte <raphael.beamonte@gmail.com>
- * Copyright (C) 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
+ * Copyright (C) 2013 Raphaël Beamonte <raphael.beamonte@gmail.com>
+ * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License, version 2 only, as
- * published by the Free Software Foundation.
+ * SPDX-License-Identifier: GPL-2.0-only
*
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 51
- * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
+#include "common/macros.h"
#define _LGPL_SOURCE
#include <assert.h>
#include <ctype.h>
#include <unistd.h>
#include <common/common.h>
+#include <common/readwrite.h>
#include <common/runas.h>
#include <common/compat/getenv.h>
#include <common/compat/string.h>
#include <common/compat/dirent.h>
+#include <common/compat/directory-handle.h>
+#include <common/dynamic-buffer.h>
+#include <common/string-utils/format.h>
#include <lttng/constant.h>
#include "utils.h"
#include "defaults.h"
#include "time.h"
+#define PROC_MEMINFO_PATH "/proc/meminfo"
+#define PROC_MEMINFO_MEMAVAILABLE_LINE "MemAvailable:"
+#define PROC_MEMINFO_MEMTOTAL_LINE "MemTotal:"
+
+/* The length of the longest field of `/proc/meminfo`. */
+#define PROC_MEMINFO_FIELD_MAX_NAME_LEN 20
+
+#if (PROC_MEMINFO_FIELD_MAX_NAME_LEN == 20)
+#define MAX_NAME_LEN_SCANF_IS_A_BROKEN_API "19"
+#else
+#error MAX_NAME_LEN_SCANF_IS_A_BROKEN_API must be updated to match (PROC_MEMINFO_FIELD_MAX_NAME_LEN - 1)
+#endif
+
+#define FALLBACK_USER_BUFLEN 16384
+#define FALLBACK_GROUP_BUFLEN 16384
+
/*
* Return a partial realpath(3) of the path even if the full path does not
* exist. For instance, with /tmp/test1/test2/test3, if test2/ does not exist
* but the /tmp/test1 does, the real path for /tmp/test1 is concatened with
* /test2/test3 then returned. In normal time, realpath(3) fails if the end
* point directory does not exist.
- * In case resolved_path is NULL, the string returned was allocated in the
- * function and thus need to be freed by the caller. The size argument allows
- * to specify the size of the resolved_path argument if given, or the size to
- * allocate.
+ *
+ * Return a newly-allocated string.
*/
-LTTNG_HIDDEN
-char *utils_partial_realpath(const char *path, char *resolved_path, size_t size)
+static
+char *utils_partial_realpath(const char *path)
{
char *cut_path = NULL, *try_path = NULL, *try_path_prev = NULL;
const char *next, *prev, *end;
+ char *resolved_path = NULL;
/* Safety net */
if (path == NULL) {
cut_path = NULL;
}
- /* Allocate memory for the resolved path if necessary */
+ /* Allocate memory for the resolved path. */
+ resolved_path = zmalloc(LTTNG_PATH_MAX);
if (resolved_path == NULL) {
- resolved_path = zmalloc(size);
- if (resolved_path == NULL) {
- PERROR("zmalloc resolved path");
- goto error;
- }
+ PERROR("zmalloc resolved path");
+ goto error;
}
/*
}
/* Concatenate the strings */
- snprintf(resolved_path, size, "%s%s", try_path_prev, cut_path);
+ snprintf(resolved_path, LTTNG_PATH_MAX, "%s%s",
+ try_path_prev, cut_path);
/* Free the allocated memory */
free(cut_path);
* return it as is
*/
} else {
- strncpy(resolved_path, path, size);
+ strncpy(resolved_path, path, LTTNG_PATH_MAX);
}
/* Then we return the 'partially' resolved path */
* Copy the current token which is neither a '.' nor a '..'.
*/
path[expanded_path_len++] = '/';
- memcpy(&path[expanded_path_len], curr_char, curr_token_len);
+ memmove(&path[expanded_path_len], curr_char, curr_token_len);
expanded_path_len += curr_token_len;
}
* The returned string was allocated in the function, it is thus of
* the responsibility of the caller to free this memory.
*/
-LTTNG_HIDDEN
+static
char *_utils_expand_path(const char *path, bool keep_symlink)
{
int ret;
if (keep_symlink) {
/* Resolve partially our path */
- absolute_path = utils_partial_realpath(absolute_path,
- absolute_path, LTTNG_PATH_MAX);
+ char *new_absolute_path = utils_partial_realpath(absolute_path);
+ if (!new_absolute_path) {
+ goto error;
+ }
+
+ free(absolute_path);
+ absolute_path = new_absolute_path;
}
ret = expand_double_slashes_dot_and_dotdot(absolute_path);
if (ret) {
PERROR("close pipe");
}
+ src[i] = -1;
}
}
return fd;
}
-/*
- * On some filesystems (e.g. nfs), mkdir will validate access rights before
- * checking for the existence of the path element. This means that on a setup
- * where "/home/" is a mounted NFS share, and running as an unpriviledged user,
- * recursively creating a path of the form "/home/my_user/trace/" will fail with
- * EACCES on mkdir("/home", ...).
- *
- * Performing a stat(...) on the path to check for existence allows us to
- * work around this behaviour.
- */
-static
-int mkdir_check_exists(const char *path, mode_t mode)
-{
- int ret = 0;
- struct stat st;
-
- ret = stat(path, &st);
- if (ret == 0) {
- if (S_ISDIR(st.st_mode)) {
- /* Directory exists, skip. */
- goto end;
- } else {
- /* Exists, but is not a directory. */
- errno = ENOTDIR;
- ret = -1;
- goto end;
- }
- }
-
- /*
- * Let mkdir handle other errors as the caller expects mkdir
- * semantics.
- */
- ret = mkdir(path, mode);
-end:
- return ret;
-}
-
/*
* Create directory using the given path and mode.
*
int utils_mkdir(const char *path, mode_t mode, int uid, int gid)
{
int ret;
-
- if (uid < 0 || gid < 0) {
- ret = mkdir_check_exists(path, mode);
- } else {
- ret = run_as_mkdir(path, mode, uid, gid);
- }
- if (ret < 0) {
- if (errno != EEXIST) {
- PERROR("mkdir %s, uid %d, gid %d", path ? path : "NULL",
- uid, gid);
- } else {
- ret = 0;
- }
- }
-
- return ret;
-}
-
-/*
- * Internal version of mkdir_recursive. Runs as the current user.
- * Don't call directly; use utils_mkdir_recursive().
- *
- * This function is ominously marked as "unsafe" since it should only
- * be called by a caller that has transitioned to the uid and gid under which
- * the directory creation should occur.
- */
-LTTNG_HIDDEN
-int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode)
-{
- char *p, tmp[PATH_MAX];
- size_t len;
- int ret;
-
- assert(path);
-
- ret = snprintf(tmp, sizeof(tmp), "%s", path);
- if (ret < 0) {
- PERROR("snprintf mkdir");
- goto error;
- }
-
- len = ret;
- if (tmp[len - 1] == '/') {
- tmp[len - 1] = 0;
- }
-
- for (p = tmp + 1; *p; p++) {
- if (*p == '/') {
- *p = 0;
- if (tmp[strlen(tmp) - 1] == '.' &&
- tmp[strlen(tmp) - 2] == '.' &&
- tmp[strlen(tmp) - 3] == '/') {
- ERR("Using '/../' is not permitted in the trace path (%s)",
- tmp);
- ret = -1;
- goto error;
- }
- ret = mkdir_check_exists(tmp, mode);
- if (ret < 0) {
- if (errno != EACCES) {
- PERROR("mkdir recursive");
- ret = -errno;
- goto error;
- }
- }
- *p = '/';
- }
- }
-
- ret = mkdir_check_exists(tmp, mode);
- if (ret < 0) {
- PERROR("mkdir recursive last element");
- ret = -errno;
+ struct lttng_directory_handle *handle;
+ const struct lttng_credentials creds = {
+ .uid = LTTNG_OPTIONAL_INIT_VALUE(uid),
+ .gid = LTTNG_OPTIONAL_INIT_VALUE(gid),
+ };
+
+ handle = lttng_directory_handle_create(NULL);
+ if (!handle) {
+ ret = -1;
+ goto end;
}
-
-error:
+ ret = lttng_directory_handle_create_subdirectory_as_user(
+ handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+end:
+ lttng_directory_handle_put(handle);
return ret;
}
int utils_mkdir_recursive(const char *path, mode_t mode, int uid, int gid)
{
int ret;
-
- if (uid < 0 || gid < 0) {
- /* Run as current user. */
- ret = _utils_mkdir_recursive_unsafe(path, mode);
- } else {
- ret = run_as_mkdir_recursive(path, mode, uid, gid);
- }
- if (ret < 0) {
- PERROR("mkdir %s, uid %d, gid %d", path ? path : "NULL",
- uid, gid);
- }
-
- return ret;
-}
-
-/*
- * path is the output parameter. It needs to be PATH_MAX len.
- *
- * Return 0 on success or else a negative value.
- */
-static int utils_stream_file_name(char *path,
- const char *path_name, const char *file_name,
- uint64_t size, uint64_t count,
- const char *suffix)
-{
- int ret;
- char full_path[PATH_MAX];
- char *path_name_suffix = NULL;
- char *extra = NULL;
-
- ret = snprintf(full_path, sizeof(full_path), "%s/%s",
- path_name, file_name);
- if (ret < 0) {
- PERROR("snprintf create output file");
- goto error;
- }
-
- /* Setup extra string if suffix or/and a count is needed. */
- if (size > 0 && suffix) {
- ret = asprintf(&extra, "_%" PRIu64 "%s", count, suffix);
- } else if (size > 0) {
- ret = asprintf(&extra, "_%" PRIu64, count);
- } else if (suffix) {
- ret = asprintf(&extra, "%s", suffix);
- }
- if (ret < 0) {
- PERROR("Allocating extra string to name");
- goto error;
- }
-
- /*
- * If we split the trace in multiple files, we have to add the count at
- * the end of the tracefile name.
- */
- if (extra) {
- ret = asprintf(&path_name_suffix, "%s%s", full_path, extra);
- if (ret < 0) {
- PERROR("Allocating path name with extra string");
- goto error_free_suffix;
- }
- strncpy(path, path_name_suffix, PATH_MAX - 1);
- path[PATH_MAX - 1] = '\0';
- } else {
- ret = lttng_strncpy(path, full_path, PATH_MAX);
- if (ret) {
- ERR("Failed to copy stream file name");
- goto error_free_suffix;
- }
- }
- path[PATH_MAX - 1] = '\0';
- ret = 0;
-
- free(path_name_suffix);
-error_free_suffix:
- free(extra);
-error:
- return ret;
-}
-
-/*
- * Create the stream file on disk.
- *
- * Return 0 on success or else a negative value.
- */
-LTTNG_HIDDEN
-int utils_create_stream_file(const char *path_name, char *file_name, uint64_t size,
- uint64_t count, int uid, int gid, char *suffix)
-{
- int ret, flags, mode;
- char path[PATH_MAX];
-
- ret = utils_stream_file_name(path, path_name, file_name,
- size, count, suffix);
- if (ret < 0) {
- goto error;
- }
-
- /*
- * With the session rotation feature on the relay, we might need to seek
- * and truncate a tracefile, so we need read and write access.
- */
- flags = O_RDWR | O_CREAT | O_TRUNC;
- /* Open with 660 mode */
- mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
-
- if (uid < 0 || gid < 0) {
- ret = open(path, flags, mode);
- } else {
- ret = run_as_open(path, flags, mode, uid, gid);
- }
- if (ret < 0) {
- PERROR("open stream path %s", path);
+ struct lttng_directory_handle *handle;
+ const struct lttng_credentials creds = {
+ .uid = LTTNG_OPTIONAL_INIT_VALUE(uid),
+ .gid = LTTNG_OPTIONAL_INIT_VALUE(gid),
+ };
+
+ handle = lttng_directory_handle_create(NULL);
+ if (!handle) {
+ ret = -1;
+ goto end;
}
-error:
+ ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
+ handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+end:
+ lttng_directory_handle_put(handle);
return ret;
}
/*
- * Unlink the stream tracefile from disk.
+ * out_stream_path is the output parameter.
*
* Return 0 on success or else a negative value.
*/
LTTNG_HIDDEN
-int utils_unlink_stream_file(const char *path_name, char *file_name, uint64_t size,
- uint64_t count, int uid, int gid, char *suffix)
+int utils_stream_file_path(const char *path_name, const char *file_name,
+ uint64_t size, uint64_t count, const char *suffix,
+ char *out_stream_path, size_t stream_path_len)
{
int ret;
- char path[PATH_MAX];
+ char count_str[MAX_INT_DEC_LEN(count) + 1] = {};
+ const char *path_separator;
- ret = utils_stream_file_name(path, path_name, file_name,
- size, count, suffix);
- if (ret < 0) {
- goto error;
- }
- if (uid < 0 || gid < 0) {
- ret = unlink(path);
+ if (path_name && (path_name[0] == '\0' ||
+ path_name[strlen(path_name) - 1] == '/')) {
+ path_separator = "";
} else {
- ret = run_as_unlink(path, uid, gid);
+ path_separator = "/";
}
- if (ret < 0) {
- goto error;
- }
-error:
- DBG("utils_unlink_stream_file %s returns %d", path, ret);
- return ret;
-}
-/*
- * Change the output tracefile according to the given size and count The
- * new_count pointer is set during this operation.
- *
- * From the consumer, the stream lock MUST be held before calling this function
- * because we are modifying the stream status.
- *
- * Return 0 on success or else a negative value.
- */
-LTTNG_HIDDEN
-int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size,
- uint64_t count, int uid, int gid, int out_fd, uint64_t *new_count,
- int *stream_fd)
-{
- int ret;
-
- assert(stream_fd);
-
- ret = close(out_fd);
- if (ret < 0) {
- PERROR("Closing tracefile");
- goto error;
+ path_name = path_name ? : "";
+ suffix = suffix ? : "";
+ if (size > 0) {
+ ret = snprintf(count_str, sizeof(count_str), "_%" PRIu64,
+ count);
+ assert(ret > 0 && ret < sizeof(count_str));
}
- *stream_fd = -1;
- if (count > 0) {
- /*
- * In tracefile rotation, for the relay daemon we need
- * to unlink the old file if present, because it may
- * still be open in reading by the live thread, and we
- * need to ensure that we do not overwrite the content
- * between get_index and get_packet. Since we have no
- * way to verify integrity of the data content compared
- * to the associated index, we need to ensure the reader
- * has exclusive access to the file content, and that
- * the open of the data file is performed in get_index.
- * Unlinking the old file rather than overwriting it
- * achieves this.
- */
- if (new_count) {
- *new_count = (*new_count + 1) % count;
- }
- ret = utils_unlink_stream_file(path_name, file_name, size,
- new_count ? *new_count : 0, uid, gid, 0);
- if (ret < 0 && errno != ENOENT) {
- goto error;
- }
+ ret = snprintf(out_stream_path, stream_path_len, "%s%s%s%s%s",
+ path_name, path_separator, file_name, count_str,
+ suffix);
+ if (ret < 0 || ret >= stream_path_len) {
+ ERR("Truncation occurred while formatting stream path");
+ ret = -1;
} else {
- if (new_count) {
- (*new_count)++;
- }
- }
-
- ret = utils_create_stream_file(path_name, file_name, size,
- new_count ? *new_count : 0, uid, gid, 0);
- if (ret < 0) {
- goto error;
+ ret = 0;
}
- *stream_fd = ret;
-
- /* Success. */
- ret = 0;
-
-error:
return ret;
}
-
/**
* Parse a string that represents a size in human readable format. It
* supports decimal integers suffixed by 'k', 'K', 'M' or 'G'.
/**
* Parse a string that represents a time in human readable format. It
- * supports decimal integers suffixed by 's', 'u', 'm', 'us', and 'ms'.
+ * supports decimal integers suffixed by:
+ * "us" for microsecond,
+ * "ms" for millisecond,
+ * "s" for second,
+ * "m" for minute,
+ * "h" for hour
*
* The suffix multiply the integer by:
- * 'u'/'us': 1
- * 'm'/'ms': 1000
- * 's': 1000000
+ * "us" : 1
+ * "ms" : 1000
+ * "s" : 1000000
+ * "m" : 60000000
+ * "h" : 3600000000
*
* Note that unit-less numbers are assumed to be microseconds.
*
{
int ret;
uint64_t base_time;
- long multiplier = 1;
+ uint64_t multiplier = 1;
const char *str_end;
char *num_end;
/* Check if a prefix is present. */
switch (*num_end) {
case 'u':
- multiplier = 1;
- /* Skip another letter in the 'us' case. */
- num_end += (*(num_end + 1) == 's') ? 2 : 1;
+ /*
+ * Microsecond (us)
+ *
+ * Skip the "us" if the string matches the "us" suffix,
+ * otherwise let the check for the end of the string handle
+ * the error reporting.
+ */
+ if (*(num_end + 1) == 's') {
+ num_end += 2;
+ }
break;
case 'm':
- multiplier = 1000;
- /* Skip another letter in the 'ms' case. */
- num_end += (*(num_end + 1) == 's') ? 2 : 1;
+ if (*(num_end + 1) == 's') {
+ /* Millisecond (ms) */
+ multiplier = USEC_PER_MSEC;
+ /* Skip the 's' */
+ num_end++;
+ } else {
+ /* Minute (m) */
+ multiplier = USEC_PER_MINUTE;
+ }
+ num_end++;
break;
case 's':
- multiplier = 1000000;
+ /* Second */
+ multiplier = USEC_PER_SEC;
+ num_end++;
+ break;
+ case 'h':
+ /* Hour */
+ multiplier = USEC_PER_HOURS;
num_end++;
break;
case '\0':
#define HAS_FLS_U32
#endif
-#if defined(__x86_64)
+#if defined(__x86_64) && defined(__LP64__)
static inline
unsigned int fls_u64(uint64_t x)
{
* Otherwise returns the value of HOME.
*/
LTTNG_HIDDEN
-char *utils_get_home_dir(void)
+const char *utils_get_home_dir(void)
{
char *val = NULL;
struct passwd *pwd;
}
/*
- * Return the group ID matching name, else 0 if it cannot be found.
+ * Return 0 on success and set *gid to the group_ID matching the passed name.
+ * Else -1 if it cannot be found or an error occurred.
*/
LTTNG_HIDDEN
-gid_t utils_get_group_id(const char *name)
+int utils_get_group_id(const char *name, bool warn, gid_t *gid)
{
- struct group *grp;
+ static volatile int warn_once;
+ int ret;
+ long sys_len;
+ size_t len;
+ struct group grp;
+ struct group *result;
+ struct lttng_dynamic_buffer buffer;
+
+ /* Get the system limit, if it exists. */
+ sys_len = sysconf(_SC_GETGR_R_SIZE_MAX);
+ if (sys_len == -1) {
+ len = 1024;
+ } else {
+ len = (size_t) sys_len;
+ }
- grp = getgrnam(name);
- if (!grp) {
- static volatile int warn_once;
+ lttng_dynamic_buffer_init(&buffer);
+ ret = lttng_dynamic_buffer_set_size(&buffer, len);
+ if (ret) {
+ ERR("Failed to allocate group info buffer");
+ ret = -1;
+ goto error;
+ }
+
+ while ((ret = getgrnam_r(name, &grp, buffer.data, buffer.size, &result)) == ERANGE) {
+ const size_t new_len = 2 * buffer.size;
- if (!warn_once) {
- WARN("No tracing group detected");
- warn_once = 1;
+ /* Buffer is not big enough, increase its size. */
+ if (new_len < buffer.size) {
+ ERR("Group info buffer size overflow");
+ ret = -1;
+ goto error;
}
- return 0;
+
+ ret = lttng_dynamic_buffer_set_size(&buffer, new_len);
+ if (ret) {
+ ERR("Failed to grow group info buffer to %zu bytes",
+ new_len);
+ ret = -1;
+ goto error;
+ }
+ }
+ if (ret) {
+ if (ret == ESRCH) {
+ DBG("Could not find group file entry for group name '%s'",
+ name);
+ } else {
+ PERROR("Failed to get group file entry for group name '%s'",
+ name);
+ }
+
+ ret = -1;
+ goto error;
+ }
+
+ /* Group not found. */
+ if (!result) {
+ ret = -1;
+ goto error;
}
- return grp->gr_gid;
+
+ *gid = result->gr_gid;
+ ret = 0;
+
+error:
+ if (ret && warn && !warn_once) {
+ WARN("No tracing group detected");
+ warn_once = 1;
+ }
+ lttng_dynamic_buffer_reset(&buffer);
+ return ret;
}
/*
LTTNG_HIDDEN
int utils_recursive_rmdir(const char *path)
{
- DIR *dir;
- size_t path_len;
- int dir_fd, ret = 0, closeret, is_empty = 1;
- struct dirent *entry;
-
- /* Open directory */
- dir = opendir(path);
- if (!dir) {
- PERROR("Cannot open '%s' path", path);
- return -1;
- }
- dir_fd = lttng_dirfd(dir);
- if (dir_fd < 0) {
- PERROR("lttng_dirfd");
- return -1;
- }
-
- path_len = strlen(path);
- while ((entry = readdir(dir))) {
- struct stat st;
- size_t name_len;
- char filename[PATH_MAX];
-
- if (!strcmp(entry->d_name, ".")
- || !strcmp(entry->d_name, "..")) {
- continue;
- }
-
- name_len = strlen(entry->d_name);
- if (path_len + name_len + 2 > sizeof(filename)) {
- ERR("Failed to remove file: path name too long (%s/%s)",
- path, entry->d_name);
- continue;
- }
- if (snprintf(filename, sizeof(filename), "%s/%s",
- path, entry->d_name) < 0) {
- ERR("Failed to format path.");
- continue;
- }
-
- if (stat(filename, &st)) {
- PERROR("stat");
- continue;
- }
+ int ret;
+ struct lttng_directory_handle *handle;
- if (S_ISDIR(st.st_mode)) {
- char subpath[PATH_MAX];
-
- strncpy(subpath, path, PATH_MAX);
- subpath[PATH_MAX - 1] = '\0';
- strncat(subpath, "/",
- PATH_MAX - strlen(subpath) - 1);
- strncat(subpath, entry->d_name,
- PATH_MAX - strlen(subpath) - 1);
- if (utils_recursive_rmdir(subpath)) {
- is_empty = 0;
- }
- } else if (S_ISREG(st.st_mode)) {
- is_empty = 0;
- } else {
- ret = -EINVAL;
- goto end;
- }
+ handle = lttng_directory_handle_create(NULL);
+ if (!handle) {
+ ret = -1;
+ goto end;
}
+ ret = lttng_directory_handle_remove_subdirectory(handle, path);
end:
- closeret = closedir(dir);
- if (closeret) {
- PERROR("closedir");
- }
- if (is_empty) {
- DBG3("Attempting rmdir %s", path);
- ret = rmdir(path);
- }
+ lttng_directory_handle_put(handle);
return ret;
}
return ret;
}
+static
+int read_proc_meminfo_field(const char *field, size_t *value)
+{
+ int ret;
+ FILE *proc_meminfo;
+ char name[PROC_MEMINFO_FIELD_MAX_NAME_LEN] = {};
+
+ proc_meminfo = fopen(PROC_MEMINFO_PATH, "r");
+ if (!proc_meminfo) {
+ PERROR("Failed to fopen() " PROC_MEMINFO_PATH);
+ ret = -1;
+ goto fopen_error;
+ }
+
+ /*
+ * Read the contents of /proc/meminfo line by line to find the right
+ * field.
+ */
+ while (!feof(proc_meminfo)) {
+ unsigned long value_kb;
+
+ ret = fscanf(proc_meminfo,
+ "%" MAX_NAME_LEN_SCANF_IS_A_BROKEN_API "s %lu kB\n",
+ name, &value_kb);
+ if (ret == EOF) {
+ /*
+ * fscanf() returning EOF can indicate EOF or an error.
+ */
+ if (ferror(proc_meminfo)) {
+ PERROR("Failed to parse " PROC_MEMINFO_PATH);
+ }
+ break;
+ }
+
+ if (ret == 2 && strcmp(name, field) == 0) {
+ /*
+ * This number is displayed in kilo-bytes. Return the
+ * number of bytes.
+ */
+ *value = ((size_t) value_kb) * 1024;
+ ret = 0;
+ goto found;
+ }
+ }
+ /* Reached the end of the file without finding the right field. */
+ ret = -1;
+
+found:
+ fclose(proc_meminfo);
+fopen_error:
+ return ret;
+}
+
+/*
+ * Returns an estimate of the number of bytes of memory available based on the
+ * the information in `/proc/meminfo`. The number returned by this function is
+ * a best guess.
+ */
+LTTNG_HIDDEN
+int utils_get_memory_available(size_t *value)
+{
+ return read_proc_meminfo_field(PROC_MEMINFO_MEMAVAILABLE_LINE, value);
+}
+
+/*
+ * Returns the total size of the memory on the system in bytes based on the
+ * the information in `/proc/meminfo`.
+ */
+LTTNG_HIDDEN
+int utils_get_memory_total(size_t *value)
+{
+ return read_proc_meminfo_field(PROC_MEMINFO_MEMTOTAL_LINE, value);
+}
+
+LTTNG_HIDDEN
+int utils_change_working_directory(const char *path)
+{
+ int ret;
+
+ assert(path);
+
+ DBG("Changing working directory to \"%s\"", path);
+ ret = chdir(path);
+ if (ret) {
+ PERROR("Failed to change working directory to \"%s\"", path);
+ goto end;
+ }
+
+ /* Check for write access */
+ if (access(path, W_OK)) {
+ if (errno == EACCES) {
+ /*
+ * Do not treat this as an error since the permission
+ * might change in the lifetime of the process
+ */
+ DBG("Working directory \"%s\" is not writable", path);
+ } else {
+ PERROR("Failed to check if working directory \"%s\" is writable",
+ path);
+ }
+ }
+
+end:
+ return ret;
+}
+
LTTNG_HIDDEN
-int timespec_to_ms(struct timespec ts, unsigned long *ms)
+enum lttng_error_code utils_user_id_from_name(const char *user_name, uid_t *uid)
{
- unsigned long res, remain_ms;
+ struct passwd p, *pres;
+ int ret;
+ enum lttng_error_code ret_val = LTTNG_OK;
+ char *buf = NULL;
+ ssize_t buflen;
- if (ts.tv_sec > ULONG_MAX / MSEC_PER_SEC) {
- errno = EOVERFLOW;
- return -1; /* multiplication overflow */
+ buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
+ if (buflen < 0) {
+ buflen = FALLBACK_USER_BUFLEN;
}
- res = ts.tv_sec * MSEC_PER_SEC;
- remain_ms = ULONG_MAX - res;
- if (ts.tv_nsec / NSEC_PER_MSEC > remain_ms) {
- errno = EOVERFLOW;
- return -1; /* addition overflow */
+
+ buf = zmalloc(buflen);
+ if (!buf) {
+ ret_val = LTTNG_ERR_NOMEM;
+ goto end;
}
- res += ts.tv_nsec / NSEC_PER_MSEC;
- *ms = res;
- return 0;
+
+ for (;;) {
+ ret = getpwnam_r(user_name, &p, buf, buflen, &pres);
+ switch (ret) {
+ case EINTR:
+ continue;
+ case ERANGE:
+ buflen *= 2;
+ free(buf);
+ buf = zmalloc(buflen);
+ if (!buf) {
+ ret_val = LTTNG_ERR_NOMEM;
+ goto end;
+ }
+ continue;
+ default:
+ goto end_loop;
+ }
+ }
+end_loop:
+
+ switch (ret) {
+ case 0:
+ if (pres == NULL) {
+ ret_val = LTTNG_ERR_USER_NOT_FOUND;
+ } else {
+ *uid = p.pw_uid;
+ DBG("Lookup of tracker UID/VUID: name '%s' maps to uid %" PRId64,
+ user_name, (int64_t) *uid);
+ ret_val = LTTNG_OK;
+ }
+ break;
+ case ENOENT:
+ case ESRCH:
+ case EBADF:
+ case EPERM:
+ ret_val = LTTNG_ERR_USER_NOT_FOUND;
+ break;
+ default:
+ ret_val = LTTNG_ERR_NOMEM;
+ }
+end:
+ free(buf);
+ return ret_val;
}
LTTNG_HIDDEN
-struct timespec timespec_abs_diff(struct timespec t1, struct timespec t2)
+enum lttng_error_code utils_group_id_from_name(
+ const char *group_name, gid_t *gid)
{
- uint64_t ts1 = (uint64_t) t1.tv_sec * (uint64_t) NSEC_PER_SEC +
- (uint64_t) t1.tv_nsec;
- uint64_t ts2 = (uint64_t) t2.tv_sec * (uint64_t) NSEC_PER_SEC +
- (uint64_t) t2.tv_nsec;
- uint64_t diff = max(ts1, ts2) - min(ts1, ts2);
- struct timespec res;
-
- res.tv_sec = diff / (uint64_t) NSEC_PER_SEC;
- res.tv_nsec = diff % (uint64_t) NSEC_PER_SEC;
- return res;
+ struct group g, *gres;
+ int ret;
+ enum lttng_error_code ret_val = LTTNG_OK;
+ char *buf = NULL;
+ ssize_t buflen;
+
+ buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
+ if (buflen < 0) {
+ buflen = FALLBACK_GROUP_BUFLEN;
+ }
+
+ buf = zmalloc(buflen);
+ if (!buf) {
+ ret_val = LTTNG_ERR_NOMEM;
+ goto end;
+ }
+
+ for (;;) {
+ ret = getgrnam_r(group_name, &g, buf, buflen, &gres);
+ switch (ret) {
+ case EINTR:
+ continue;
+ case ERANGE:
+ buflen *= 2;
+ free(buf);
+ buf = zmalloc(buflen);
+ if (!buf) {
+ ret_val = LTTNG_ERR_NOMEM;
+ goto end;
+ }
+ continue;
+ default:
+ goto end_loop;
+ }
+ }
+end_loop:
+
+ switch (ret) {
+ case 0:
+ if (gres == NULL) {
+ ret_val = LTTNG_ERR_GROUP_NOT_FOUND;
+ } else {
+ *gid = g.gr_gid;
+ DBG("Lookup of tracker GID/GUID: name '%s' maps to gid %" PRId64,
+ group_name, (int64_t) *gid);
+ ret_val = LTTNG_OK;
+ }
+ break;
+ case ENOENT:
+ case ESRCH:
+ case EBADF:
+ case EPERM:
+ ret_val = LTTNG_ERR_GROUP_NOT_FOUND;
+ break;
+ default:
+ ret_val = LTTNG_ERR_NOMEM;
+ }
+end:
+ free(buf);
+ return ret_val;
+}
+
+LTTNG_HIDDEN
+int utils_parse_unsigned_long_long(const char *str,
+ unsigned long long *value)
+{
+ int ret;
+ char *endptr;
+
+ assert(str);
+ assert(value);
+
+ errno = 0;
+ *value = strtoull(str, &endptr, 10);
+
+ /* Conversion failed. Out of range? */
+ if (errno != 0) {
+ /* Don't print an error; allow the caller to log a better error. */
+ DBG("Failed to parse string as unsigned long long number: string = '%s', errno = %d",
+ str, errno);
+ ret = -1;
+ goto end;
+ }
+
+ /* Not the end of the string or empty string. */
+ if (*endptr || endptr == str) {
+ DBG("Failed to parse string as unsigned long long number: string = '%s'",
+ str);
+ ret = -1;
+ goto end;
+ }
+
+ ret = 0;
+
+end:
+ return ret;
}