X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=eebed2adb71934800c5f0f49b42c6277817fa8e1;hp=a092d940f422979b724fa5a61a72365c54b83ad7;hb=3afa94aeca5a0daae40fd7b6cc96b7e4c150c7d8;hpb=81684730b3134c61ca310bf26733c01d783103d7 diff --git a/src/common/utils.c b/src/common/utils.c index a092d940f..eebed2adb 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -1,24 +1,14 @@ /* - * Copyright (C) 2012 - David Goulet - * Copyright (C) 2013 - Raphaël Beamonte - * Copyright (C) 2013 - Jérémie Galarneau + * Copyright (C) 2012 David Goulet + * Copyright (C) 2013 Raphaël Beamonte + * Copyright (C) 2013 Jérémie Galarneau * - * 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 #include #include #include @@ -33,32 +23,51 @@ #include #include +#include #include #include #include #include +#include +#include +#include #include #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) { @@ -139,13 +148,11 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) 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; } /* @@ -169,7 +176,8 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) } /* 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); @@ -181,7 +189,7 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) * return it as is */ } else { - strncpy(resolved_path, path, size); + strncpy(resolved_path, path, LTTNG_PATH_MAX); } /* Then we return the 'partially' resolved path */ @@ -283,7 +291,7 @@ int expand_double_slashes_dot_and_dotdot(char *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; } @@ -307,7 +315,7 @@ error: * 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; @@ -360,8 +368,13 @@ char *_utils_expand_path(const char *path, bool keep_symlink) 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); @@ -400,13 +413,11 @@ error: 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); @@ -414,7 +425,6 @@ char *utils_expand_path_keep_symlink(const char *path) /* * Create a pipe in dst. */ -LTTNG_HIDDEN int utils_create_pipe(int *dst) { int ret; @@ -437,7 +447,6 @@ int utils_create_pipe(int *dst) * Make sure the pipe opened by this function are closed at some point. Use * utils_close_pipe(). */ -LTTNG_HIDDEN int utils_create_pipe_cloexec(int *dst) { int ret, i; @@ -470,7 +479,6 @@ error: * utils_close_pipe(). Using pipe() and fcntl rather than pipe2() to * support OSes other than Linux 2.6.23+. */ -LTTNG_HIDDEN int utils_create_pipe_cloexec_nonblock(int *dst) { int ret, i; @@ -508,7 +516,6 @@ error: /* * Close both read and write side of the pipe. */ -LTTNG_HIDDEN void utils_close_pipe(int *src) { int i, ret; @@ -527,13 +534,13 @@ void utils_close_pipe(int *src) if (ret) { PERROR("close pipe"); } + src[i] = -1; } } /* * Create a new string using two strings range. */ -LTTNG_HIDDEN char *utils_strdupdelim(const char *begin, const char *end) { char *str; @@ -554,7 +561,6 @@ error: /* * Set CLOEXEC flag to the give file descriptor. */ -LTTNG_HIDDEN int utils_set_fd_cloexec(int fd) { int ret; @@ -577,13 +583,12 @@ end: /* * Create pid file to the given path and filename. */ -LTTNG_HIDDEN int utils_create_pid_file(pid_t pid, const char *filepath) { int ret; FILE *fp; - assert(filepath); + LTTNG_ASSERT(filepath); fp = fopen(filepath, "w"); if (fp == NULL) { @@ -611,14 +616,13 @@ error: * Create lock file to the given path and filename. * Returns the associated file descriptor, -1 on error. */ -LTTNG_HIDDEN int utils_create_lock_file(const char *filepath) { int ret; int fd; struct flock lock; - assert(filepath); + LTTNG_ASSERT(filepath); memset(&lock, 0, sizeof(lock)); fd = open(filepath, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | @@ -653,129 +657,30 @@ 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. * * On success, return 0 else a negative error code. */ -LTTNG_HIDDEN 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; } @@ -785,225 +690,68 @@ error: * * On success, return 0 else a negative error code. */ -LTTNG_HIDDEN 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); + LTTNG_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'. @@ -1019,7 +767,6 @@ error: * * @return 0 on success, -1 on failure. */ -LTTNG_HIDDEN int utils_parse_size_suffix(const char * const str, uint64_t * const size) { int ret; @@ -1126,7 +873,6 @@ end: * * @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; @@ -1250,7 +996,7 @@ static inline unsigned int fls_u32(uint32_t x) #define HAS_FLS_U32 #endif -#if defined(__x86_64) +#if defined(__x86_64) && defined(__LP64__) static inline unsigned int fls_u64(uint64_t x) { @@ -1339,7 +1085,6 @@ static __attribute__((unused)) unsigned int fls_u32(uint32_t x) * Return the minimum order for which x <= (1UL << order). * Return -1 if x is 0. */ -LTTNG_HIDDEN int utils_get_count_order_u32(uint32_t x) { if (!x) { @@ -1353,7 +1098,6 @@ int utils_get_count_order_u32(uint32_t x) * Return the minimum order for which x <= (1UL << order). * Return -1 if x is 0. */ -LTTNG_HIDDEN int utils_get_count_order_u64(uint64_t x) { if (!x) { @@ -1367,8 +1111,7 @@ int utils_get_count_order_u64(uint64_t x) * Obtain the value of LTTNG_HOME environment variable, if exists. * 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; @@ -1399,7 +1142,6 @@ end: * Get user's home directory. Dynamically allocated, must be freed * by the caller. */ -LTTNG_HIDDEN char *utils_get_user_home_dir(uid_t uid) { struct passwd pwd; @@ -1440,15 +1182,14 @@ end: * * Return amount of bytes set in the buffer or else 0 on error. */ -LTTNG_HIDDEN size_t utils_get_current_time_str(const char *format, char *dst, size_t len) { size_t ret; time_t rawtime; struct tm *timeinfo; - assert(format); - assert(dst); + LTTNG_ASSERT(format); + LTTNG_ASSERT(dst); /* Get date and time for session path */ time(&rawtime); @@ -1463,24 +1204,82 @@ size_t utils_get_current_time_str(const char *format, char *dst, size_t len) } /* - * 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; } - return grp->gr_gid; + + /* 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; } /* @@ -1489,7 +1288,6 @@ gid_t utils_get_group_id(const char *name) * of elements in the long_options array. Returns NULL if the string's * allocation fails. */ -LTTNG_HIDDEN char *utils_generate_optstring(const struct option *long_options, size_t opt_count) { @@ -1532,86 +1330,22 @@ end: * Try to remove a hierarchy of empty directories, recursively. Don't unlink * any file. Try to rmdir any empty directory within the hierarchy. */ -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; } -LTTNG_HIDDEN int utils_truncate_stream_file(int fd, off_t length) { int ret; @@ -1643,7 +1377,6 @@ static const char *get_man_bin_path(void) return DEFAULT_MAN_BIN_PATH; } -LTTNG_HIDDEN int utils_show_help(int section, const char *page_name, const char *help_msg) { @@ -1658,7 +1391,7 @@ int utils_show_help(int section, const char *page_name, /* Section integer -> section string */ ret = sprintf(section_string, "%d", section); - assert(ret > 0 && ret < 8); + LTTNG_ASSERT(ret > 0 && ret < 8); /* * Execute man pager. @@ -1673,3 +1406,270 @@ int utils_show_help(int section, const char *page_name, 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. + */ +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`. + */ +int utils_get_memory_total(size_t *value) +{ + return read_proc_meminfo_field(PROC_MEMINFO_MEMTOTAL_LINE, value); +} + +int utils_change_working_directory(const char *path) +{ + int ret; + + LTTNG_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; +} + +enum lttng_error_code utils_user_id_from_name(const char *user_name, uid_t *uid) +{ + struct passwd p, *pres; + int ret; + enum lttng_error_code ret_val = LTTNG_OK; + char *buf = NULL; + ssize_t buflen; + + buflen = sysconf(_SC_GETPW_R_SIZE_MAX); + if (buflen < 0) { + buflen = FALLBACK_USER_BUFLEN; + } + + buf = zmalloc(buflen); + if (!buf) { + ret_val = LTTNG_ERR_NOMEM; + goto end; + } + + 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; +} + +enum lttng_error_code utils_group_id_from_name( + const char *group_name, gid_t *gid) +{ + 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; +} + +int utils_parse_unsigned_long_long(const char *str, + unsigned long long *value) +{ + int ret; + char *endptr; + + LTTNG_ASSERT(str); + LTTNG_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; +}