Change the utils_expand_path function to use utils_partial_realpath
[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>
6c71277b 30#include <grp.h>
81b86775
DG
31
32#include <common/common.h>
fe4477ee 33#include <common/runas.h>
81b86775
DG
34
35#include "utils.h"
feb0f3e5 36#include "defaults.h"
81b86775 37
5154230f
RB
38/*
39 * Return a partial realpath(3) of the path even if the full path does not
40 * exist. For instance, with /tmp/test1/test2/test3, if test2/ does not exist
41 * but the /tmp/test1 does, the real path for /tmp/test1 is concatened with
42 * /test2/test3 then returned. In normal time, realpath(3) fails if the end
43 * point directory does not exist.
44 * In case resolved_path is NULL, the string returned was allocated in the
45 * function and thus need to be freed by the caller. The size argument allows
46 * to specify the size of the resolved_path argument if given, or the size to
47 * allocate.
48 */
49LTTNG_HIDDEN
50char *utils_partial_realpath(const char *path, char *resolved_path, size_t size)
51{
52 char *cut_path, *try_path = NULL, *try_path_prev = NULL;
53 const char *next, *prev, *end;
54
55 /* Safety net */
56 if (path == NULL) {
57 goto error;
58 }
59
60 /*
61 * Identify the end of the path, we don't want to treat the
62 * last char if it is a '/', we will just keep it on the side
63 * to be added at the end, and return a value coherent with
64 * the path given as argument
65 */
66 end = path + strlen(path);
67 if (*(end-1) == '/') {
68 end--;
69 }
70
71 /* Initiate the values of the pointers before looping */
72 next = path;
73 prev = next;
74 /* Only to ensure try_path is not NULL to enter the while */
75 try_path = (char *)next;
76
77 /* Resolve the canonical path of the first part of the path */
78 while (try_path != NULL && next != end) {
79 /*
80 * If there is not any '/' left, we want to try with
81 * the full path
82 */
83 next = strpbrk(next + 1, "/");
84 if (next == NULL) {
85 next = end;
86 }
87
88 /* Cut the part we will be trying to resolve */
89 cut_path = strndup(path, next - path);
90
91 /* Try to resolve this part */
92 try_path = realpath((char *)cut_path, NULL);
93 if (try_path == NULL) {
94 /*
95 * There was an error, we just want to be assured it
96 * is linked to an unexistent directory, if it's another
97 * reason, we spawn an error
98 */
99 switch (errno) {
100 case ENOENT:
101 /* Ignore the error */
102 break;
103 default:
104 PERROR("realpath (partial_realpath)");
105 goto error;
106 break;
107 }
108 } else {
109 /* Save the place we are before trying the next step */
110 free(try_path_prev);
111 try_path_prev = try_path;
112 prev = next;
113 }
114
115 /* Free the allocated memory */
116 free(cut_path);
117 };
118
119 /* Allocate memory for the resolved path if necessary */
120 if (resolved_path == NULL) {
121 resolved_path = zmalloc(size);
122 if (resolved_path == NULL) {
123 PERROR("zmalloc resolved path");
124 goto error;
125 }
126 }
127
128 /*
129 * If we were able to solve at least partially the path, we can concatenate
130 * what worked and what didn't work
131 */
132 if (try_path_prev != NULL) {
133 /* If we risk to concatenate two '/', we remove one of them */
134 if (try_path_prev[strlen(try_path_prev) - 1] == '/' && prev[0] == '/') {
135 try_path_prev[strlen(try_path_prev) - 1] = '\0';
136 }
137
138 /*
139 * Duplicate the memory used by prev in case resolved_path and
140 * path are pointers for the same memory space
141 */
142 cut_path = strdup(prev);
143
144 /* Concatenate the strings */
145 snprintf(resolved_path, size, "%s%s", try_path_prev, cut_path);
146
147 /* Free the allocated memory */
148 free(cut_path);
149 free(try_path_prev);
150 /*
151 * Else, we just copy the path in our resolved_path to
152 * return it as is
153 */
154 } else {
155 strncpy(resolved_path, path, size);
156 }
157
158 /* Then we return the 'partially' resolved path */
159 return resolved_path;
160
161error:
162 free(resolved_path);
163 return NULL;
164}
165
a2e78ff0
RB
166/*
167 * Resolve the './' and '../' strings in the middle of a path using
168 * our very own way to do it, so that it works even if the directory
169 * does not exist
170 */
171LTTNG_HIDDEN
172char *utils_resolve_relative(const char *path)
173{
174 char *next, *previous, *slash, *start_path, *absolute_path = NULL;
175
176 /* Safety net */
177 if (path == NULL) {
178 goto error;
179 }
180
181 /* Allocate memory for the absolute path */
182 absolute_path = zmalloc(PATH_MAX);
183 if (absolute_path == NULL) {
184 PERROR("zmalloc expand path");
185 goto error;
186 }
187
188 /* Copy the path in the absolute path */
189 strncpy(absolute_path, path, PATH_MAX);
190
191 /* As long as we find '/./' in the path string */
192 while ((next = strstr(absolute_path, "/./"))) {
193
194 /* We prepare the start_path not containing it */
195 start_path = strndup(absolute_path, next - absolute_path);
196
197 /* And we concatenate it with the part after this string */
198 snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 2);
199
200 free(start_path);
201 }
202
203 /* As long as we find '/../' in the path string */
204 while ((next = strstr(absolute_path, "/../"))) {
205 /* If the path starts with '/../', there's a problem */
206 if (next == absolute_path) {
207 ERR("%s: Path cannot be resolved", path);
208 goto error;
209 }
210
211 /* We find the last level of directory */
212 previous = absolute_path;
213 while ((slash = strpbrk(previous + 1, "/")) && slash != next) {
214 previous = slash;
215 }
216
217 /* Then we prepare the start_path not containing it */
218 start_path = strndup(absolute_path, previous - absolute_path);
219
220 /* And we concatenate it with the part after the '/../' */
221 snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 3);
222
223 free(start_path);
224 }
225
226 return absolute_path;
227
228error:
229 free(absolute_path);
230 return NULL;
231}
232
81b86775 233/*
3d229795
RB
234 * Make a full resolution of the given path even if it doesn't exist.
235 * This function uses the utils_partial_realpath function to resolve
236 * symlinks and relatives paths at the start of the string, and
237 * implements functionnalities to resolve the './' and '../' strings
238 * in the middle of a path. This function is only necessary because
239 * realpath(3) does not accept to resolve unexistent paths.
240 * The returned string was allocated in the function, it is thus of
241 * the responsibility of the caller to free this memory.
81b86775 242 */
90e535ef 243LTTNG_HIDDEN
81b86775
DG
244char *utils_expand_path(const char *path)
245{
3d229795 246 char *next, *previous, *slash, *start_path, *absolute_path = NULL;
81b86775
DG
247
248 /* Safety net */
249 if (path == NULL) {
250 goto error;
251 }
252
3d229795
RB
253 /* Allocate memory for the absolute_path */
254 absolute_path = zmalloc(PATH_MAX);
255 if (absolute_path == NULL) {
81b86775
DG
256 PERROR("zmalloc expand path");
257 goto error;
258 }
259
3d229795
RB
260 /*
261 * If the path is not already absolute nor explicitly relative,
262 * consider we're in the current directory
263 */
264 if (*path != '/' && strncmp(path, "./", 2) != 0 &&
265 strncmp(path, "../", 3) != 0) {
266 snprintf(absolute_path, PATH_MAX, "./%s", path);
267 /* Else, we just copy the path */
116f95d9 268 } else {
3d229795
RB
269 strncpy(absolute_path, path, PATH_MAX);
270 }
116f95d9 271
3d229795
RB
272 /* Resolve partially our path */
273 absolute_path = utils_partial_realpath(absolute_path,
274 absolute_path, PATH_MAX);
116f95d9 275
3d229795
RB
276 /* As long as we find '/./' in the working_path string */
277 while ((next = strstr(absolute_path, "/./"))) {
116f95d9 278
3d229795
RB
279 /* We prepare the start_path not containing it */
280 start_path = strndup(absolute_path, next - absolute_path);
116f95d9 281
3d229795
RB
282 /* And we concatenate it with the part after this string */
283 snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 2);
116f95d9 284
3d229795
RB
285 free(start_path);
286 }
116f95d9 287
3d229795
RB
288 /* As long as we find '/../' in the working_path string */
289 while ((next = strstr(absolute_path, "/../"))) {
290 /* We find the last level of directory */
291 previous = absolute_path;
292 while ((slash = strpbrk(previous, "/")) && slash != next) {
293 previous = slash + 1;
81b86775 294 }
81b86775 295
3d229795
RB
296 /* Then we prepare the start_path not containing it */
297 start_path = strndup(absolute_path, previous - absolute_path);
298
299 /* And we concatenate it with the part after the '/../' */
300 snprintf(absolute_path, PATH_MAX, "%s%s", start_path, next + 4);
301
302 /* We can free the memory used for the start path*/
303 free(start_path);
304
305 /* Then we verify for symlinks using partial_realpath */
306 absolute_path = utils_partial_realpath(absolute_path,
307 absolute_path, PATH_MAX);
116f95d9 308 }
81b86775 309
3d229795 310 return absolute_path;
81b86775
DG
311
312error:
3d229795 313 free(absolute_path);
81b86775
DG
314 return NULL;
315}
316
317/*
318 * Create a pipe in dst.
319 */
90e535ef 320LTTNG_HIDDEN
81b86775
DG
321int utils_create_pipe(int *dst)
322{
323 int ret;
324
325 if (dst == NULL) {
326 return -1;
327 }
328
329 ret = pipe(dst);
330 if (ret < 0) {
331 PERROR("create pipe");
332 }
333
334 return ret;
335}
336
337/*
338 * Create pipe and set CLOEXEC flag to both fd.
339 *
340 * Make sure the pipe opened by this function are closed at some point. Use
341 * utils_close_pipe().
342 */
90e535ef 343LTTNG_HIDDEN
81b86775
DG
344int utils_create_pipe_cloexec(int *dst)
345{
346 int ret, i;
347
348 if (dst == NULL) {
349 return -1;
350 }
351
352 ret = utils_create_pipe(dst);
353 if (ret < 0) {
354 goto error;
355 }
356
357 for (i = 0; i < 2; i++) {
358 ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
359 if (ret < 0) {
360 PERROR("fcntl pipe cloexec");
361 goto error;
362 }
363 }
364
365error:
366 return ret;
367}
368
094f381c
MD
369/*
370 * Create pipe and set fd flags to FD_CLOEXEC and O_NONBLOCK.
371 *
372 * Make sure the pipe opened by this function are closed at some point. Use
373 * utils_close_pipe(). Using pipe() and fcntl rather than pipe2() to
374 * support OSes other than Linux 2.6.23+.
375 */
376LTTNG_HIDDEN
377int utils_create_pipe_cloexec_nonblock(int *dst)
378{
379 int ret, i;
380
381 if (dst == NULL) {
382 return -1;
383 }
384
385 ret = utils_create_pipe(dst);
386 if (ret < 0) {
387 goto error;
388 }
389
390 for (i = 0; i < 2; i++) {
391 ret = fcntl(dst[i], F_SETFD, FD_CLOEXEC);
392 if (ret < 0) {
393 PERROR("fcntl pipe cloexec");
394 goto error;
395 }
396 /*
397 * Note: we override any flag that could have been
398 * previously set on the fd.
399 */
400 ret = fcntl(dst[i], F_SETFL, O_NONBLOCK);
401 if (ret < 0) {
402 PERROR("fcntl pipe nonblock");
403 goto error;
404 }
405 }
406
407error:
408 return ret;
409}
410
81b86775
DG
411/*
412 * Close both read and write side of the pipe.
413 */
90e535ef 414LTTNG_HIDDEN
81b86775
DG
415void utils_close_pipe(int *src)
416{
417 int i, ret;
418
419 if (src == NULL) {
420 return;
421 }
422
423 for (i = 0; i < 2; i++) {
424 /* Safety check */
425 if (src[i] < 0) {
426 continue;
427 }
428
429 ret = close(src[i]);
430 if (ret) {
431 PERROR("close pipe");
432 }
433 }
434}
a4b92340
DG
435
436/*
437 * Create a new string using two strings range.
438 */
90e535ef 439LTTNG_HIDDEN
a4b92340
DG
440char *utils_strdupdelim(const char *begin, const char *end)
441{
442 char *str;
443
444 str = zmalloc(end - begin + 1);
445 if (str == NULL) {
446 PERROR("zmalloc strdupdelim");
447 goto error;
448 }
449
450 memcpy(str, begin, end - begin);
451 str[end - begin] = '\0';
452
453error:
454 return str;
455}
b662582b
DG
456
457/*
458 * Set CLOEXEC flag to the give file descriptor.
459 */
90e535ef 460LTTNG_HIDDEN
b662582b
DG
461int utils_set_fd_cloexec(int fd)
462{
463 int ret;
464
465 if (fd < 0) {
466 ret = -EINVAL;
467 goto end;
468 }
469
470 ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
471 if (ret < 0) {
472 PERROR("fcntl cloexec");
473 ret = -errno;
474 }
475
476end:
477 return ret;
478}
35f90c40
DG
479
480/*
481 * Create pid file to the given path and filename.
482 */
90e535ef 483LTTNG_HIDDEN
35f90c40
DG
484int utils_create_pid_file(pid_t pid, const char *filepath)
485{
486 int ret;
487 FILE *fp;
488
489 assert(filepath);
490
491 fp = fopen(filepath, "w");
492 if (fp == NULL) {
493 PERROR("open pid file %s", filepath);
494 ret = -1;
495 goto error;
496 }
497
498 ret = fprintf(fp, "%d\n", pid);
499 if (ret < 0) {
500 PERROR("fprintf pid file");
501 }
502
503 fclose(fp);
504 DBG("Pid %d written in file %s", pid, filepath);
505error:
506 return ret;
507}
2d851108
DG
508
509/*
510 * Recursively create directory using the given path and mode.
511 *
512 * On success, return 0 else a negative error code.
513 */
90e535ef 514LTTNG_HIDDEN
2d851108
DG
515int utils_mkdir_recursive(const char *path, mode_t mode)
516{
517 char *p, tmp[PATH_MAX];
2d851108
DG
518 size_t len;
519 int ret;
520
521 assert(path);
522
523 ret = snprintf(tmp, sizeof(tmp), "%s", path);
524 if (ret < 0) {
525 PERROR("snprintf mkdir");
526 goto error;
527 }
528
529 len = ret;
530 if (tmp[len - 1] == '/') {
531 tmp[len - 1] = 0;
532 }
533
534 for (p = tmp + 1; *p; p++) {
535 if (*p == '/') {
536 *p = 0;
537 if (tmp[strlen(tmp) - 1] == '.' &&
538 tmp[strlen(tmp) - 2] == '.' &&
539 tmp[strlen(tmp) - 3] == '/') {
540 ERR("Using '/../' is not permitted in the trace path (%s)",
541 tmp);
542 ret = -1;
543 goto error;
544 }
0c7bcad5 545 ret = mkdir(tmp, mode);
2d851108 546 if (ret < 0) {
0c7bcad5
MD
547 if (errno != EEXIST) {
548 PERROR("mkdir recursive");
549 ret = -errno;
550 goto error;
2d851108
DG
551 }
552 }
553 *p = '/';
554 }
555 }
556
557 ret = mkdir(tmp, mode);
558 if (ret < 0) {
559 if (errno != EEXIST) {
560 PERROR("mkdir recursive last piece");
561 ret = -errno;
562 } else {
563 ret = 0;
564 }
565 }
566
567error:
568 return ret;
569}
fe4477ee
JD
570
571/*
572 * Create the stream tracefile on disk.
573 *
574 * Return 0 on success or else a negative value.
575 */
bc182241 576LTTNG_HIDDEN
07b86b52 577int utils_create_stream_file(const char *path_name, char *file_name, uint64_t size,
309167d2 578 uint64_t count, int uid, int gid, char *suffix)
fe4477ee 579{
be96a7d1 580 int ret, out_fd, flags, mode;
309167d2
JD
581 char full_path[PATH_MAX], *path_name_suffix = NULL, *path;
582 char *extra = NULL;
fe4477ee
JD
583
584 assert(path_name);
585 assert(file_name);
586
587 ret = snprintf(full_path, sizeof(full_path), "%s/%s",
588 path_name, file_name);
589 if (ret < 0) {
590 PERROR("snprintf create output file");
591 goto error;
592 }
593
309167d2
JD
594 /* Setup extra string if suffix or/and a count is needed. */
595 if (size > 0 && suffix) {
596 ret = asprintf(&extra, "_%" PRIu64 "%s", count, suffix);
597 } else if (size > 0) {
598 ret = asprintf(&extra, "_%" PRIu64, count);
599 } else if (suffix) {
600 ret = asprintf(&extra, "%s", suffix);
601 }
602 if (ret < 0) {
603 PERROR("Allocating extra string to name");
604 goto error;
605 }
606
fe4477ee
JD
607 /*
608 * If we split the trace in multiple files, we have to add the count at the
609 * end of the tracefile name
610 */
309167d2
JD
611 if (extra) {
612 ret = asprintf(&path_name_suffix, "%s%s", full_path, extra);
fe4477ee 613 if (ret < 0) {
309167d2
JD
614 PERROR("Allocating path name with extra string");
615 goto error_free_suffix;
fe4477ee 616 }
309167d2 617 path = path_name_suffix;
fe4477ee
JD
618 } else {
619 path = full_path;
620 }
621
be96a7d1 622 flags = O_WRONLY | O_CREAT | O_TRUNC;
0f907de1 623 /* Open with 660 mode */
be96a7d1
DG
624 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
625
626 if (uid < 0 || gid < 0) {
627 out_fd = open(path, flags, mode);
628 } else {
629 out_fd = run_as_open(path, flags, mode, uid, gid);
630 }
fe4477ee
JD
631 if (out_fd < 0) {
632 PERROR("open stream path %s", path);
633 goto error_open;
634 }
635 ret = out_fd;
636
637error_open:
309167d2
JD
638 free(path_name_suffix);
639error_free_suffix:
640 free(extra);
fe4477ee
JD
641error:
642 return ret;
643}
644
645/*
646 * Change the output tracefile according to the given size and count The
647 * new_count pointer is set during this operation.
648 *
649 * From the consumer, the stream lock MUST be held before calling this function
650 * because we are modifying the stream status.
651 *
652 * Return 0 on success or else a negative value.
653 */
bc182241 654LTTNG_HIDDEN
fe4477ee 655int utils_rotate_stream_file(char *path_name, char *file_name, uint64_t size,
309167d2
JD
656 uint64_t count, int uid, int gid, int out_fd, uint64_t *new_count,
657 int *stream_fd)
fe4477ee
JD
658{
659 int ret;
660
309167d2
JD
661 assert(new_count);
662 assert(stream_fd);
663
fe4477ee
JD
664 ret = close(out_fd);
665 if (ret < 0) {
666 PERROR("Closing tracefile");
667 goto error;
668 }
669
670 if (count > 0) {
671 *new_count = (*new_count + 1) % count;
672 } else {
673 (*new_count)++;
674 }
675
309167d2
JD
676 ret = utils_create_stream_file(path_name, file_name, size, *new_count,
677 uid, gid, 0);
678 if (ret < 0) {
679 goto error;
680 }
681 *stream_fd = ret;
682
683 /* Success. */
684 ret = 0;
685
fe4477ee
JD
686error:
687 return ret;
688}
70d0b120
SM
689
690/**
691 * Prints the error message corresponding to a regex error code.
692 *
693 * @param errcode The error code.
694 * @param regex The regex object that produced the error code.
695 */
696static void regex_print_error(int errcode, regex_t *regex)
697{
698 /* Get length of error message and allocate accordingly */
699 size_t length;
700 char *buffer;
701
702 assert(regex != NULL);
703
704 length = regerror(errcode, regex, NULL, 0);
705 if (length == 0) {
706 ERR("regerror returned a length of 0");
707 return;
708 }
709
710 buffer = zmalloc(length);
711 if (!buffer) {
712 ERR("regex_print_error: zmalloc failed");
713 return;
714 }
715
716 /* Get and print error message */
717 regerror(errcode, regex, buffer, length);
718 ERR("regex error: %s\n", buffer);
719 free(buffer);
720
721}
722
723/**
724 * Parse a string that represents a size in human readable format. It
725 * supports decimal integers suffixed by 'k', 'M' or 'G'.
726 *
727 * The suffix multiply the integer by:
728 * 'k': 1024
729 * 'M': 1024^2
730 * 'G': 1024^3
731 *
732 * @param str The string to parse.
733 * @param size Pointer to a size_t that will be filled with the
cfa9a5a2 734 * resulting size.
70d0b120
SM
735 *
736 * @return 0 on success, -1 on failure.
737 */
00a52467 738LTTNG_HIDDEN
70d0b120
SM
739int utils_parse_size_suffix(char *str, uint64_t *size)
740{
741 regex_t regex;
742 int ret;
743 const int nmatch = 3;
744 regmatch_t suffix_match, matches[nmatch];
745 unsigned long long base_size;
746 long shift = 0;
747
748 if (!str) {
749 return 0;
750 }
751
752 /* Compile regex */
753 ret = regcomp(&regex, "^\\(0x\\)\\{0,1\\}[0-9][0-9]*\\([kKMG]\\{0,1\\}\\)$", 0);
754 if (ret != 0) {
755 regex_print_error(ret, &regex);
756 ret = -1;
757 goto end;
758 }
759
760 /* Match regex */
761 ret = regexec(&regex, str, nmatch, matches, 0);
762 if (ret != 0) {
763 ret = -1;
764 goto free;
765 }
766
767 /* There is a match ! */
768 errno = 0;
769 base_size = strtoull(str, NULL, 0);
770 if (errno != 0) {
771 PERROR("strtoull");
772 ret = -1;
773 goto free;
774 }
775
776 /* Check if there is a suffix */
777 suffix_match = matches[2];
778 if (suffix_match.rm_eo - suffix_match.rm_so == 1) {
779 switch (*(str + suffix_match.rm_so)) {
780 case 'K':
781 case 'k':
782 shift = KIBI_LOG2;
783 break;
784 case 'M':
785 shift = MEBI_LOG2;
786 break;
787 case 'G':
788 shift = GIBI_LOG2;
789 break;
790 default:
791 ERR("parse_human_size: invalid suffix");
792 ret = -1;
793 goto free;
794 }
795 }
796
797 *size = base_size << shift;
798
799 /* Check for overflow */
800 if ((*size >> shift) != base_size) {
801 ERR("parse_size_suffix: oops, overflow detected.");
802 ret = -1;
803 goto free;
804 }
805
806 ret = 0;
807
808free:
809 regfree(&regex);
810end:
811 return ret;
812}
cfa9a5a2
DG
813
814/*
815 * fls: returns the position of the most significant bit.
816 * Returns 0 if no bit is set, else returns the position of the most
817 * significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
818 */
819#if defined(__i386) || defined(__x86_64)
820static inline unsigned int fls_u32(uint32_t x)
821{
822 int r;
823
824 asm("bsrl %1,%0\n\t"
825 "jnz 1f\n\t"
826 "movl $-1,%0\n\t"
827 "1:\n\t"
828 : "=r" (r) : "rm" (x));
829 return r + 1;
830}
831#define HAS_FLS_U32
832#endif
833
834#ifndef HAS_FLS_U32
835static __attribute__((unused)) unsigned int fls_u32(uint32_t x)
836{
837 unsigned int r = 32;
838
839 if (!x) {
840 return 0;
841 }
842 if (!(x & 0xFFFF0000U)) {
843 x <<= 16;
844 r -= 16;
845 }
846 if (!(x & 0xFF000000U)) {
847 x <<= 8;
848 r -= 8;
849 }
850 if (!(x & 0xF0000000U)) {
851 x <<= 4;
852 r -= 4;
853 }
854 if (!(x & 0xC0000000U)) {
855 x <<= 2;
856 r -= 2;
857 }
858 if (!(x & 0x80000000U)) {
859 x <<= 1;
860 r -= 1;
861 }
862 return r;
863}
864#endif
865
866/*
867 * Return the minimum order for which x <= (1UL << order).
868 * Return -1 if x is 0.
869 */
870LTTNG_HIDDEN
871int utils_get_count_order_u32(uint32_t x)
872{
873 if (!x) {
874 return -1;
875 }
876
877 return fls_u32(x - 1);
878}
feb0f3e5
AM
879
880/**
881 * Obtain the value of LTTNG_HOME environment variable, if exists.
882 * Otherwise returns the value of HOME.
883 */
00a52467 884LTTNG_HIDDEN
feb0f3e5
AM
885char *utils_get_home_dir(void)
886{
887 char *val = NULL;
888 val = getenv(DEFAULT_LTTNG_HOME_ENV_VAR);
889 if (val != NULL) {
890 return val;
891 }
892 return getenv(DEFAULT_LTTNG_FALLBACK_HOME_ENV_VAR);
893}
26fe5938
DG
894
895/*
896 * With the given format, fill dst with the time of len maximum siz.
897 *
898 * Return amount of bytes set in the buffer or else 0 on error.
899 */
900LTTNG_HIDDEN
901size_t utils_get_current_time_str(const char *format, char *dst, size_t len)
902{
903 size_t ret;
904 time_t rawtime;
905 struct tm *timeinfo;
906
907 assert(format);
908 assert(dst);
909
910 /* Get date and time for session path */
911 time(&rawtime);
912 timeinfo = localtime(&rawtime);
913 ret = strftime(dst, len, format, timeinfo);
914 if (ret == 0) {
915 ERR("Unable to strftime with format %s at dst %p of len %lu", format,
916 dst, len);
917 }
918
919 return ret;
920}
6c71277b
MD
921
922/*
923 * Return the group ID matching name, else 0 if it cannot be found.
924 */
925LTTNG_HIDDEN
926gid_t utils_get_group_id(const char *name)
927{
928 struct group *grp;
929
930 grp = getgrnam(name);
931 if (!grp) {
932 static volatile int warn_once;
933
934 if (!warn_once) {
935 WARN("No tracing group detected");
936 warn_once = 1;
937 }
938 return 0;
939 }
940 return grp->gr_gid;
941}
This page took 0.108627 seconds and 4 git commands to generate.