X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=include%2Flttng%2Fevents-internal.h;h=869ea70d050a6f41fac612af18a6cc09aa57995d;hb=8c0393c3679b2f047a723b23e012188b064797d4;hp=58e625df3022efb2256570aeb1d0c4f20ebdfb2e;hpb=e4a26d6bbfd9693708d9ae988827b576460c3741;p=lttng-modules.git

diff --git a/include/lttng/events-internal.h b/include/lttng/events-internal.h
index 58e625df..869ea70d 100644
--- a/include/lttng/events-internal.h
+++ b/include/lttng/events-internal.h
@@ -23,6 +23,35 @@ struct lttng_enabler_ref {
 	struct lttng_enabler *ref;		/* backward ref */
 };
 
+struct lttng_krp;				/* Kretprobe handling */
+
+struct lttng_uprobe_handler {
+	struct lttng_kernel_event_common *event;
+	loff_t offset;
+	struct uprobe_consumer up_consumer;
+	struct list_head node;
+};
+
+struct lttng_kprobe {
+	struct kprobe kp;
+	char *symbol_name;
+};
+
+struct lttng_uprobe {
+	struct inode *inode;
+	struct list_head head;
+};
+
+enum lttng_syscall_entryexit {
+	LTTNG_SYSCALL_ENTRY,
+	LTTNG_SYSCALL_EXIT,
+};
+
+enum lttng_syscall_abi {
+	LTTNG_SYSCALL_ABI_NATIVE,
+	LTTNG_SYSCALL_ABI_COMPAT,
+};
+
 struct lttng_kernel_event_common_private {
 	struct lttng_kernel_event_common *pub;		/* Public event interface */
 
@@ -187,7 +216,7 @@ struct lttng_kernel_ctx_field {
 	size_t (*get_size)(void *priv, struct lttng_kernel_probe_ctx *probe_ctx,
 			size_t offset);
 	void (*record)(void *priv, struct lttng_kernel_probe_ctx *probe_ctx,
-			struct lib_ring_buffer_ctx *ctx,
+			struct lttng_kernel_ring_buffer_ctx *ctx,
 			struct lttng_channel *chan);
 	void (*get_value)(void *priv, struct lttng_kernel_probe_ctx *probe_ctx,
 			struct lttng_ctx_value *value);
@@ -202,6 +231,208 @@ struct lttng_kernel_ctx {
 	size_t largest_align;	/* in bytes */
 };
 
+struct lttng_metadata_cache {
+	char *data;			/* Metadata cache */
+	unsigned int cache_alloc;	/* Metadata allocated size (bytes) */
+	unsigned int metadata_written;	/* Number of bytes written in metadata cache */
+	atomic_t producing;		/* Metadata being produced (incomplete) */
+	struct kref refcount;		/* Metadata cache usage */
+	struct list_head metadata_stream;	/* Metadata stream list */
+	uuid_le uuid;			/* Trace session unique ID (copy) */
+	struct mutex lock;		/* Produce/consume lock */
+	uint64_t version;		/* Current version of the metadata */
+};
+
+struct lttng_metadata_stream {
+	void *priv;			/* Ring buffer private data */
+	struct lttng_metadata_cache *metadata_cache;
+	unsigned int metadata_in;	/* Bytes read from the cache */
+	unsigned int metadata_out;	/* Bytes consumed from stream */
+	int finalized;			/* Has channel been finalized */
+	wait_queue_head_t read_wait;	/* Reader buffer-level wait queue */
+	struct list_head list;		/* Stream list */
+	struct lttng_transport *transport;
+	uint64_t version;		/* Current version of the metadata cache */
+	bool coherent;			/* Stream in a coherent state */
+};
+
+struct lttng_kernel_channel_buffer_ops_private {
+	struct lttng_kernel_channel_buffer_ops *pub;	/* Public channel buffer ops interface */
+
+	struct channel *(*channel_create)(const char *name,
+				void *priv,
+				void *buf_addr,
+				size_t subbuf_size, size_t num_subbuf,
+				unsigned int switch_timer_interval,
+				unsigned int read_timer_interval);
+	void (*channel_destroy)(struct channel *chan);
+	struct lib_ring_buffer *(*buffer_read_open)(struct channel *chan);
+	int (*buffer_has_read_closed_stream)(struct channel *chan);
+	void (*buffer_read_close)(struct lib_ring_buffer *buf);
+	/*
+	 * packet_avail_size returns the available size in the current
+	 * packet. Note that the size returned is only a hint, since it
+	 * may change due to concurrent writes.
+	 */
+	size_t (*packet_avail_size)(struct channel *chan);
+	wait_queue_head_t *(*get_writer_buf_wait_queue)(struct channel *chan, int cpu);
+	wait_queue_head_t *(*get_hp_wait_queue)(struct channel *chan);
+	int (*is_finalized)(struct channel *chan);
+	int (*is_disabled)(struct channel *chan);
+	int (*timestamp_begin) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *timestamp_begin);
+	int (*timestamp_end) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *timestamp_end);
+	int (*events_discarded) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *events_discarded);
+	int (*content_size) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *content_size);
+	int (*packet_size) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *packet_size);
+	int (*stream_id) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *stream_id);
+	int (*current_timestamp) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *ts);
+	int (*sequence_number) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *seq);
+	int (*instance_id) (const struct lib_ring_buffer_config *config,
+			struct lib_ring_buffer *bufb,
+			uint64_t *id);
+};
+
+struct lttng_counter_ops {
+	struct lib_counter *(*counter_create)(size_t nr_dimensions,
+			const size_t *max_nr_elem,	/* for each dimension */
+			int64_t global_sum_step);
+	void (*counter_destroy)(struct lib_counter *counter);
+	int (*counter_add)(struct lib_counter *counter, const size_t *dimension_indexes,
+			int64_t v);
+	/*
+	 * counter_read reads a specific cpu's counter if @cpu >= 0, or
+	 * the global aggregation counter if @cpu == -1.
+	 */
+	int (*counter_read)(struct lib_counter *counter, const size_t *dimension_indexes, int cpu,
+			 int64_t *value, bool *overflow, bool *underflow);
+	/*
+	 * counter_aggregate returns the total sum of all per-cpu counters and
+	 * the global aggregation counter.
+	 */
+	int (*counter_aggregate)(struct lib_counter *counter, const size_t *dimension_indexes,
+			int64_t *value, bool *overflow, bool *underflow);
+	int (*counter_clear)(struct lib_counter *counter, const size_t *dimension_indexes);
+};
+
+struct lttng_counter {
+	struct file *file;		/* File associated to counter. */
+	struct file *owner;
+	struct lttng_counter_transport *transport;
+	struct lib_counter *counter;
+	struct lttng_counter_ops *ops;
+};
+
+struct lttng_event_notifier_group {
+	struct file *file;		/* File associated to event notifier group */
+	struct file *notif_file;	/* File used to expose notifications to userspace. */
+	struct list_head node;		/* event notifier group list */
+	struct list_head enablers_head; /* List of enablers */
+	struct list_head event_notifiers_head; /* List of event notifier */
+	struct lttng_event_notifier_ht event_notifiers_ht; /* Hash table of event notifiers */
+	struct lttng_kernel_channel_buffer_ops *ops;
+	struct lttng_transport *transport;
+	struct channel *chan;		/* Ring buffer channel for event notifier group. */
+	struct lib_ring_buffer *buf;	/* Ring buffer for event notifier group. */
+	wait_queue_head_t read_wait;
+	struct irq_work wakeup_pending;	/* Pending wakeup irq work. */
+	struct lttng_kernel_event_notifier *sc_unknown;	/* for unknown syscalls */
+	struct lttng_kernel_event_notifier *sc_compat_unknown;
+
+	struct lttng_syscall_filter *sc_filter;
+
+	struct hlist_head *event_notifier_syscall_dispatch;
+	struct hlist_head *event_notifier_compat_syscall_dispatch;
+	struct hlist_head *event_notifier_exit_syscall_dispatch;
+	struct hlist_head *event_notifier_exit_compat_syscall_dispatch;
+
+	struct hlist_head event_notifier_unknown_syscall_dispatch;
+	struct hlist_head event_notifier_compat_unknown_syscall_dispatch;
+	struct hlist_head event_notifier_exit_unknown_syscall_dispatch;
+	struct hlist_head event_notifier_exit_compat_unknown_syscall_dispatch;
+
+	int syscall_all_entry;
+	int syscall_all_exit;
+
+	unsigned int sys_enter_registered:1, sys_exit_registered:1;
+
+	struct lttng_counter *error_counter;
+	size_t error_counter_len;
+};
+
+struct lttng_transport {
+	char *name;
+	struct module *owner;
+	struct list_head node;
+	struct lttng_kernel_channel_buffer_ops ops;
+};
+
+struct lttng_counter_transport {
+	char *name;
+	struct module *owner;
+	struct list_head node;
+	struct lttng_counter_ops ops;
+};
+
+struct lttng_kernel_session_private {
+	struct lttng_kernel_session *pub;	/* Public session interface */
+
+	int been_active;			/* Has trace session been active ? */
+	struct file *file;			/* File associated to session */
+	struct list_head chan;			/* Channel list head */
+	struct list_head events;		/* Event list head */
+	struct list_head list;			/* Session list */
+	unsigned int free_chan_id;		/* Next chan ID to allocate */
+	uuid_le uuid;				/* Trace session unique ID */
+	struct lttng_metadata_cache *metadata_cache;
+	unsigned int metadata_dumped:1,
+		tstate:1;			/* Transient enable state */
+	/* List of event enablers */
+	struct list_head enablers_head;
+	/* Hash table of events */
+	struct lttng_event_ht events_ht;
+	char name[LTTNG_KERNEL_ABI_SESSION_NAME_LEN];
+	char creation_time[LTTNG_KERNEL_ABI_SESSION_CREATION_TIME_ISO8601_LEN];
+};
+
+struct lttng_id_hash_node {
+	struct hlist_node hlist;
+	int id;
+};
+
+enum tracker_type {
+	TRACKER_PID,
+	TRACKER_VPID,
+	TRACKER_UID,
+	TRACKER_VUID,
+	TRACKER_GID,
+	TRACKER_VGID,
+
+	TRACKER_UNKNOWN,
+};
+
+struct lttng_kernel_id_tracker_private {
+	struct lttng_kernel_id_tracker *pub;	/* Public interface */
+
+	struct lttng_kernel_session *session;
+	enum tracker_type tracker_type;
+};
+
 extern struct lttng_kernel_ctx *lttng_static_ctx;
 
 static inline
@@ -746,6 +977,143 @@ int lttng_kretprobes_event_enable_state(struct lttng_kernel_event_common *event,
 }
 #endif
 
+void lttng_lock_sessions(void);
+void lttng_unlock_sessions(void);
+
+struct list_head *lttng_get_probe_list_head(void);
+
+int lttng_fix_pending_events(void);
+int lttng_fix_pending_event_notifiers(void);
+int lttng_session_active(void);
+bool lttng_event_notifier_active(void);
+
+struct lttng_kernel_session *lttng_session_create(void);
+int lttng_session_enable(struct lttng_kernel_session *session);
+int lttng_session_disable(struct lttng_kernel_session *session);
+void lttng_session_destroy(struct lttng_kernel_session *session);
+int lttng_session_metadata_regenerate(struct lttng_kernel_session *session);
+int lttng_session_statedump(struct lttng_kernel_session *session);
+void metadata_cache_destroy(struct kref *kref);
+
+struct lttng_counter *lttng_kernel_counter_create(
+		const char *counter_transport_name, size_t number_dimensions,
+		const size_t *dimensions_sizes);
+int lttng_kernel_counter_read(struct lttng_counter *counter,
+		const size_t *dimension_indexes, int32_t cpu,
+		int64_t *val, bool *overflow, bool *underflow);
+int lttng_kernel_counter_aggregate(struct lttng_counter *counter,
+		const size_t *dimension_indexes, int64_t *val,
+		bool *overflow, bool *underflow);
+int lttng_kernel_counter_clear(struct lttng_counter *counter,
+		const size_t *dimension_indexes);
+struct lttng_event_notifier_group *lttng_event_notifier_group_create(void);
+int lttng_event_notifier_group_create_error_counter(
+		struct file *event_notifier_group_file,
+		const struct lttng_kernel_abi_counter_conf *error_counter_conf);
+void lttng_event_notifier_group_destroy(
+		struct lttng_event_notifier_group *event_notifier_group);
+
+struct lttng_channel *lttng_channel_create(struct lttng_kernel_session *session,
+				       const char *transport_name,
+				       void *buf_addr,
+				       size_t subbuf_size, size_t num_subbuf,
+				       unsigned int switch_timer_interval,
+				       unsigned int read_timer_interval,
+				       enum channel_type channel_type);
+struct lttng_channel *lttng_global_channel_create(struct lttng_kernel_session *session,
+				       int overwrite, void *buf_addr,
+				       size_t subbuf_size, size_t num_subbuf,
+				       unsigned int switch_timer_interval,
+				       unsigned int read_timer_interval);
+
+void lttng_metadata_channel_destroy(struct lttng_channel *chan);
+struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_channel *chan,
+				struct lttng_kernel_abi_event *event_param,
+				const struct lttng_kernel_event_desc *event_desc,
+				enum lttng_kernel_abi_instrumentation itype);
+struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_channel *chan,
+				struct lttng_kernel_abi_event *event_param,
+				const struct lttng_kernel_event_desc *event_desc,
+				enum lttng_kernel_abi_instrumentation itype);
+struct lttng_kernel_event_recorder *lttng_event_compat_old_create(struct lttng_channel *chan,
+		struct lttng_kernel_abi_old_event *old_event_param,
+		const struct lttng_kernel_event_desc *internal_desc);
+
+struct lttng_kernel_event_notifier *lttng_event_notifier_create(
+				const struct lttng_kernel_event_desc *event_notifier_desc,
+				uint64_t id,
+				uint64_t error_counter_idx,
+				struct lttng_event_notifier_group *event_notifier_group,
+				struct lttng_kernel_abi_event_notifier *event_notifier_param,
+				enum lttng_kernel_abi_instrumentation itype);
+struct lttng_kernel_event_notifier *_lttng_event_notifier_create(
+				const struct lttng_kernel_event_desc *event_notifier_desc,
+				uint64_t id,
+				uint64_t error_counter_idx,
+				struct lttng_event_notifier_group *event_notifier_group,
+				struct lttng_kernel_abi_event_notifier *event_notifier_param,
+				enum lttng_kernel_abi_instrumentation itype);
+
+int lttng_channel_enable(struct lttng_channel *channel);
+int lttng_channel_disable(struct lttng_channel *channel);
+int lttng_event_enable(struct lttng_kernel_event_common *event);
+int lttng_event_disable(struct lttng_kernel_event_common *event);
+
+void lttng_transport_register(struct lttng_transport *transport);
+void lttng_transport_unregister(struct lttng_transport *transport);
+
+void lttng_counter_transport_register(struct lttng_counter_transport *transport);
+void lttng_counter_transport_unregister(struct lttng_counter_transport *transport);
+
+void synchronize_trace(void);
+int lttng_abi_init(void);
+int lttng_abi_compat_old_init(void);
+void lttng_abi_exit(void);
+void lttng_abi_compat_old_exit(void);
+
+const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name);
+void lttng_event_desc_put(const struct lttng_kernel_event_desc *desc);
+int lttng_probes_init(void);
+void lttng_probes_exit(void);
+
+int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
+		struct channel *chan, bool *coherent);
+
+int lttng_id_tracker_get_node_id(const struct lttng_id_hash_node *node);
+int lttng_id_tracker_empty_set(struct lttng_kernel_id_tracker *lf);
+int lttng_id_tracker_init(struct lttng_kernel_id_tracker *lf,
+		struct lttng_kernel_session *session,
+		enum tracker_type type);
+void lttng_id_tracker_fini(struct lttng_kernel_id_tracker *lf);
+void lttng_id_tracker_destroy(struct lttng_kernel_id_tracker *lf, bool rcu);
+int lttng_id_tracker_add(struct lttng_kernel_id_tracker *lf, int id);
+int lttng_id_tracker_del(struct lttng_kernel_id_tracker *lf, int id);
+
+int lttng_session_track_id(struct lttng_kernel_session *session,
+		enum tracker_type tracker_type, int id);
+int lttng_session_untrack_id(struct lttng_kernel_session *session,
+		enum tracker_type tracker_type, int id);
+
+int lttng_session_list_tracker_ids(struct lttng_kernel_session *session,
+		enum tracker_type tracker_type);
+
+void lttng_clock_ref(void);
+void lttng_clock_unref(void);
+
+void lttng_free_event_filter_runtime(struct lttng_kernel_event_common *event);
+
+int lttng_probes_init(void);
+
+int lttng_logger_init(void);
+void lttng_logger_exit(void);
+
+extern int lttng_statedump_start(struct lttng_kernel_session *session);
+
+int lttng_calibrate(struct lttng_kernel_abi_calibrate *calibrate);
+
+extern const struct file_operations lttng_tracepoint_list_fops;
+extern const struct file_operations lttng_syscall_list_fops;
+
 #define lttng_kernel_static_ctx_field(_event_field, _get_size, _record, _get_value, _destroy, _priv)	\
 	__LTTNG_COMPOUND_LITERAL(const struct lttng_kernel_ctx_field, {					\
 		.event_field = (_event_field),								\