src/bin/lttng-relayd/session.c

   1 /*
   2  * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
   3  *                      David Goulet <dgoulet@efficios.com>
   4  *               2015 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License, version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 51
  17  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #define _LGPL_SOURCE
  21 #include <common/common.h>
  22 #include <common/uuid.h>
  23 #include <common/time.h>
  24 #include <common/utils.h>
  25 #include <common/uuid.h>
  26 #include <common/compat/path.h>
  27 #include <urcu/rculist.h>
  28
  29 #include <sys/stat.h>
  30
  31 #include "ctf-trace.h"
  32 #include "lttng-relayd.h"
  33 #include "session.h"
  34 #include "sessiond-trace-chunks.h"
  35 #include "stream.h"
  36 #include <common/defaults.h>
  37 #include "utils.h"
  38
  39 /* Global session id used in the session creation. */
  40 static uint64_t last_relay_session_id;
  41 static pthread_mutex_t last_relay_session_id_lock = PTHREAD_MUTEX_INITIALIZER;
  42
  43 static int init_session_output_path_group_by_host(struct relay_session *session)
  44 {
  45         /*
  46          * session_directory:
  47          *
  48          * if base_path is \0'
  49          *   hostname/session_name
  50          * else
  51          *   hostname/base_path
  52          */
  53         char *session_directory = NULL;
  54         int ret = 0;
  55
  56         if (session->output_path[0] != '\0') {
  57                 goto end;
  58         }
  59         /*
  60          * If base path is set, it overrides the session name for the
  61          * session relative base path. No timestamp is appended if the
  62          * base path is overridden.
  63          *
  64          * If the session name already contains the creation time (e.g.
  65          * auto-<timestamp>, don't append yet another timestamp after
  66          * the session name in the generated path.
  67          *
  68          * Otherwise, generate the path with session_name-<timestamp>.
  69          */
  70         if (session->base_path[0] != '\0') {
  71                 ret = asprintf(&session_directory, "%s/%s", session->hostname,
  72                                 session->base_path);
  73         } else if (session->session_name_contains_creation_time) {
  74                 ret = asprintf(&session_directory, "%s/%s", session->hostname,
  75                                 session->session_name);
  76         } else {
  77                 char session_creation_datetime[DATETIME_STR_LEN];
  78
  79                 ret = time_to_datetime_str(
  80                                 LTTNG_OPTIONAL_GET(session->creation_time),
  81                                 session_creation_datetime,
  82                                 sizeof(session_creation_datetime));
  83                 if (ret) {
  84                         ERR("Failed to format session creation timestamp while initializing session output directory handle");
  85                         ret = -1;
  86                         goto end;
  87                 }
  88
  89                 ret = asprintf(&session_directory, "%s/%s-%s",
  90                                 session->hostname, session->session_name,
  91                                 session_creation_datetime);
  92         }
  93         if (ret < 0) {
  94                 PERROR("Failed to format session directory name");
  95                 goto end;
  96         }
  97
  98         if (strlen(session_directory) >= LTTNG_PATH_MAX) {
  99                 ERR("Session output directory exceeds maximal length");
 100                 ret = -1;
 101                 goto end;
 102         }
 103         strcpy(session->output_path, session_directory);
 104         ret = 0;
 105
 106 end:
 107         free(session_directory);
 108         return ret;
 109 }
 110
 111 static int init_session_output_path_group_by_session(
 112                 struct relay_session *session)
 113 {
 114         /*
 115          * session_directory:
 116          *
 117          *   session_name/hostname-creation_time/base_path
 118          *
 119          * For session name including the datetime, use it as the complete name
 120          * since. Do not perform modification on it since the datetime is an
 121          * integral part of the name and how a user identify a session.
 122          */
 123         int ret = 0;
 124         char *session_directory = NULL;
 125         char creation_datetime[DATETIME_STR_LEN];
 126
 127         if (session->output_path[0] != '\0') {
 128                 /* output_path as been generated already */
 129                 goto end;
 130         }
 131
 132         ret = time_to_datetime_str(LTTNG_OPTIONAL_GET(session->creation_time),
 133                         creation_datetime, sizeof(creation_datetime));
 134         if (ret) {
 135                 ERR("Failed to format session creation timestamp while initializing session output directory handle");
 136                 ret = -1;
 137                 goto end;
 138         }
 139
 140         ret = asprintf(&session_directory, "%s/%s-%s%s%s",
 141                         session->session_name, session->hostname,
 142                         creation_datetime,
 143                         session->base_path[0] != '\0' ? "/" : "",
 144                         session->base_path);
 145         if (ret < 0) {
 146                 PERROR("Failed to format session directory name");
 147                 goto end;
 148         }
 149
 150         if (strlen(session_directory) >= LTTNG_PATH_MAX) {
 151                 ERR("Session output directory exceeds maximal length");
 152                 ret = -1;
 153                 goto end;
 154         }
 155
 156         strcpy(session->output_path, session_directory);
 157         ret = 0;
 158
 159 end:
 160         free(session_directory);
 161         return ret;
 162 }
 163
 164 static int init_session_output_path(struct relay_session *session)
 165 {
 166         int ret;
 167
 168         switch (opt_group_output_by) {
 169         case RELAYD_GROUP_OUTPUT_BY_HOST:
 170                 ret = init_session_output_path_group_by_host(session);
 171                 break;
 172         case RELAYD_GROUP_OUTPUT_BY_SESSION:
 173                 ret = init_session_output_path_group_by_session(session);
 174                 break;
 175         case RELAYD_GROUP_OUTPUT_BY_UNKNOWN:
 176         default:
 177                 abort();
 178                 break;
 179         }
 180
 181         return ret;
 182 }
 183
 184 static struct lttng_directory_handle *session_create_output_directory_handle(
 185                 struct relay_session *session)
 186 {
 187         int ret;
 188         /*
 189          * relayd_output_path/session_directory
 190          * e.g. /home/user/lttng-traces/hostname/session_name
 191          */
 192         char *full_session_path = NULL;
 193         struct lttng_directory_handle *handle = NULL;
 194
 195         pthread_mutex_lock(&session->lock);
 196         full_session_path = create_output_path(session->output_path);
 197         if (!full_session_path) {
 198                 goto end;
 199         }
 200
 201         ret = utils_mkdir_recursive(
 202                         full_session_path, S_IRWXU | S_IRWXG, -1, -1);
 203         if (ret) {
 204                 ERR("Failed to create session output path \"%s\"",
 205                                 full_session_path);
 206                 goto end;
 207         }
 208
 209         handle = lttng_directory_handle_create(full_session_path);
 210 end:
 211         pthread_mutex_unlock(&session->lock);
 212         free(full_session_path);
 213         return handle;
 214 }
 215
 216 static int session_set_anonymous_chunk(struct relay_session *session)
 217 {
 218         int ret = 0;
 219         struct lttng_trace_chunk *chunk = NULL;
 220         enum lttng_trace_chunk_status status;
 221         struct lttng_directory_handle *output_directory;
 222
 223         output_directory = session_create_output_directory_handle(session);
 224         if (!output_directory) {
 225                 goto end;
 226         }
 227
 228         chunk = lttng_trace_chunk_create_anonymous();
 229         if (!chunk) {
 230                 goto end;
 231         }
 232
 233         status = lttng_trace_chunk_set_credentials_current_user(chunk);
 234         if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 235                 ret = -1;
 236                 goto end;
 237         }
 238
 239         status = lttng_trace_chunk_set_as_owner(chunk, output_directory);
 240         if (status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 241                 ret = -1;
 242                 goto end;
 243         }
 244         output_directory = NULL;
 245         session->current_trace_chunk = chunk;
 246         chunk = NULL;
 247 end:
 248         lttng_trace_chunk_put(chunk);
 249         lttng_directory_handle_put(output_directory);
 250         return ret;
 251 }
 252
 253 /*
 254  * Check if a name is safe to use in a path.
 255  *
 256  * A name that is deemed "path-safe":
 257  *   - Does not contains a path separator (/ or \, platform dependant),
 258  *   - Does not start with a '.' (hidden file/folder),
 259  *   - Is not empty.
 260  */
 261 static bool is_name_path_safe(const char *name)
 262 {
 263         const size_t name_len = strlen(name);
 264
 265         /* Not empty. */
 266         if (name_len == 0) {
 267                 WARN("An empty name is not allowed to be used in a path");
 268                 return false;
 269         }
 270         /* Does not start with '.'. */
 271         if (name[0] == '.') {
 272                 WARN("Name \"%s\" is not allowed to be used in a path since it starts with '.'", name);
 273                 return false;
 274         }
 275         /* Does not contain a path-separator. */
 276         if (strchr(name, LTTNG_PATH_SEPARATOR)) {
 277                 WARN("Name \"%s\" is not allowed to be used in a path since it contains a path separator", name);
 278                 return false;
 279         }
 280
 281         return true;
 282 }
 283
 284 /*
 285  * Create a new session by assigning a new session ID.
 286  *
 287  * Return allocated session or else NULL.
 288  */
 289 struct relay_session *session_create(const char *session_name,
 290                 const char *hostname, const char *base_path,
 291                 uint32_t live_timer,
 292                 bool snapshot,
 293                 const lttng_uuid sessiond_uuid,
 294                 const uint64_t *id_sessiond,
 295                 const uint64_t *current_chunk_id,
 296                 const time_t *creation_time,
 297                 uint32_t major,
 298                 uint32_t minor,
 299                 bool session_name_contains_creation_time)
 300 {
 301         int ret;
 302         struct relay_session *session = NULL;
 303
 304         assert(session_name);
 305         assert(hostname);
 306         assert(base_path);
 307
 308         if (!is_name_path_safe(session_name)) {
 309                 ERR("Refusing to create session as the provided session name is not path-safe");
 310                 goto error;
 311         }
 312         if (!is_name_path_safe(hostname)) {
 313                 ERR("Refusing to create session as the provided hostname is not path-safe");
 314                 goto error;
 315         }
 316         if (strstr(base_path, "../")) {
 317                 ERR("Invalid session base path walks up the path hierarchy: \"%s\"",
 318                                 base_path);
 319                 goto error;
 320         }
 321
 322         session = zmalloc(sizeof(*session));
 323         if (!session) {
 324                 PERROR("Failed to allocate session");
 325                 goto error;
 326         }
 327         if (lttng_strncpy(session->session_name, session_name,
 328                         sizeof(session->session_name))) {
 329                 WARN("Session name exceeds maximal allowed length");
 330                 goto error;
 331         }
 332         if (lttng_strncpy(session->hostname, hostname,
 333                         sizeof(session->hostname))) {
 334                 WARN("Hostname exceeds maximal allowed length");
 335                 goto error;
 336         }
 337         if (lttng_strncpy(session->base_path, base_path,
 338                         sizeof(session->base_path))) {
 339                 WARN("Base path exceeds maximal allowed length");
 340                 goto error;
 341         }
 342         if (creation_time) {
 343                 LTTNG_OPTIONAL_SET(&session->creation_time, *creation_time);
 344         }
 345         session->session_name_contains_creation_time =
 346                         session_name_contains_creation_time;
 347
 348         session->ctf_traces_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
 349         if (!session->ctf_traces_ht) {
 350                 goto error;
 351         }
 352
 353         pthread_mutex_lock(&last_relay_session_id_lock);
 354         session->id = ++last_relay_session_id;
 355         pthread_mutex_unlock(&last_relay_session_id_lock);
 356
 357         session->major = major;
 358         session->minor = minor;
 359         lttng_ht_node_init_u64(&session->session_n, session->id);
 360         urcu_ref_init(&session->ref);
 361         CDS_INIT_LIST_HEAD(&session->recv_list);
 362         pthread_mutex_init(&session->lock, NULL);
 363         pthread_mutex_init(&session->recv_list_lock, NULL);
 364
 365         session->live_timer = live_timer;
 366         session->snapshot = snapshot;
 367         lttng_uuid_copy(session->sessiond_uuid, sessiond_uuid);
 368
 369         if (id_sessiond) {
 370                 LTTNG_OPTIONAL_SET(&session->id_sessiond, *id_sessiond);
 371         }
 372
 373         if (major == 2 && minor >= 11) {
 374                 /* Only applies for 2.11+ peers using trace chunks. */
 375                 ret = init_session_output_path(session);
 376                 if (ret) {
 377                         goto error;
 378                 }
 379         }
 380
 381         ret = sessiond_trace_chunk_registry_session_created(
 382                         sessiond_trace_chunk_registry, sessiond_uuid);
 383         if (ret) {
 384                 goto error;
 385         }
 386
 387         if (id_sessiond && current_chunk_id) {
 388                 enum lttng_trace_chunk_status chunk_status;
 389                 struct lttng_directory_handle *session_output_directory;
 390
 391                 session->current_trace_chunk =
 392                                 sessiond_trace_chunk_registry_get_chunk(
 393                                         sessiond_trace_chunk_registry,
 394                                         session->sessiond_uuid,
 395                                         session->id_sessiond.value,
 396                                         *current_chunk_id);
 397                 if (!session->current_trace_chunk) {
 398                         char uuid_str[LTTNG_UUID_STR_LEN];
 399
 400                         lttng_uuid_to_str(sessiond_uuid, uuid_str);
 401                         ERR("Could not find trace chunk: sessiond = {%s}, sessiond session id = %" PRIu64 ", trace chunk id = %" PRIu64,
 402                                         uuid_str, *id_sessiond,
 403                                         *current_chunk_id);
 404                         goto error;
 405                 }
 406
 407                 chunk_status = lttng_trace_chunk_get_session_output_directory_handle(
 408                                 session->current_trace_chunk,
 409                                 &session_output_directory);
 410                 if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 411                         goto error;
 412                 }
 413
 414                 assert(session_output_directory);
 415                 session->output_directory = session_output_directory;
 416         } else if (!id_sessiond) {
 417                 /*
 418                  * Pre-2.11 peers will not announce trace chunks. An
 419                  * anonymous trace chunk which will remain set for the
 420                  * duration of the session is created.
 421                  */
 422                 ret = session_set_anonymous_chunk(session);
 423                 if (ret) {
 424                         goto error;
 425                 }
 426         } else {
 427                 session->output_directory =
 428                                 session_create_output_directory_handle(session);
 429                 if (!session->output_directory) {
 430                         goto error;
 431                 }
 432         }
 433
 434         lttng_ht_add_unique_u64(sessions_ht, &session->session_n);
 435         return session;
 436
 437 error:
 438         session_put(session);
 439         return NULL;
 440 }
 441
 442 /* Should be called with RCU read-side lock held. */
 443 bool session_get(struct relay_session *session)
 444 {
 445         return urcu_ref_get_unless_zero(&session->ref);
 446 }
 447
 448 /*
 449  * Lookup a session within the session hash table using the session id
 450  * as key. A session reference is taken when a session is returned.
 451  * session_put() must be called on that session.
 452  *
 453  * Return session or NULL if not found.
 454  */
 455 struct relay_session *session_get_by_id(uint64_t id)
 456 {
 457         struct relay_session *session = NULL;
 458         struct lttng_ht_node_u64 *node;
 459         struct lttng_ht_iter iter;
 460
 461         rcu_read_lock();
 462         lttng_ht_lookup(sessions_ht, &id, &iter);
 463         node = lttng_ht_iter_get_node_u64(&iter);
 464         if (!node) {
 465                 DBG("Session find by ID %" PRIu64 " id NOT found", id);
 466                 goto end;
 467         }
 468         session = caa_container_of(node, struct relay_session, session_n);
 469         DBG("Session find by ID %" PRIu64 " id found", id);
 470         if (!session_get(session)) {
 471                 session = NULL;
 472         }
 473 end:
 474         rcu_read_unlock();
 475         return session;
 476 }
 477
 478 static void rcu_destroy_session(struct rcu_head *rcu_head)
 479 {
 480         struct relay_session *session =
 481                         caa_container_of(rcu_head, struct relay_session,
 482                                 rcu_node);
 483         /*
 484          * Since each trace has a reference on the session, it means
 485          * that if we are at the point where we teardown the session, no
 486          * trace belonging to that session exist at this point.
 487          * Calling lttng_ht_destroy in call_rcu worker thread so we
 488          * don't hold the RCU read-side lock while calling it.
 489          */
 490         lttng_ht_destroy(session->ctf_traces_ht);
 491         free(session);
 492 }
 493
 494 /*
 495  * Delete session from the given hash table.
 496  *
 497  * Return lttng ht del error code being 0 on success and 1 on failure.
 498  */
 499 static int session_delete(struct relay_session *session)
 500 {
 501         struct lttng_ht_iter iter;
 502
 503         iter.iter.node = &session->session_n.node;
 504         return lttng_ht_del(sessions_ht, &iter);
 505 }
 506
 507
 508 static void destroy_session(struct relay_session *session)
 509 {
 510         int ret;
 511
 512         ret = session_delete(session);
 513         assert(!ret);
 514         lttng_trace_chunk_put(session->current_trace_chunk);
 515         session->current_trace_chunk = NULL;
 516         lttng_trace_chunk_put(session->pending_closure_trace_chunk);
 517         session->pending_closure_trace_chunk = NULL;
 518         ret = sessiond_trace_chunk_registry_session_destroyed(
 519                         sessiond_trace_chunk_registry, session->sessiond_uuid);
 520         assert(!ret);
 521         lttng_directory_handle_put(session->output_directory);
 522         session->output_directory = NULL;
 523         call_rcu(&session->rcu_node, rcu_destroy_session);
 524 }
 525
 526 static void session_release(struct urcu_ref *ref)
 527 {
 528         struct relay_session *session =
 529                         caa_container_of(ref, struct relay_session, ref);
 530
 531         destroy_session(session);
 532 }
 533
 534 void session_put(struct relay_session *session)
 535 {
 536         if (!session) {
 537                 return;
 538         }
 539         rcu_read_lock();
 540         urcu_ref_put(&session->ref, session_release);
 541         rcu_read_unlock();
 542 }
 543
 544 int session_close(struct relay_session *session)
 545 {
 546         int ret = 0;
 547         struct ctf_trace *trace;
 548         struct lttng_ht_iter iter;
 549         struct relay_stream *stream;
 550
 551         pthread_mutex_lock(&session->lock);
 552         DBG("closing session %" PRIu64 ": is conn already closed %d",
 553                         session->id, session->connection_closed);
 554         session->connection_closed = true;
 555         pthread_mutex_unlock(&session->lock);
 556
 557         rcu_read_lock();
 558         cds_lfht_for_each_entry(session->ctf_traces_ht->ht,
 559                         &iter.iter, trace, node.node) {
 560                 ret = ctf_trace_close(trace);
 561                 if (ret) {
 562                         goto rcu_unlock;
 563                 }
 564         }
 565         cds_list_for_each_entry_rcu(stream, &session->recv_list,
 566                         recv_node) {
 567                 /* Close streams which have not been published yet. */
 568                 try_stream_close(stream);
 569         }
 570 rcu_unlock:
 571         rcu_read_unlock();
 572         if (ret) {
 573                 return ret;
 574         }
 575         /* Put self-reference from create. */
 576         session_put(session);
 577         return ret;
 578 }
 579
 580 int session_abort(struct relay_session *session)
 581 {
 582         int ret = 0;
 583
 584         if (!session) {
 585                 return 0;
 586         }
 587
 588         pthread_mutex_lock(&session->lock);
 589         DBG("aborting session %" PRIu64, session->id);
 590         session->aborted = true;
 591         pthread_mutex_unlock(&session->lock);
 592         return ret;
 593 }
 594
 595 void print_sessions(void)
 596 {
 597         struct lttng_ht_iter iter;
 598         struct relay_session *session;
 599
 600         if (!sessions_ht) {
 601                 return;
 602         }
 603
 604         rcu_read_lock();
 605         cds_lfht_for_each_entry(sessions_ht->ht, &iter.iter, session,
 606                         session_n.node) {
 607                 if (!session_get(session)) {
 608                         continue;
 609                 }
 610                 DBG("session %p refcount %ld session %" PRIu64,
 611                         session,
 612                         session->ref.refcount,
 613                         session->id);
 614                 session_put(session);
 615         }
 616         rcu_read_unlock();
 617 }