| 1 | /* |
| 2 | * Copyright (C) 2013 David Goulet <dgoulet@efficios.com> |
| 3 | * |
| 4 | * SPDX-License-Identifier: GPL-2.0-only |
| 5 | * |
| 6 | */ |
| 7 | |
| 8 | #define _LGPL_SOURCE |
| 9 | |
| 10 | #include "lttng-sessiond.hpp" |
| 11 | #include "notification-thread-commands.hpp" |
| 12 | #include "ust-app.hpp" |
| 13 | #include "ust-registry-session-pid.hpp" |
| 14 | #include "ust-registry-session-uid.hpp" |
| 15 | #include "ust-registry.hpp" |
| 16 | #include "utils.hpp" |
| 17 | |
| 18 | #include <common/common.hpp> |
| 19 | #include <common/exception.hpp> |
| 20 | #include <common/format.hpp> |
| 21 | #include <common/hashtable/utils.hpp> |
| 22 | #include <common/make-unique-wrapper.hpp> |
| 23 | |
| 24 | #include <lttng/lttng.h> |
| 25 | |
| 26 | #include <inttypes.h> |
| 27 | |
| 28 | namespace ls = lttng::sessiond; |
| 29 | namespace lst = lttng::sessiond::trace; |
| 30 | namespace lsu = lttng::sessiond::ust; |
| 31 | |
| 32 | /* |
| 33 | * Destroy event function call of the call RCU. |
| 34 | */ |
| 35 | static void ust_registry_event_destroy_rcu(struct rcu_head *head) |
| 36 | { |
| 37 | DIAGNOSTIC_PUSH |
| 38 | DIAGNOSTIC_IGNORE_INVALID_OFFSETOF |
| 39 | lttng::sessiond::ust::registry_event *event = |
| 40 | lttng::utils::container_of(head, <tng::sessiond::ust::registry_event::_head); |
| 41 | DIAGNOSTIC_POP |
| 42 | |
| 43 | lttng::sessiond::ust::registry_event_destroy(event); |
| 44 | } |
| 45 | |
| 46 | /* |
| 47 | * For a given event in a registry, delete the entry and destroy the event. |
| 48 | * This MUST be called within a RCU read side lock section. |
| 49 | */ |
| 50 | void ust_registry_channel_destroy_event(lsu::registry_channel *chan, |
| 51 | lttng::sessiond::ust::registry_event *event) |
| 52 | { |
| 53 | int ret; |
| 54 | struct lttng_ht_iter iter; |
| 55 | |
| 56 | LTTNG_ASSERT(chan); |
| 57 | LTTNG_ASSERT(event); |
| 58 | ASSERT_RCU_READ_LOCKED(); |
| 59 | |
| 60 | /* Delete the node first. */ |
| 61 | iter.iter.node = &event->_node; |
| 62 | ret = lttng_ht_del(chan->_events, &iter); |
| 63 | LTTNG_ASSERT(!ret); |
| 64 | |
| 65 | call_rcu(&event->_head, ust_registry_event_destroy_rcu); |
| 66 | |
| 67 | return; |
| 68 | } |
| 69 | |
| 70 | lsu::registry_session *ust_registry_session_per_uid_create(const lttng::sessiond::trace::abi& abi, |
| 71 | uint32_t major, |
| 72 | uint32_t minor, |
| 73 | const char *root_shm_path, |
| 74 | const char *shm_path, |
| 75 | uid_t euid, |
| 76 | gid_t egid, |
| 77 | uint64_t tracing_id, |
| 78 | uid_t tracing_uid) |
| 79 | { |
| 80 | try { |
| 81 | return new lsu::registry_session_per_uid(abi, |
| 82 | major, |
| 83 | minor, |
| 84 | root_shm_path, |
| 85 | shm_path, |
| 86 | euid, |
| 87 | egid, |
| 88 | tracing_id, |
| 89 | tracing_uid); |
| 90 | } catch (const std::exception& ex) { |
| 91 | ERR("Failed to create per-uid registry session: %s", ex.what()); |
| 92 | return nullptr; |
| 93 | } |
| 94 | } |
| 95 | |
| 96 | lsu::registry_session *ust_registry_session_per_pid_create(struct ust_app *app, |
| 97 | const lttng::sessiond::trace::abi& abi, |
| 98 | uint32_t major, |
| 99 | uint32_t minor, |
| 100 | const char *root_shm_path, |
| 101 | const char *shm_path, |
| 102 | uid_t euid, |
| 103 | gid_t egid, |
| 104 | uint64_t tracing_id) |
| 105 | { |
| 106 | try { |
| 107 | return new lsu::registry_session_per_pid( |
| 108 | *app, abi, major, minor, root_shm_path, shm_path, euid, egid, tracing_id); |
| 109 | } catch (const std::exception& ex) { |
| 110 | ERR("Failed to create per-pid registry session: %s", ex.what()); |
| 111 | return nullptr; |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | /* |
| 116 | * Destroy session registry. This does NOT free the given pointer since it |
| 117 | * might get passed as a reference. The registry lock should NOT be acquired. |
| 118 | */ |
| 119 | void ust_registry_session_destroy(lsu::registry_session *reg) |
| 120 | { |
| 121 | delete reg; |
| 122 | } |
| 123 | |
| 124 | lsu::registry_enum::registry_enum(std::string in_name, |
| 125 | enum lst::integer_type::signedness in_signedness) : |
| 126 | name{ std::move(in_name) }, signedness{ in_signedness } |
| 127 | { |
| 128 | cds_lfht_node_init(&this->node.node); |
| 129 | this->rcu_head = {}; |
| 130 | } |
| 131 | |
| 132 | bool lsu::operator==(const lsu::registry_enum& lhs, const lsu::registry_enum& rhs) noexcept |
| 133 | { |
| 134 | if (lhs.signedness != rhs.signedness) { |
| 135 | return false; |
| 136 | } |
| 137 | |
| 138 | return lhs._is_equal(rhs); |
| 139 | } |