*/
#define _GNU_SOURCE
-#include <fcntl.h>
#include <getopt.h>
#include <grp.h>
#include <limits.h>
#include <unistd.h>
#include <config.h>
-#include <bin/lttng-consumerd/lttng-consumerd.h>
-#include <common/lttngerr.h>
-#include <common/kernel-consumer/kernel-consumer.h>
-#include <common/ust-consumer/ust-consumer.h>
#include <common/common.h>
-#include <common/defaults.h>
#include <common/compat/poll.h>
+#include <common/compat/socket.h>
+#include <common/defaults.h>
+#include <common/kernel-consumer/kernel-consumer.h>
+#include <common/ust-consumer/ust-consumer.h>
#include "lttng-sessiond.h"
#include "channel.h"
#include "event.h"
#include "futex.h"
#include "kernel.h"
+#include "modprobe.h"
#include "shm.h"
#include "ust-ctl.h"
#include "utils.h"
/* Const values */
const char default_home_dir[] = DEFAULT_HOME_DIR;
-const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
+const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
/* Consumer daemon specific control data */
static struct consumer_data kconsumer_data = {
.type = LTTNG_CONSUMER_KERNEL,
- .err_unix_sock_path = KCONSUMERD_ERR_SOCK_PATH,
- .cmd_unix_sock_path = KCONSUMERD_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
};
static struct consumer_data ustconsumer64_data = {
.type = LTTNG_CONSUMER64_UST,
- .err_unix_sock_path = USTCONSUMERD64_ERR_SOCK_PATH,
- .cmd_unix_sock_path = USTCONSUMERD64_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
};
static struct consumer_data ustconsumer32_data = {
.type = LTTNG_CONSUMER32_UST,
- .err_unix_sock_path = USTCONSUMERD32_ERR_SOCK_PATH,
- .cmd_unix_sock_path = USTCONSUMERD32_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
};
static int dispatch_thread_exit;
if (bin) {
consumerd64_bin = bin;
}
- libdir = getenv("LTTNG_TOOLS_CONSUMERD32_LIBDIR");
+ libdir = getenv("LTTNG_CONSUMERD32_LIBDIR");
if (libdir) {
consumerd32_libdir = libdir;
}
- libdir = getenv("LTTNG_TOOLS_CONSUMERD64_LIBDIR");
+ libdir = getenv("LTTNG_CONSUMERD64_LIBDIR");
if (libdir) {
consumerd64_libdir = libdir;
}
return 0;
}
-/*
- * Remove modules in reverse load order.
- */
-static int modprobe_remove_kernel_modules(void)
-{
- int ret = 0, i;
- char modprobe[256];
-
- for (i = ARRAY_SIZE(kernel_modules_list) - 1; i >= 0; i--) {
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe -r -q %s",
- kernel_modules_list[i].name);
- if (ret < 0) {
- perror("snprintf modprobe -r");
- goto error;
- }
- modprobe[sizeof(modprobe) - 1] = '\0';
- ret = system(modprobe);
- if (ret == -1) {
- ERR("Unable to launch modprobe -r for module %s",
- kernel_modules_list[i].name);
- } else if (kernel_modules_list[i].required
- && WEXITSTATUS(ret) != 0) {
- ERR("Unable to remove module %s",
- kernel_modules_list[i].name);
- } else {
- DBG("Modprobe removal successful %s",
- kernel_modules_list[i].name);
- }
- }
-
-error:
- return ret;
-}
-
/*
* Return group ID of the tracing group or -1 if not found.
*/
*/
static int init_thread_quit_pipe(void)
{
- int ret;
+ int ret, i;
- ret = pipe2(thread_quit_pipe, O_CLOEXEC);
+ ret = pipe(thread_quit_pipe);
if (ret < 0) {
- perror("thread quit pipe");
+ PERROR("thread quit pipe");
goto error;
}
+ for (i = 0; i < 2; i++) {
+ ret = fcntl(thread_quit_pipe[i], F_SETFD, FD_CLOEXEC);
+ if (ret < 0) {
+ PERROR("fcntl");
+ goto error;
+ }
+ }
+
error:
return ret;
}
static void teardown_kernel_session(struct ltt_session *session)
{
if (!session->kernel_session) {
- DBG3("No kernel session when tearingdown session");
+ DBG3("No kernel session when tearing down session");
return;
}
int ret;
if (!session->ust_session) {
- DBG3("No UST session when tearingdown session");
+ DBG3("No UST session when tearing down session");
return;
}
}
free(cmd);
- DBG("Cleaning up all session");
+ DBG("Cleaning up all sessions");
/* Destroy session list mutex */
if (session_list_ptr != NULL) {
DBG2("Closing kernel fd");
close(kernel_tracer_fd);
DBG("Unloading kernel modules");
- modprobe_remove_kernel_modules();
+ modprobe_remove_lttng_all();
}
close(thread_quit_pipe[0]);
{
struct ltt_session *sess, *stmp;
+ session_lock_list();
+
/* For all tracing session(s) */
cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
+ session_lock(sess);
if (sess->ust_session) {
ust_app_global_update(sess->ust_session, app_sock);
}
+ session_unlock(sess);
}
+
+ session_unlock_list();
}
/*
}
/*
- * Add channel(s) and event(s) to newly registered apps
- * from lttng global UST domain.
+ * Validate UST version compatibility.
*/
- update_ust_app(ust_cmd.sock);
+ ret = ust_app_validate_version(ust_cmd.sock);
+ if (ret >= 0) {
+ /*
+ * Add channel(s) and event(s) to newly registered apps
+ * from lttng global UST domain.
+ */
+ update_ust_app(ust_cmd.sock);
+ }
ret = ust_app_register_done(ust_cmd.sock);
if (ret < 0) {
}
/*
- * modprobe_kernel_modules
+ * Check version of the lttng-modules.
*/
-static int modprobe_kernel_modules(void)
+static int validate_lttng_modules_version(void)
{
- int ret = 0, i;
- char modprobe[256];
-
- for (i = 0; i < ARRAY_SIZE(kernel_modules_list); i++) {
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe %s%s",
- kernel_modules_list[i].required ? "" : "-q ",
- kernel_modules_list[i].name);
- if (ret < 0) {
- perror("snprintf modprobe");
- goto error;
- }
- modprobe[sizeof(modprobe) - 1] = '\0';
- ret = system(modprobe);
- if (ret == -1) {
- ERR("Unable to launch modprobe for module %s",
- kernel_modules_list[i].name);
- } else if (kernel_modules_list[i].required
- && WEXITSTATUS(ret) != 0) {
- ERR("Unable to load module %s",
- kernel_modules_list[i].name);
- } else {
- DBG("Modprobe successfully %s",
- kernel_modules_list[i].name);
- }
- }
-
-error:
- return ret;
+ return kernel_validate_version(kernel_tracer_fd);
}
/*
- * mount_debugfs
+ * Setup necessary data for kernel tracer action.
*/
-static int mount_debugfs(char *path)
+static int init_kernel_tracer(void)
{
int ret;
- char *type = "debugfs";
- ret = run_as_mkdir_recursive(path, S_IRWXU | S_IRWXG, geteuid(), getegid());
- if (ret < 0) {
- PERROR("Cannot create debugfs path");
- goto error;
- }
-
- ret = mount(type, path, type, 0, NULL);
+ /* Modprobe lttng kernel modules */
+ ret = modprobe_lttng_control();
if (ret < 0) {
- PERROR("Cannot mount debugfs");
- goto error;
- }
-
- DBG("Mounted debugfs successfully at %s", path);
-
-error:
- return ret;
-}
-
-/*
- * Setup necessary data for kernel tracer action.
- */
-static void init_kernel_tracer(void)
-{
- int ret;
- char *proc_mounts = "/proc/mounts";
- char line[256];
- char *debugfs_path = NULL, *lttng_path = NULL;
- FILE *fp;
-
- /* Detect debugfs */
- fp = fopen(proc_mounts, "r");
- if (fp == NULL) {
- ERR("Unable to probe %s", proc_mounts);
goto error;
}
- while (fgets(line, sizeof(line), fp) != NULL) {
- if (strstr(line, "debugfs") != NULL) {
- /* Remove first string */
- strtok(line, " ");
- /* Dup string here so we can reuse line later on */
- debugfs_path = strdup(strtok(NULL, " "));
- DBG("Got debugfs path : %s", debugfs_path);
- break;
- }
- }
-
- fclose(fp);
-
- /* Mount debugfs if needded */
- if (debugfs_path == NULL) {
- ret = asprintf(&debugfs_path, "/mnt/debugfs");
- if (ret < 0) {
- perror("asprintf debugfs path");
- goto error;
- }
- ret = mount_debugfs(debugfs_path);
- if (ret < 0) {
- perror("Cannot mount debugfs");
- goto error;
- }
+ /* Open debugfs lttng */
+ kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
+ if (kernel_tracer_fd < 0) {
+ DBG("Failed to open %s", module_proc_lttng);
+ ret = -1;
+ goto error_open;
}
- /* Modprobe lttng kernel modules */
- ret = modprobe_kernel_modules();
+ /* Validate kernel version */
+ ret = validate_lttng_modules_version();
if (ret < 0) {
- goto error;
+ goto error_version;
}
- /* Setup lttng kernel path */
- ret = asprintf(<tng_path, "%s/lttng", debugfs_path);
+ ret = modprobe_lttng_data();
if (ret < 0) {
- perror("asprintf lttng path");
- goto error;
+ goto error_modules;
}
- /* Open debugfs lttng */
- kernel_tracer_fd = open(lttng_path, O_RDWR);
- if (kernel_tracer_fd < 0) {
- DBG("Failed to open %s", lttng_path);
- goto error;
- }
-
- free(lttng_path);
- free(debugfs_path);
DBG("Kernel tracer fd %d", kernel_tracer_fd);
- return;
+ return 0;
+
+error_version:
+ modprobe_remove_lttng_control();
+ close(kernel_tracer_fd);
+ kernel_tracer_fd = 0;
+ return LTTCOMM_KERN_VERSION;
+
+error_modules:
+ close(kernel_tracer_fd);
+
+error_open:
+ modprobe_remove_lttng_control();
error:
- if (lttng_path) {
- free(lttng_path);
- }
- if (debugfs_path) {
- free(debugfs_path);
- }
WARN("No kernel tracer available");
kernel_tracer_fd = 0;
- return;
+ return LTTCOMM_KERN_NA;
}
/*
case LTTNG_UST_FUNCTION:
tmp[i].type = LTTNG_EVENT_FUNCTION;
break;
- case LTTNG_UST_TRACEPOINT_LOGLEVEL:
- tmp[i].type = LTTNG_EVENT_TRACEPOINT_LOGLEVEL;
+ }
+ tmp[i].loglevel = uevent->attr.loglevel;
+ switch (uevent->attr.loglevel_type) {
+ case LTTNG_UST_LOGLEVEL_ALL:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
+ break;
+ case LTTNG_UST_LOGLEVEL_RANGE:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
+ break;
+ case LTTNG_UST_LOGLEVEL_SINGLE:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
break;
}
i++;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
- ret = LTTCOMM_NOT_IMPLEMENTED;
- goto error;
+#endif
default:
ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
- ret = LTTCOMM_NOT_IMPLEMENTED;
- goto error;
+#endif
default:
ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
channel_name);
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
/*
* Command LTTNG_ENABLE_EVENT processed by the client thread.
- *
- * TODO: currently, both events and loglevels are kept within the same
- * namespace for UST global registry/app registery, so if an event
- * happen to have the same name as the loglevel (very unlikely though),
- * and an attempt is made to enable/disable both in the same session,
- * the first to be created will be the only one allowed to exist.
*/
static int cmd_enable_event(struct ltt_session *session, int domain,
char *channel_name, struct lttng_event *event)
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
}
break;
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
/*
* Command LTTNG_CREATE_SESSION processed by the client thread.
*/
-static int cmd_create_session(char *name, char *path, struct ucred *creds)
+static int cmd_create_session(char *name, char *path, lttng_sock_cred *creds)
{
int ret;
- ret = session_create(name, path, creds->uid, creds->gid);
+ ret = session_create(name, path, LTTNG_SOCK_GET_UID_CRED(creds),
+ LTTNG_SOCK_GET_GID_CRED(creds));
if (ret != LTTCOMM_OK) {
goto error;
}
}
break;
}
+ case LTTNG_DOMAIN_UST:
+ {
+ struct lttng_ust_calibrate ucalibrate;
+
+ ucalibrate.type = calibrate->type;
+ ret = ust_app_calibrate_glb(&ucalibrate);
+ if (ret < 0) {
+ ret = LTTCOMM_UST_CALIBRATE_FAIL;
+ goto error;
+ }
+ break;
+ }
default:
- /* TODO: Userspace tracing */
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
default:
/* TODO: Userspace tracing */
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
default:
*channels = NULL;
- ret = -LTTCOMM_NOT_IMPLEMENTED;
+ ret = -LTTCOMM_UND;
goto error;
}
break;
}
default:
- ret = -LTTCOMM_NOT_IMPLEMENTED;
+ ret = -LTTCOMM_UND;
goto error;
}
/* Kernel tracer check */
if (kernel_tracer_fd == 0) {
/* Basically, load kernel tracer modules */
- init_kernel_tracer();
- if (kernel_tracer_fd == 0) {
- ret = LTTCOMM_KERN_NA;
+ ret = init_kernel_tracer();
+ if (ret != 0) {
goto error;
}
}
*/
if (need_tracing_session) {
if (!session_access_ok(cmd_ctx->session,
- cmd_ctx->creds.uid, cmd_ctx->creds.gid)) {
+ LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+ LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds))) {
ret = LTTCOMM_EPERM;
goto error;
}
ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.disable.channel_name,
cmd_ctx->lsm->u.disable.name);
- ret = LTTCOMM_OK;
break;
}
case LTTNG_DISABLE_ALL_EVENT:
unsigned int nr_sessions;
session_lock_list();
- nr_sessions = lttng_sessions_count(cmd_ctx->creds.uid, cmd_ctx->creds.gid);
- if (nr_sessions == 0) {
- ret = LTTCOMM_NO_SESSION;
- session_unlock_list();
- goto error;
- }
+ nr_sessions = lttng_sessions_count(
+ LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+ LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+
ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * nr_sessions);
if (ret < 0) {
session_unlock_list();
/* Filled the session array */
list_lttng_sessions((struct lttng_session *)(cmd_ctx->llm->payload),
- cmd_ctx->creds.uid, cmd_ctx->creds.gid);
+ LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+ LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
session_unlock_list();
* Notify parent pid that we are ready to accept command for client side.
*/
if (opt_sig_parent) {
- kill(ppid, SIGCHLD);
+ kill(ppid, SIGUSR1);
}
while (1) {
*/
static int check_existing_daemon(void)
{
- if (access(client_unix_sock_path, F_OK) < 0 &&
- access(apps_unix_sock_path, F_OK) < 0) {
- return 0;
- }
-
/* Is there anybody out there ? */
if (lttng_session_daemon_alive()) {
return -EEXIST;
- } else {
- return 0;
}
+
+ return 0;
}
/*
* Set the tracing group gid onto the client socket.
*
* Race window between mkdir and chown is OK because we are going from more
- * permissive (root.root) to les permissive (root.tracing).
+ * permissive (root.root) to less permissive (root.tracing).
*/
static int set_permissions(char *rundir)
{
perror("chown");
}
+ /* Ensure tracing group can search the run dir */
+ ret = chmod(rundir, S_IRWXU | S_IXGRP);
+ if (ret < 0) {
+ ERR("Unable to set permissions on %s", rundir);
+ perror("chmod");
+ }
+
/* lttng client socket path */
ret = chown(client_unix_sock_path, 0, gid);
if (ret < 0) {
*/
static int create_kernel_poll_pipe(void)
{
- return pipe2(kernel_poll_pipe, O_CLOEXEC);
+ int ret, i;
+
+ ret = pipe(kernel_poll_pipe);
+ if (ret < 0) {
+ PERROR("kernel poll pipe");
+ goto error;
+ }
+
+ for (i = 0; i < 2; i++) {
+ ret = fcntl(kernel_poll_pipe[i], F_SETFD, FD_CLOEXEC);
+ if (ret < 0) {
+ PERROR("fcntl kernel_poll_pipe");
+ goto error;
+ }
+ }
+
+error:
+ return ret;
}
/*
*/
static int create_apps_cmd_pipe(void)
{
- return pipe2(apps_cmd_pipe, O_CLOEXEC);
+ int ret, i;
+
+ ret = pipe(apps_cmd_pipe);
+ if (ret < 0) {
+ PERROR("apps cmd pipe");
+ goto error;
+ }
+
+ for (i = 0; i < 2; i++) {
+ ret = fcntl(apps_cmd_pipe[i], F_SETFD, FD_CLOEXEC);
+ if (ret < 0) {
+ PERROR("fcntl apps_cmd_pipe");
+ goto error;
+ }
+ }
+
+error:
+ return ret;
}
/*
DBG3("Creating LTTng run directory: %s", rundir);
- ret = mkdir(rundir, S_IRWXU | S_IRWXG );
+ ret = mkdir(rundir, S_IRWXU);
if (ret < 0) {
if (errno != EEXIST) {
ERR("Unable to create %s", rundir);
switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
- snprintf(path, PATH_MAX, KCONSUMERD_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_KCONSUMERD_PATH, rundir);
break;
case LTTNG_CONSUMER64_UST:
- snprintf(path, PATH_MAX, USTCONSUMERD64_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD64_PATH, rundir);
break;
case LTTNG_CONSUMER32_UST:
- snprintf(path, PATH_MAX, USTCONSUMERD32_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD32_PATH, rundir);
break;
default:
ERR("Consumer type unknown");
DBG2("Creating consumer directory: %s", path);
- ret = mkdir(path, S_IRWXU | S_IRWXG);
+ ret = mkdir(path, S_IRWXU);
if (ret < 0) {
if (errno != EEXIST) {
ERR("Failed to create %s", path);
{
switch (sig) {
case SIGPIPE:
- DBG("SIGPIPE caugth");
+ DBG("SIGPIPE caught");
return;
case SIGINT:
- DBG("SIGINT caugth");
+ DBG("SIGINT caught");
stop_threads();
break;
case SIGTERM:
- DBG("SIGTERM caugth");
+ DBG("SIGTERM caught");
stop_threads();
break;
default:
void *status;
const char *home_path;
+ init_kernel_workarounds();
+
rcu_register_thread();
/* Create thread quit pipe */
/* Setup kernel consumerd path */
snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX,
- KCONSUMERD_ERR_SOCK_PATH, rundir);
+ DEFAULT_KCONSUMERD_ERR_SOCK_PATH, rundir);
snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX,
- KCONSUMERD_CMD_SOCK_PATH, rundir);
+ DEFAULT_KCONSUMERD_CMD_SOCK_PATH, rundir);
DBG2("Kernel consumer err path: %s",
kconsumer_data.err_unix_sock_path);
/* 32 bits consumerd path setup */
snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX,
- USTCONSUMERD32_ERR_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, rundir);
snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX,
- USTCONSUMERD32_CMD_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, rundir);
DBG2("UST consumer 32 bits err path: %s",
ustconsumer32_data.err_unix_sock_path);
/* 64 bits consumerd path setup */
snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX,
- USTCONSUMERD64_ERR_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, rundir);
snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX,
- USTCONSUMERD64_CMD_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, rundir);
DBG2("UST consumer 64 bits err path: %s",
ustconsumer64_data.err_unix_sock_path);