src/bin/lttng-relayd/ctf-trace.c

   1 /*
   2  * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
   3  *                      David Goulet <dgoulet@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License, version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 51
  16  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #define _LGPL_SOURCE
  21 #include <assert.h>
  22
  23 #include <common/common.h>
  24 #include <common/utils.h>
  25
  26 #include "ctf-trace.h"
  27 #include "lttng-relayd.h"
  28 #include "stream.h"
  29
  30 static uint64_t last_relay_ctf_trace_id;
  31
  32 static void rcu_destroy_ctf_trace(struct rcu_head *head)
  33 {
  34         struct lttng_ht_node_str *node =
  35                 caa_container_of(head, struct lttng_ht_node_str, head);
  36         struct ctf_trace *trace=
  37                 caa_container_of(node, struct ctf_trace, node);
  38
  39         free(trace);
  40 }
  41
  42 static void rcu_destroy_stream(struct rcu_head *head)
  43 {
  44         struct relay_stream *stream =
  45                 caa_container_of(head, struct relay_stream, rcu_node);
  46
  47         stream_destroy(stream);
  48 }
  49
  50 /*
  51  * Destroy a ctf trace and all stream contained in it.
  52  *
  53  * MUST be called with the RCU read side lock.
  54  */
  55 void ctf_trace_destroy(struct ctf_trace *obj)
  56 {
  57         struct relay_stream *stream, *tmp_stream;
  58
  59         assert(obj);
  60         /*
  61          * Getting to this point, every stream referenced to that object have put
  62          * back their ref since the've been closed by the control side.
  63          */
  64         assert(!obj->refcount);
  65
  66         cds_list_for_each_entry_safe(stream, tmp_stream, &obj->stream_list,
  67                         trace_list) {
  68                 stream_delete(relay_streams_ht, stream);
  69                 call_rcu(&stream->rcu_node, rcu_destroy_stream);
  70         }
  71
  72         call_rcu(&obj->node.head, rcu_destroy_ctf_trace);
  73 }
  74
  75 void ctf_trace_try_destroy(struct relay_session *session,
  76                 struct ctf_trace *ctf_trace)
  77 {
  78         assert(session);
  79         assert(ctf_trace);
  80
  81         /*
  82          * Considering no viewer attach to the session and the trace having no more
  83          * stream attached, wipe the trace.
  84          */
  85         if (uatomic_read(&session->viewer_refcount) == 0 &&
  86                         uatomic_read(&ctf_trace->refcount) == 0) {
  87                 ctf_trace_delete(session->ctf_traces_ht, ctf_trace);
  88                 ctf_trace_destroy(ctf_trace);
  89         }
  90 }
  91
  92 /*
  93  * Create and return an allocated ctf_trace object. NULL on error.
  94  */
  95 struct ctf_trace *ctf_trace_create(char *path_name)
  96 {
  97         struct ctf_trace *obj;
  98
  99         assert(path_name);
 100
 101         obj = zmalloc(sizeof(*obj));
 102         if (!obj) {
 103                 PERROR("ctf_trace alloc");
 104                 goto error;
 105         }
 106
 107         CDS_INIT_LIST_HEAD(&obj->stream_list);
 108
 109         obj->id = ++last_relay_ctf_trace_id;
 110         lttng_ht_node_init_str(&obj->node, path_name);
 111
 112         DBG("Created ctf_trace %" PRIu64 " with path: %s", obj->id, path_name);
 113
 114 error:
 115         return obj;
 116 }
 117
 118 /*
 119  * Return a ctf_trace object if found by id in the given hash table else NULL.
 120  *
 121  * Must be called with rcu_read_lock() taken.
 122  */
 123 struct ctf_trace *ctf_trace_find_by_path(struct lttng_ht *ht,
 124                 char *path_name)
 125 {
 126         struct lttng_ht_node_str *node;
 127         struct lttng_ht_iter iter;
 128         struct ctf_trace *trace = NULL;
 129
 130         assert(ht);
 131
 132         lttng_ht_lookup(ht, (void *) path_name, &iter);
 133         node = lttng_ht_iter_get_node_str(&iter);
 134         if (!node) {
 135                 DBG("CTF Trace path %s not found", path_name);
 136                 goto end;
 137         }
 138         trace = caa_container_of(node, struct ctf_trace, node);
 139
 140 end:
 141         return trace;
 142 }
 143
 144 /*
 145  * Add stream to a given hash table.
 146  */
 147 void ctf_trace_add(struct lttng_ht *ht, struct ctf_trace *trace)
 148 {
 149         assert(ht);
 150         assert(trace);
 151
 152         lttng_ht_add_str(ht, &trace->node);
 153 }
 154
 155 /*
 156  * Delete stream from a given hash table.
 157  */
 158 void ctf_trace_delete(struct lttng_ht *ht, struct ctf_trace *trace)
 159 {
 160         int ret;
 161         struct lttng_ht_iter iter;
 162
 163         assert(ht);
 164         assert(trace);
 165
 166         iter.iter.node = &trace->node.node;
 167         ret = lttng_ht_del(ht, &iter);
 168         assert(!ret);
 169 }