X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=src%2Fside.c;h=67f57bea2cfb381ff50e09ee77322b02b89fce18;hb=92c377f9b51720376d64c8d7c5bb5a2f67eabc9d;hp=b180e416e64b558f70117fdb6ed00e25ca80b3c4;hpb=b2a84b9fd88e0e5abed91793b6667ce891ca0327;p=libside.git

diff --git a/src/side.c b/src/side.c
index b180e41..67f57be 100644
--- a/src/side.c
+++ b/src/side.c
@@ -38,6 +38,20 @@ struct side_tracer_handle {
 	void *priv;
 };
 
+struct side_callback {
+	union {
+		void (*call)(const struct side_event_description *desc,
+			const struct side_arg_vec *side_arg_vec,
+			void *priv);
+		void (*call_variadic)(const struct side_event_description *desc,
+			const struct side_arg_vec *side_arg_vec,
+			const struct side_arg_dynamic_struct *var_struct,
+			void *priv);
+	} u;
+	void *priv;
+	void *key;
+};
+
 static struct side_rcu_gp_state rcu_gp;
 
 /*
@@ -61,9 +75,9 @@ static DEFINE_SIDE_LIST_HEAD(side_tracer_list);
  * The empty callback has a NULL function callback pointer, which stops
  * iteration on the array of callbacks immediately.
  */
-const struct side_callback side_empty_callback = { };
+const char side_empty_callback[sizeof(struct side_callback)];
 
-void side_call(const struct side_event_state *event_state, const struct side_arg_vec *side_arg_vec)
+void side_call_key(const struct side_event_state *event_state, const struct side_arg_vec *side_arg_vec, void *key)
 {
 	struct side_rcu_read_state rcu_read_state;
 	const struct side_event_state_0 *es0;
@@ -76,21 +90,31 @@ void side_call(const struct side_event_state *event_state, const struct side_arg
 		side_init();
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, const struct side_event_state_0, p);
-	assert(!(side_ptr_get(es0->desc)->flags & SIDE_EVENT_FLAG_VARIADIC));
+	es0 = side_container_of(event_state, const struct side_event_state_0, parent);
+	assert(!(es0->desc->flags & SIDE_EVENT_FLAG_VARIADIC));
 	enabled = __atomic_load_n(&es0->enabled, __ATOMIC_RELAXED);
 	if (side_unlikely(enabled & SIDE_EVENT_ENABLED_KERNEL_USER_EVENT_MASK)) {
 		// TODO: call kernel write.
 	}
 	side_rcu_read_begin(&rcu_gp, &rcu_read_state);
-	for (side_cb = side_rcu_dereference(side_ptr_get(es0->callbacks)); side_cb->u.call != NULL; side_cb++)
-		side_cb->u.call(side_ptr_get(es0->desc), side_arg_vec, side_cb->priv);
+	for (side_cb = side_rcu_dereference(es0->callbacks); side_cb->u.call != NULL; side_cb++) {
+		/* A NULL key is always a match. */
+		if (key && side_cb->key && side_cb->key != key)
+			continue;
+		side_cb->u.call(es0->desc, side_arg_vec, side_cb->priv);
+	}
 	side_rcu_read_end(&rcu_gp, &rcu_read_state);
 }
 
-void side_call_variadic(const struct side_event_state *event_state,
+void side_call(const struct side_event_state *event_state, const struct side_arg_vec *side_arg_vec)
+{
+	side_call_key(event_state, side_arg_vec, NULL);
+}
+
+void side_call_variadic_key(const struct side_event_state *event_state,
 	const struct side_arg_vec *side_arg_vec,
-	const struct side_arg_dynamic_struct *var_struct)
+	const struct side_arg_dynamic_struct *var_struct,
+	void *key)
 {
 	struct side_rcu_read_state rcu_read_state;
 	const struct side_event_state_0 *es0;
@@ -103,22 +127,33 @@ void side_call_variadic(const struct side_event_state *event_state,
 		side_init();
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, const struct side_event_state_0, p);
-	assert(side_ptr_get(es0->desc)->flags & SIDE_EVENT_FLAG_VARIADIC);
+	es0 = side_container_of(event_state, const struct side_event_state_0, parent);
+	assert(es0->desc->flags & SIDE_EVENT_FLAG_VARIADIC);
 	enabled = __atomic_load_n(&es0->enabled, __ATOMIC_RELAXED);
 	if (side_unlikely(enabled & SIDE_EVENT_ENABLED_KERNEL_USER_EVENT_MASK)) {
 		// TODO: call kernel write.
 	}
 	side_rcu_read_begin(&rcu_gp, &rcu_read_state);
-	for (side_cb = side_rcu_dereference(side_ptr_get(es0->callbacks)); side_cb->u.call_variadic != NULL; side_cb++)
-		side_cb->u.call_variadic(side_ptr_get(es0->desc), side_arg_vec, var_struct, side_cb->priv);
+	for (side_cb = side_rcu_dereference(es0->callbacks); side_cb->u.call_variadic != NULL; side_cb++) {
+		/* A NULL key is always a match. */
+		if (key && side_cb->key && side_cb->key != key)
+			continue;
+		side_cb->u.call_variadic(es0->desc, side_arg_vec, var_struct, side_cb->priv);
+	}
 	side_rcu_read_end(&rcu_gp, &rcu_read_state);
 }
 
+void side_call_variadic(const struct side_event_state *event_state,
+	const struct side_arg_vec *side_arg_vec,
+	const struct side_arg_dynamic_struct *var_struct)
+{
+	side_call_variadic_key(event_state, side_arg_vec, var_struct, NULL);
+}
+
 static
 const struct side_callback *side_tracer_callback_lookup(
 		const struct side_event_description *desc,
-		void *call, void *priv)
+		void *call, void *priv, void *key)
 {
 	struct side_event_state *event_state = side_ptr_get(desc->state);
 	const struct side_event_state_0 *es0;
@@ -126,9 +161,9 @@ const struct side_callback *side_tracer_callback_lookup(
 
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, const struct side_event_state_0, p);
-	for (cb = side_ptr_get(es0->callbacks); cb->u.call != NULL; cb++) {
-		if ((void *) cb->u.call == call && cb->priv == priv)
+	es0 = side_container_of(event_state, const struct side_event_state_0, parent);
+	for (cb = es0->callbacks; cb->u.call != NULL; cb++) {
+		if ((void *) cb->u.call == call && cb->priv == priv && cb->key == key)
 			return cb;
 	}
 	return NULL;
@@ -136,7 +171,7 @@ const struct side_callback *side_tracer_callback_lookup(
 
 static
 int _side_tracer_callback_register(struct side_event_description *desc,
-		void *call, void *priv)
+		void *call, void *priv, void *key)
 {
 	struct side_event_state *event_state;
 	struct side_callback *old_cb, *new_cb;
@@ -154,18 +189,18 @@ int _side_tracer_callback_register(struct side_event_description *desc,
 	event_state = side_ptr_get(desc->state);
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, struct side_event_state_0, p);
-	old_nr_cb = desc->nr_callbacks;
+	es0 = side_container_of(event_state, struct side_event_state_0, parent);
+	old_nr_cb = es0->nr_callbacks;
 	if (old_nr_cb == UINT32_MAX) {
 		ret = SIDE_ERROR_INVAL;
 		goto unlock;
 	}
 	/* Reject duplicate (call, priv) tuples. */
-	if (side_tracer_callback_lookup(desc, call, priv)) {
+	if (side_tracer_callback_lookup(desc, call, priv, key)) {
 		ret = SIDE_ERROR_EXIST;
 		goto unlock;
 	}
-	old_cb = (struct side_callback *) side_ptr_get(es0->callbacks);
+	old_cb = (struct side_callback *) es0->callbacks;
 	/* old_nr_cb + 1 (new cb) + 1 (NULL) */
 	new_cb = (struct side_callback *) calloc(old_nr_cb + 2, sizeof(struct side_callback));
 	if (!new_cb) {
@@ -180,12 +215,13 @@ int _side_tracer_callback_register(struct side_event_description *desc,
 		new_cb[old_nr_cb].u.call =
 			(side_tracer_callback_func) call;
 	new_cb[old_nr_cb].priv = priv;
+	new_cb[old_nr_cb].key = key;
 	/* High order bits are already zeroed. */
-	side_rcu_assign_pointer(side_ptr_get(es0->callbacks), new_cb);
+	side_rcu_assign_pointer(es0->callbacks, new_cb);
 	side_rcu_wait_grace_period(&rcu_gp);
 	if (old_nr_cb)
 		free(old_cb);
-	desc->nr_callbacks++;
+	es0->nr_callbacks++;
 	/* Increment concurrently with kernel setting the top bits. */
 	if (!old_nr_cb)
 		(void) __atomic_add_fetch(&es0->enabled, 1, __ATOMIC_RELAXED);
@@ -196,24 +232,24 @@ unlock:
 
 int side_tracer_callback_register(struct side_event_description *desc,
 		side_tracer_callback_func call,
-		void *priv)
+		void *priv, void *key)
 {
 	if (desc->flags & SIDE_EVENT_FLAG_VARIADIC)
 		return SIDE_ERROR_INVAL;
-	return _side_tracer_callback_register(desc, (void *) call, priv);
+	return _side_tracer_callback_register(desc, (void *) call, priv, key);
 }
 
 int side_tracer_callback_variadic_register(struct side_event_description *desc,
 		side_tracer_callback_variadic_func call_variadic,
-		void *priv)
+		void *priv, void *key)
 {
 	if (!(desc->flags & SIDE_EVENT_FLAG_VARIADIC))
 		return SIDE_ERROR_INVAL;
-	return _side_tracer_callback_register(desc, (void *) call_variadic, priv);
+	return _side_tracer_callback_register(desc, (void *) call_variadic, priv, key);
 }
 
 static int _side_tracer_callback_unregister(struct side_event_description *desc,
-		void *call, void *priv)
+		void *call, void *priv, void *key)
 {
 	struct side_event_state *event_state;
 	struct side_callback *old_cb, *new_cb;
@@ -233,18 +269,18 @@ static int _side_tracer_callback_unregister(struct side_event_description *desc,
 	event_state = side_ptr_get(desc->state);
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, struct side_event_state_0, p);
-	cb_pos = side_tracer_callback_lookup(desc, call, priv);
+	es0 = side_container_of(event_state, struct side_event_state_0, parent);
+	cb_pos = side_tracer_callback_lookup(desc, call, priv, key);
 	if (!cb_pos) {
 		ret = SIDE_ERROR_NOENT;
 		goto unlock;
 	}
-	old_nr_cb = desc->nr_callbacks;
-	old_cb = (struct side_callback *) side_ptr_get(es0->callbacks);
+	old_nr_cb = es0->nr_callbacks;
+	old_cb = (struct side_callback *) es0->callbacks;
 	if (old_nr_cb == 1) {
 		new_cb = (struct side_callback *) &side_empty_callback;
 	} else {
-		pos_idx = cb_pos - side_ptr_get(es0->callbacks);
+		pos_idx = cb_pos - es0->callbacks;
 		/* Remove entry at pos_idx. */
 		/* old_nr_cb - 1 (removed cb) + 1 (NULL) */
 		new_cb = (struct side_callback *) calloc(old_nr_cb, sizeof(struct side_callback));
@@ -256,10 +292,10 @@ static int _side_tracer_callback_unregister(struct side_event_description *desc,
 		memcpy(&new_cb[pos_idx], &old_cb[pos_idx + 1], old_nr_cb - pos_idx - 1);
 	}
 	/* High order bits are already zeroed. */
-	side_rcu_assign_pointer(side_ptr_get(es0->callbacks), new_cb);
+	side_rcu_assign_pointer(es0->callbacks, new_cb);
 	side_rcu_wait_grace_period(&rcu_gp);
 	free(old_cb);
-	desc->nr_callbacks--;
+	es0->nr_callbacks--;
 	/* Decrement concurrently with kernel setting the top bits. */
 	if (old_nr_cb == 1)
 		(void) __atomic_add_fetch(&es0->enabled, -1, __ATOMIC_RELAXED);
@@ -270,20 +306,20 @@ unlock:
 
 int side_tracer_callback_unregister(struct side_event_description *desc,
 		side_tracer_callback_func call,
-		void *priv)
+		void *priv, void *key)
 {
 	if (desc->flags & SIDE_EVENT_FLAG_VARIADIC)
 		return SIDE_ERROR_INVAL;
-	return _side_tracer_callback_unregister(desc, (void *) call, priv);
+	return _side_tracer_callback_unregister(desc, (void *) call, priv, key);
 }
 
 int side_tracer_callback_variadic_unregister(struct side_event_description *desc,
 		side_tracer_callback_variadic_func call_variadic,
-		void *priv)
+		void *priv, void *key)
 {
 	if (!(desc->flags & SIDE_EVENT_FLAG_VARIADIC))
 		return SIDE_ERROR_INVAL;
-	return _side_tracer_callback_unregister(desc, (void *) call_variadic, priv);
+	return _side_tracer_callback_unregister(desc, (void *) call_variadic, priv, key);
 }
 
 struct side_events_register_handle *side_events_register(struct side_event_description **events, uint32_t nr_events)
@@ -317,24 +353,25 @@ static
 void side_event_remove_callbacks(struct side_event_description *desc)
 {
 	struct side_event_state *event_state = side_ptr_get(desc->state);
-	uint32_t nr_cb = desc->nr_callbacks;
 	struct side_event_state_0 *es0;
 	struct side_callback *old_cb;
+	uint32_t nr_cb;
 
-	if (!nr_cb)
-		return;
 	if (side_unlikely(event_state->version != 0))
 		abort();
-	es0 = side_container_of(event_state, struct side_event_state_0, p);
-	old_cb = (struct side_callback *) side_ptr_get(es0->callbacks);
+	es0 = side_container_of(event_state, struct side_event_state_0, parent);
+	nr_cb = es0->nr_callbacks;
+	if (!nr_cb)
+		return;
+	old_cb = (struct side_callback *) es0->callbacks;
 	(void) __atomic_add_fetch(&es0->enabled, -1, __ATOMIC_RELAXED);
 	/*
 	 * Setting the state back to 0 cb and empty callbacks out of
 	 * caution. This should not matter because instrumentation is
 	 * unreachable.
 	 */
-	desc->nr_callbacks = 0;
-	side_rcu_assign_pointer(side_ptr_get(es0->callbacks), &side_empty_callback);
+	es0->nr_callbacks = 0;
+	side_rcu_assign_pointer(es0->callbacks, &side_empty_callback);
 	/*
 	 * No need to wait for grace period because instrumentation is
 	 * unreachable.