#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 <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
/*
* Return a partial realpath(3) of the path even if the full path does not
return NULL;
}
+static
+int expand_double_slashes_dot_and_dotdot(char *path)
+{
+ size_t expanded_path_len, path_len;
+ const char *curr_char, *path_last_char, *next_slash, *prev_slash;
+
+ path_len = strlen(path);
+ path_last_char = &path[path_len];
+
+ if (path_len == 0) {
+ goto error;
+ }
+
+ expanded_path_len = 0;
+
+ /* We iterate over the provided path to expand the "//", "../" and "./" */
+ for (curr_char = path; curr_char <= path_last_char; curr_char = next_slash + 1) {
+ /* Find the next forward slash. */
+ size_t curr_token_len;
+
+ if (curr_char == path_last_char) {
+ expanded_path_len++;
+ break;
+ }
+
+ next_slash = memchr(curr_char, '/', path_last_char - curr_char);
+ if (next_slash == NULL) {
+ /* Reached the end of the provided path. */
+ next_slash = path_last_char;
+ }
+
+ /* Compute how long is the previous token. */
+ curr_token_len = next_slash - curr_char;
+ switch(curr_token_len) {
+ case 0:
+ /*
+ * The pointer has not move meaning that curr_char is
+ * pointing to a slash. It that case there is no token
+ * to copy, so continue the iteration to find the next
+ * token
+ */
+ continue;
+ case 1:
+ /*
+ * The pointer moved 1 character. Check if that
+ * character is a dot ('.'), if it is: omit it, else
+ * copy the token to the normalized path.
+ */
+ if (curr_char[0] == '.') {
+ continue;
+ }
+ break;
+ case 2:
+ /*
+ * The pointer moved 2 characters. Check if these
+ * characters are double dots ('..'). If that is the
+ * case, we need to remove the last token of the
+ * normalized path.
+ */
+ if (curr_char[0] == '.' && curr_char[1] == '.') {
+ /*
+ * Find the previous path component by
+ * using the memrchr function to find the
+ * previous forward slash and substract that
+ * len to the resulting path.
+ */
+ prev_slash = lttng_memrchr(path, '/', expanded_path_len);
+ /*
+ * If prev_slash is NULL, we reached the
+ * beginning of the path. We can't go back any
+ * further.
+ */
+ if (prev_slash != NULL) {
+ expanded_path_len = prev_slash - path;
+ }
+ continue;
+ }
+ break;
+ default:
+ break;
+ }
+
+ /*
+ * Copy the current token which is neither a '.' nor a '..'.
+ */
+ path[expanded_path_len++] = '/';
+ memcpy(&path[expanded_path_len], curr_char, curr_token_len);
+ expanded_path_len += curr_token_len;
+ }
+
+ if (expanded_path_len == 0) {
+ path[expanded_path_len++] = '/';
+ }
+
+ path[expanded_path_len] = '\0';
+ return 0;
+error:
+ return -1;
+}
+
/*
* Make a full resolution of the given path even if it doesn't exist.
* This function uses the utils_partial_realpath function to resolve
* the responsibility of the caller to free this memory.
*/
LTTNG_HIDDEN
-char *utils_expand_path(const char *path)
+char *_utils_expand_path(const char *path, bool keep_symlink)
{
- char *next, *previous, *slash, *start_path, *absolute_path = NULL;
+ int ret;
+ char *absolute_path = NULL;
char *last_token;
- int is_dot, is_dotdot;
+ bool is_dot, is_dotdot;
/* Safety net */
if (path == NULL) {
}
/* Allocate memory for the absolute_path */
- absolute_path = zmalloc(PATH_MAX);
+ absolute_path = zmalloc(LTTNG_PATH_MAX);
if (absolute_path == NULL) {
PERROR("zmalloc expand path");
goto error;
}
- /*
- * If the path is not already absolute nor explicitly relative,
- * consider we're in the current directory
- */
- if (*path != '/' && strncmp(path, "./", 2) != 0 &&
- strncmp(path, "../", 3) != 0) {
- snprintf(absolute_path, PATH_MAX, "./%s", path);
- /* Else, we just copy the path */
- } else {
- strncpy(absolute_path, path, PATH_MAX);
- }
-
- /* Resolve partially our path */
- absolute_path = utils_partial_realpath(absolute_path,
- absolute_path, PATH_MAX);
-
- /* As long as we find '/./' in the working_path string */
- while ((next = strstr(absolute_path, "/./"))) {
-
- /* We prepare the start_path not containing it */
- start_path = lttng_strndup(absolute_path, next - absolute_path);
- if (!start_path) {
- PERROR("lttng_strndup");
+ if (path[0] == '/') {
+ ret = lttng_strncpy(absolute_path, path, LTTNG_PATH_MAX);
+ if (ret) {
+ ERR("Path exceeds maximal size of %i bytes", LTTNG_PATH_MAX);
goto error;
}
- /* And we concatenate it with the part after this string */
- snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 2);
-
- free(start_path);
- }
+ } else {
+ /*
+ * This is a relative path. We need to get the present working
+ * directory and start the path walk from there.
+ */
+ char current_working_dir[LTTNG_PATH_MAX];
+ char *cwd_ret;
- /* As long as we find '/../' in the working_path string */
- while ((next = strstr(absolute_path, "/../"))) {
- /* We find the last level of directory */
- previous = absolute_path;
- while ((slash = strpbrk(previous, "/")) && slash != next) {
- previous = slash + 1;
+ cwd_ret = getcwd(current_working_dir, sizeof(current_working_dir));
+ if (!cwd_ret) {
+ goto error;
}
-
- /* Then we prepare the start_path not containing it */
- start_path = lttng_strndup(absolute_path, previous - absolute_path);
- if (!start_path) {
- PERROR("lttng_strndup");
+ /*
+ * Get the number of character in the CWD and allocate an array
+ * to can hold it and the path provided by the caller.
+ */
+ ret = snprintf(absolute_path, LTTNG_PATH_MAX, "%s/%s",
+ current_working_dir, path);
+ if (ret >= LTTNG_PATH_MAX) {
+ ERR("Concatenating current working directory %s and path %s exceeds maximal size of %i bytes",
+ current_working_dir, path, LTTNG_PATH_MAX);
goto error;
}
+ }
- /* And we concatenate it with the part after the '/../' */
- snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 4);
-
- /* We can free the memory used for the start path*/
- free(start_path);
-
- /* Then we verify for symlinks using partial_realpath */
+ if (keep_symlink) {
+ /* Resolve partially our path */
absolute_path = utils_partial_realpath(absolute_path,
- absolute_path, PATH_MAX);
+ absolute_path, LTTNG_PATH_MAX);
+ }
+
+ ret = expand_double_slashes_dot_and_dotdot(absolute_path);
+ if (ret) {
+ goto error;
}
/* Identify the last token */
free(absolute_path);
return NULL;
}
+LTTNG_HIDDEN
+char *utils_expand_path(const char *path)
+{
+ return _utils_expand_path(path, true);
+}
+LTTNG_HIDDEN
+char *utils_expand_path_keep_symlink(const char *path)
+{
+ return _utils_expand_path(path, false);
+}
/*
* Create a pipe in dst.
*/
S_IRGRP | S_IWGRP);
if (fd < 0) {
PERROR("open lock file %s", filepath);
- ret = -1;
+ fd = -1;
goto error;
}
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;
- }
-
-error:
+ struct lttng_directory_handle handle;
+ const struct lttng_credentials creds = {
+ .uid = (uid_t) uid,
+ .gid = (gid_t) gid,
+ };
+
+ (void) lttng_directory_handle_init(&handle, NULL);
+ ret = lttng_directory_handle_create_subdirectory_as_user(
+ &handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+ lttng_directory_handle_fini(&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);
- }
-
+ struct lttng_directory_handle handle;
+ const struct lttng_credentials creds = {
+ .uid = (uid_t) uid,
+ .gid = (gid_t) gid,
+ };
+
+ (void) lttng_directory_handle_init(&handle, NULL);
+ ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
+ &handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+ lttng_directory_handle_fini(&handle);
return ret;
}
strncpy(path, path_name_suffix, PATH_MAX - 1);
path[PATH_MAX - 1] = '\0';
} else {
- strncpy(path, full_path, PATH_MAX - 1);
+ 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;
goto error;
}
- flags = O_WRONLY | O_CREAT | O_TRUNC;
+ /*
+ * 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;
return ret;
}
+/**
+ * Parse a string that represents a time in human readable format. It
+ * 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:
+ * "us" : 1
+ * "ms" : 1000
+ * "s" : 1000000
+ * "m" : 60000000
+ * "h" : 3600000000
+ *
+ * Note that unit-less numbers are assumed to be microseconds.
+ *
+ * @param str The string to parse, assumed to be NULL-terminated.
+ * @param time_us Pointer to a uint64_t that will be filled with the
+ * resulting time in microseconds.
+ *
+ * @return 0 on success, -1 on failure.
+ */
+LTTNG_HIDDEN
+int utils_parse_time_suffix(char const * const str, uint64_t * const time_us)
+{
+ int ret;
+ uint64_t base_time;
+ uint64_t multiplier = 1;
+ const char *str_end;
+ char *num_end;
+
+ if (!str) {
+ DBG("utils_parse_time_suffix: received a NULL string.");
+ ret = -1;
+ goto end;
+ }
+
+ /* strtoull will accept a negative number, but we don't want to. */
+ if (strchr(str, '-') != NULL) {
+ DBG("utils_parse_time_suffix: invalid time string, should not contain '-'.");
+ ret = -1;
+ goto end;
+ }
+
+ /* str_end will point to the \0 */
+ str_end = str + strlen(str);
+ errno = 0;
+ base_time = strtoull(str, &num_end, 10);
+ if (errno != 0) {
+ PERROR("utils_parse_time_suffix strtoull on string \"%s\"", str);
+ ret = -1;
+ goto end;
+ }
+
+ if (num_end == str) {
+ /* strtoull parsed nothing, not good. */
+ DBG("utils_parse_time_suffix: strtoull had nothing good to parse.");
+ ret = -1;
+ goto end;
+ }
+
+ /* Check if a prefix is present. */
+ switch (*num_end) {
+ case 'u':
+ /*
+ * 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':
+ 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':
+ /* Second */
+ multiplier = USEC_PER_SEC;
+ num_end++;
+ break;
+ case 'h':
+ /* Hour */
+ multiplier = USEC_PER_HOURS;
+ num_end++;
+ break;
+ case '\0':
+ break;
+ default:
+ DBG("utils_parse_time_suffix: invalid suffix.");
+ ret = -1;
+ goto end;
+ }
+
+ /* Check for garbage after the valid input. */
+ if (num_end != str_end) {
+ DBG("utils_parse_time_suffix: Garbage after time string.");
+ ret = -1;
+ goto end;
+ }
+
+ *time_us = base_time * multiplier;
+
+ /* Check for overflow */
+ if ((*time_us / multiplier) != base_time) {
+ DBG("utils_parse_time_suffix: oops, overflow detected.");
+ ret = -1;
+ goto end;
+ }
+
+ ret = 0;
+end:
+ return ret;
+}
+
/*
* fls: returns the position of the most significant bit.
* Returns 0 if no bit is set, else returns the position of the most
return home_dir;
}
-/*
- * Obtain the value of LTTNG_KMOD_PROBES environment variable, if exists.
- * Otherwise returns NULL.
- */
-LTTNG_HIDDEN
-char *utils_get_kmod_probes_list(void)
-{
- return lttng_secure_getenv(DEFAULT_LTTNG_KMOD_PROBES);
-}
-
-/*
- * Obtain the value of LTTNG_EXTRA_KMOD_PROBES environment variable, if
- * exists. Otherwise returns NULL.
- */
-LTTNG_HIDDEN
-char *utils_get_extra_kmod_probes_list(void)
-{
- return lttng_secure_getenv(DEFAULT_LTTNG_EXTRA_KMOD_PROBES);
-}
-
/*
* With the given format, fill dst with the time of len maximum siz.
*
}
/*
- * 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;
+ }
+
+ 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;
+ }
- grp = getgrnam(name);
- if (!grp) {
- static volatile int warn_once;
+ 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;
+ }
+
+ 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;
}
- return 0;
}
- return grp->gr_gid;
+ if (ret) {
+ 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;
+ }
+
+ *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;
}
/*
int utils_truncate_stream_file(int fd, off_t length)
{
int ret;
+ off_t lseek_ret;
ret = ftruncate(fd, length);
if (ret < 0) {
PERROR("ftruncate");
goto end;
}
- ret = lseek(fd, length, SEEK_SET);
- if (ret < 0) {
+ lseek_ret = lseek(fd, length, SEEK_SET);
+ if (lseek_ret < 0) {
PERROR("lseek");
+ ret = -1;
goto end;
}
end:
}
LTTNG_HIDDEN
-int utils_show_man_page(int section, const char *page_name)
+int utils_show_help(int section, const char *page_name,
+ const char *help_msg)
{
char section_string[8];
const char *man_bin_path = get_man_bin_path();
- int ret;
+ int ret = 0;
+
+ if (help_msg) {
+ printf("%s", help_msg);
+ goto end;
+ }
/* Section integer -> section string */
ret = sprintf(section_string, "%d", section);
*/
ret = execlp(man_bin_path, "man", "-M", MANPATH,
section_string, page_name, NULL);
+
+end:
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);
+}