ust consumer: data_pending check is endpoint active
[lttng-tools.git] / src / common / utils.c
CommitLineData
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
31#include <common/common.h>
fe4477ee 32#include <common/runas.h>
81b86775
DG
33
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 43LTTNG_HIDDEN
81b86775
DG
44char *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
87error:
88 free(expanded_path);
89 free(cut_path);
90 return NULL;
91}
92
93/*
94 * Create a pipe in dst.
95 */
90e535ef 96LTTNG_HIDDEN
81b86775
DG
97int 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 119LTTNG_HIDDEN
81b86775
DG
120int 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
141error:
142 return ret;
143}
144
145/*
146 * Close both read and write side of the pipe.
147 */
90e535ef 148LTTNG_HIDDEN
81b86775
DG
149void utils_close_pipe(int *src)
150{
151 int i, ret;
152
153 if (src == NULL) {
154 return;
155 }
156
157 for (i = 0; i < 2; i++) {
158 /* Safety check */
159 if (src[i] < 0) {
160 continue;
161 }
162
163 ret = close(src[i]);
164 if (ret) {
165 PERROR("close pipe");
166 }
167 }
168}
a4b92340
DG
169
170/*
171 * Create a new string using two strings range.
172 */
90e535ef 173LTTNG_HIDDEN
a4b92340
DG
174char *utils_strdupdelim(const char *begin, const char *end)
175{
176 char *str;
177
178 str = zmalloc(end - begin + 1);
179 if (str == NULL) {
180 PERROR("zmalloc strdupdelim");
181 goto error;
182 }
183
184 memcpy(str, begin, end - begin);
185 str[end - begin] = '\0';
186
187error:
188 return str;
189}
b662582b
DG
190
191/*
192 * Set CLOEXEC flag to the give file descriptor.
193 */
90e535ef 194LTTNG_HIDDEN
b662582b
DG
195int utils_set_fd_cloexec(int fd)
196{
197 int ret;
198
199 if (fd < 0) {
200 ret = -EINVAL;
201 goto end;
202 }
203
204 ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
205 if (ret < 0) {
206 PERROR("fcntl cloexec");
207 ret = -errno;
208 }
209
210end:
211 return ret;
212}
35f90c40
DG
213
214/*
215 * Create pid file to the given path and filename.
216 */
90e535ef 217LTTNG_HIDDEN
35f90c40
DG
218int utils_create_pid_file(pid_t pid, const char *filepath)
219{
220 int ret;
221 FILE *fp;
222
223 assert(filepath);
224
225 fp = fopen(filepath, "w");
226 if (fp == NULL) {
227 PERROR("open pid file %s", filepath);
228 ret = -1;
229 goto error;
230 }
231
232 ret = fprintf(fp, "%d\n", pid);
233 if (ret < 0) {
234 PERROR("fprintf pid file");
235 }
236
237 fclose(fp);
238 DBG("Pid %d written in file %s", pid, filepath);
239error:
240 return ret;
241}
2d851108
DG
242
243/*
244 * Recursively create directory using the given path and mode.
245 *
246 * On success, return 0 else a negative error code.
247 */
90e535ef 248LTTNG_HIDDEN
2d851108
DG
249int utils_mkdir_recursive(const char *path, mode_t mode)
250{
251 char *p, tmp[PATH_MAX];
2d851108
DG
252 size_t len;
253 int ret;
254
255 assert(path);
256
257 ret = snprintf(tmp, sizeof(tmp), "%s", path);
258 if (ret < 0) {
259 PERROR("snprintf mkdir");
260 goto error;
261 }
262
263 len = ret;
264 if (tmp[len - 1] == '/') {
265 tmp[len - 1] = 0;
266 }
267
268 for (p = tmp + 1; *p; p++) {
269 if (*p == '/') {
270 *p = 0;
271 if (tmp[strlen(tmp) - 1] == '.' &&
272 tmp[strlen(tmp) - 2] == '.' &&
273 tmp[strlen(tmp) - 3] == '/') {
274 ERR("Using '/../' is not permitted in the trace path (%s)",
275 tmp);
276 ret = -1;
277 goto error;
278 }
0c7bcad5 279 ret = mkdir(tmp, mode);
2d851108 280 if (ret < 0) {
0c7bcad5
MD
281 if (errno != EEXIST) {
282 PERROR("mkdir recursive");
283 ret = -errno;
284 goto error;
2d851108
DG
285 }
286 }
287 *p = '/';
288 }
289 }
290
291 ret = mkdir(tmp, mode);
292 if (ret < 0) {
293 if (errno != EEXIST) {
294 PERROR("mkdir recursive last piece");
295 ret = -errno;
296 } else {
297 ret = 0;
298 }
299 }
300
301error:
302 return ret;
303}
fe4477ee
JD
304
305/*
306 * Create the stream tracefile on disk.
307 *
308 * Return 0 on success or else a negative value.
309 */
bc182241 310LTTNG_HIDDEN
07b86b52 311int utils_create_stream_file(const char *path_name, char *file_name, uint64_t size,
fe4477ee
JD
312 uint64_t count, int uid, int gid)
313{
be96a7d1 314 int ret, out_fd, flags, mode;
fe4477ee
JD
315 char full_path[PATH_MAX], *path_name_id = NULL, *path;
316
317 assert(path_name);
318 assert(file_name);
319
320 ret = snprintf(full_path, sizeof(full_path), "%s/%s",
321 path_name, file_name);
322 if (ret < 0) {
323 PERROR("snprintf create output file");
324 goto error;
325 }
326
327 /*
328 * If we split the trace in multiple files, we have to add the count at the
329 * end of the tracefile name
330 */
331 if (size > 0) {
332 ret = asprintf(&path_name_id, "%s_%" PRIu64, full_path, count);
333 if (ret < 0) {
334 PERROR("Allocating path name ID");
335 goto error;
336 }
337 path = path_name_id;
338 } else {
339 path = full_path;
340 }
341
be96a7d1 342 flags = O_WRONLY | O_CREAT | O_TRUNC;
0f907de1 343 /* Open with 660 mode */
be96a7d1
DG
344 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
345
346 if (uid < 0 || gid < 0) {
347 out_fd = open(path, flags, mode);
348 } else {
349 out_fd = run_as_open(path, flags, mode, uid, gid);
350 }
fe4477ee
JD
351 if (out_fd < 0) {
352 PERROR("open stream path %s", path);
353 goto error_open;
354 }
355 ret = out_fd;
356
357error_open:
358 free(path_name_id);
359error:
360 return ret;
361}
362
363/*
364 * Change the output tracefile according to the given size and count The
365 * new_count pointer is set during this operation.
366 *
367 * From the consumer, the stream lock MUST be held before calling this function
368 * because we are modifying the stream status.
369 *
370 * Return 0 on success or else a negative value.
371 */
bc182241 372LTTNG_HIDDEN
fe4477ee
JD
373int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size,
374 uint64_t count, int uid, int gid, int out_fd, uint64_t *new_count)
375{
376 int ret;
377
378 ret = close(out_fd);
379 if (ret < 0) {
380 PERROR("Closing tracefile");
381 goto error;
382 }
383
384 if (count > 0) {
385 *new_count = (*new_count + 1) % count;
386 } else {
387 (*new_count)++;
388 }
389
390 return utils_create_stream_file(path_name, file_name, size, *new_count,
391 uid, gid);
392error:
393 return ret;
394}
70d0b120
SM
395
396/**
397 * Prints the error message corresponding to a regex error code.
398 *
399 * @param errcode The error code.
400 * @param regex The regex object that produced the error code.
401 */
402static void regex_print_error(int errcode, regex_t *regex)
403{
404 /* Get length of error message and allocate accordingly */
405 size_t length;
406 char *buffer;
407
408 assert(regex != NULL);
409
410 length = regerror(errcode, regex, NULL, 0);
411 if (length == 0) {
412 ERR("regerror returned a length of 0");
413 return;
414 }
415
416 buffer = zmalloc(length);
417 if (!buffer) {
418 ERR("regex_print_error: zmalloc failed");
419 return;
420 }
421
422 /* Get and print error message */
423 regerror(errcode, regex, buffer, length);
424 ERR("regex error: %s\n", buffer);
425 free(buffer);
426
427}
428
429/**
430 * Parse a string that represents a size in human readable format. It
431 * supports decimal integers suffixed by 'k', 'M' or 'G'.
432 *
433 * The suffix multiply the integer by:
434 * 'k': 1024
435 * 'M': 1024^2
436 * 'G': 1024^3
437 *
438 * @param str The string to parse.
439 * @param size Pointer to a size_t that will be filled with the
cfa9a5a2 440 * resulting size.
70d0b120
SM
441 *
442 * @return 0 on success, -1 on failure.
443 */
00a52467 444LTTNG_HIDDEN
70d0b120
SM
445int utils_parse_size_suffix(char *str, uint64_t *size)
446{
447 regex_t regex;
448 int ret;
449 const int nmatch = 3;
450 regmatch_t suffix_match, matches[nmatch];
451 unsigned long long base_size;
452 long shift = 0;
453
454 if (!str) {
455 return 0;
456 }
457
458 /* Compile regex */
459 ret = regcomp(&regex, "^\\(0x\\)\\{0,1\\}[0-9][0-9]*\\([kKMG]\\{0,1\\}\\)$", 0);
460 if (ret != 0) {
461 regex_print_error(ret, &regex);
462 ret = -1;
463 goto end;
464 }
465
466 /* Match regex */
467 ret = regexec(&regex, str, nmatch, matches, 0);
468 if (ret != 0) {
469 ret = -1;
470 goto free;
471 }
472
473 /* There is a match ! */
474 errno = 0;
475 base_size = strtoull(str, NULL, 0);
476 if (errno != 0) {
477 PERROR("strtoull");
478 ret = -1;
479 goto free;
480 }
481
482 /* Check if there is a suffix */
483 suffix_match = matches[2];
484 if (suffix_match.rm_eo - suffix_match.rm_so == 1) {
485 switch (*(str + suffix_match.rm_so)) {
486 case 'K':
487 case 'k':
488 shift = KIBI_LOG2;
489 break;
490 case 'M':
491 shift = MEBI_LOG2;
492 break;
493 case 'G':
494 shift = GIBI_LOG2;
495 break;
496 default:
497 ERR("parse_human_size: invalid suffix");
498 ret = -1;
499 goto free;
500 }
501 }
502
503 *size = base_size << shift;
504
505 /* Check for overflow */
506 if ((*size >> shift) != base_size) {
507 ERR("parse_size_suffix: oops, overflow detected.");
508 ret = -1;
509 goto free;
510 }
511
512 ret = 0;
513
514free:
515 regfree(&regex);
516end:
517 return ret;
518}
cfa9a5a2
DG
519
520/*
521 * fls: returns the position of the most significant bit.
522 * Returns 0 if no bit is set, else returns the position of the most
523 * significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
524 */
525#if defined(__i386) || defined(__x86_64)
526static inline unsigned int fls_u32(uint32_t x)
527{
528 int r;
529
530 asm("bsrl %1,%0\n\t"
531 "jnz 1f\n\t"
532 "movl $-1,%0\n\t"
533 "1:\n\t"
534 : "=r" (r) : "rm" (x));
535 return r + 1;
536}
537#define HAS_FLS_U32
538#endif
539
540#ifndef HAS_FLS_U32
541static __attribute__((unused)) unsigned int fls_u32(uint32_t x)
542{
543 unsigned int r = 32;
544
545 if (!x) {
546 return 0;
547 }
548 if (!(x & 0xFFFF0000U)) {
549 x <<= 16;
550 r -= 16;
551 }
552 if (!(x & 0xFF000000U)) {
553 x <<= 8;
554 r -= 8;
555 }
556 if (!(x & 0xF0000000U)) {
557 x <<= 4;
558 r -= 4;
559 }
560 if (!(x & 0xC0000000U)) {
561 x <<= 2;
562 r -= 2;
563 }
564 if (!(x & 0x80000000U)) {
565 x <<= 1;
566 r -= 1;
567 }
568 return r;
569}
570#endif
571
572/*
573 * Return the minimum order for which x <= (1UL << order).
574 * Return -1 if x is 0.
575 */
576LTTNG_HIDDEN
577int utils_get_count_order_u32(uint32_t x)
578{
579 if (!x) {
580 return -1;
581 }
582
583 return fls_u32(x - 1);
584}
feb0f3e5
AM
585
586/**
587 * Obtain the value of LTTNG_HOME environment variable, if exists.
588 * Otherwise returns the value of HOME.
589 */
00a52467 590LTTNG_HIDDEN
feb0f3e5
AM
591char *utils_get_home_dir(void)
592{
593 char *val = NULL;
594 val = getenv(DEFAULT_LTTNG_HOME_ENV_VAR);
595 if (val != NULL) {
596 return val;
597 }
598 return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR);
599}
26fe5938
DG
600
601/*
602 * With the given format, fill dst with the time of len maximum siz.
603 *
604 * Return amount of bytes set in the buffer or else 0 on error.
605 */
606LTTNG_HIDDEN
607size_t utils_get_current_time_str(const char *format, char *dst, size_t len)
608{
609 size_t ret;
610 time_t rawtime;
611 struct tm *timeinfo;
612
613 assert(format);
614 assert(dst);
615
616 /* Get date and time for session path */
617 time(&rawtime);
618 timeinfo = localtime(&rawtime);
619 ret = strftime(dst, len, format, timeinfo);
620 if (ret == 0) {
621 ERR("Unable to strftime with format %s at dst %p of len %lu", format,
622 dst, len);
623 }
624
625 return ret;
626}
This page took 0.079818 seconds and 4 git commands to generate.