#include <unistd.h>
#include <common/common.h>
+#include <common/readwrite.h>
#include <common/runas.h>
#include <common/compat/getenv.h>
#include <common/compat/string.h>
#include <common/compat/dirent.h>
+#include <common/compat/directory-handle.h>
#include <lttng/constant.h>
#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
}
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;
path_last_char = &path[path_len];
if (path_len == 0) {
- path = NULL;
goto error;
}
}
path[expanded_path_len] = '\0';
-
+ return 0;
error:
- return path;
+ return -1;
}
/*
int ret;
char *absolute_path = NULL;
char *last_token;
- int is_dot, is_dotdot;
+ bool is_dot, is_dotdot;
/* Safety net */
if (path == NULL) {
absolute_path, LTTNG_PATH_MAX);
}
- 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;
}
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.
*
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;
- }
-
-error:
+ struct lttng_directory_handle handle;
+ struct lttng_credentials creds = {
+ .uid = (uid_t) uid,
+ .gid = (gid_t) gid,
+ };
+
+ (void) lttng_directory_handle_init(&handle, NULL);
+ ret = lttng_directory_handle_create_subdirectory_as_user(
+ &handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+ lttng_directory_handle_fini(&handle);
return ret;
}
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);
- }
-
+ struct lttng_directory_handle handle;
+ struct lttng_credentials creds = {
+ .uid = (uid_t) uid,
+ .gid = (gid_t) gid,
+ };
+
+ (void) lttng_directory_handle_init(&handle, NULL);
+ ret = lttng_directory_handle_create_subdirectory_recursive_as_user(
+ &handle, path, mode,
+ (uid >= 0 || gid >= 0) ? &creds : NULL);
+ lttng_directory_handle_fini(&handle);
return ret;
}
/**
* 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.
*
{
int ret;
uint64_t base_time;
- long multiplier = 1;
+ uint64_t multiplier = 1;
const char *str_end;
char *num_end;
/* 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':
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);
+}