X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-registry.c;h=2e33b9575f9d1e298af8eb539c510997c2e1588c;hp=71fdc4fd8294d48c8f335222b2af2381cb1972e0;hb=0d32d1a95331da3baf00ad1eb7be907129c6a9db;hpb=890d8fe47755c3bad936389cf48ffa141cff41c9 diff --git a/src/bin/lttng-sessiond/ust-registry.c b/src/bin/lttng-sessiond/ust-registry.c index 71fdc4fd8..2e33b9575 100644 --- a/src/bin/lttng-sessiond/ust-registry.c +++ b/src/bin/lttng-sessiond/ust-registry.c @@ -1,18 +1,8 @@ /* - * Copyright (C) 2013 - David Goulet + * Copyright (C) 2013 David Goulet * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License, version 2 only, as - * published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along with - * this program; if not, write to the Free Software Foundation, Inc., 51 - * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -25,15 +15,20 @@ #include "ust-registry.h" #include "ust-app.h" +#include "ust-field-utils.h" #include "utils.h" +#include "lttng-sessiond.h" +#include "notification-thread-commands.h" + /* * Hash table match function for event in the registry. */ static int ht_match_event(struct cds_lfht_node *node, const void *_key) { - struct ust_registry_event *event; const struct ust_registry_event *key; + struct ust_registry_event *event; + int i; assert(node); assert(_key); @@ -42,17 +37,39 @@ static int ht_match_event(struct cds_lfht_node *node, const void *_key) assert(event); key = _key; - /* It has to be a perfect match. */ + /* It has to be a perfect match. First, compare the event names. */ if (strncmp(event->name, key->name, sizeof(event->name))) { goto no_match; } - /* It has to be a perfect match. */ - if (strncmp(event->signature, key->signature, - strlen(event->signature))) { + /* Compare log levels. */ + if (event->loglevel_value != key->loglevel_value) { + goto no_match; + } + + /* Compare the number of fields. */ + if (event->nr_fields != key->nr_fields) { goto no_match; } + /* Compare each field individually. */ + for (i = 0; i < event->nr_fields; i++) { + if (!match_ustctl_field(&event->fields[i], &key->fields[i])) { + goto no_match; + } + } + + /* Compare model URI. */ + if (event->model_emf_uri != NULL && key->model_emf_uri == NULL) { + goto no_match; + } else if(event->model_emf_uri == NULL && key->model_emf_uri != NULL) { + goto no_match; + } else if (event->model_emf_uri != NULL && key->model_emf_uri != NULL) { + if (strcmp(event->model_emf_uri, key->model_emf_uri)) { + goto no_match; + } + } + /* Match */ return 1; @@ -60,17 +77,128 @@ no_match: return 0; } -static unsigned long ht_hash_event(void *_key, unsigned long seed) +static unsigned long ht_hash_event(const void *_key, unsigned long seed) { - uint64_t xored_key; - struct ust_registry_event *key = _key; + uint64_t hashed_key; + const struct ust_registry_event *key = _key; assert(key); - xored_key = (uint64_t) (hash_key_str(key->name, seed) ^ - hash_key_str(key->signature, seed)); + hashed_key = (uint64_t) hash_key_str(key->name, seed); - return hash_key_u64(&xored_key, seed); + return hash_key_u64(&hashed_key, seed); +} + +static int compare_enums(const struct ust_registry_enum *reg_enum_a, + const struct ust_registry_enum *reg_enum_b) +{ + int ret = 0; + size_t i; + + assert(strcmp(reg_enum_a->name, reg_enum_b->name) == 0); + if (reg_enum_a->nr_entries != reg_enum_b->nr_entries) { + ret = -1; + goto end; + } + for (i = 0; i < reg_enum_a->nr_entries; i++) { + const struct ustctl_enum_entry *entries_a, *entries_b; + + entries_a = ®_enum_a->entries[i]; + entries_b = ®_enum_b->entries[i]; + if (entries_a->start.value != entries_b->start.value) { + ret = -1; + goto end; + } + if (entries_a->end.value != entries_b->end.value) { + ret = -1; + goto end; + } + if (entries_a->start.signedness != entries_b->start.signedness) { + ret = -1; + goto end; + } + if (entries_a->end.signedness != entries_b->end.signedness) { + ret = -1; + goto end; + } + + if (strcmp(entries_a->string, entries_b->string)) { + ret = -1; + goto end; + } + } +end: + return ret; +} + +/* + * Hash table match function for enumerations in the session. Match is + * performed on enumeration name, and confirmed by comparing the enum + * entries. + */ +static int ht_match_enum(struct cds_lfht_node *node, const void *_key) +{ + struct ust_registry_enum *_enum; + const struct ust_registry_enum *key; + + assert(node); + assert(_key); + + _enum = caa_container_of(node, struct ust_registry_enum, + node.node); + assert(_enum); + key = _key; + + if (strncmp(_enum->name, key->name, LTTNG_UST_SYM_NAME_LEN)) { + goto no_match; + } + if (compare_enums(_enum, key)) { + goto no_match; + } + + /* Match. */ + return 1; + +no_match: + return 0; +} + +/* + * Hash table match function for enumerations in the session. Match is + * performed by enumeration ID. + */ +static int ht_match_enum_id(struct cds_lfht_node *node, const void *_key) +{ + struct ust_registry_enum *_enum; + const struct ust_registry_enum *key = _key; + + assert(node); + assert(_key); + + _enum = caa_container_of(node, struct ust_registry_enum, node.node); + assert(_enum); + + if (_enum->id != key->id) { + goto no_match; + } + + /* Match. */ + return 1; + +no_match: + return 0; +} + +/* + * Hash table hash function for enumerations in the session. The + * enumeration name is used for hashing. + */ +static unsigned long ht_hash_enum(void *_key, unsigned long seed) +{ + struct ust_registry_enum *key = _key; + + assert(key); + return hash_key_str(key->name, seed); } /* @@ -85,33 +213,57 @@ int validate_event_field(struct ustctl_field *field, const char *event_name, struct ust_app *app) { + int ret = 0; + switch(field->type.atype) { case ustctl_atype_integer: case ustctl_atype_enum: case ustctl_atype_array: case ustctl_atype_sequence: case ustctl_atype_string: + case ustctl_atype_variant: + case ustctl_atype_array_nestable: + case ustctl_atype_sequence_nestable: + case ustctl_atype_enum_nestable: + case ustctl_atype_variant_nestable: + break; + case ustctl_atype_struct: + if (field->type.u.legacy._struct.nr_fields != 0) { + WARN("Unsupported non-empty struct field."); + ret = -EINVAL; + goto end; + } + break; + case ustctl_atype_struct_nestable: + if (field->type.u.struct_nestable.nr_fields != 0) { + WARN("Unsupported non-empty struct field."); + ret = -EINVAL; + goto end; + } break; case ustctl_atype_float: - switch (field->type.u.basic._float.mant_dig) { + switch (field->type.u._float.mant_dig) { case 0: WARN("UST application '%s' (pid: %d) has unknown float mantissa '%u' " "in field '%s', rejecting event '%s'", app->name, app->pid, - field->type.u.basic._float.mant_dig, + field->type.u._float.mant_dig, field->name, event_name); - return -EINVAL; + ret = -EINVAL; + goto end; default: break; } break; default: - return -ENOENT; + ret = -ENOENT; + goto end; } - return 0; +end: + return ret; } static @@ -377,6 +529,175 @@ void ust_registry_destroy_event(struct ust_registry_channel *chan, return; } +static void destroy_enum(struct ust_registry_enum *reg_enum) +{ + if (!reg_enum) { + return; + } + free(reg_enum->entries); + free(reg_enum); +} + +static void destroy_enum_rcu(struct rcu_head *head) +{ + struct ust_registry_enum *reg_enum = + caa_container_of(head, struct ust_registry_enum, rcu_head); + + destroy_enum(reg_enum); +} + +/* + * Lookup enumeration by name and comparing enumeration entries. + * Needs to be called from RCU read-side critical section. + */ +static struct ust_registry_enum *ust_registry_lookup_enum( + struct ust_registry_session *session, + const struct ust_registry_enum *reg_enum_lookup) +{ + struct ust_registry_enum *reg_enum = NULL; + struct lttng_ht_node_str *node; + struct lttng_ht_iter iter; + + cds_lfht_lookup(session->enums->ht, + ht_hash_enum((void *) reg_enum_lookup, lttng_ht_seed), + ht_match_enum, reg_enum_lookup, &iter.iter); + node = lttng_ht_iter_get_node_str(&iter); + if (!node) { + goto end; + } + reg_enum = caa_container_of(node, struct ust_registry_enum, node); +end: + return reg_enum; +} + +/* + * Lookup enumeration by enum ID. + * Needs to be called from RCU read-side critical section. + */ +struct ust_registry_enum * + ust_registry_lookup_enum_by_id(struct ust_registry_session *session, + const char *enum_name, uint64_t enum_id) +{ + struct ust_registry_enum *reg_enum = NULL; + struct lttng_ht_node_str *node; + struct lttng_ht_iter iter; + struct ust_registry_enum reg_enum_lookup; + + memset(®_enum_lookup, 0, sizeof(reg_enum_lookup)); + strncpy(reg_enum_lookup.name, enum_name, LTTNG_UST_SYM_NAME_LEN); + reg_enum_lookup.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + reg_enum_lookup.id = enum_id; + cds_lfht_lookup(session->enums->ht, + ht_hash_enum((void *) ®_enum_lookup, lttng_ht_seed), + ht_match_enum_id, ®_enum_lookup, &iter.iter); + node = lttng_ht_iter_get_node_str(&iter); + if (!node) { + goto end; + } + reg_enum = caa_container_of(node, struct ust_registry_enum, node); +end: + return reg_enum; +} + +/* + * Create a ust_registry_enum from the given parameters and add it to the + * registry hash table, or find it if already there. + * + * On success, return 0 else a negative value. + * + * Should be called with session registry mutex held. + * + * We receive ownership of entries. + */ +int ust_registry_create_or_find_enum(struct ust_registry_session *session, + int session_objd, char *enum_name, + struct ustctl_enum_entry *entries, size_t nr_entries, + uint64_t *enum_id) +{ + int ret = 0; + struct cds_lfht_node *nodep; + struct ust_registry_enum *reg_enum = NULL, *old_reg_enum; + + assert(session); + assert(enum_name); + + rcu_read_lock(); + + /* + * This should not happen but since it comes from the UST tracer, an + * external party, don't assert and simply validate values. + */ + if (session_objd < 0) { + ret = -EINVAL; + goto end; + } + + /* Check if the enumeration was already dumped */ + reg_enum = zmalloc(sizeof(*reg_enum)); + if (!reg_enum) { + PERROR("zmalloc ust registry enumeration"); + ret = -ENOMEM; + goto end; + } + strncpy(reg_enum->name, enum_name, LTTNG_UST_SYM_NAME_LEN); + reg_enum->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + /* entries will be owned by reg_enum. */ + reg_enum->entries = entries; + reg_enum->nr_entries = nr_entries; + entries = NULL; + + old_reg_enum = ust_registry_lookup_enum(session, reg_enum); + if (old_reg_enum) { + DBG("enum %s already in sess_objd: %u", enum_name, session_objd); + /* Fall through. Use prior enum. */ + destroy_enum(reg_enum); + reg_enum = old_reg_enum; + } else { + DBG("UST registry creating enum: %s, sess_objd: %u", + enum_name, session_objd); + if (session->next_enum_id == -1ULL) { + ret = -EOVERFLOW; + destroy_enum(reg_enum); + goto end; + } + reg_enum->id = session->next_enum_id++; + cds_lfht_node_init(®_enum->node.node); + nodep = cds_lfht_add_unique(session->enums->ht, + ht_hash_enum(reg_enum, lttng_ht_seed), + ht_match_enum_id, reg_enum, + ®_enum->node.node); + assert(nodep == ®_enum->node.node); + } + DBG("UST registry reply with enum %s with id %" PRIu64 " in sess_objd: %u", + enum_name, reg_enum->id, session_objd); + *enum_id = reg_enum->id; +end: + free(entries); + rcu_read_unlock(); + return ret; +} + +/* + * For a given enumeration in a registry, delete the entry and destroy + * the enumeration. + * This MUST be called within a RCU read side lock section. + */ +static void ust_registry_destroy_enum(struct ust_registry_session *reg_session, + struct ust_registry_enum *reg_enum) +{ + int ret; + struct lttng_ht_iter iter; + + assert(reg_session); + assert(reg_enum); + + /* Delete the node first. */ + iter.iter.node = ®_enum->node.node; + ret = lttng_ht_del(reg_session->enums, &iter); + assert(!ret); + call_rcu(®_enum->rcu_head, destroy_enum_rcu); +} + /* * We need to execute ht_destroy outside of RCU read-side critical * section and outside of call_rcu thread, so we postpone its execution @@ -401,13 +722,23 @@ void destroy_channel_rcu(struct rcu_head *head) * free the registry pointer since it might not have been allocated before so * it's the caller responsability. */ -static void destroy_channel(struct ust_registry_channel *chan) +static void destroy_channel(struct ust_registry_channel *chan, bool notif) { struct lttng_ht_iter iter; struct ust_registry_event *event; + enum lttng_error_code cmd_ret; assert(chan); + if (notif) { + cmd_ret = notification_thread_command_remove_channel( + notification_thread_handle, chan->consumer_key, + LTTNG_DOMAIN_UST); + if (cmd_ret != LTTNG_OK) { + ERR("Failed to remove channel from notification thread"); + } + } + rcu_read_lock(); /* Destroy all event associated with this registry. */ cds_lfht_for_each_entry(chan->ht->ht, &iter.iter, event, node.node) { @@ -465,7 +796,7 @@ int ust_registry_channel_add(struct ust_registry_session *session, return 0; error: - destroy_channel(chan); + destroy_channel(chan, false); error_alloc: return ret; } @@ -504,7 +835,7 @@ end: * Remove channel using key from registry and free memory. */ void ust_registry_channel_del_free(struct ust_registry_session *session, - uint64_t key) + uint64_t key, bool notif) { struct lttng_ht_iter iter; struct ust_registry_channel *chan; @@ -523,7 +854,7 @@ void ust_registry_channel_del_free(struct ust_registry_session *session, ret = lttng_ht_del(session->channels, &iter); assert(!ret); rcu_read_unlock(); - destroy_channel(chan); + destroy_channel(chan, notif); end: return; @@ -550,7 +881,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp, const char *root_shm_path, const char *shm_path, uid_t euid, - gid_t egid) + gid_t egid, + uint64_t tracing_id, + uid_t tracing_uid) { int ret; struct ust_registry_session *session; @@ -574,6 +907,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp, session->metadata_fd = -1; session->uid = euid; session->gid = egid; + session->next_enum_id = 0; + session->major = major; + session->minor = minor; strncpy(session->root_shm_path, root_shm_path, sizeof(session->root_shm_path)); session->root_shm_path[sizeof(session->root_shm_path) - 1] = '\0'; @@ -609,6 +945,15 @@ int ust_registry_session_init(struct ust_registry_session **sessionp, session->metadata_fd = ret; } + session->enums = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); + if (!session->enums) { + ERR("Failed to create enums hash table"); + goto error; + } + /* hash/match functions are specified at call site. */ + session->enums->match_fct = NULL; + session->enums->hash_fct = NULL; + session->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64); if (!session->channels) { goto error; @@ -620,6 +965,9 @@ int ust_registry_session_init(struct ust_registry_session **sessionp, goto error; } + session->tracing_id = tracing_id; + session->tracing_uid = tracing_uid; + pthread_mutex_lock(&session->lock); ret = ust_metadata_session_statedump(session, app, major, minor); pthread_mutex_unlock(&session->lock); @@ -648,6 +996,7 @@ void ust_registry_session_destroy(struct ust_registry_session *reg) int ret; struct lttng_ht_iter iter; struct ust_registry_channel *chan; + struct ust_registry_enum *reg_enum; if (!reg) { return; @@ -665,7 +1014,7 @@ void ust_registry_session_destroy(struct ust_registry_session *reg) /* Delete the node from the ht and free it. */ ret = lttng_ht_del(reg->channels, &iter); assert(!ret); - destroy_channel(chan); + destroy_channel(chan, true); } rcu_read_unlock(); ht_cleanup_push(reg->channels); @@ -687,7 +1036,19 @@ void ust_registry_session_destroy(struct ust_registry_session *reg) /* * Try deleting the directory hierarchy. */ - (void) run_as_recursive_rmdir(reg->root_shm_path, - reg->uid, reg->gid); + (void) run_as_rmdir_recursive(reg->root_shm_path, + reg->uid, reg->gid, + LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG); + } + /* Destroy the enum hash table */ + if (reg->enums) { + rcu_read_lock(); + /* Destroy all enum entries associated with this registry. */ + cds_lfht_for_each_entry(reg->enums->ht, &iter.iter, reg_enum, + node.node) { + ust_registry_destroy_enum(reg, reg_enum); + } + rcu_read_unlock(); + ht_cleanup_push(reg->enums); } }