X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=646ebbbc7d34e6705d82fa654773ccbc387c5c66;hp=3f74e1fae3c21487e71e8a6aeec3be1a38558677;hb=11f8d2f7f00b61b467bf78518036d7cb96e8b9fc;hpb=857f0d94259cbe44649a16a8c098658352b97fa9 diff --git a/src/common/utils.c b/src/common/utils.c index 3f74e1fae..646ebbbc7 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -1,20 +1,10 @@ /* - * 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. */ #define _LGPL_SOURCE @@ -33,14 +23,32 @@ #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 /* * Return a partial realpath(3) of the path even if the full path does not @@ -197,7 +205,7 @@ error: } static -char *expand_double_slashes_dot_and_dotdot(char *path) +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; @@ -206,7 +214,6 @@ char *expand_double_slashes_dot_and_dotdot(char *path) path_last_char = &path[path_len]; if (path_len == 0) { - path = NULL; goto error; } @@ -292,9 +299,9 @@ char *expand_double_slashes_dot_and_dotdot(char *path) } path[expanded_path_len] = '\0'; - + return 0; error: - return path; + return -1; } /* @@ -307,13 +314,13 @@ 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; char *absolute_path = NULL; char *last_token; - int is_dot, is_dotdot; + bool is_dot, is_dotdot; /* Safety net */ if (path == NULL) { @@ -362,10 +369,13 @@ char *_utils_expand_path(const char *path, bool keep_symlink) /* Resolve partially our path */ absolute_path = utils_partial_realpath(absolute_path, absolute_path, LTTNG_PATH_MAX); + if (!absolute_path) { + goto error; + } } - absolute_path = expand_double_slashes_dot_and_dotdot(absolute_path); - if (!absolute_path) { + ret = expand_double_slashes_dot_and_dotdot(absolute_path); + if (ret) { goto error; } @@ -527,6 +537,7 @@ void utils_close_pipe(int *src) if (ret) { PERROR("close pipe"); } + src[i] = -1; } } @@ -653,44 +664,6 @@ 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. * @@ -700,82 +673,22 @@ 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 = (uid_t) uid, + .gid = (gid_t) 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; } @@ -789,221 +702,66 @@ 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 = (uid_t) uid, + .gid = (gid_t) 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'. @@ -1104,12 +862,19 @@ end: /** * 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. * @@ -1124,7 +889,7 @@ int utils_parse_time_suffix(char const * const str, uint64_t * const time_us) { int ret; uint64_t base_time; - long multiplier = 1; + uint64_t multiplier = 1; const char *str_end; char *num_end; @@ -1161,17 +926,37 @@ int utils_parse_time_suffix(char const * const str, uint64_t * const time_us) /* 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': @@ -1223,7 +1008,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) { @@ -1341,7 +1126,7 @@ int utils_get_count_order_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; @@ -1436,24 +1221,77 @@ 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; + } + + 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; } /* @@ -1508,79 +1346,17 @@ end: 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; } @@ -1646,3 +1422,109 @@ 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. + */ +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; +}