Add METADATA ioctl

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/ltt-debugfs-abi.c b/ltt-debugfs-abi.c
index 41774e4356a70cbede41747b5067ffd67c64d262..340f7ddc1d685cdace58f4357eece818398e587b 100644 (file)
--- a/ltt-debugfs-abi.c
+++ b/ltt-debugfs-abi.c
@@ -41,8 +41,15 @@ static struct dentry *lttng_dentry;
 static const struct file_operations lttng_fops;
 static const struct file_operations lttng_session_fops;
 static const struct file_operations lttng_channel_fops;
+static const struct file_operations lttng_metadata_fops;
 static const struct file_operations lttng_event_fops;
 
+enum channel_type {
+       PER_CPU_CHANNEL,
+       GLOBAL_CHANNEL,
+       METADATA_CHANNEL,
+};
+
 static
 int lttng_abi_create_session(void)
 {
@@ -107,10 +114,52 @@ static const struct file_operations lttng_fops = {
 #endif
 };
 
+/*
+ * We tolerate no failure in this function (if one happens, we print a dmesg
+ * error, but cannot return any error, because the channel information is
+ * invariant.
+ */
+static
+void lttng_metadata_create_events(struct file *channel_file)
+{
+       struct ltt_channel *channel = channel_file->private_data;
+       char *event_name = "lttng-metadata";
+       struct ltt_event *event;
+       int ret;
+       void *probe;
+
+       probe = ltt_probe_get(event_name);
+       if (!probe) {
+               ret = -ENOENT;
+               goto probe_error;
+       }
+       /*
+        * We tolerate no failure path after event creation. It will stay
+        * invariant for the rest of the session.
+        */
+       event = ltt_event_create(channel, event_name, INSTRUM_TRACEPOINTS,
+                                probe, NULL);
+       if (!event) {
+               goto event_error;
+               ret = -EEXIST;
+       }
+       return;
+
+event_error:
+       ltt_probe_put(probe);
+probe_error:
+       WARN_ON(1);
+       return;         /* not allowed to return error */
+}
+
+static
 int lttng_abi_create_channel(struct file *session_file,
-                            struct lttng_channel __user *uchan_param)
+                            struct lttng_channel __user *uchan_param,
+                            enum channel_type channel_type)
 {
        struct ltt_session *session = session_file->private_data;
+       const struct file_operations *fops;
+       const char *transport_name;
        struct ltt_channel *chan;
        struct file *chan_file;
        struct lttng_channel chan_param;
@@ -131,11 +180,30 @@ int lttng_abi_create_channel(struct file *session_file,
                ret = PTR_ERR(chan_file);
                goto file_error;
        }
+       switch (channel_type) {
+       case PER_CPU_CHANNEL:
+               transport_name = chan_param.overwrite ?
+                       "relay-overwrite" : "relay-discard";
+               fops = &lttng_channel_fops;
+               break;
+       case GLOBAL_CHANNEL:
+               transport_name = chan_param.overwrite ?
+                       "global-relay-overwrite" : "global-relay-discard";
+               fops = &lttng_channel_fops;
+               break;
+       case METADATA_CHANNEL:
+               transport_name = "global-relay-discard";
+               fops = &lttng_metadata_fops;
+               break;
+       default:
+               transport_name = "<unknown>";
+               break;
+       }
        /*
         * We tolerate no failure path after channel creation. It will stay
         * invariant for the rest of the session.
         */
-       chan = ltt_channel_create(session, chan_param.overwrite, NULL,
+       chan = ltt_channel_create(session, transport_name, NULL,
                                  chan_param.subbuf_size,
                                  chan_param.num_subbuf,
                                  chan_param.switch_timer_interval,
@@ -147,6 +215,9 @@ int lttng_abi_create_channel(struct file *session_file,
        chan->file = chan_file;
        chan_file->private_data = chan;
        fd_install(chan_fd, chan_file);
+       if (channel_type == METADATA_CHANNEL)
+               lttng_metadata_create_events(chan_file);
+
        /* The channel created holds a reference on the session */
        atomic_long_inc(&session_file->f_count);
 
@@ -180,11 +251,17 @@ long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
        switch (cmd) {
        case LTTNG_CHANNEL:
-               return lttng_abi_create_channel(file, (struct lttng_channel __user *)arg);
+               return lttng_abi_create_channel(file,
+                               (struct lttng_channel __user *)arg,
+                               PER_CPU_CHANNEL);
        case LTTNG_SESSION_START:
                return ltt_session_start(session);
        case LTTNG_SESSION_STOP:
                return ltt_session_stop(session);
+       case LTTNG_METADATA:
+               return lttng_abi_create_channel(file,
+                               (struct lttng_channel __user *)arg,
+                               METADATA_CHANNEL);
        default:
                return -ENOIOCTLCMD;
        }
@@ -344,7 +421,6 @@ name_error:
  *     LTTNG_EVENT
  *             Returns an event file descriptor or failure.
  *
- * The returned session will be deleted when its file descriptor is closed.
  * Channel and event file descriptors also hold a reference on the session.
  */
 static
@@ -360,6 +436,30 @@ long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        }
 }
 
+/**
+ *     lttng_metadata_ioctl - lttng syscall through ioctl
+ *
+ *     @file: the file
+ *     @cmd: the command
+ *     @arg: command arg
+ *
+ *     This ioctl implements lttng commands:
+ *      LTTNG_STREAM
+ *              Returns an event stream file descriptor or failure.
+ *
+ * Channel and event file descriptors also hold a reference on the session.
+ */
+static
+long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+       switch (cmd) {
+       case LTTNG_STREAM:
+               return lttng_abi_open_stream(file);
+       default:
+               return -ENOIOCTLCMD;
+       }
+}
+
 /* TODO: poll */
 #if 0
 /**
@@ -410,6 +510,14 @@ static const struct file_operations lttng_channel_fops = {
 #endif
 };
 
+static const struct file_operations lttng_metadata_fops = {
+       .release = lttng_channel_release,
+       .unlocked_ioctl = lttng_metadata_ioctl,
+#ifdef CONFIG_COMPAT
+       .compat_ioctl = lttng_metadata_ioctl,
+#endif
+};
+
 static
 int lttng_event_release(struct inode *inode, struct file *file)
 {

diff --git a/ltt-debugfs-abi.h b/ltt-debugfs-abi.h
index a232e1318c1a33ffe0d0d007f0b9ab1ae581fef8..3a2af561294582caf1c00872744b11ebddd37551 100644 (file)
--- a/ltt-debugfs-abi.h
+++ b/ltt-debugfs-abi.h
@@ -38,5 +38,6 @@ struct lttng_event {
 #define LTTNG_CHANNEL          _IOW(0xF6, 0x43, struct lttng_channel)
 #define LTTNG_STREAM           _IO(0xF6, 0x44)
 #define LTTNG_EVENT            _IOW(0xF6, 0x45, struct lttng_event)
+#define LTTNG_METADATA         _IOW(0xF6, 0x46, struct lttng_channel)
 
 #endif /* _LTT_DEBUGFS_ABI_H */

diff --git a/ltt-events.c b/ltt-events.c
index 947d772cf37bec3c1a6b1d2557e2aeb2f19dd904..184f2daa145caf573ff522bfd006aa3b8a8eaaca 100644 (file)
--- a/ltt-events.c
+++ b/ltt-events.c
@@ -108,21 +108,20 @@ static struct ltt_transport *ltt_transport_find(char *name)
 }
 
 struct ltt_channel *ltt_channel_create(struct ltt_session *session,
-                                      int overwrite, void *buf_addr,
+                                      const char *transport_name,
+                                      void *buf_addr,
                                       size_t subbuf_size, size_t num_subbuf,
                                       unsigned int switch_timer_interval,
                                       unsigned int read_timer_interval)
 {
        struct ltt_channel *chan;
        struct ltt_transport *transport;
-       char *transport_name;
 
        mutex_lock(&sessions_mutex);
        if (session->active) {
                printk(KERN_WARNING "LTTng refusing to add channel to active session\n");
                goto active;    /* Refuse to add channel to active session */
        }
-       transport_name = overwrite ? "relay-overwrite" : "relay-discard";
        transport = ltt_transport_find(transport_name);
        if (!transport) {
                printk(KERN_WARNING "LTTng transport %s not found\n",

diff --git a/ltt-events.h b/ltt-events.h
index e8171b032110138198e4405a30de191b2757912e..443d185cc292ebe8d6363c4af31b50a30b2c55a7 100644 (file)
--- a/ltt-events.h
+++ b/ltt-events.h
@@ -78,6 +78,12 @@ int ltt_session_stop(struct ltt_session *session);
 void ltt_session_destroy(struct ltt_session *session);
 
 struct ltt_channel *ltt_channel_create(struct ltt_session *session,
+                                      const char *transport_name,
+                                      void *buf_addr,
+                                      size_t subbuf_size, size_t num_subbuf,
+                                      unsigned int switch_timer_interval,
+                                      unsigned int read_timer_interval);
+struct ltt_channel *ltt_global_channel_create(struct ltt_session *session,
                                       int overwrite, void *buf_addr,
                                       size_t subbuf_size, size_t num_subbuf,
                                       unsigned int switch_timer_interval,