/*
* Copyright (C) 2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
* SPDX-License-Identifier: GPL-2.0-only
*
*/
+#include "lttng/tracker.h"
+#include "common/dynamic-array.h"
+#include "common/macros.h"
#define _LGPL_SOURCE
#include <grp.h>
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
+#include <urcu.h>
+#include <urcu/list.h>
+#include <urcu/rculfhash.h>
#include "tracker.h"
#include <common/defaults.h>
#include <common/error.h>
#include <common/hashtable/hashtable.h>
#include <common/hashtable/utils.h>
+#include <common/tracker.h>
#include <lttng/lttng-error.h>
-#include <lttng/tracker-internal.h>
-#define FALLBACK_USER_BUFLEN 16384
-#define FALLBACK_GROUP_BUFLEN 16384
+struct process_attr_tracker_value_node {
+ struct process_attr_value *value;
+ struct cds_lfht_node inclusion_set_ht_node;
+ struct rcu_head rcu_head;
+};
-struct lttng_tracker_list *lttng_tracker_list_create(void)
+struct process_attr_tracker {
+ enum lttng_tracking_policy policy;
+ struct cds_lfht *inclusion_set_ht;
+};
+
+static void process_attr_tracker_value_node_rcu_free(struct rcu_head *rcu_head)
+{
+ struct process_attr_tracker_value_node *node =
+ container_of(rcu_head, typeof(*node), rcu_head);
+
+ free(node);
+}
+
+struct process_attr_tracker *process_attr_tracker_create(void)
{
- struct lttng_tracker_list *t;
+ struct process_attr_tracker *tracker;
- t = zmalloc(sizeof(*t));
- if (!t) {
+ tracker = zmalloc(sizeof(*tracker));
+ if (!tracker) {
return NULL;
}
- t->ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
+
+ (void) process_attr_tracker_set_tracking_policy(
+ tracker, LTTNG_TRACKING_POLICY_INCLUDE_ALL);
+
+ tracker->inclusion_set_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
- if (!t->ht) {
+ if (!tracker->inclusion_set_ht) {
goto error;
}
- CDS_INIT_LIST_HEAD(&t->list_head);
- t->state = LTTNG_TRACK_ALL;
- return t;
+ return tracker;
error:
- free(t);
+ process_attr_tracker_destroy(tracker);
return NULL;
}
-static int match_tracker_key(struct cds_lfht_node *node, const void *key)
+static void process_attr_tracker_remove_value_node(
+ struct process_attr_tracker *tracker,
+ struct process_attr_tracker_value_node *value_node)
{
- const struct lttng_tracker_id *tracker_key = key;
- struct lttng_tracker_list_node *tracker_node;
-
- tracker_node = caa_container_of(
- node, struct lttng_tracker_list_node, ht_node);
-
- return lttng_tracker_id_is_equal(tracker_node->id, tracker_key);
+ cds_lfht_del(tracker->inclusion_set_ht,
+ &value_node->inclusion_set_ht_node);
+ process_attr_value_destroy(value_node->value);
+ call_rcu(&value_node->rcu_head,
+ process_attr_tracker_value_node_rcu_free);
}
-static unsigned long hash_tracker_key(
- const struct lttng_tracker_id *tracker_key)
+static void process_attr_tracker_clear_inclusion_set(
+ struct process_attr_tracker *tracker)
{
- unsigned long key_hash = 0;
- int value;
- const char *string;
- enum lttng_tracker_id_type type;
-
- /* We do not care for invalid state during hash computation */
- type = lttng_tracker_id_get_type(tracker_key);
- (void) lttng_tracker_id_get_value(tracker_key, &value);
- (void) lttng_tracker_id_get_string(tracker_key, &string);
-
- switch (type) {
- case LTTNG_ID_ALL:
- break;
- case LTTNG_ID_VALUE:
- key_hash ^= hash_key_ulong(
- (void *) (unsigned long) value, lttng_ht_seed);
- break;
- case LTTNG_ID_STRING:
- key_hash ^= hash_key_str(string, lttng_ht_seed);
- break;
- case LTTNG_ID_UNKNOWN:
- break;
- }
- key_hash ^= hash_key_ulong(
- (void *) (unsigned long) type, lttng_ht_seed);
- return key_hash;
-}
+ int ret;
+ struct lttng_ht_iter iter;
+ struct process_attr_tracker_value_node *value_node;
-static struct lttng_tracker_id **lttng_tracker_list_lookup(
- const struct lttng_tracker_list *tracker_list,
- const struct lttng_tracker_id *key)
-{
- struct lttng_tracker_list_node *list_node;
- struct cds_lfht_iter iter;
- struct cds_lfht_node *node;
+ if (!tracker->inclusion_set_ht) {
+ return;
+ }
- cds_lfht_lookup(tracker_list->ht, hash_tracker_key(key),
- match_tracker_key, key, &iter);
- node = cds_lfht_iter_get_node(&iter);
- if (!node) {
- return NULL;
+ rcu_read_lock();
+ cds_lfht_for_each_entry (tracker->inclusion_set_ht, &iter.iter,
+ value_node, inclusion_set_ht_node) {
+ process_attr_tracker_remove_value_node(tracker, value_node);
}
- list_node = caa_container_of(
- node, struct lttng_tracker_list_node, ht_node);
- return &list_node->id;
+ rcu_read_unlock();
+ ret = cds_lfht_destroy(tracker->inclusion_set_ht, NULL);
+ assert(ret == 0);
+ tracker->inclusion_set_ht = NULL;
}
-static void destroy_list_node_rcu(struct rcu_head *head)
+static int process_attr_tracker_create_inclusion_set(
+ struct process_attr_tracker *tracker)
{
- struct lttng_tracker_list_node *n = caa_container_of(
- head, struct lttng_tracker_list_node, rcu_head);
-
- lttng_tracker_id_destroy(n->id);
- free(n);
+ assert(!tracker->inclusion_set_ht);
+ tracker->inclusion_set_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
+ CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
+ return tracker->inclusion_set_ht ? 0 : -1;
}
-static void _lttng_tracker_list_remove(struct lttng_tracker_list *tracker_list,
- struct lttng_tracker_list_node *n)
+void process_attr_tracker_destroy(struct process_attr_tracker *tracker)
{
- cds_list_del(&n->list_node);
-
- rcu_read_lock();
- cds_lfht_del(tracker_list->ht, &n->ht_node);
- rcu_read_unlock();
+ if (!tracker) {
+ return;
+ }
- call_rcu(&n->rcu_head, destroy_list_node_rcu);
+ process_attr_tracker_clear_inclusion_set(tracker);
+ free(tracker);
}
-static void lttng_tracker_list_reset(struct lttng_tracker_list *tracker_list)
+enum lttng_tracking_policy process_attr_tracker_get_tracking_policy(
+ const struct process_attr_tracker *tracker)
{
- struct lttng_tracker_list_node *n, *t;
-
- cds_list_for_each_entry_safe (
- n, t, &tracker_list->list_head, list_node) {
- _lttng_tracker_list_remove(tracker_list, n);
- }
- tracker_list->state = LTTNG_TRACK_ALL;
+ return tracker->policy;
}
-/* Protected by session mutex held by caller. */
-int lttng_tracker_list_add(struct lttng_tracker_list *tracker_list,
- const struct lttng_tracker_id *_id)
+int process_attr_tracker_set_tracking_policy(
+ struct process_attr_tracker *tracker,
+ enum lttng_tracking_policy tracking_policy)
{
- struct lttng_tracker_id **id;
- struct lttng_tracker_list_node *n = NULL;
- int ret;
+ int ret = 0;
- if (lttng_tracker_id_get_type(_id) == LTTNG_ID_ALL) {
- /* Track all, so remove each individual item. */
- lttng_tracker_list_reset(tracker_list);
- ret = LTTNG_OK;
- goto error;
- }
- rcu_read_lock();
- id = lttng_tracker_list_lookup(tracker_list, _id);
- /*
- * It is okay to release the RCU read lock here since id is only checked
- * for != NULL and not dereferenced.
- */
- rcu_read_unlock();
- if (id) {
- ret = LTTNG_ERR_ID_TRACKED;
- goto error;
- }
- n = zmalloc(sizeof(*n));
- if (!n) {
- ret = LTTNG_ERR_NOMEM;
- goto error;
+ if (tracker->policy == tracking_policy) {
+ goto end;
}
- n->id = lttng_tracker_id_duplicate(_id);
- if (!n->id) {
- ret = LTTNG_ERR_NOMEM;
- goto error;
+ process_attr_tracker_clear_inclusion_set(tracker);
+ ret = process_attr_tracker_create_inclusion_set(tracker);
+ if (ret) {
+ goto end;
}
-
- cds_list_add_tail(&n->list_node, &tracker_list->list_head);
- tracker_list->state = LTTNG_TRACK_LIST;
-
- rcu_read_lock();
- cds_lfht_add(tracker_list->ht, hash_tracker_key(n->id), &n->ht_node);
- rcu_read_unlock();
-
- return LTTNG_OK;
-
-error:
- free(n);
+ tracker->policy = tracking_policy;
+end:
return ret;
}
-/*
- * Lookup and remove.
- * Protected by session mutex held by caller.
- */
-int lttng_tracker_list_remove(struct lttng_tracker_list *tracker_list,
- const struct lttng_tracker_id *_id)
+static int match_inclusion_set_value(
+ struct cds_lfht_node *node, const void *key)
{
- enum lttng_error_code ret = LTTNG_OK;
- struct lttng_tracker_id **id;
- struct lttng_tracker_list_node *n;
-
- if (lttng_tracker_id_get_type(_id) == LTTNG_ID_ALL) {
- /* Untrack all. */
- lttng_tracker_list_reset(tracker_list);
- /* Set state to "track none". */
- tracker_list->state = LTTNG_TRACK_NONE;
- goto end;
- }
+ const struct process_attr_value *value_key = key;
+ const struct process_attr_tracker_value_node *value_node =
+ caa_container_of(node,
+ struct process_attr_tracker_value_node,
+ inclusion_set_ht_node);
- rcu_read_lock();
- id = lttng_tracker_list_lookup(tracker_list, _id);
- if (!id) {
- ret = LTTNG_ERR_ID_NOT_TRACKED;
- goto rcu_unlock;
- }
+ return process_attr_tracker_value_equal(value_node->value, value_key);
+}
- n = caa_container_of(id, struct lttng_tracker_list_node, id);
- _lttng_tracker_list_remove(tracker_list, n);
+static struct process_attr_tracker_value_node *process_attr_tracker_lookup(
+ const struct process_attr_tracker *tracker,
+ const struct process_attr_value *value)
+{
+ struct cds_lfht_iter iter;
+ struct cds_lfht_node *node;
-rcu_unlock:
+ assert(tracker->policy == LTTNG_TRACKING_POLICY_INCLUDE_SET);
+
+ rcu_read_lock();
+ cds_lfht_lookup(tracker->inclusion_set_ht,
+ process_attr_value_hash(value),
+ match_inclusion_set_value, value, &iter);
+ node = cds_lfht_iter_get_node(&iter);
rcu_read_unlock();
-end:
- return ret;
+
+ return node ? container_of(node, struct process_attr_tracker_value_node,
+ inclusion_set_ht_node) :
+ NULL;
}
-void lttng_tracker_list_destroy(struct lttng_tracker_list *tracker_list)
+/* Protected by session mutex held by caller. */
+enum process_attr_tracker_status process_attr_tracker_inclusion_set_add_value(
+ struct process_attr_tracker *tracker,
+ const struct process_attr_value *value)
{
- int ret;
+ enum process_attr_tracker_status status =
+ PROCESS_ATTR_TRACKER_STATUS_OK;
+ struct process_attr_value *value_copy = NULL;
+ struct process_attr_tracker_value_node *value_node = NULL;
- if (!tracker_list) {
- return;
+ rcu_read_lock();
+ if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
+ status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
+ goto end;
}
- lttng_tracker_list_reset(tracker_list);
- ret = cds_lfht_destroy(tracker_list->ht, NULL);
- assert(!ret);
- free(tracker_list);
-}
-static int lttng_lookup_user(const char *username, int *result)
-{
- struct passwd p, *pres;
- int ret, retval = LTTNG_OK;
- char *buf = NULL;
- ssize_t buflen;
-
- buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
- if (buflen < 0) {
- buflen = FALLBACK_USER_BUFLEN;
- }
- buf = zmalloc(buflen);
- if (!buf) {
- retval = LTTNG_ERR_NOMEM;
+ if (process_attr_tracker_lookup(tracker, value)) {
+ status = PROCESS_ATTR_TRACKER_STATUS_EXISTS;
goto end;
}
- for (;;) {
- ret = getpwnam_r(username, &p, buf, buflen, &pres);
- switch (ret) {
- case EINTR:
- continue;
- case ERANGE:
- buflen *= 2;
- free(buf);
- buf = zmalloc(buflen);
- if (!buf) {
- retval = LTTNG_ERR_NOMEM;
- goto end;
- }
- continue;
- default:
- goto end_loop;
- }
- }
-end_loop:
-
- switch (ret) {
- case 0:
- if (pres == NULL) {
- retval = LTTNG_ERR_USER_NOT_FOUND;
- } else {
- *result = (int) p.pw_uid;
- DBG("Lookup of tracker UID/VUID: name '%s' maps to id %d.",
- username, *result);
- retval = LTTNG_OK;
- }
- break;
- case ENOENT:
- case ESRCH:
- case EBADF:
- case EPERM:
- retval = LTTNG_ERR_USER_NOT_FOUND;
- break;
- default:
- retval = LTTNG_ERR_NOMEM;
- }
-end:
- free(buf);
- return retval;
-}
-static int lttng_lookup_group(const char *groupname, int *result)
-{
- struct group g, *gres;
- int ret, retval = LTTNG_OK;
- char *buf = NULL;
- ssize_t buflen;
-
- buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
- if (buflen < 0) {
- buflen = FALLBACK_GROUP_BUFLEN;
+ value_node = zmalloc(sizeof(*value_node));
+ if (!value_node) {
+ status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+ goto end;
}
- buf = zmalloc(buflen);
- if (!buf) {
- retval = LTTNG_ERR_NOMEM;
+
+ value_copy = process_attr_value_copy(value);
+ if (!value_copy) {
+ status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
goto end;
}
- for (;;) {
- ret = getgrnam_r(groupname, &g, buf, buflen, &gres);
- switch (ret) {
- case EINTR:
- continue;
- case ERANGE:
- buflen *= 2;
- free(buf);
- buf = zmalloc(buflen);
- if (!buf) {
- retval = LTTNG_ERR_NOMEM;
- goto end;
- }
- continue;
- default:
- goto end_loop;
- }
+
+ value_node->value = value_copy;
+ cds_lfht_add(tracker->inclusion_set_ht,
+ process_attr_value_hash(value_copy),
+ &value_node->inclusion_set_ht_node);
+ value_copy = NULL;
+ value_node = NULL;
+end:
+ if (value_copy) {
+ process_attr_value_destroy(value_copy);
}
-end_loop:
-
- switch (ret) {
- case 0:
- if (gres == NULL) {
- retval = LTTNG_ERR_GROUP_NOT_FOUND;
- } else {
- *result = (int) g.gr_gid;
- DBG("Lookup of tracker GID/GUID: name '%s' maps to id %d.",
- groupname, *result);
- retval = LTTNG_OK;
- }
- break;
- case ENOENT:
- case ESRCH:
- case EBADF:
- case EPERM:
- retval = LTTNG_ERR_GROUP_NOT_FOUND;
- break;
- default:
- retval = LTTNG_ERR_NOMEM;
+ if (value_node) {
+ free(value_node);
}
-end:
- free(buf);
- return retval;
+ rcu_read_unlock();
+ return status;
}
-int lttng_tracker_id_lookup_string(enum lttng_tracker_type tracker_type,
- const struct lttng_tracker_id *id,
- int *result)
+/* Protected by session mutex held by caller. */
+enum process_attr_tracker_status
+process_attr_tracker_inclusion_set_remove_value(
+ struct process_attr_tracker *tracker,
+ const struct process_attr_value *value)
{
- enum lttng_tracker_id_status status;
- int value;
- const char *string;
-
- switch (lttng_tracker_id_get_type(id)) {
- case LTTNG_ID_ALL:
- *result = -1;
- return LTTNG_OK;
- case LTTNG_ID_VALUE:
- status = lttng_tracker_id_get_value(id, &value);
- if (status != LTTNG_TRACKER_ID_STATUS_OK) {
- return LTTNG_ERR_INVALID;
- }
- *result = id->value;
- return LTTNG_OK;
- case LTTNG_ID_STRING:
- status = lttng_tracker_id_get_string(id, &string);
- if (status != LTTNG_TRACKER_ID_STATUS_OK) {
- return LTTNG_ERR_INVALID;
- }
- switch (tracker_type) {
- case LTTNG_TRACKER_PID:
- case LTTNG_TRACKER_VPID:
- ERR("Lookup of tracker PID/VPID by name unsupported.");
- return LTTNG_ERR_INVALID;
- case LTTNG_TRACKER_UID:
- case LTTNG_TRACKER_VUID:
- DBG("Lookup of tracker UID/VUID by name.");
- return lttng_lookup_user(string, result);
- case LTTNG_TRACKER_GID:
- case LTTNG_TRACKER_VGID:
- DBG("Lookup of tracker GID/VGID by name.");
- return lttng_lookup_group(string, result);
- default:
- return LTTNG_ERR_INVALID;
- }
- default:
- return LTTNG_ERR_INVALID;
- }
-}
+ struct process_attr_tracker_value_node *value_node;
+ enum process_attr_tracker_status status =
+ PROCESS_ATTR_TRACKER_STATUS_OK;
-/*
- * Protected by session mutex held by caller.
- * On success, _ids and the ids it contains must be freed by the caller.
- */
-int lttng_tracker_id_get_list(const struct lttng_tracker_list *tracker_list,
- struct lttng_tracker_ids **_ids)
-{
- int retval = LTTNG_OK, ret;
- struct lttng_tracker_list_node *n;
- ssize_t count = 0, i = 0;
- struct lttng_tracker_ids *ids = NULL;
- struct lttng_tracker_id *id;
- enum lttng_tracker_id_status status;
-
- switch (tracker_list->state) {
- case LTTNG_TRACK_LIST:
- cds_list_for_each_entry (
- n, &tracker_list->list_head, list_node) {
- count++;
- }
- ids = lttng_tracker_ids_create(count);
- if (ids == NULL) {
- PERROR("Failed to allocate tracked ID list");
- retval = -LTTNG_ERR_NOMEM;
- goto end;
- }
- cds_list_for_each_entry (
- n, &tracker_list->list_head, list_node) {
- id = lttng_tracker_ids_get_pointer_of_index(ids, i);
- if (!id) {
- retval = -LTTNG_ERR_INVALID;
- goto error;
- }
-
- ret = lttng_tracker_id_copy(id, n->id);
- if (ret) {
- retval = -LTTNG_ERR_NOMEM;
- goto error;
- }
- i++;
- }
- break;
- case LTTNG_TRACK_ALL:
-
- ids = lttng_tracker_ids_create(1);
- if (ids == NULL) {
- PERROR("Failed to allocate tracked ID list");
- retval = -LTTNG_ERR_NOMEM;
- goto end;
- }
+ rcu_read_lock();
+ if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
+ status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
+ goto end;
+ }
- id = lttng_tracker_ids_get_pointer_of_index(ids, 0);
- status = lttng_tracker_id_set_all(id);
- if (status != LTTNG_TRACKER_ID_STATUS_OK) {
- ERR("Invalid tracker id for track all");
- retval = -LTTNG_ERR_INVALID;
- goto error;
- }
- break;
- case LTTNG_TRACK_NONE:
- /* No ids track, so we return 0 element collection. */
- ids = lttng_tracker_ids_create(0);
- if (ids == NULL) {
- PERROR("alloc list ids");
- retval = -LTTNG_ERR_NOMEM;
- goto end;
- }
- break;
+ value_node = process_attr_tracker_lookup(tracker, value);
+ if (!value_node) {
+ status = PROCESS_ATTR_TRACKER_STATUS_MISSING;
+ goto end;
}
- *_ids = ids;
+ process_attr_tracker_remove_value_node(tracker, value_node);
end:
- return retval;
-
-error:
- lttng_tracker_ids_destroy(ids);
- return retval;
+ rcu_read_unlock();
+ return status;
}
-int lttng_tracker_id_set_list(struct lttng_tracker_list *tracker_list,
- const struct lttng_tracker_ids *ids)
+enum process_attr_tracker_status process_attr_tracker_get_inclusion_set(
+ const struct process_attr_tracker *tracker,
+ struct lttng_process_attr_values **_values)
{
- unsigned int i, count;
- const struct lttng_tracker_id *id;
- enum lttng_tracker_id_status status;
-
- assert(tracker_list);
- assert(ids);
-
- lttng_tracker_list_reset(tracker_list);
-
- status = lttng_tracker_ids_get_count(ids, &count);
- if (status != LTTNG_TRACKER_ID_STATUS_OK) {
- return LTTNG_ERR_INVALID;
+ struct lttng_ht_iter iter;
+ struct process_attr_tracker_value_node *value_node;
+ enum process_attr_tracker_status status =
+ PROCESS_ATTR_TRACKER_STATUS_OK;
+ struct lttng_process_attr_values *values;
+ struct process_attr_value *new_value = NULL;
+
+ values = lttng_process_attr_values_create();
+ if (!values) {
+ status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+ goto error;
}
- if (count == 0) {
- /* Set state to "track none". */
- tracker_list->state = LTTNG_TRACK_NONE;
- return LTTNG_OK;
+ if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
+ status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
+ goto error;
}
- if (count == 1) {
- id = lttng_tracker_ids_get_at_index(ids, 0);
- if (lttng_tracker_id_get_type(id) == LTTNG_ID_ALL) {
- /* Track all. */
- return LTTNG_OK;
+ rcu_read_lock();
+ cds_lfht_for_each_entry (tracker->inclusion_set_ht, &iter.iter,
+ value_node, inclusion_set_ht_node) {
+ int ret;
+
+ new_value = process_attr_value_copy(value_node->value);
+ if (!new_value) {
+ status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+ goto error_unlock;
}
- }
- for (i = 0; i < count; i++) {
- int ret;
- id = lttng_tracker_ids_get_at_index(ids, i);
- ret = lttng_tracker_list_add(tracker_list, id);
- if (ret != LTTNG_OK) {
- return ret;
+ ret = lttng_dynamic_pointer_array_add_pointer(
+ &values->array, new_value);
+ if (ret) {
+ status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+ goto error_unlock;
}
+
+ new_value = NULL;
}
- return LTTNG_OK;
+ rcu_read_unlock();
+ *_values = values;
+ return status;
+error_unlock:
+ rcu_read_unlock();
+error:
+ lttng_process_attr_values_destroy(values);
+ process_attr_value_destroy(new_value);
+ return status;
}
projects / lttng-tools.git / blobdiff