X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Futils.c;h=a092d940f422979b724fa5a61a72365c54b83ad7;hp=2417a7d255ffb1445e12ec9e24ba2b5a29900e1d;hb=81684730b3134c61ca310bf26733c01d783103d7;hpb=d7c23421dddd4dcfbdfd329299816fa7d020eeb8 diff --git a/src/common/utils.c b/src/common/utils.c index 2417a7d25..a092d940f 100644 --- a/src/common/utils.c +++ b/src/common/utils.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include @@ -40,6 +41,7 @@ #include "utils.h" #include "defaults.h" +#include "time.h" /* * Return a partial realpath(3) of the path even if the full path does not @@ -107,7 +109,7 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) } /* Try to resolve this part */ - try_path = realpath((char *)cut_path, try_path_buf); + try_path = realpath((char *) cut_path, try_path_buf); if (try_path == NULL) { free(try_path_buf); /* @@ -188,9 +190,113 @@ char *utils_partial_realpath(const char *path, char *resolved_path, size_t size) error: free(resolved_path); free(cut_path); + free(try_path); + if (try_path_prev != try_path) { + free(try_path_prev); + } 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 @@ -202,11 +308,12 @@ error: * 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) { @@ -214,67 +321,52 @@ char *utils_expand_path(const char *path) } /* 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 */ @@ -308,7 +400,17 @@ 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); +} /* * Create a pipe in dst. */ @@ -523,7 +625,7 @@ int utils_create_lock_file(const char *filepath) S_IRGRP | S_IWGRP); if (fd < 0) { PERROR("open lock file %s", filepath); - ret = -1; + fd = -1; goto error; } @@ -551,6 +653,44 @@ 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. * @@ -562,7 +702,7 @@ int utils_mkdir(const char *path, mode_t mode, int uid, int gid) int ret; if (uid < 0 || gid < 0) { - ret = mkdir(path, mode); + ret = mkdir_check_exists(path, mode); } else { ret = run_as_mkdir(path, mode, uid, gid); } @@ -617,9 +757,9 @@ int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode) ret = -1; goto error; } - ret = mkdir(tmp, mode); + ret = mkdir_check_exists(tmp, mode); if (ret < 0) { - if (errno != EEXIST) { + if (errno != EACCES) { PERROR("mkdir recursive"); ret = -errno; goto error; @@ -629,14 +769,10 @@ int _utils_mkdir_recursive_unsafe(const char *path, mode_t mode) } } - ret = mkdir(tmp, mode); + ret = mkdir_check_exists(tmp, mode); if (ret < 0) { - if (errno != EEXIST) { - PERROR("mkdir recursive last element"); - ret = -errno; - } else { - ret = 0; - } + PERROR("mkdir recursive last element"); + ret = -errno; } error: @@ -716,7 +852,11 @@ static int utils_stream_file_name(char *path, 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; @@ -746,7 +886,11 @@ int utils_create_stream_file(const char *path_name, char *file_name, uint64_t si 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; @@ -808,7 +952,6 @@ int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size, { int ret; - assert(new_count); assert(stream_fd); ret = close(out_fd); @@ -816,6 +959,7 @@ int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size, PERROR("Closing tracefile"); goto error; } + *stream_fd = -1; if (count > 0) { /* @@ -831,18 +975,22 @@ int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size, * Unlinking the old file rather than overwriting it * achieves this. */ - *new_count = (*new_count + 1) % count; - ret = utils_unlink_stream_file(path_name, file_name, - size, *new_count, uid, gid, 0); + 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; } } else { - (*new_count)++; + if (new_count) { + (*new_count)++; + } } - ret = utils_create_stream_file(path_name, file_name, size, *new_count, - uid, gid, 0); + ret = utils_create_stream_file(path_name, file_name, size, + new_count ? *new_count : 0, uid, gid, 0); if (ret < 0) { goto error; } @@ -954,6 +1102,134 @@ end: 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 @@ -974,6 +1250,59 @@ static inline unsigned int fls_u32(uint32_t x) #define HAS_FLS_U32 #endif +#if defined(__x86_64) +static inline +unsigned int fls_u64(uint64_t x) +{ + long r; + + asm("bsrq %1,%0\n\t" + "jnz 1f\n\t" + "movq $-1,%0\n\t" + "1:\n\t" + : "=r" (r) : "rm" (x)); + return r + 1; +} +#define HAS_FLS_U64 +#endif + +#ifndef HAS_FLS_U64 +static __attribute__((unused)) +unsigned int fls_u64(uint64_t x) +{ + unsigned int r = 64; + + if (!x) + return 0; + + if (!(x & 0xFFFFFFFF00000000ULL)) { + x <<= 32; + r -= 32; + } + if (!(x & 0xFFFF000000000000ULL)) { + x <<= 16; + r -= 16; + } + if (!(x & 0xFF00000000000000ULL)) { + x <<= 8; + r -= 8; + } + if (!(x & 0xF000000000000000ULL)) { + x <<= 4; + r -= 4; + } + if (!(x & 0xC000000000000000ULL)) { + x <<= 2; + r -= 2; + } + if (!(x & 0x8000000000000000ULL)) { + x <<= 1; + r -= 1; + } + return r; +} +#endif + #ifndef HAS_FLS_U32 static __attribute__((unused)) unsigned int fls_u32(uint32_t x) { @@ -1020,6 +1349,20 @@ int utils_get_count_order_u32(uint32_t x) return fls_u32(x - 1); } +/* + * 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) { + return -1; + } + + return fls_u64(x - 1); +} + /** * Obtain the value of LTTNG_HOME environment variable, if exists. * Otherwise returns the value of HOME. @@ -1092,26 +1435,6 @@ end: 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. * @@ -1231,14 +1554,15 @@ int utils_recursive_rmdir(const char *path) path_len = strlen(path); while ((entry = readdir(dir))) { - if (!strcmp(entry->d_name, ".") - || !strcmp(entry->d_name, "..")) - continue; - 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)", @@ -1286,3 +1610,66 @@ end: } return ret; } + +LTTNG_HIDDEN +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; + } + lseek_ret = lseek(fd, length, SEEK_SET); + if (lseek_ret < 0) { + PERROR("lseek"); + ret = -1; + goto end; + } +end: + return ret; +} + +static const char *get_man_bin_path(void) +{ + char *env_man_path = lttng_secure_getenv(DEFAULT_MAN_BIN_PATH_ENV); + + if (env_man_path) { + return env_man_path; + } + + return DEFAULT_MAN_BIN_PATH; +} + +LTTNG_HIDDEN +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 = 0; + + if (help_msg) { + printf("%s", help_msg); + goto end; + } + + /* Section integer -> section string */ + ret = sprintf(section_string, "%d", section); + assert(ret > 0 && ret < 8); + + /* + * Execute man pager. + * + * We provide -M to man here because LTTng-tools can + * be installed outside /usr, in which case its man pages are + * not located in the default /usr/share/man directory. + */ + ret = execlp(man_bin_path, "man", "-M", MANPATH, + section_string, page_name, NULL); + +end: + return ret; +}