[lttng-tools.git] / src / common / utils.c

/*
 * Copyright (C) 2012 - David Goulet <dgoulet@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.
 *
 * 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 _GNU_SOURCE
#include <assert.h>
#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <inttypes.h>
#include <regex.h>

#include <common/common.h>
#include <common/runas.h>

#include "utils.h"
#include "defaults.h"

/*
 * Return the realpath(3) of the path even if the last directory token does not
 * exist. For example, with /tmp/test1/test2, if test2/ does not exist but the
 * /tmp/test1 does, the real path is returned. In normal time, realpath(3)
 * fails if the end point directory does not exist.
 */
LTTNG_HIDDEN
char *utils_expand_path(const char *path)
{
	const char *end_path = path;
	char *next, *cut_path = NULL, *expanded_path = NULL;

	/* Safety net */
	if (path == NULL) {
		goto error;
	}

	/* Find last token delimited by '/' */
	while ((next = strpbrk(end_path + 1, "/"))) {
		end_path = next;
	}

	/* Cut last token from original path */
	cut_path = strndup(path, end_path - path);

	expanded_path = zmalloc(PATH_MAX);
	if (expanded_path == NULL) {
		PERROR("zmalloc expand path");
		goto error;
	}

	expanded_path = realpath((char *)cut_path, expanded_path);
	if (expanded_path == NULL) {
		switch (errno) {
		case ENOENT:
			ERR("%s: No such file or directory", cut_path);
			break;
		default:
			PERROR("realpath utils expand path");
			break;
		}
		goto error;
	}

	/* Add end part to expanded path */
	strncat(expanded_path, end_path, PATH_MAX - strlen(expanded_path) - 1);

	free(cut_path);
	return expanded_path;

error:
	free(expanded_path);
	free(cut_path);
	return NULL;
}

/*
 * Create a pipe in dst.
 */
LTTNG_HIDDEN
int utils_create_pipe(int *dst)
{
	int ret;

	if (dst == NULL) {
		return -1;
	}

	ret = pipe(dst);
	if (ret < 0) {
		PERROR("create pipe");
	}

	return ret;
}

/*
 * Create pipe and set CLOEXEC flag to both fd.
 *
 * 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;

	if (dst == NULL) {
		return -1;
	}

	ret = utils_create_pipe(dst);
	if (ret < 0) {
		goto error;
	}

	for (i = 0; i < 2; i++) {
		ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
		if (ret < 0) {
			PERROR("fcntl pipe cloexec");
			goto error;
		}
	}

error:
	return ret;
}

/*
 * Create pipe and set fd flags to FD_CLOEXEC and O_NONBLOCK.
 *
 * Make sure the pipe opened by this function are closed at some point. Use
 * 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;

	if (dst == NULL) {
		return -1;
	}

	ret = utils_create_pipe(dst);
	if (ret < 0) {
		goto error;
	}

	for (i = 0; i < 2; i++) {
		ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
		if (ret < 0) {
			PERROR("fcntl pipe cloexec");
			goto error;
		}
		/*
		 * Note: we override any flag that could have been
		 * previously set on the fd.
		 */
		ret = fcntl(dst[i], F_SETFL, O_NONBLOCK);
		if (ret < 0) {
			PERROR("fcntl pipe nonblock");
			goto error;
		}
	}

error:
	return ret;
}

/*
 * Close both read and write side of the pipe.
 */
LTTNG_HIDDEN
void utils_close_pipe(int *src)
{
	int i, ret;

	if (src == NULL) {
		return;
	}

	for (i = 0; i < 2; i++) {
		/* Safety check */
		if (src[i] < 0) {
			continue;
		}

		ret = close(src[i]);
		if (ret) {
			PERROR("close pipe");
		}
	}
}

/*
 * Create a new string using two strings range.
 */
LTTNG_HIDDEN
char *utils_strdupdelim(const char *begin, const char *end)
{
	char *str;

	str = zmalloc(end - begin + 1);
	if (str == NULL) {
		PERROR("zmalloc strdupdelim");
		goto error;
	}

	memcpy(str, begin, end - begin);
	str[end - begin] = '\0';

error:
	return str;
}

/*
 * Set CLOEXEC flag to the give file descriptor.
 */
LTTNG_HIDDEN
int utils_set_fd_cloexec(int fd)
{
	int ret;

	if (fd < 0) {
		ret = -EINVAL;
		goto end;
	}

	ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
	if (ret < 0) {
		PERROR("fcntl cloexec");
		ret = -errno;
	}

end:
	return ret;
}

/*
 * 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);

	fp = fopen(filepath, "w");
	if (fp == NULL) {
		PERROR("open pid file %s", filepath);
		ret = -1;
		goto error;
	}

	ret = fprintf(fp, "%d\n", pid);
	if (ret < 0) {
		PERROR("fprintf pid file");
	}

	fclose(fp);
	DBG("Pid %d written in file %s", pid, filepath);
error:
	return ret;
}

/*
 * Recursively create directory using the given path and mode.
 *
 * On success, return 0 else a negative error code.
 */
LTTNG_HIDDEN
int utils_mkdir_recursive(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(tmp, mode);
			if (ret < 0) {
				if (errno != EEXIST) {
					PERROR("mkdir recursive");
					ret = -errno;
					goto error;
				}
			}
			*p = '/';
		}
	}

	ret = mkdir(tmp, mode);
	if (ret < 0) {
		if (errno != EEXIST) {
			PERROR("mkdir recursive last piece");
			ret = -errno;
		} else {
			ret = 0;
		}
	}

error:
	return ret;
}

/*
 * Create the stream tracefile 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)
{
	int ret, out_fd, flags, mode;
	char full_path[PATH_MAX], *path_name_id = NULL, *path;

	assert(path_name);
	assert(file_name);

	ret = snprintf(full_path, sizeof(full_path), "%s/%s",
			path_name, file_name);
	if (ret < 0) {
		PERROR("snprintf create output file");
		goto error;
	}

	/*
	 * If we split the trace in multiple files, we have to add the count at the
	 * end of the tracefile name
	 */
	if (size > 0) {
		ret = asprintf(&path_name_id, "%s_%" PRIu64, full_path, count);
		if (ret < 0) {
			PERROR("Allocating path name ID");
			goto error;
		}
		path = path_name_id;
	} else {
		path = full_path;
	}

	flags = O_WRONLY | O_CREAT | O_TRUNC;
	/* Open with 660 mode */
	mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;

	if (uid < 0 || gid < 0) {
		out_fd = open(path, flags, mode);
	} else {
		out_fd = run_as_open(path, flags, mode, uid, gid);
	}
	if (out_fd < 0) {
		PERROR("open stream path %s", path);
		goto error_open;
	}
	ret = out_fd;

error_open:
	free(path_name_id);
error:
	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 ret;

	ret = close(out_fd);
	if (ret < 0) {
		PERROR("Closing tracefile");
		goto error;
	}

	if (count > 0) {
		*new_count = (*new_count + 1) % count;
	} else {
		(*new_count)++;
	}

	return utils_create_stream_file(path_name, file_name, size, *new_count,
			uid, gid);
error:
	return ret;
}

/**
 * Prints the error message corresponding to a regex error code.
 *
 * @param errcode	The error code.
 * @param regex		The regex object that produced the error code.
 */
static void regex_print_error(int errcode, regex_t *regex)
{
	/* Get length of error message and allocate accordingly */
	size_t length;
	char *buffer;

	assert(regex != NULL);

	length = regerror(errcode, regex, NULL, 0);
	if (length == 0) {
		ERR("regerror returned a length of 0");
		return;
	}

	buffer = zmalloc(length);
	if (!buffer) {
		ERR("regex_print_error: zmalloc failed");
		return;
	}

	/* Get and print error message */
	regerror(errcode, regex, buffer, length);
	ERR("regex error: %s\n", buffer);
	free(buffer);

}

/**
 * Parse a string that represents a size in human readable format. It
 * supports decimal integers suffixed by 'k', 'M' or 'G'.
 *
 * The suffix multiply the integer by:
 * 'k': 1024
 * 'M': 1024^2
 * 'G': 1024^3
 *
 * @param str	The string to parse.
 * @param size	Pointer to a size_t that will be filled with the
 *		resulting size.
 *
 * @return 0 on success, -1 on failure.
 */
LTTNG_HIDDEN
int utils_parse_size_suffix(char *str, uint64_t *size)
{
	regex_t regex;
	int ret;
	const int nmatch = 3;
	regmatch_t suffix_match, matches[nmatch];
	unsigned long long base_size;
	long shift = 0;

	if (!str) {
		return 0;
	}

	/* Compile regex */
	ret = regcomp(&regex, "^\\(0x\\)\\{0,1\\}[0-9][0-9]*\\([kKMG]\\{0,1\\}\\)$", 0);
	if (ret != 0) {
		regex_print_error(ret, &regex);
		ret = -1;
		goto end;
	}

	/* Match regex */
	ret = regexec(&regex, str, nmatch, matches, 0);
	if (ret != 0) {
		ret = -1;
		goto free;
	}

	/* There is a match ! */
	errno = 0;
	base_size = strtoull(str, NULL, 0);
	if (errno != 0) {
		PERROR("strtoull");
		ret = -1;
		goto free;
	}

	/* Check if there is a suffix */
	suffix_match = matches[2];
	if (suffix_match.rm_eo - suffix_match.rm_so == 1) {
		switch (*(str + suffix_match.rm_so)) {
		case 'K':
		case 'k':
			shift = KIBI_LOG2;
			break;
		case 'M':
			shift = MEBI_LOG2;
			break;
		case 'G':
			shift = GIBI_LOG2;
			break;
		default:
			ERR("parse_human_size: invalid suffix");
			ret = -1;
			goto free;
		}
	}

	*size = base_size << shift;

	/* Check for overflow */
	if ((*size >> shift) != base_size) {
		ERR("parse_size_suffix: oops, overflow detected.");
		ret = -1;
		goto free;
	}

	ret = 0;

free:
	regfree(&regex);
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
 * significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
 */
#if defined(__i386) || defined(__x86_64)
static inline unsigned int fls_u32(uint32_t x)
{
	int r;

	asm("bsrl %1,%0\n\t"
		"jnz 1f\n\t"
		"movl $-1,%0\n\t"
		"1:\n\t"
		: "=r" (r) : "rm" (x));
	return r + 1;
}
#define HAS_FLS_U32
#endif

#ifndef HAS_FLS_U32
static __attribute__((unused)) unsigned int fls_u32(uint32_t x)
{
	unsigned int r = 32;

	if (!x) {
		return 0;
	}
	if (!(x & 0xFFFF0000U)) {
		x <<= 16;
		r -= 16;
	}
	if (!(x & 0xFF000000U)) {
		x <<= 8;
		r -= 8;
	}
	if (!(x & 0xF0000000U)) {
		x <<= 4;
		r -= 4;
	}
	if (!(x & 0xC0000000U)) {
		x <<= 2;
		r -= 2;
	}
	if (!(x & 0x80000000U)) {
		x <<= 1;
		r -= 1;
	}
	return r;
}
#endif

/*
 * 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) {
		return -1;
	}

	return fls_u32(x - 1);
}

/**
 * Obtain the value of LTTNG_HOME environment variable, if exists.
 * Otherwise returns the value of HOME.
 */
LTTNG_HIDDEN
char *utils_get_home_dir(void)
{
	char *val = NULL;
	val = getenv(DEFAULT_LTTNG_HOME_ENV_VAR);
	if (val != NULL) {
		return val;
	}
	return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR);
}

/*
 * With the given format, fill dst with the time of len maximum siz.
 *
 * 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);

	/* Get date and time for session path */
	time(&rawtime);
	timeinfo = localtime(&rawtime);
	ret = strftime(dst, len, format, timeinfo);
	if (ret == 0) {
		ERR("Unable to strftime with format %s at dst %p of len %lu", format,
				dst, len);
	}

	return ret;
}
Commit	Line	Data
81b86775 DG	1	/*
	2	* Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License, version 2 only, as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 51
	15	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	16	*/
	17
	18	#define _GNU_SOURCE
35f90c40	19	#include <assert.h>
81b86775 DG	20	#include <ctype.h>
	21	#include <fcntl.h>
	22	#include <limits.h>
	23	#include <stdlib.h>
	24	#include <string.h>
2d851108	25	#include <sys/stat.h>
0c7bcad5	26	#include <sys/types.h>
2d851108	27	#include <unistd.h>
fe4477ee	28	#include <inttypes.h>
70d0b120	29	#include <regex.h>
81b86775 DG	30
81b86775 DG	31	#include <common/common.h>
fe4477ee	32	#include <common/runas.h>
81b86775 DG	33
81b86775 DG	34	#include "utils.h"
feb0f3e5	35	#include "defaults.h"
81b86775 DG	36
	37	/*
	38	* Return the realpath(3) of the path even if the last directory token does not
	39	* exist. For example, with /tmp/test1/test2, if test2/ does not exist but the
	40	* /tmp/test1 does, the real path is returned. In normal time, realpath(3)
	41	* fails if the end point directory does not exist.
	42	*/
90e535ef	43	LTTNG_HIDDEN
81b86775 DG	44	char utils_expand_path(const char path)
	45	{
	46	const char *end_path = path;
	47	char next, cut_path = NULL, *expanded_path = NULL;
	48
	49	/* Safety net */
	50	if (path == NULL) {
	51	goto error;
	52	}
	53
	54	/* Find last token delimited by '/' */
	55	while ((next = strpbrk(end_path + 1, "/"))) {
	56	end_path = next;
	57	}
	58
	59	/* Cut last token from original path */
	60	cut_path = strndup(path, end_path - path);
	61
	62	expanded_path = zmalloc(PATH_MAX);
	63	if (expanded_path == NULL) {
	64	PERROR("zmalloc expand path");
	65	goto error;
	66	}
	67
	68	expanded_path = realpath((char *)cut_path, expanded_path);
	69	if (expanded_path == NULL) {
	70	switch (errno) {
	71	case ENOENT:
	72	ERR("%s: No such file or directory", cut_path);
	73	break;
	74	default:
	75	PERROR("realpath utils expand path");
	76	break;
	77	}
	78	goto error;
	79	}
	80
	81	/* Add end part to expanded path */
c30ce0b3	82	strncat(expanded_path, end_path, PATH_MAX - strlen(expanded_path) - 1);
81b86775 DG	83
	84	free(cut_path);
	85	return expanded_path;
	86
	87	error:
	88	free(expanded_path);
	89	free(cut_path);
	90	return NULL;
	91	}
	92
	93	/*
	94	* Create a pipe in dst.
	95	*/
90e535ef	96	LTTNG_HIDDEN
81b86775 DG	97	int utils_create_pipe(int *dst)
	98	{
	99	int ret;
	100
	101	if (dst == NULL) {
	102	return -1;
	103	}
	104
	105	ret = pipe(dst);
	106	if (ret < 0) {
	107	PERROR("create pipe");
	108	}
	109
	110	return ret;
	111	}
	112
	113	/*
	114	* Create pipe and set CLOEXEC flag to both fd.
	115	*
	116	* Make sure the pipe opened by this function are closed at some point. Use
	117	* utils_close_pipe().
	118	*/
90e535ef	119	LTTNG_HIDDEN
81b86775 DG	120	int utils_create_pipe_cloexec(int *dst)
	121	{
	122	int ret, i;
	123
	124	if (dst == NULL) {
	125	return -1;
	126	}
	127
	128	ret = utils_create_pipe(dst);
	129	if (ret < 0) {
	130	goto error;
	131	}
	132
	133	for (i = 0; i < 2; i++) {
	134	ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
	135	if (ret < 0) {
	136	PERROR("fcntl pipe cloexec");
	137	goto error;
	138	}
	139	}
	140
	141	error:
	142	return ret;
	143	}
	144
094f381c MD	145	/*
	146	* Create pipe and set fd flags to FD_CLOEXEC and O_NONBLOCK.
	147	*
	148	* Make sure the pipe opened by this function are closed at some point. Use
	149	* utils_close_pipe(). Using pipe() and fcntl rather than pipe2() to
	150	* support OSes other than Linux 2.6.23+.
	151	*/
	152	LTTNG_HIDDEN
	153	int utils_create_pipe_cloexec_nonblock(int *dst)
	154	{
	155	int ret, i;
	156
	157	if (dst == NULL) {
	158	return -1;
	159	}
	160
	161	ret = utils_create_pipe(dst);
	162	if (ret < 0) {
	163	goto error;
	164	}
	165
	166	for (i = 0; i < 2; i++) {
	167	ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
	168	if (ret < 0) {
	169	PERROR("fcntl pipe cloexec");
	170	goto error;
	171	}
	172	/*
	173	* Note: we override any flag that could have been
	174	* previously set on the fd.
	175	*/
	176	ret = fcntl(dst[i], F_SETFL, O_NONBLOCK);
	177	if (ret < 0) {
	178	PERROR("fcntl pipe nonblock");
	179	goto error;
	180	}
	181	}
	182
	183	error:
	184	return ret;
	185	}
	186
81b86775 DG	187	/*
	188	* Close both read and write side of the pipe.
	189	*/
90e535ef	190	LTTNG_HIDDEN
81b86775 DG	191	void utils_close_pipe(int *src)
	192	{
	193	int i, ret;
	194
	195	if (src == NULL) {
	196	return;
	197	}
	198
	199	for (i = 0; i < 2; i++) {
	200	/* Safety check */
	201	if (src[i] < 0) {
	202	continue;
	203	}
	204
	205	ret = close(src[i]);
	206	if (ret) {
	207	PERROR("close pipe");
	208	}
	209	}
	210	}
a4b92340 DG	211
	212	/*
	213	* Create a new string using two strings range.
	214	*/
90e535ef	215	LTTNG_HIDDEN
a4b92340 DG	216	char utils_strdupdelim(const char begin, const char *end)
	217	{
	218	char *str;
	219
	220	str = zmalloc(end - begin + 1);
	221	if (str == NULL) {
	222	PERROR("zmalloc strdupdelim");
	223	goto error;
	224	}
	225
	226	memcpy(str, begin, end - begin);
	227	str[end - begin] = '\0';
	228
	229	error:
	230	return str;
	231	}
b662582b DG	232
	233	/*
	234	* Set CLOEXEC flag to the give file descriptor.
	235	*/
90e535ef	236	LTTNG_HIDDEN
b662582b DG	237	int utils_set_fd_cloexec(int fd)
	238	{
	239	int ret;
	240
	241	if (fd < 0) {
	242	ret = -EINVAL;
	243	goto end;
	244	}
	245
	246	ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
	247	if (ret < 0) {
	248	PERROR("fcntl cloexec");
	249	ret = -errno;
	250	}
	251
	252	end:
	253	return ret;
	254	}
35f90c40 DG	255
	256	/*
	257	* Create pid file to the given path and filename.
	258	*/
90e535ef	259	LTTNG_HIDDEN
35f90c40 DG	260	int utils_create_pid_file(pid_t pid, const char *filepath)
	261	{
	262	int ret;
	263	FILE *fp;
	264
	265	assert(filepath);
	266
	267	fp = fopen(filepath, "w");
	268	if (fp == NULL) {
	269	PERROR("open pid file %s", filepath);
	270	ret = -1;
	271	goto error;
	272	}
	273
	274	ret = fprintf(fp, "%d\n", pid);
	275	if (ret < 0) {
	276	PERROR("fprintf pid file");
	277	}
	278
	279	fclose(fp);
	280	DBG("Pid %d written in file %s", pid, filepath);
	281	error:
	282	return ret;
	283	}
2d851108 DG	284
	285	/*
	286	* Recursively create directory using the given path and mode.
	287	*
	288	* On success, return 0 else a negative error code.
	289	*/
90e535ef	290	LTTNG_HIDDEN
2d851108 DG	291	int utils_mkdir_recursive(const char *path, mode_t mode)
	292	{
	293	char *p, tmp[PATH_MAX];
2d851108 DG	294	size_t len;
	295	int ret;
	296
	297	assert(path);
	298
	299	ret = snprintf(tmp, sizeof(tmp), "%s", path);
	300	if (ret < 0) {
	301	PERROR("snprintf mkdir");
	302	goto error;
	303	}
	304
	305	len = ret;
	306	if (tmp[len - 1] == '/') {
	307	tmp[len - 1] = 0;
	308	}
	309
	310	for (p = tmp + 1; *p; p++) {
	311	if (*p == '/') {
	312	*p = 0;
	313	if (tmp[strlen(tmp) - 1] == '.' &&
	314	tmp[strlen(tmp) - 2] == '.' &&
	315	tmp[strlen(tmp) - 3] == '/') {
	316	ERR("Using '/../' is not permitted in the trace path (%s)",
	317	tmp);
	318	ret = -1;
	319	goto error;
	320	}
0c7bcad5	321	ret = mkdir(tmp, mode);
2d851108	322	if (ret < 0) {
0c7bcad5 MD	323	if (errno != EEXIST) {
	324	PERROR("mkdir recursive");
	325	ret = -errno;
	326	goto error;
2d851108 DG	327	}
	328	}
	329	*p = '/';
	330	}
	331	}
	332
	333	ret = mkdir(tmp, mode);
	334	if (ret < 0) {
	335	if (errno != EEXIST) {
	336	PERROR("mkdir recursive last piece");
	337	ret = -errno;
	338	} else {
	339	ret = 0;
	340	}
	341	}
	342
	343	error:
	344	return ret;
	345	}
fe4477ee JD	346
	347	/*
	348	* Create the stream tracefile on disk.
	349	*
	350	* Return 0 on success or else a negative value.
	351	*/
bc182241	352	LTTNG_HIDDEN
07b86b52	353	int utils_create_stream_file(const char path_name, char file_name, uint64_t size,
fe4477ee JD	354	uint64_t count, int uid, int gid)
fe4477ee JD	355	{
be96a7d1	356	int ret, out_fd, flags, mode;
fe4477ee JD	357	char full_path[PATH_MAX], path_name_id = NULL, path;
	358
	359	assert(path_name);
	360	assert(file_name);
	361
	362	ret = snprintf(full_path, sizeof(full_path), "%s/%s",
	363	path_name, file_name);
	364	if (ret < 0) {
	365	PERROR("snprintf create output file");
	366	goto error;
	367	}
	368
	369	/*
	370	* If we split the trace in multiple files, we have to add the count at the
	371	* end of the tracefile name
	372	*/
	373	if (size > 0) {
	374	ret = asprintf(&path_name_id, "%s_%" PRIu64, full_path, count);
	375	if (ret < 0) {
	376	PERROR("Allocating path name ID");
	377	goto error;
	378	}
	379	path = path_name_id;
	380	} else {
	381	path = full_path;
	382	}
	383
be96a7d1	384	flags = O_WRONLY \| O_CREAT \| O_TRUNC;
0f907de1	385	/* Open with 660 mode */
be96a7d1 DG	386	mode = S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IWGRP;
	387
	388	if (uid < 0 \|\| gid < 0) {
	389	out_fd = open(path, flags, mode);
	390	} else {
	391	out_fd = run_as_open(path, flags, mode, uid, gid);
	392	}
fe4477ee JD	393	if (out_fd < 0) {
	394	PERROR("open stream path %s", path);
	395	goto error_open;
	396	}
	397	ret = out_fd;
	398
	399	error_open:
	400	free(path_name_id);
	401	error:
	402	return ret;
	403	}
	404
	405	/*
	406	* Change the output tracefile according to the given size and count The
	407	* new_count pointer is set during this operation.
	408	*
	409	* From the consumer, the stream lock MUST be held before calling this function
	410	* because we are modifying the stream status.
	411	*
	412	* Return 0 on success or else a negative value.
	413	*/
bc182241	414	LTTNG_HIDDEN
fe4477ee JD	415	int utils_rotate_stream_file(char path_name, char file_name, uint64_t size,
	416	uint64_t count, int uid, int gid, int out_fd, uint64_t *new_count)
	417	{
	418	int ret;
	419
	420	ret = close(out_fd);
	421	if (ret < 0) {
	422	PERROR("Closing tracefile");
	423	goto error;
	424	}
	425
	426	if (count > 0) {
	427	new_count = (new_count + 1) % count;
	428	} else {
	429	(*new_count)++;
	430	}
	431
	432	return utils_create_stream_file(path_name, file_name, size, *new_count,
	433	uid, gid);
	434	error:
	435	return ret;
	436	}
70d0b120 SM	437
	438	/**
	439	* Prints the error message corresponding to a regex error code.
	440	*
	441	* @param errcode The error code.
	442	* @param regex The regex object that produced the error code.
	443	*/
	444	static void regex_print_error(int errcode, regex_t *regex)
	445	{
	446	/* Get length of error message and allocate accordingly */
	447	size_t length;
	448	char *buffer;
	449
	450	assert(regex != NULL);
	451
	452	length = regerror(errcode, regex, NULL, 0);
	453	if (length == 0) {
	454	ERR("regerror returned a length of 0");
	455	return;
	456	}
	457
	458	buffer = zmalloc(length);
	459	if (!buffer) {
	460	ERR("regex_print_error: zmalloc failed");
	461	return;
	462	}
	463
	464	/* Get and print error message */
	465	regerror(errcode, regex, buffer, length);
	466	ERR("regex error: %s\n", buffer);
	467	free(buffer);
	468
	469	}
	470
	471	/**
	472	* Parse a string that represents a size in human readable format. It
	473	* supports decimal integers suffixed by 'k', 'M' or 'G'.
	474	*
	475	* The suffix multiply the integer by:
	476	* 'k': 1024
	477	* 'M': 1024^2
	478	* 'G': 1024^3
	479	*
	480	* @param str The string to parse.
	481	* @param size Pointer to a size_t that will be filled with the
cfa9a5a2	482	* resulting size.
70d0b120 SM	483	*
	484	* @return 0 on success, -1 on failure.
	485	*/
00a52467	486	LTTNG_HIDDEN
70d0b120 SM	487	int utils_parse_size_suffix(char str, uint64_t size)
	488	{
	489	regex_t regex;
	490	int ret;
	491	const int nmatch = 3;
	492	regmatch_t suffix_match, matches[nmatch];
	493	unsigned long long base_size;
	494	long shift = 0;
	495
	496	if (!str) {
	497	return 0;
	498	}
	499
	500	/* Compile regex */
	501	ret = regcomp(&regex, "^\\(0x\\)\\{0,1\\}[0-9][0-9]*\\([kKMG]\\{0,1\\}\\)$", 0);
	502	if (ret != 0) {
	503	regex_print_error(ret, &regex);
	504	ret = -1;
	505	goto end;
	506	}
	507
	508	/* Match regex */
	509	ret = regexec(&regex, str, nmatch, matches, 0);
	510	if (ret != 0) {
	511	ret = -1;
	512	goto free;
	513	}
	514
	515	/* There is a match ! */
	516	errno = 0;
	517	base_size = strtoull(str, NULL, 0);
	518	if (errno != 0) {
	519	PERROR("strtoull");
	520	ret = -1;
	521	goto free;
	522	}
	523
	524	/* Check if there is a suffix */
	525	suffix_match = matches[2];
	526	if (suffix_match.rm_eo - suffix_match.rm_so == 1) {
	527	switch (*(str + suffix_match.rm_so)) {
	528	case 'K':
	529	case 'k':
	530	shift = KIBI_LOG2;
	531	break;
	532	case 'M':
	533	shift = MEBI_LOG2;
	534	break;
	535	case 'G':
	536	shift = GIBI_LOG2;
	537	break;
	538	default:
	539	ERR("parse_human_size: invalid suffix");
	540	ret = -1;
	541	goto free;
	542	}
	543	}
	544
	545	*size = base_size << shift;
	546
	547	/* Check for overflow */
	548	if ((*size >> shift) != base_size) {
	549	ERR("parse_size_suffix: oops, overflow detected.");
	550	ret = -1;
551	goto free;
552	}
553
554	ret = 0;
555
556	free:
557	regfree(&regex);
558	end:
559	return ret;
560	}
cfa9a5a2 DG	561
	562	/*
	563	* fls: returns the position of the most significant bit.
	564	* Returns 0 if no bit is set, else returns the position of the most
	565	* significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
	566	*/
	567	#if defined(__i386) \|\| defined(__x86_64)
	568	static inline unsigned int fls_u32(uint32_t x)
	569	{
	570	int r;
	571
	572	asm("bsrl %1,%0\n\t"
	573	"jnz 1f\n\t"
	574	"movl $-1,%0\n\t"
	575	"1:\n\t"
	576	: "=r" (r) : "rm" (x));
	577	return r + 1;
	578	}
	579	#define HAS_FLS_U32
	580	#endif
	581
	582	#ifndef HAS_FLS_U32
	583	static __attribute__((unused)) unsigned int fls_u32(uint32_t x)
	584	{
	585	unsigned int r = 32;
	586
	587	if (!x) {
	588	return 0;
	589	}
	590	if (!(x & 0xFFFF0000U)) {
	591	x <<= 16;
	592	r -= 16;
	593	}
	594	if (!(x & 0xFF000000U)) {
	595	x <<= 8;
	596	r -= 8;
	597	}
	598	if (!(x & 0xF0000000U)) {
	599	x <<= 4;
	600	r -= 4;
	601	}
	602	if (!(x & 0xC0000000U)) {
	603	x <<= 2;
	604	r -= 2;
	605	}
	606	if (!(x & 0x80000000U)) {
	607	x <<= 1;
	608	r -= 1;
	609	}
	610	return r;
	611	}
	612	#endif
	613
	614	/*
	615	* Return the minimum order for which x <= (1UL << order).
	616	* Return -1 if x is 0.
	617	*/
	618	LTTNG_HIDDEN
	619	int utils_get_count_order_u32(uint32_t x)
	620	{
	621	if (!x) {
	622	return -1;
	623	}
	624
625	return fls_u32(x - 1);
626	}
feb0f3e5 AM	627
	628	/**
	629	* Obtain the value of LTTNG_HOME environment variable, if exists.
	630	* Otherwise returns the value of HOME.
	631	*/
00a52467	632	LTTNG_HIDDEN
feb0f3e5 AM	633	char *utils_get_home_dir(void)
	634	{
	635	char *val = NULL;
	636	val = getenv(DEFAULT_LTTNG_HOME_ENV_VAR);
	637	if (val != NULL) {
	638	return val;
	639	}
	640	return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR);
	641	}
26fe5938 DG	642
	643	/*
	644	* With the given format, fill dst with the time of len maximum siz.
	645	*
	646	* Return amount of bytes set in the buffer or else 0 on error.
	647	*/
	648	LTTNG_HIDDEN
	649	size_t utils_get_current_time_str(const char format, char dst, size_t len)
	650	{
	651	size_t ret;
	652	time_t rawtime;
	653	struct tm *timeinfo;
	654
	655	assert(format);
	656	assert(dst);
	657
	658	/* Get date and time for session path */
	659	time(&rawtime);
	660	timeinfo = localtime(&rawtime);
	661	ret = strftime(dst, len, format, timeinfo);
	662	if (ret == 0) {
	663	ERR("Unable to strftime with format %s at dst %p of len %lu", format,
	664	dst, len);
	665	}
	666
	667	return ret;
	668	}