ltt-sessiond/ust-app.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; only version 2
   7  * of the License.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include <lttngerr.h>
  28
  29 #include "hashtable.h"
  30 #include "ust-app.h"
  31 #include "../hashtable/hash.h"
  32
  33 /*
  34  * Delete a traceable application structure from the global list.
  35  */
  36 static void delete_ust_app(struct ust_app *lta)
  37 {
  38         int ret;
  39         struct cds_lfht_node *node;
  40         struct cds_lfht_iter iter;
  41
  42         rcu_read_lock();
  43
  44         hashtable_get_first(lta->channels, &iter);
  45         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
  46                 ret = hashtable_del(lta->channels, &iter);
  47                 if (!ret) {
  48                         trace_ust_destroy_channel(
  49                                         caa_container_of(node, struct ltt_ust_channel, node));
  50                 }
  51                 hashtable_get_next(lta->channels, &iter);
  52         }
  53
  54         free(lta->channels);
  55         close(lta->key.sock);
  56
  57         /* Remove from apps hash table */
  58         node = hashtable_lookup(ust_app_ht,
  59                         (void *) ((unsigned long) lta->key.pid), sizeof(void *), &iter);
  60         if (node == NULL) {
  61                 ERR("UST app pid %d not found in hash table", lta->key.pid);
  62         } else {
  63                 ret = hashtable_del(ust_app_ht, &iter);
  64                 if (ret) {
  65                         ERR("UST app unable to delete app %d from hash table",
  66                                         lta->key.pid);
  67                 } else {
  68                         DBG2("UST app pid %d deleted", lta->key.pid);
  69                 }
  70         }
  71
  72         /* Remove from key hash table */
  73         node = hashtable_lookup(ust_app_sock_key_map,
  74                         (void *) ((unsigned long) lta->key.sock), sizeof(void *), &iter);
  75         if (node == NULL) {
  76                 ERR("UST app key %d not found in key hash table", lta->key.sock);
  77         } else {
  78                 ret = hashtable_del(ust_app_sock_key_map, &iter);
  79                 if (ret) {
  80                         ERR("UST app unable to delete app sock %d from key hash table",
  81                                         lta->key.sock);
  82                 } else {
  83                         DBG2("UST app pair sock %d key %d deleted",
  84                                         lta->key.sock, lta->key.pid);
  85                 }
  86         }
  87
  88         free(lta);
  89
  90         rcu_read_unlock();
  91 }
  92
  93 /*
  94  * URCU intermediate call to delete an UST app.
  95  */
  96 static void delete_ust_app_rcu(struct rcu_head *head)
  97 {
  98         struct cds_lfht_node *node =
  99                 caa_container_of(head, struct cds_lfht_node, head);
 100         struct ust_app *app =
 101                 caa_container_of(node, struct ust_app, node);
 102
 103         delete_ust_app(app);
 104 }
 105
 106 /*
 107  * Find an ust_app using the sock and return it.
 108  */
 109 static struct ust_app *find_app_by_sock(int sock)
 110 {
 111         struct cds_lfht_node *node;
 112         struct ust_app_key *key;
 113         struct cds_lfht_iter iter;
 114         //struct ust_app *app;
 115
 116         rcu_read_lock();
 117
 118         node = hashtable_lookup(ust_app_sock_key_map,
 119                         (void *)((unsigned long) sock), sizeof(void *), &iter);
 120         if (node == NULL) {
 121                 DBG2("UST app find by sock %d key not found", sock);
 122                 rcu_read_unlock();
 123                 goto error;
 124         }
 125
 126         key = caa_container_of(node, struct ust_app_key, node);
 127
 128         node = hashtable_lookup(ust_app_ht,
 129                         (void *)((unsigned long) key->pid), sizeof(void *), &iter);
 130         if (node == NULL) {
 131                 DBG2("UST app find by sock %d not found", sock);
 132                 rcu_read_unlock();
 133                 goto error;
 134         }
 135         rcu_read_unlock();
 136
 137         return caa_container_of(node, struct ust_app, node);
 138
 139 error:
 140         return NULL;
 141 }
 142
 143 /*
 144  * Return pointer to traceable apps list.
 145  */
 146 struct cds_lfht *ust_app_get_ht(void)
 147 {
 148         return ust_app_ht;
 149 }
 150
 151 /*
 152  * Return ust app pointer or NULL if not found.
 153  */
 154 struct ust_app *ust_app_find_by_pid(pid_t pid)
 155 {
 156         struct cds_lfht_node *node;
 157         struct cds_lfht_iter iter;
 158
 159         rcu_read_lock();
 160         node = hashtable_lookup(ust_app_ht,
 161                         (void *)((unsigned long) pid), sizeof(void *), &iter);
 162         if (node == NULL) {
 163                 rcu_read_unlock();
 164                 DBG2("UST app no found with pid %d", pid);
 165                 goto error;
 166         }
 167         rcu_read_unlock();
 168
 169         DBG2("Found UST app by pid %d", pid);
 170
 171         return caa_container_of(node, struct ust_app, node);
 172
 173 error:
 174         return NULL;
 175 }
 176
 177 /*
 178  * Using pid and uid (of the app), allocate a new ust_app struct and
 179  * add it to the global traceable app list.
 180  *
 181  * On success, return 0, else return malloc ENOMEM.
 182  */
 183 int ust_app_register(struct ust_register_msg *msg, int sock)
 184 {
 185         struct ust_app *lta;
 186
 187         lta = malloc(sizeof(struct ust_app));
 188         if (lta == NULL) {
 189                 perror("malloc");
 190                 return -ENOMEM;
 191         }
 192
 193         lta->uid = msg->uid;
 194         lta->gid = msg->gid;
 195         lta->key.pid = msg->pid;
 196         lta->ppid = msg->ppid;
 197         lta->v_major = msg->major;
 198         lta->v_minor = msg->minor;
 199         lta->key.sock = sock;
 200         strncpy(lta->name, msg->name, sizeof(lta->name));
 201         lta->name[16] = '\0';
 202         hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
 203                         sizeof(void *));
 204         lta->channels = hashtable_new_str(0);
 205
 206         /* Set sock key map */
 207         hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
 208                         sizeof(void *));
 209
 210         rcu_read_lock();
 211         hashtable_add_unique(ust_app_ht, &lta->node);
 212         hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
 213         rcu_read_unlock();
 214
 215         DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
 216                         " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
 217                         lta->key.sock, lta->name, lta->v_major, lta->v_minor);
 218
 219         return 0;
 220 }
 221
 222 /*
 223  * Unregister app by removing it from the global traceable app list and freeing
 224  * the data struct.
 225  *
 226  * The socket is already closed at this point so no close to sock.
 227  */
 228 void ust_app_unregister(int sock)
 229 {
 230         struct ust_app *lta;
 231
 232         DBG2("UST app unregistering sock %d", sock);
 233
 234         lta = find_app_by_sock(sock);
 235         if (lta) {
 236                 DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
 237                 /* FIXME: Better use a call_rcu here ? */
 238                 delete_ust_app(lta);
 239         }
 240 }
 241
 242 /*
 243  * Return traceable_app_count
 244  */
 245 unsigned long ust_app_list_count(void)
 246 {
 247         unsigned long count;
 248
 249         rcu_read_lock();
 250         count = hashtable_get_count(ust_app_ht);
 251         rcu_read_unlock();
 252
 253         return count;
 254 }
 255
 256 /*
 257  * Free and clean all traceable apps of the global list.
 258  */
 259 void ust_app_clean_list(void)
 260 {
 261         int ret;
 262         struct cds_lfht_node *node;
 263         struct cds_lfht_iter iter;
 264
 265         DBG2("UST app clean hash table");
 266
 267         rcu_read_lock();
 268
 269         hashtable_get_first(ust_app_ht, &iter);
 270         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
 271                 ret = hashtable_del(ust_app_ht, &iter);
 272                 if (!ret) {
 273                         call_rcu(&node->head, delete_ust_app_rcu);
 274                 }
 275                 hashtable_get_next(ust_app_ht, &iter);
 276         }
 277
 278         rcu_read_unlock();
 279 }
 280
 281 /*
 282  * Init UST app hash table.
 283  */
 284 void ust_app_ht_alloc(void)
 285 {
 286         ust_app_ht = hashtable_new(0);
 287         ust_app_sock_key_map = hashtable_new(0);
 288 }