From 7e6f9ef6f2e62dfe359b94562cd98197367ddbac Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Wed, 28 Jan 2015 09:48:56 -0500 Subject: [PATCH] Implement listing of pid tracker content Signed-off-by: Mathieu Desnoyers --- lttng-abi.c | 2 + lttng-abi.h | 1 + lttng-events.c | 161 ++++++++++++++++++++++++++++++++++++++++++++ lttng-events.h | 8 +++ lttng-tracker-pid.c | 8 +-- 5 files changed, 176 insertions(+), 4 deletions(-) diff --git a/lttng-abi.c b/lttng-abi.c index f3d98fc1..81d813c5 100644 --- a/lttng-abi.c +++ b/lttng-abi.c @@ -510,6 +510,8 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg) return lttng_session_track_pid(session, (int) arg); case LTTNG_KERNEL_SESSION_UNTRACK_PID: return lttng_session_untrack_pid(session, (int) arg); + case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS: + return lttng_session_list_tracker_pids(session); default: return -ENOIOCTLCMD; } diff --git a/lttng-abi.h b/lttng-abi.h index bcea06e3..275c3496 100644 --- a/lttng-abi.h +++ b/lttng-abi.h @@ -189,6 +189,7 @@ struct lttng_kernel_context { _IOR(0xF6, 0x58, int32_t) #define LTTNG_KERNEL_SESSION_UNTRACK_PID \ _IOR(0xF6, 0x59, int32_t) +#define LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS _IO(0xF6, 0x58) /* Channel FD ioctl */ #define LTTNG_KERNEL_STREAM _IO(0xF6, 0x62) diff --git a/lttng-events.c b/lttng-events.c index 8a48c6b5..d7efd425 100644 --- a/lttng-events.c +++ b/lttng-events.c @@ -28,6 +28,10 @@ #include #include #include +#include +#include +#include +#include "wrapper/file.h" #include "wrapper/uuid.h" #include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ #include "wrapper/random.h" @@ -660,6 +664,163 @@ unlock: return ret; } +static +void *pid_list_start(struct seq_file *m, loff_t *pos) +{ + struct lttng_session *session = m->private; + struct lttng_pid_tracker *lpf; + struct lttng_pid_hash_node *e; + int iter = 0, i; + + mutex_lock(&sessions_mutex); + lpf = session->pid_tracker; + if (lpf) { + for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) { + struct hlist_head *head = &lpf->pid_hash[i]; + + hlist_for_each_entry(e, head, hlist) { + if (iter++ >= *pos) + return e; + } + } + } else { + /* PID tracker disabled. */ + if (iter >= *pos && iter == 0) { + return session; /* empty tracker */ + } + iter++; + } + /* End of list */ + return NULL; +} + +/* Called with sessions_mutex held. */ +static +void *pid_list_next(struct seq_file *m, void *p, loff_t *ppos) +{ + struct lttng_session *session = m->private; + struct lttng_pid_tracker *lpf; + struct lttng_pid_hash_node *e; + int iter = 0, i; + + (*ppos)++; + lpf = session->pid_tracker; + if (lpf) { + for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) { + struct hlist_head *head = &lpf->pid_hash[i]; + + hlist_for_each_entry(e, head, hlist) { + if (iter++ >= *ppos) + return e; + } + } + } else { + /* PID tracker disabled. */ + if (iter >= *ppos && iter == 0) + return session; /* empty tracker */ + iter++; + } + + /* End of list */ + return NULL; +} + +static +void pid_list_stop(struct seq_file *m, void *p) +{ + mutex_unlock(&sessions_mutex); +} + +static +int pid_list_show(struct seq_file *m, void *p) +{ + int pid; + + if (p == m->private) { + /* Tracker disabled. */ + pid = -1; + } else { + const struct lttng_pid_hash_node *e = p; + + pid = lttng_pid_tracker_get_node_pid(e); + } + seq_printf(m, "process { pid = %d; };\n", pid); + return 0; +} + +static +const struct seq_operations lttng_tracker_pids_list_seq_ops = { + .start = pid_list_start, + .next = pid_list_next, + .stop = pid_list_stop, + .show = pid_list_show, +}; + +static +int lttng_tracker_pids_list_open(struct inode *inode, struct file *file) +{ + return seq_open(file, <tng_tracker_pids_list_seq_ops); +} + +static +int lttng_tracker_pids_list_release(struct inode *inode, struct file *file) +{ + struct seq_file *m = file->private_data; + struct lttng_session *session = m->private; + int ret; + + WARN_ON_ONCE(!session); + ret = seq_release(inode, file); + if (!ret && session) + fput(session->file); + return ret; +} + +const struct file_operations lttng_tracker_pids_list_fops = { + .owner = THIS_MODULE, + .open = lttng_tracker_pids_list_open, + .read = seq_read, + .llseek = seq_lseek, + .release = lttng_tracker_pids_list_release, +}; + +int lttng_session_list_tracker_pids(struct lttng_session *session) +{ + struct file *tracker_pids_list_file; + struct seq_file *m; + int file_fd, ret; + + file_fd = lttng_get_unused_fd(); + if (file_fd < 0) { + ret = file_fd; + goto fd_error; + } + + tracker_pids_list_file = anon_inode_getfile("[lttng_tracker_pids_list]", + <tng_tracker_pids_list_fops, + NULL, O_RDWR); + if (IS_ERR(tracker_pids_list_file)) { + ret = PTR_ERR(tracker_pids_list_file); + goto file_error; + } + ret = lttng_tracker_pids_list_fops.open(NULL, tracker_pids_list_file); + if (ret < 0) + goto open_error; + m = tracker_pids_list_file->private_data; + m->private = session; + fd_install(file_fd, tracker_pids_list_file); + atomic_long_inc(&session->file->f_count); + + return file_fd; + +open_error: + fput(tracker_pids_list_file); +file_error: + put_unused_fd(file_fd); +fd_error: + return ret; +} + /* * Serialize at most one packet worth of metadata into a metadata * channel. diff --git a/lttng-events.h b/lttng-events.h index 7d331459..d761360c 100644 --- a/lttng-events.h +++ b/lttng-events.h @@ -336,6 +336,11 @@ struct lttng_pid_tracker { struct hlist_head pid_hash[LTTNG_PID_TABLE_SIZE]; }; +struct lttng_pid_hash_node { + struct hlist_node hlist; + int pid; +}; + struct lttng_session { int active; /* Is trace session active ? */ int been_active; /* Has trace session been active ? */ @@ -412,6 +417,7 @@ void lttng_probes_exit(void); int lttng_metadata_output_channel(struct lttng_metadata_stream *stream, struct channel *chan); +int lttng_pid_tracker_get_node_pid(const struct lttng_pid_hash_node *node); struct lttng_pid_tracker *lttng_pid_tracker_create(void); void lttng_pid_tracker_destroy(struct lttng_pid_tracker *lpf); bool lttng_pid_tracker_lookup(struct lttng_pid_tracker *lpf, int pid); @@ -421,6 +427,8 @@ int lttng_pid_tracker_del(struct lttng_pid_tracker *lpf, int pid); int lttng_session_track_pid(struct lttng_session *session, int pid); int lttng_session_untrack_pid(struct lttng_session *session, int pid); +int lttng_session_list_tracker_pids(struct lttng_session *session); + #if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS) int lttng_syscalls_register(struct lttng_channel *chan, void *filter); int lttng_syscalls_unregister(struct lttng_channel *chan); diff --git a/lttng-tracker-pid.c b/lttng-tracker-pid.c index f8f0a51d..a62ec4e4 100644 --- a/lttng-tracker-pid.c +++ b/lttng-tracker-pid.c @@ -42,10 +42,10 @@ * sessions_mutex across calls to create, destroy, add, and del * functions of this API. */ -struct lttng_pid_hash_node { - struct hlist_node hlist; - int pid; -}; +int lttng_pid_tracker_get_node_pid(const struct lttng_pid_hash_node *node) +{ + return node->pid; +} /* * Lookup performed from RCU read-side critical section (RCU sched), -- 2.34.1