From: Michael Jeanson Date: Wed, 8 May 2024 18:20:30 +0000 (-0400) Subject: fix: Add missing 'pselect6_time32' and 'ppoll_time32' syscall overrides X-Git-Url: https://git.liburcu.org/?p=lttng-modules.git;a=commitdiff_plain;h=HEAD;hp=18fd64422b4297f9beea82f1c1a97b80791312e4 fix: Add missing 'pselect6_time32' and 'ppoll_time32' syscall overrides The instrumentation currently has overrides to the generated syscall tracepoints of 'ppoll' and 'pselect6' to extract additional information from the parameters. On arm-32 and x86-32 these 2 syscalls were renamed to 'ppoll_time32' and 'pselect6_time32' and new syscalls using 64-bit time_t were introduced with the old names. This results in missing overrides on these architectures for the 32-bit variants that were renamed. Add the '_time32' overrides to restore the previous behavior. Change-Id: I81e3a3ddc3f3cea58d86edcdf4a1fc9b600637c2 Signed-off-by: Michael Jeanson Signed-off-by: Mathieu Desnoyers --- diff --git a/include/instrumentation/events/timer.h b/include/instrumentation/events/timer.h index 193650bb..2fc280c1 100644 --- a/include/instrumentation/events/timer.h +++ b/include/instrumentation/events/timer.h @@ -124,6 +124,7 @@ LTTNG_TRACEPOINT_EVENT(timer_start, #endif #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0) || \ + LTTNG_KERNEL_RANGE(4,19,312, 4,20,0) || \ LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0)) /** * timer_expire_entry - called immediately before the timer callback diff --git a/include/instrumentation/syscalls/syscalls_pointers_override.h b/include/instrumentation/syscalls/syscalls_pointers_override.h index 00e5990c..92467749 100644 --- a/include/instrumentation/syscalls/syscalls_pointers_override.h +++ b/include/instrumentation/syscalls/syscalls_pointers_override.h @@ -390,6 +390,11 @@ end: ; /* Label at end of compound statement. */ \ lttng_tp_mempool_free(tp_locvar->fds_ex); #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) +/* + * Instead of extracting the user-space pointers of the 3 fd_set, + * extract the bitmask of the FDs in the sets (in, out, ex) in the form + * of an array of uint8_t (1024 FDs is the limit in the kernel). + */ #define OVERRIDE_32_select #define OVERRIDE_64_select SC_LTTNG_TRACEPOINT_EVENT_CODE(select, @@ -427,6 +432,11 @@ SC_LTTNG_TRACEPOINT_EVENT_CODE(select, #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +/* + * Instead of extracting the user-space pointers of the 3 fd_set, + * extract the bitmask of the FDs in the sets (in, out, ex) in the form + * of an array of uint8_t (1024 FDs is the limit in the kernel). + */ #define OVERRIDE_32_pselect6 #define OVERRIDE_64_pselect6 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6, @@ -464,6 +474,48 @@ SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6, ) #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ +#if defined(CONFIG_X86_32) || defined(CONFIG_ARM) +/* + * Instead of extracting the user-space pointers of the 3 fd_set, + * extract the bitmask of the FDs in the sets (in, out, ex) in the form + * of an array of uint8_t (1024 FDs is the limit in the kernel). + */ +#define OVERRIDE_32_pselect6_time32 +SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6_time32, + TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp, + fd_set __user * exp, struct old_timespec32 __user * tvp, void __user * sig), + TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig), + TP_locvar( + LTTNG_SYSCALL_SELECT_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_SELECT_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(int, n, n)) + sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + sc_inout(ctf_integer(struct old_timespec32 *, tvp, tvp)) + sc_in(ctf_integer_hex(void *, sig, sig)) + + sc_inout( +#if (__BYTE_ORDER == __LITTLE_ENDIAN) + LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) +#else + LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) + LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) + LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) +#endif + ) + ), + TP_code_post( + LTTNG_SYSCALL_SELECT_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */ + #ifdef LTTNG_CREATE_FIELD_METADATA #ifndef ONCE_LTTNG_TRACE_POLL_H #define ONCE_LTTNG_TRACE_POLL_H @@ -652,6 +704,13 @@ end: \ lttng_tp_mempool_free(tp_locvar->fds); #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) +/* + * Instead of printing the pointer address of the poll set, extract all the FDs + * and flags from the poll set. For now, only output the standardized + * set of events to limit the verbosity of the output, and also extract + * the raw value. In the future, moving to CTF2 will allow hiding unset + * fields and then allow extracting all the fields. + */ #define OVERRIDE_32_poll #define OVERRIDE_64_poll SC_LTTNG_TRACEPOINT_EVENT_CODE(poll, @@ -679,6 +738,13 @@ SC_LTTNG_TRACEPOINT_EVENT_CODE(poll, #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) +/* + * Instead of printing the pointer address of the poll set, extract all the FDs + * and flags from the poll set. For now, only output the standardized + * set of events to limit the verbosity of the output, and also extract + * the raw value. In the future, moving to CTF2 will allow hiding unset + * fields and then allow extracting all the fields. + */ #define OVERRIDE_32_ppoll #define OVERRIDE_64_ppoll SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll, @@ -707,6 +773,41 @@ SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll, ) #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ +#if defined(CONFIG_X86_32) || defined(CONFIG_ARM) +/* + * Instead of printing the pointer address of the poll set, extract all the FDs + * and flags from the poll set. For now, only output the standardized + * set of events to limit the verbosity of the output, and also extract + * the raw value. In the future, moving to CTF2 will allow hiding unset + * fields and then allow extracting all the fields. + */ +#define OVERRIDE_32_ppoll_time32 +SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll_time32, + TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, + unsigned int nfds, struct old_timespec32 * tsp, const sigset_t * sigmask, size_t sigsetsize), + TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), + TP_locvar( + LTTNG_SYSCALL_POLL_locvar + ), + TP_code_pre( + LTTNG_SYSCALL_POLL_code_pre + ), + TP_FIELDS( + sc_exit(ctf_integer(long, ret, ret)) + sc_in(ctf_integer(struct old_timespec32 *, tsp, tsp)) + sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) + sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) + sc_inout(ctf_integer(unsigned int, nfds, nfds)) + sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) + sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) + LTTNG_SYSCALL_POLL_fds_field + ), + TP_code_post( + LTTNG_SYSCALL_POLL_code_post + ) +) +#endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */ + #include SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op, diff --git a/include/ringbuffer/backend_types.h b/include/ringbuffer/backend_types.h index 337f1cda..c23889ea 100644 --- a/include/ringbuffer/backend_types.h +++ b/include/ringbuffer/backend_types.h @@ -82,7 +82,7 @@ struct channel_backend { struct lttng_kernel_ring_buffer *buf; /* Channel per-cpu buffers */ unsigned long num_subbuf; /* Number of sub-buffers for writer */ - u64 start_tsc; /* Channel creation TSC value */ + u64 start_timestamp; /* Channel creation timestamp value */ void *priv; /* Client-specific information */ void *priv_ops; /* Client-specific ops pointer */ void (*release_priv_ops)(void *priv_ops); diff --git a/include/ringbuffer/config.h b/include/ringbuffer/config.h index 43523de3..e63463b0 100644 --- a/include/ringbuffer/config.h +++ b/include/ringbuffer/config.h @@ -41,9 +41,9 @@ struct lttng_kernel_ring_buffer_client_cb { /* Slow path only, at subbuffer switch */ size_t (*subbuffer_header_size) (void); - void (*buffer_begin) (struct lttng_kernel_ring_buffer *buf, u64 tsc, + void (*buffer_begin) (struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx); - void (*buffer_end) (struct lttng_kernel_ring_buffer *buf, u64 tsc, + void (*buffer_end) (struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx); @@ -151,10 +151,10 @@ struct lttng_kernel_ring_buffer_config { */ } wakeup; /* - * tsc_bits: timestamp bits saved at each record. + * timestamp_bits: timestamp bits saved at each record. * 0 and 64 disable the timestamp compression scheme. */ - unsigned int tsc_bits; + unsigned int timestamp_bits; struct lttng_kernel_ring_buffer_client_cb cb; }; @@ -182,7 +182,7 @@ struct lttng_kernel_ring_buffer_ctx_private { * prior to record header alignment * padding. */ - u64 tsc; /* time-stamp counter value */ + u64 timestamp; /* time-stamp counter value */ unsigned int rflags; /* reservation flags */ struct lttng_kernel_ring_buffer *buf; /* @@ -244,18 +244,18 @@ void lib_ring_buffer_ctx_init(struct lttng_kernel_ring_buffer_ctx *ctx, /* * Reservation flags. * - * RING_BUFFER_RFLAG_FULL_TSC + * RING_BUFFER_RFLAG_FULL_TIMESTAMP * * This flag is passed to record_header_size() and to the primitive used to * write the record header. It indicates that the full 64-bit time value is * needed in the record header. If this flag is not set, the record header needs - * only to contain "tsc_bits" bit of time value. + * only to contain "timestamp_bits" bit of time value. * * Reservation flags can be added by the client, starting from * "(RING_BUFFER_FLAGS_END << 0)". It can be used to pass information from * record_header_size() to lib_ring_buffer_write_record_header(). */ -#define RING_BUFFER_RFLAG_FULL_TSC (1U << 0) +#define RING_BUFFER_RFLAG_FULL_TIMESTAMP (1U << 0) #define RING_BUFFER_RFLAG_END (1U << 1) #ifndef LTTNG_TRACER_CORE_H diff --git a/include/ringbuffer/frontend_api.h b/include/ringbuffer/frontend_api.h index b473a61b..e8d77d95 100644 --- a/include/ringbuffer/frontend_api.h +++ b/include/ringbuffer/frontend_api.h @@ -80,8 +80,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co *o_begin = v_read(config, &buf->offset); *o_old = *o_begin; - ctx->priv.tsc = lib_ring_buffer_clock_read(chan); - if ((int64_t) ctx->priv.tsc == -EIO) + ctx->priv.timestamp = lib_ring_buffer_clock_read(chan); + if ((int64_t) ctx->priv.timestamp == -EIO) return 1; /* @@ -91,8 +91,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co */ prefetch(&buf->commit_hot[subbuf_index(*o_begin, chan)]); - if (last_tsc_overflow(config, buf, ctx->priv.tsc)) - ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TSC; + if (last_timestamp_overflow(config, buf, ctx->priv.timestamp)) + ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP; if (unlikely(subbuf_offset(*o_begin, chan) == 0)) return 1; @@ -128,7 +128,8 @@ int lib_ring_buffer_try_reserve(const struct lttng_kernel_ring_buffer_config *co * @ctx: ring buffer context. (input and output) Must be already initialized. * * Atomic wait-free slot reservation. The reserved space starts at the context - * "pre_offset". Its length is "slot_size". The associated time-stamp is "tsc". + * "pre_offset". Its length is "slot_size". The associated time-stamp is + * "timestamp". * * Return : * 0 on success. @@ -171,12 +172,12 @@ int lib_ring_buffer_reserve(const struct lttng_kernel_ring_buffer_config *config goto slow_path; /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * record headers, never the opposite (missing a full TSC record header - * when it would be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp record headers, never the opposite (missing a + * full timestamp record header when it would be needed). */ - save_last_tsc(config, ctx->priv.buf, ctx->priv.tsc); + save_last_timestamp(config, ctx->priv.buf, ctx->priv.timestamp); /* * Push the reader if necessary @@ -308,17 +309,18 @@ int lib_ring_buffer_try_discard_reserve(const struct lttng_kernel_ring_buffer_co /* * We need to ensure that if the cmpxchg succeeds and discards the - * record, the next record will record a full TSC, because it cannot - * rely on the last_tsc associated with the discarded record to detect - * overflows. The only way to ensure this is to set the last_tsc to 0 - * (assuming no 64-bit TSC overflow), which forces to write a 64-bit - * timestamp in the next record. + * record, the next record will record a full timestamp, because + * it cannot rely on the last_timestamp associated with the + * discarded record to detect overflows. The only way to ensure + * this is to set the last_timestamp to 0 (assuming no 64-bit + * timestamp overflow), which forces to write a 64-bit timestamp in + * the next record. * - * Note: if discard fails, we must leave the TSC in the record header. - * It is needed to keep track of TSC overflows for the following - * records. + * Note: if discard fails, we must leave the timestamp in the + * record header. It is needed to keep track of timestamp + * overflows for the following records. */ - save_last_tsc(config, buf, 0ULL); + save_last_timestamp(config, buf, 0ULL); if (likely(v_cmpxchg(config, &buf->offset, end_offset, ctx->priv.pre_offset) != end_offset)) diff --git a/include/ringbuffer/frontend_internal.h b/include/ringbuffer/frontend_internal.h index 999a7bb9..39dbbf08 100644 --- a/include/ringbuffer/frontend_internal.h +++ b/include/ringbuffer/frontend_internal.h @@ -71,62 +71,63 @@ unsigned long subbuf_index(unsigned long offset, struct lttng_kernel_ring_buffer } /* - * Last TSC comparison functions. Check if the current TSC overflows tsc_bits - * bits from the last TSC read. When overflows are detected, the full 64-bit - * timestamp counter should be written in the record header. Reads and writes - * last_tsc atomically. + * Last timestamp comparison functions. Check if the current timestamp + * overflows timestamp_bits bits from the last timestamp read. When + * overflows are detected, the full 64-bit timestamp counter should be + * written in the record header. Reads and writes last_timestamp + * atomically. */ #if (BITS_PER_LONG == 32) static inline -void save_last_tsc(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +void save_last_timestamp(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return; /* * Ensure the compiler performs this update in a single instruction. */ - v_set(config, &buf->last_tsc, (unsigned long)(tsc >> config->tsc_bits)); + v_set(config, &buf->last_timestamp, (unsigned long)(timestamp >> config->timestamp_bits)); } static inline -int last_tsc_overflow(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +int last_timestamp_overflow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - unsigned long tsc_shifted; + unsigned long timestamp_shifted; - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return 0; - tsc_shifted = (unsigned long)(tsc >> config->tsc_bits); - if (unlikely(tsc_shifted - - (unsigned long)v_read(config, &buf->last_tsc))) + timestamp_shifted = (unsigned long)(timestamp >> config->timestamp_bits); + if (unlikely(timestamp_shifted + - (unsigned long)v_read(config, &buf->last_timestamp))) return 1; else return 0; } #else static inline -void save_last_tsc(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +void save_last_timestamp(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return; - v_set(config, &buf->last_tsc, (unsigned long)tsc); + v_set(config, &buf->last_timestamp, (unsigned long)timestamp); } static inline -int last_tsc_overflow(const struct lttng_kernel_ring_buffer_config *config, - struct lttng_kernel_ring_buffer *buf, u64 tsc) +int last_timestamp_overflow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, u64 timestamp) { - if (config->tsc_bits == 0 || config->tsc_bits == 64) + if (config->timestamp_bits == 0 || config->timestamp_bits == 64) return 0; - if (unlikely((tsc - v_read(config, &buf->last_tsc)) - >> config->tsc_bits)) + if (unlikely((timestamp - v_read(config, &buf->last_timestamp)) + >> config->timestamp_bits)) return 1; else return 0; @@ -264,7 +265,7 @@ int lib_ring_buffer_reserve_committed(const struct lttng_kernel_ring_buffer_conf } /* - * Receive end of subbuffer TSC as parameter. It has been read in the + * Receive end of subbuffer timestamp as parameter. It has been read in the * space reservation loop of either reserve or switch, which ensures it * progresses monotonically with event records in the buffer. Therefore, * it ensures that the end timestamp of a subbuffer is <= begin diff --git a/include/ringbuffer/frontend_types.h b/include/ringbuffer/frontend_types.h index 07d23be2..65782ea7 100644 --- a/include/ringbuffer/frontend_types.h +++ b/include/ringbuffer/frontend_types.h @@ -114,7 +114,7 @@ struct lttng_kernel_ring_buffer { */ atomic_t record_disabled; /* End of first 32 bytes cacheline */ - union v_atomic last_tsc; /* + union v_atomic last_timestamp; /* * Last timestamp written in the buffer. */ diff --git a/include/wrapper/blkdev.h b/include/wrapper/blkdev.h index b637bb91..76397f6b 100644 --- a/include/wrapper/blkdev.h +++ b/include/wrapper/blkdev.h @@ -52,7 +52,7 @@ struct class *wrapper_get_block_class(void) * extern struct class block_class; */ static inline -struct class *__canary__get_block_class(void) +const struct class *__canary__get_block_class(void) { return &block_class; } diff --git a/include/wrapper/trace-clock.h b/include/wrapper/trace-clock.h index adb1101f..18578a61 100644 --- a/include/wrapper/trace-clock.h +++ b/include/wrapper/trace-clock.h @@ -56,7 +56,7 @@ extern struct lttng_trace_clock *lttng_trace_clock; #ifdef LTTNG_USE_NMI_SAFE_CLOCK -DECLARE_PER_CPU(u64, lttng_last_tsc); +DECLARE_PER_CPU(u64, lttng_last_timestamp); /* * Sometimes called with preemption enabled. Can be interrupted. @@ -64,12 +64,12 @@ DECLARE_PER_CPU(u64, lttng_last_tsc); static inline u64 trace_clock_monotonic_wrapper(void) { u64 now, last, result; - u64 *last_tsc_ptr; + u64 *last_timestamp_ptr; /* Use fast nmi-safe monotonic clock provided by the Linux kernel. */ preempt_disable(); - last_tsc_ptr = this_cpu_ptr(<tng_last_tsc); - last = *last_tsc_ptr; + last_timestamp_ptr = this_cpu_ptr(<tng_last_timestamp); + last = *last_timestamp_ptr; /* * Read "last" before "now". It is not strictly required, but it ensures * that an interrupt coming in won't artificially trigger a case where @@ -80,7 +80,7 @@ static inline u64 trace_clock_monotonic_wrapper(void) now = ktime_get_mono_fast_ns(); if (U64_MAX / 2 < now - last) now = last; - result = cmpxchg64_local(last_tsc_ptr, last, now); + result = cmpxchg64_local(last_timestamp_ptr, last, now); preempt_enable(); if (result == last) { /* Update done. */ diff --git a/src/lib/ringbuffer/ring_buffer_backend.c b/src/lib/ringbuffer/ring_buffer_backend.c index 02a9d487..74d249f3 100644 --- a/src/lib/ringbuffer/ring_buffer_backend.c +++ b/src/lib/ringbuffer/ring_buffer_backend.c @@ -256,7 +256,7 @@ void channel_backend_reset(struct channel_backend *chanb) * num_subbuf_order, buf_size_order, extra_reader_sb, num_subbuf, * priv, notifiers, config, cpumask and name. */ - chanb->start_tsc = config->cb.ring_buffer_clock_read(chan); + chanb->start_timestamp = config->cb.ring_buffer_clock_read(chan); } #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) @@ -471,7 +471,7 @@ int channel_backend_init(struct channel_backend *chanb, if (ret) goto free_bufs; } - chanb->start_tsc = config->cb.ring_buffer_clock_read(chan); + chanb->start_timestamp = config->cb.ring_buffer_clock_read(chan); return 0; diff --git a/src/lib/ringbuffer/ring_buffer_frontend.c b/src/lib/ringbuffer/ring_buffer_frontend.c index fbf3a168..df0705cb 100644 --- a/src/lib/ringbuffer/ring_buffer_frontend.c +++ b/src/lib/ringbuffer/ring_buffer_frontend.c @@ -173,7 +173,7 @@ void lib_ring_buffer_reset(struct lttng_kernel_ring_buffer *buf) } atomic_long_set(&buf->consumed, 0); atomic_set(&buf->record_disabled, 0); - v_set(config, &buf->last_tsc, 0); + v_set(config, &buf->last_timestamp, 0); lib_ring_buffer_backend_reset(&buf->backend); /* Don't reset number of active readers */ v_set(config, &buf->records_lost_full, 0); @@ -232,7 +232,7 @@ int lib_ring_buffer_create(struct lttng_kernel_ring_buffer *buf, struct lttng_kernel_ring_buffer_channel *chan = container_of(chanb, struct lttng_kernel_ring_buffer_channel, backend); void *priv = chanb->priv; size_t subbuf_header_size; - u64 tsc; + u64 timestamp; int ret; /* Test for cpu hotplug */ @@ -294,8 +294,8 @@ int lib_ring_buffer_create(struct lttng_kernel_ring_buffer *buf, subbuf_header_size = config->cb.subbuffer_header_size(); v_set(config, &buf->offset, subbuf_header_size); subbuffer_id_clear_noref(config, &buf->backend.buf_wsb[0].id); - tsc = config->cb.ring_buffer_clock_read(buf->backend.chan); - config->cb.buffer_begin(buf, tsc, 0); + timestamp = config->cb.ring_buffer_clock_read(buf->backend.chan); + config->cb.buffer_begin(buf, timestamp, 0); v_add(config, subbuf_header_size, &buf->commit_hot[0].cc); if (config->cb.buffer_create) { @@ -1599,7 +1599,7 @@ void lib_ring_buffer_switch_old_start(struct lttng_kernel_ring_buffer *buf, unsigned long commit_count; struct commit_counters_hot *cc_hot; - config->cb.buffer_begin(buf, ctx->priv.tsc, oldidx); + config->cb.buffer_begin(buf, ctx->priv.timestamp, oldidx); /* * Order all writes to buffer before the commit count update that will @@ -1658,7 +1658,7 @@ void lib_ring_buffer_switch_old_end(struct lttng_kernel_ring_buffer *buf, * postponed until the commit counter is incremented for the * current space reservation. */ - *ts_end = ctx->priv.tsc; + *ts_end = ctx->priv.timestamp; /* * Order all writes to buffer and store to ts_end before the commit @@ -1701,7 +1701,7 @@ void lib_ring_buffer_switch_new_start(struct lttng_kernel_ring_buffer *buf, unsigned long commit_count; struct commit_counters_hot *cc_hot; - config->cb.buffer_begin(buf, ctx->priv.tsc, beginidx); + config->cb.buffer_begin(buf, ctx->priv.timestamp, beginidx); /* * Order all writes to buffer before the commit count update that will @@ -1757,7 +1757,7 @@ void lib_ring_buffer_switch_new_end(struct lttng_kernel_ring_buffer *buf, * postponed until the commit counter is incremented for the * current space reservation. */ - *ts_end = ctx->priv.tsc; + *ts_end = ctx->priv.timestamp; } /* @@ -1780,7 +1780,7 @@ int lib_ring_buffer_try_switch_slow(enum switch_mode mode, offsets->switch_old_start = 0; off = subbuf_offset(offsets->begin, chan); - ctx->priv.tsc = config->cb.ring_buffer_clock_read(chan); + ctx->priv.timestamp = config->cb.ring_buffer_clock_read(chan); /* * Ensure we flush the header of an empty subbuffer when doing the @@ -1901,12 +1901,12 @@ void lib_ring_buffer_switch_slow(struct lttng_kernel_ring_buffer *buf, enum swit != offsets.old); /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * records, never the opposite (missing a full TSC record when it would - * be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp records, never the opposite (missing a full + * timestamp record when it would be needed). */ - save_last_tsc(config, buf, ctx.priv.tsc); + save_last_timestamp(config, buf, ctx.priv.timestamp); /* * Push the reader if necessary @@ -2029,12 +2029,12 @@ retry: offsets->switch_old_end = 0; offsets->pre_header_padding = 0; - ctx->priv.tsc = config->cb.ring_buffer_clock_read(chan); - if ((int64_t) ctx->priv.tsc == -EIO) + ctx->priv.timestamp = config->cb.ring_buffer_clock_read(chan); + if ((int64_t) ctx->priv.timestamp == -EIO) return -EIO; - if (last_tsc_overflow(config, buf, ctx->priv.tsc)) - ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TSC; + if (last_timestamp_overflow(config, buf, ctx->priv.timestamp)) + ctx->priv.rflags |= RING_BUFFER_RFLAG_FULL_TIMESTAMP; if (unlikely(subbuf_offset(offsets->begin, ctx->priv.chan) == 0)) { offsets->switch_new_start = 1; /* For offsets->begin */ @@ -2221,12 +2221,12 @@ int lib_ring_buffer_reserve_slow(struct lttng_kernel_ring_buffer_ctx *ctx, != offsets.old)); /* - * Atomically update last_tsc. This update races against concurrent - * atomic updates, but the race will always cause supplementary full TSC - * records, never the opposite (missing a full TSC record when it would - * be needed). + * Atomically update last_timestamp. This update races against concurrent + * atomic updates, but the race will always cause supplementary + * full timestamp records, never the opposite (missing a full + * timestamp record when it would be needed). */ - save_last_tsc(config, buf, ctx->priv.tsc); + save_last_timestamp(config, buf, ctx->priv.timestamp); /* * Push the reader if necessary @@ -2416,6 +2416,7 @@ void lib_ring_buffer_check_deliver_slow(const struct lttng_kernel_ring_buffer_co } EXPORT_SYMBOL_GPL(lib_ring_buffer_check_deliver_slow); +static int __init init_lib_ring_buffer_frontend(void) { int cpu; @@ -2427,6 +2428,7 @@ int __init init_lib_ring_buffer_frontend(void) module_init(init_lib_ring_buffer_frontend); +static void __exit exit_lib_ring_buffer_frontend(void) { } diff --git a/src/lttng-abi.c b/src/lttng-abi.c index caec803f..afd23373 100644 --- a/src/lttng-abi.c +++ b/src/lttng-abi.c @@ -121,6 +121,7 @@ fd_error: return ret; } +static void event_notifier_send_notification_work_wakeup(struct irq_work *entry) { struct lttng_event_notifier_group *event_notifier_group = @@ -2576,6 +2577,7 @@ long lttng_metadata_ioctl(struct file *file, unsigned int cmd, unsigned long arg * @file: the file * @wait: poll table */ +static unsigned int lttng_channel_poll(struct file *file, poll_table *wait) { struct lttng_kernel_channel_buffer *channel = file->private_data; diff --git a/src/lttng-bytecode.c b/src/lttng-bytecode.c index 7708293e..3d283268 100644 --- a/src/lttng-bytecode.c +++ b/src/lttng-bytecode.c @@ -596,26 +596,6 @@ void lttng_enabler_link_bytecode(const struct lttng_kernel_event_desc *event_des } } -/* - * We own the filter_bytecode if we return success. - */ -int lttng_filter_enabler_attach_bytecode(struct lttng_event_enabler_common *enabler, - struct lttng_kernel_bytecode_node *filter_bytecode) -{ - list_add(&filter_bytecode->node, &enabler->filter_bytecode_head); - return 0; -} - -void lttng_free_enabler_filter_bytecode(struct lttng_event_enabler_common *enabler) -{ - struct lttng_kernel_bytecode_node *filter_bytecode, *tmp; - - list_for_each_entry_safe(filter_bytecode, tmp, - &enabler->filter_bytecode_head, node) { - kfree(filter_bytecode); - } -} - void lttng_free_event_filter_runtime(struct lttng_kernel_event_common *event) { struct bytecode_runtime *runtime, *tmp; diff --git a/src/lttng-calibrate.c b/src/lttng-calibrate.c index 56ee8cf8..a545ce8a 100644 --- a/src/lttng-calibrate.c +++ b/src/lttng-calibrate.c @@ -9,8 +9,9 @@ #include #include +#include -noinline +static noinline void lttng_calibrate_kretprobe(void) { asm volatile (""); diff --git a/src/lttng-clock.c b/src/lttng-clock.c index 2e623be3..2f5146db 100644 --- a/src/lttng-clock.c +++ b/src/lttng-clock.c @@ -12,6 +12,7 @@ #include #include #include +#include struct lttng_trace_clock *lttng_trace_clock; EXPORT_SYMBOL_GPL(lttng_trace_clock); diff --git a/src/lttng-context-callstack.c b/src/lttng-context-callstack.c index 5034d8a7..4385472e 100644 --- a/src/lttng-context-callstack.c +++ b/src/lttng-context-callstack.c @@ -120,6 +120,7 @@ static const struct lttng_kernel_event_field *event_fields_user[NR_FIELDS] = { false, false), }; +static const struct lttng_kernel_event_field **lttng_cs_event_fields(enum lttng_cs_ctx_modes mode) { switch (mode) { diff --git a/src/lttng-event-notifier-notification.c b/src/lttng-event-notifier-notification.c index ecbc0676..29d2d156 100644 --- a/src/lttng-event-notifier-notification.c +++ b/src/lttng-event-notifier-notification.c @@ -246,6 +246,7 @@ int capture_sequence_element_unsigned(uint8_t *ptr, return 0; } +static int capture_sequence(struct lttng_msgpack_writer *writer, struct lttng_interpreter_output *output) { diff --git a/src/lttng-events.c b/src/lttng-events.c index a0bd2322..73f591fd 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -1547,6 +1547,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event) } } +static struct lttng_kernel_id_tracker *get_tracker(struct lttng_kernel_session *session, enum tracker_type tracker_type) { @@ -2447,26 +2448,6 @@ void lttng_event_notifier_enabler_group_add(struct lttng_event_notifier_group *e mutex_unlock(&sessions_mutex); } -int lttng_event_notifier_enabler_enable( - struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - mutex_lock(&sessions_mutex); - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1; - lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - mutex_unlock(&sessions_mutex); - return 0; -} - -int lttng_event_notifier_enabler_disable( - struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - mutex_lock(&sessions_mutex); - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0; - lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group); - mutex_unlock(&sessions_mutex); - return 0; -} - int lttng_event_notifier_enabler_attach_capture_bytecode( struct lttng_event_notifier_enabler *event_notifier_enabler, struct lttng_kernel_abi_capture_bytecode __user *bytecode) @@ -2818,6 +2799,7 @@ void lttng_metadata_end(struct lttng_kernel_session *session) * The content of the printf is printed as a single atomic metadata * transaction. */ +static int lttng_metadata_printf(struct lttng_kernel_session *session, const char *fmt, ...) { diff --git a/src/lttng-ring-buffer-client.h b/src/lttng-ring-buffer-client.h index 0dc8a8d9..a1753e98 100644 --- a/src/lttng-ring-buffer-client.h +++ b/src/lttng-ring-buffer-client.h @@ -18,7 +18,7 @@ #include #define LTTNG_COMPACT_EVENT_BITS 5 -#define LTTNG_COMPACT_TSC_BITS 27 +#define LTTNG_COMPACT_TIMESTAMP_BITS 27 static struct lttng_transport lttng_relay_transport; @@ -149,7 +149,7 @@ size_t record_header_size(const struct lttng_kernel_ring_buffer_config *config, case 1: /* compact */ padding = lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += padding; - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += sizeof(uint32_t); /* id and timestamp */ } else { /* Minimum space taken by LTTNG_COMPACT_EVENT_BITS id */ @@ -165,7 +165,7 @@ size_t record_header_size(const struct lttng_kernel_ring_buffer_config *config, padding = lib_ring_buffer_align(offset, lttng_alignof(uint16_t)); offset += padding; offset += sizeof(uint16_t); - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += sizeof(uint32_t); /* timestamp */ } else { @@ -223,14 +223,14 @@ void lttng_write_event_header(const struct lttng_kernel_ring_buffer_config *conf event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, - ctx->priv.tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, + ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); break; } case 2: /* large */ { - uint32_t timestamp = (uint32_t) ctx->priv.tsc; + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -260,7 +260,7 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config switch (lttng_chan->priv->header_type) { case 1: /* compact */ - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { uint32_t id_time = 0; bt_bitfield_write(&id_time, uint32_t, @@ -269,11 +269,11 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, ctx->priv.tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); } else { uint8_t id = 0; - uint64_t timestamp = ctx->priv.tsc; + uint64_t timestamp = ctx->priv.timestamp; bt_bitfield_write(&id, uint8_t, 0, @@ -289,8 +289,8 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config break; case 2: /* large */ { - if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { - uint32_t timestamp = (uint32_t) ctx->priv.tsc; + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -298,7 +298,7 @@ void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config lib_ring_buffer_write(config, ctx, ×tamp, sizeof(timestamp)); } else { uint16_t id = 65535; - uint64_t timestamp = ctx->priv.tsc; + uint64_t timestamp = ctx->priv.timestamp; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); /* Align extended struct on largest member */ @@ -346,7 +346,7 @@ static size_t client_packet_header_size(void) return offsetof(struct packet_header, ctx.header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; @@ -361,7 +361,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, memcpy(header->uuid, session->priv->uuid.b, sizeof(session->priv->uuid)); header->stream_id = lttng_chan->priv->id; header->stream_instance_id = buf->backend.cpu; - header->ctx.timestamp_begin = tsc; + header->ctx.timestamp_begin = timestamp; header->ctx.timestamp_end = 0; header->ctx.content_size = ~0ULL; /* for debugging */ header->ctx.packet_size = ~0ULL; @@ -376,7 +376,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -387,7 +387,7 @@ static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, subbuf_idx * chan->backend.subbuf_size); unsigned long records_lost = 0; - header->ctx.timestamp_end = tsc; + header->ctx.timestamp_end = timestamp; header->ctx.content_size = (uint64_t) data_size * CHAR_BIT; /* in bits */ header->ctx.packet_size = @@ -515,7 +515,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_create = client_buffer_create, .cb.buffer_finalize = client_buffer_finalize, - .tsc_bits = LTTNG_COMPACT_TSC_BITS, + .timestamp_bits = LTTNG_COMPACT_TIMESTAMP_BITS, .alloc = RING_BUFFER_ALLOC_PER_CPU, .sync = RING_BUFFER_SYNC_PER_CPU, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/lttng-ring-buffer-event-notifier-client.h b/src/lttng-ring-buffer-event-notifier-client.h index 8526e05e..fa7bbf57 100644 --- a/src/lttng-ring-buffer-event-notifier-client.h +++ b/src/lttng-ring-buffer-event-notifier-client.h @@ -86,7 +86,7 @@ static size_t client_packet_header_size(void) return offsetof(struct event_notifier_packet_header, header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { } @@ -95,7 +95,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -200,7 +200,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_finalize = client_buffer_finalize, .cb.record_get = client_record_get, - .tsc_bits = 0, + .timestamp_bits = 0, .alloc = RING_BUFFER_ALLOC_GLOBAL, .sync = RING_BUFFER_SYNC_GLOBAL, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/lttng-ring-buffer-metadata-client.h b/src/lttng-ring-buffer-metadata-client.h index 86ec78f1..d5e7c742 100644 --- a/src/lttng-ring-buffer-metadata-client.h +++ b/src/lttng-ring-buffer-metadata-client.h @@ -81,7 +81,7 @@ static size_t client_packet_header_size(void) return offsetof(struct metadata_packet_header, header_end); } -static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; @@ -109,7 +109,7 @@ static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 tsc, +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx, unsigned long data_size, const struct lttng_kernel_ring_buffer_ctx *ctx) { @@ -214,7 +214,7 @@ static const struct lttng_kernel_ring_buffer_config client_config = { .cb.buffer_create = client_buffer_create, .cb.buffer_finalize = client_buffer_finalize, - .tsc_bits = 0, + .timestamp_bits = 0, .alloc = RING_BUFFER_ALLOC_GLOBAL, .sync = RING_BUFFER_SYNC_GLOBAL, .mode = RING_BUFFER_MODE_TEMPLATE, diff --git a/src/lttng-statedump-impl.c b/src/lttng-statedump-impl.c index 4a228ce4..a0e97e1c 100644 --- a/src/lttng-statedump-impl.c +++ b/src/lttng-statedump-impl.c @@ -36,6 +36,7 @@ #include #include +#include #include #include #include diff --git a/src/lttng-syscalls.c b/src/lttng-syscalls.c index 5ec6be5a..827ca1d3 100644 --- a/src/lttng-syscalls.c +++ b/src/lttng-syscalls.c @@ -1310,35 +1310,3 @@ long lttng_syscall_table_get_active_mask(struct lttng_kernel_syscall_table *sysc kfree(tmp_mask); return ret; } - -int lttng_abi_syscall_list(void) -{ - struct file *syscall_list_file; - int file_fd, ret; - - file_fd = get_unused_fd_flags(0); - if (file_fd < 0) { - ret = file_fd; - goto fd_error; - } - - syscall_list_file = anon_inode_getfile("[lttng_syscall_list]", - <tng_syscall_list_fops, - NULL, O_RDWR); - if (IS_ERR(syscall_list_file)) { - ret = PTR_ERR(syscall_list_file); - goto file_error; - } - ret = lttng_syscall_list_fops.open(NULL, syscall_list_file); - if (ret < 0) - goto open_error; - fd_install(file_fd, syscall_list_file); - return file_fd; - -open_error: - fput(syscall_list_file); -file_error: - put_unused_fd(file_fd); -fd_error: - return ret; -} diff --git a/src/probes/lttng-uprobes.c b/src/probes/lttng-uprobes.c index edded1e9..5463251a 100644 --- a/src/probes/lttng-uprobes.c +++ b/src/probes/lttng-uprobes.c @@ -305,14 +305,6 @@ void lttng_uprobes_destroy_event_private(struct lttng_kernel_event_common *event } EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_private); -void lttng_uprobes_destroy_event_notifier_private(struct lttng_kernel_event_notifier *event_notifier) -{ - iput(event_notifier->priv->parent.u.uprobe.inode); - kfree(event_notifier->priv->parent.desc->event_name); - kfree(event_notifier->priv->parent.desc); -} -EXPORT_SYMBOL_GPL(lttng_uprobes_destroy_event_notifier_private); - MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Yannick Brosseau"); MODULE_DESCRIPTION("Linux Trace Toolkit Uprobes Support"); diff --git a/src/probes/lttng.c b/src/probes/lttng.c index 98558567..23b1de9e 100644 --- a/src/probes/lttng.c +++ b/src/probes/lttng.c @@ -18,6 +18,7 @@ #include #include #include +#include #define TP_MODULE_NOAUTOLOAD #define LTTNG_PACKAGE_BUILD diff --git a/src/wrapper/page_alloc.c b/src/wrapper/page_alloc.c index 5e19d7b5..69988e66 100644 --- a/src/wrapper/page_alloc.c +++ b/src/wrapper/page_alloc.c @@ -11,12 +11,63 @@ #ifdef CONFIG_KALLSYMS +/* Include page_alloc wrapper before pageblock-flags.h. */ +#include + +#include #include #include #include #include -#include +#include + +#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,14,0)) +static +unsigned long (*get_pfnblock_flags_mask_sym)(const struct page *page, + unsigned long pfn, + unsigned long mask); + +unsigned long wrapper_get_pfnblock_flags_mask(const struct page *page, + unsigned long pfn, + unsigned long mask) +{ + WARN_ON_ONCE(!get_pfnblock_flags_mask_sym); + if (get_pfnblock_flags_mask_sym) { + struct irq_ibt_state irq_ibt_state; + unsigned long ret; + irq_ibt_state = wrapper_irq_ibt_save(); + ret = get_pfnblock_flags_mask_sym(page, pfn, mask); + wrapper_irq_ibt_restore(irq_ibt_state); + return ret; + } else { + return -ENOSYS; + } +} +#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,9,0)) +static +unsigned long (*get_pfnblock_flags_mask_sym)(struct page *page, + unsigned long pfn, + unsigned long mask); + +unsigned long wrapper_get_pfnblock_flags_mask(struct page *page, + unsigned long pfn, + unsigned long mask) +{ + WARN_ON_ONCE(!get_pfnblock_flags_mask_sym); + if (get_pfnblock_flags_mask_sym) { + struct irq_ibt_state irq_ibt_state; + unsigned long ret; + + irq_ibt_state = wrapper_irq_ibt_save(); + ret = get_pfnblock_flags_mask_sym(page, pfn, mask); + wrapper_irq_ibt_restore(irq_ibt_state); + return ret; + } else { + return -ENOSYS; + } +} +#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,9,0)) */ static unsigned long (*get_pfnblock_flags_mask_sym)(struct page *page, unsigned long pfn, @@ -41,6 +92,8 @@ unsigned long wrapper_get_pfnblock_flags_mask(struct page *page, return -ENOSYS; } } +#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,9,0)) */ + EXPORT_SYMBOL_GPL(wrapper_get_pfnblock_flags_mask); int wrapper_get_pfnblock_flags_mask_init(void) @@ -53,25 +106,6 @@ int wrapper_get_pfnblock_flags_mask_init(void) } EXPORT_SYMBOL_GPL(wrapper_get_pfnblock_flags_mask_init); -/* - * Canary function to check for 'get_pfnblock_flags_mask()' at compile time. - * - * From 'include/linux/pageblock-flags.h': - * - * unsigned long get_pfnblock_flags_mask(struct page *page, - * unsigned long pfn, - * unsigned long end_bitidx, - * unsigned long mask); - */ -__attribute__((unused)) static -unsigned long __canary__get_pfnblock_flags_mask(struct page *page, - unsigned long pfn, - unsigned long end_bitidx, - unsigned long mask) -{ - return get_pfnblock_flags_mask(page, pfn, end_bitidx, mask); -} - #else #include diff --git a/src/wrapper/trace-clock.c b/src/wrapper/trace-clock.c index 74995fef..7ef21cf6 100644 --- a/src/wrapper/trace-clock.c +++ b/src/wrapper/trace-clock.c @@ -11,8 +11,8 @@ #include #ifdef LTTNG_USE_NMI_SAFE_CLOCK -DEFINE_PER_CPU(u64, lttng_last_tsc); -EXPORT_PER_CPU_SYMBOL(lttng_last_tsc); +DEFINE_PER_CPU(u64, lttng_last_timestamp); +EXPORT_PER_CPU_SYMBOL(lttng_last_timestamp); #endif /* #ifdef LTTNG_USE_NMI_SAFE_CLOCK */ #ifdef LTTNG_CLOCK_NMI_SAFE_BROKEN