X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttng-events.c;h=7cd9fa1a727dc3c966eb7c83076996d897ca618c;hb=refs%2Fheads%2Fstable-2.11;hp=f5948f076283740f6a16f2487e23a42f26e3ddaa;hpb=073fe00c5096e6ecceee2240418a8bab8a46569a;p=lttng-modules.git

diff --git a/lttng-events.c b/lttng-events.c
index f5948f07..7cd9fa1a 100644
--- a/lttng-events.c
+++ b/lttng-events.c
@@ -78,21 +78,22 @@ int _lttng_field_statedump(struct lttng_session *session,
 
 void synchronize_trace(void)
 {
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) || \
+	LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
 	synchronize_rcu();
 #else
 	synchronize_sched();
 #endif
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
 #ifdef CONFIG_PREEMPT_RT_FULL
 	synchronize_rcu();
 #endif
-#else /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
+#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
 #ifdef CONFIG_PREEMPT_RT
 	synchronize_rcu();
 #endif
-#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
+#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
 }
 
 void lttng_lock_sessions(void)
@@ -190,6 +191,10 @@ void lttng_session_destroy(struct lttng_session *session)
 		WARN_ON(ret);
 	}
 	synchronize_trace();	/* Wait for in-flight events to complete */
+	list_for_each_entry(chan, &session->chan, list) {
+		ret = lttng_syscalls_destroy(chan);
+		WARN_ON(ret);
+	}
 	list_for_each_entry_safe(enabler, tmpenabler,
 			&session->enablers_head, node)
 		lttng_enabler_destroy(enabler);
@@ -199,8 +204,10 @@ void lttng_session_destroy(struct lttng_session *session)
 		BUG_ON(chan->channel_type == METADATA_CHANNEL);
 		_lttng_channel_destroy(chan);
 	}
+	mutex_lock(&session->metadata_cache->lock);
 	list_for_each_entry(metadata_stream, &session->metadata_cache->metadata_stream, list)
 		_lttng_metadata_channel_hangup(metadata_stream);
+	mutex_unlock(&session->metadata_cache->lock);
 	if (session->pid_tracker)
 		lttng_pid_tracker_destroy(session->pid_tracker);
 	kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
@@ -683,6 +690,8 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		event_return->enabled = 0;
 		event_return->registered = 1;
 		event_return->instrumentation = itype;
+		INIT_LIST_HEAD(&event_return->bytecode_runtime_head);
+		INIT_LIST_HEAD(&event_return->enablers_ref_head);
 		/*
 		 * Populate lttng_event structure before kretprobe registration.
 		 */
@@ -723,6 +732,28 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
 		event->enabled = 0;
 		event->registered = 0;
 		event->desc = event_desc;
+		switch (event_param->u.syscall.entryexit) {
+		case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
+			ret = -EINVAL;
+			goto register_error;
+		case LTTNG_KERNEL_SYSCALL_ENTRY:
+			event->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
+			break;
+		case LTTNG_KERNEL_SYSCALL_EXIT:
+			event->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
+			break;
+		}
+		switch (event_param->u.syscall.abi) {
+		case LTTNG_KERNEL_SYSCALL_ABI_ALL:
+			ret = -EINVAL;
+			goto register_error;
+		case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
+			event->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
+			break;
+		case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
+			event->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
+			break;
+		}
 		if (!event->desc) {
 			ret = -EINVAL;
 			goto register_error;
@@ -809,8 +840,7 @@ void register_event(struct lttng_event *event)
 						  event);
 		break;
 	case LTTNG_KERNEL_SYSCALL:
-		ret = lttng_syscall_filter_enable(event->chan,
-			desc->name);
+		ret = lttng_syscall_filter_enable(event->chan, event);
 		break;
 	case LTTNG_KERNEL_KPROBE:
 	case LTTNG_KERNEL_UPROBE:
@@ -853,8 +883,7 @@ int _lttng_event_unregister(struct lttng_event *event)
 		ret = 0;
 		break;
 	case LTTNG_KERNEL_SYSCALL:
-		ret = lttng_syscall_filter_disable(event->chan,
-			desc->name);
+		ret = lttng_syscall_filter_disable(event->chan, event);
 		break;
 	case LTTNG_KERNEL_NOOP:
 		ret = 0;
@@ -878,6 +907,8 @@ int _lttng_event_unregister(struct lttng_event *event)
 static
 void _lttng_event_destroy(struct lttng_event *event)
 {
+	struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
+
 	switch (event->instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
 		lttng_event_put(event->desc);
@@ -903,6 +934,11 @@ void _lttng_event_destroy(struct lttng_event *event)
 	}
 	list_del(&event->list);
 	lttng_destroy_context(event->ctx);
+	lttng_free_event_filter_runtime(event);
+	/* Free event enabler refs */
+	list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
+				 &event->enablers_ref_head, node)
+		kfree(enabler_ref);
 	kmem_cache_free(event_cache, event);
 }
 
@@ -1167,39 +1203,87 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 		struct lttng_enabler *enabler)
 {
 	const char *desc_name, *enabler_name;
+	bool compat = false, entry = false;
 
 	enabler_name = enabler->event_param.name;
 	switch (enabler->event_param.instrumentation) {
 	case LTTNG_KERNEL_TRACEPOINT:
 		desc_name = desc->name;
+		switch (enabler->type) {
+		case LTTNG_ENABLER_STAR_GLOB:
+			return lttng_match_enabler_star_glob(desc_name, enabler_name);
+		case LTTNG_ENABLER_NAME:
+			return lttng_match_enabler_name(desc_name, enabler_name);
+		default:
+			return -EINVAL;
+		}
 		break;
 	case LTTNG_KERNEL_SYSCALL:
 		desc_name = desc->name;
-		if (!strncmp(desc_name, "compat_", strlen("compat_")))
+		if (!strncmp(desc_name, "compat_", strlen("compat_"))) {
 			desc_name += strlen("compat_");
+			compat = true;
+		}
 		if (!strncmp(desc_name, "syscall_exit_",
 				strlen("syscall_exit_"))) {
 			desc_name += strlen("syscall_exit_");
 		} else if (!strncmp(desc_name, "syscall_entry_",
 				strlen("syscall_entry_"))) {
 			desc_name += strlen("syscall_entry_");
+			entry = true;
 		} else {
 			WARN_ON_ONCE(1);
 			return -EINVAL;
 		}
+		switch (enabler->event_param.u.syscall.entryexit) {
+		case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
+			break;
+		case LTTNG_KERNEL_SYSCALL_ENTRY:
+			if (!entry)
+				return 0;
+			break;
+		case LTTNG_KERNEL_SYSCALL_EXIT:
+			if (entry)
+				return 0;
+			break;
+		default:
+			return -EINVAL;
+		}
+		switch (enabler->event_param.u.syscall.abi) {
+		case LTTNG_KERNEL_SYSCALL_ABI_ALL:
+			break;
+		case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
+			if (compat)
+				return 0;
+			break;
+		case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
+			if (!compat)
+				return 0;
+			break;
+		default:
+			return -EINVAL;
+		}
+		switch (enabler->event_param.u.syscall.match) {
+		case LTTNG_SYSCALL_MATCH_NAME:
+			switch (enabler->type) {
+			case LTTNG_ENABLER_STAR_GLOB:
+				return lttng_match_enabler_star_glob(desc_name, enabler_name);
+			case LTTNG_ENABLER_NAME:
+				return lttng_match_enabler_name(desc_name, enabler_name);
+			default:
+				return -EINVAL;
+			}
+			break;
+		case LTTNG_SYSCALL_MATCH_NR:
+			return -EINVAL;	/* Not implemented. */
+		default:
+			return -EINVAL;
+		}
 		break;
 	default:
 		WARN_ON_ONCE(1);
 		return -EINVAL;
 	}
-	switch (enabler->type) {
-	case LTTNG_ENABLER_STAR_GLOB:
-		return lttng_match_enabler_star_glob(desc_name, enabler_name);
-	case LTTNG_ENABLER_NAME:
-		return lttng_match_enabler_name(desc_name, enabler_name);
-	default:
-		return -EINVAL;
-	}
 }
 
 static
@@ -1325,9 +1409,21 @@ void lttng_create_event_if_missing(struct lttng_enabler *enabler)
 static
 int lttng_enabler_ref_events(struct lttng_enabler *enabler)
 {
-	struct lttng_session *session = enabler->chan->session;
+	struct lttng_channel *chan = enabler->chan;
+	struct lttng_session *session = chan->session;
 	struct lttng_event *event;
 
+	if (enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
+			enabler->event_param.u.syscall.entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT &&
+			enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
+			enabler->event_param.u.syscall.match == LTTNG_SYSCALL_MATCH_NAME &&
+			!strcmp(enabler->event_param.name, "*")) {
+		if (enabler->enabled)
+			WRITE_ONCE(chan->syscall_all, 1);
+		else
+			WRITE_ONCE(chan->syscall_all, 0);
+	}
+
 	/* First ensure that probe events are created for this enabler. */
 	lttng_create_event_if_missing(enabler);
 
@@ -1683,7 +1779,7 @@ int lttng_metadata_printf(struct lttng_session *session,
 	size_t len;
 	va_list ap;
 
-	WARN_ON_ONCE(!READ_ONCE(session->active));
+	WARN_ON_ONCE(!LTTNG_READ_ONCE(session->active));
 
 	va_start(ap, fmt);
 	str = kvasprintf(GFP_KERNEL, fmt, ap);
@@ -2269,7 +2365,7 @@ int _lttng_event_metadata_statedump(struct lttng_session *session,
 {
 	int ret = 0;
 
-	if (event->metadata_dumped || !READ_ONCE(session->active))
+	if (event->metadata_dumped || !LTTNG_READ_ONCE(session->active))
 		return 0;
 	if (chan->channel_type == METADATA_CHANNEL)
 		return 0;
@@ -2341,7 +2437,7 @@ int _lttng_channel_metadata_statedump(struct lttng_session *session,
 {
 	int ret = 0;
 
-	if (chan->metadata_dumped || !READ_ONCE(session->active))
+	if (chan->metadata_dumped || !LTTNG_READ_ONCE(session->active))
 		return 0;
 
 	if (chan->channel_type == METADATA_CHANNEL)
@@ -2567,7 +2663,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
 	struct lttng_event *event;
 	int ret = 0;
 
-	if (!READ_ONCE(session->active))
+	if (!LTTNG_READ_ONCE(session->active))
 		return 0;
 
 	lttng_metadata_begin(session);
@@ -2776,7 +2872,7 @@ void lttng_transport_unregister(struct lttng_transport *transport)
 }
 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
 
 enum cpuhp_state lttng_hp_prepare;
 enum cpuhp_state lttng_hp_online;
@@ -2892,7 +2988,7 @@ static void __exit lttng_exit_cpu_hotplug(void)
 	cpuhp_remove_multi_state(lttng_hp_prepare);
 }
 
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
 static int lttng_init_cpu_hotplug(void)
 {
 	return 0;
@@ -2900,7 +2996,7 @@ static int lttng_init_cpu_hotplug(void)
 static void lttng_exit_cpu_hotplug(void)
 {
 }
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
 
 
 static int __init lttng_events_init(void)