d61b4fd608af0fd1171bc6232b8ced4900237893
[packages/lttng-modules.git] / git.patch
1 diff --git a/Kconfig b/Kconfig
2 index acdab73..10eccff 100644
3 --- a/Kconfig
4 +++ b/Kconfig
5 @@ -2,7 +2,7 @@
6  
7  config LTTNG
8         tristate "LTTng support"
9 -       select TRACEPOINTS
10 +       select TRACING
11         help
12           LTTng is an open source tracing framework for Linux.
13  
14 diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h b/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
15 index 73463d5..e547040 100644
16 --- a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
17 +++ b/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
18 @@ -220,6 +220,7 @@ LTTNG_TRACEPOINT_EVENT_MAP(
19         LTTNG_KERNEL_RANGE(5,4,19, 5,5,0) || \
20         LTTNG_KERNEL_RANGE(5,5,3, 5,6,0) || \
21         LTTNG_UBUNTU_KERNEL_RANGE(4,15,18,92, 4,16,0,0) || \
22 +       LTTNG_UBUNTU_KERNEL_RANGE(5,0,21,44, 5,1,0,0) || \
23         LTTNG_UBUNTU_KERNEL_RANGE(5,3,18,43, 5,3,18,45) || \
24         LTTNG_UBUNTU_KERNEL_RANGE(5,3,18,46, 5,4,0,0))
25  LTTNG_TRACEPOINT_EVENT_MAP(
26 diff --git a/instrumentation/events/lttng-module/ext4.h b/instrumentation/events/lttng-module/ext4.h
27 index 5f7ab28..b172c8d 100644
28 --- a/instrumentation/events/lttng-module/ext4.h
29 +++ b/instrumentation/events/lttng-module/ext4.h
30 @@ -460,6 +460,21 @@ LTTNG_TRACEPOINT_EVENT(ext4_mb_release_group_pa,
31  )
32  #endif
33  
34 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) || \
35 +       LTTNG_KERNEL_RANGE(5,8,6, 5,9,0))
36 +LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations,
37 +       TP_PROTO(struct inode *inode, unsigned int len, unsigned int needed),
38 +
39 +       TP_ARGS(inode, len, needed),
40 +
41 +       TP_FIELDS(
42 +               ctf_integer(dev_t, dev, inode->i_sb->s_dev)
43 +               ctf_integer(ino_t, ino, inode->i_ino)
44 +               ctf_integer(unsigned int, len, len)
45 +               ctf_integer(unsigned int, needed, needed)
46 +       )
47 +)
48 +#else
49  LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations,
50         TP_PROTO(struct inode *inode),
51  
52 @@ -470,6 +485,7 @@ LTTNG_TRACEPOINT_EVENT(ext4_discard_preallocations,
53                 ctf_integer(ino_t, ino, inode->i_ino)
54         )
55  )
56 +#endif
57  
58  LTTNG_TRACEPOINT_EVENT(ext4_mb_discard_preallocations,
59         TP_PROTO(struct super_block *sb, int needed),
60 @@ -878,12 +894,26 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
61         TP_ARGS(sb, group)
62  )
63  
64 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0))
65 +LTTNG_TRACEPOINT_EVENT(ext4_read_block_bitmap_load,
66 +       TP_PROTO(struct super_block *sb, unsigned long group, bool prefetch),
67 +
68 +       TP_ARGS(sb, group, prefetch),
69 +
70 +       TP_FIELDS(
71 +               ctf_integer(dev_t, dev, sb->s_dev)
72 +               ctf_integer(__u32, group, group)
73 +               ctf_integer(bool, prefetch, prefetch)
74 +       )
75 +)
76 +#else
77  LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_read_block_bitmap_load,
78  
79         TP_PROTO(struct super_block *sb, unsigned long group),
80  
81         TP_ARGS(sb, group)
82  )
83 +#endif
84  
85  LTTNG_TRACEPOINT_EVENT_INSTANCE(ext4__bitmap_load, ext4_load_inode_bitmap,
86  
87 diff --git a/instrumentation/events/lttng-module/i2c.h b/instrumentation/events/lttng-module/i2c.h
88 index dcbabf6..131d134 100644
89 --- a/instrumentation/events/lttng-module/i2c.h
90 +++ b/instrumentation/events/lttng-module/i2c.h
91 @@ -23,7 +23,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(i2c_write,
92  
93         TP_code_pre(
94                 tp_locvar->extract_sensitive_payload =
95 -                       READ_ONCE(extract_sensitive_payload);
96 +                       LTTNG_READ_ONCE(extract_sensitive_payload);
97         ),
98  
99         TP_FIELDS(
100 @@ -78,7 +78,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(i2c_reply,
101  
102         TP_code_pre(
103                 tp_locvar->extract_sensitive_payload =
104 -                       READ_ONCE(extract_sensitive_payload);
105 +                       LTTNG_READ_ONCE(extract_sensitive_payload);
106         ),
107  
108         TP_FIELDS(
109 diff --git a/instrumentation/events/lttng-module/rcu.h b/instrumentation/events/lttng-module/rcu.h
110 index 6a0b58d..24bd51d 100644
111 --- a/instrumentation/events/lttng-module/rcu.h
112 +++ b/instrumentation/events/lttng-module/rcu.h
113 @@ -394,7 +394,8 @@ LTTNG_TRACEPOINT_EVENT(rcu_fqs,
114   */
115  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))      \
116         || LTTNG_KERNEL_RANGE(5,5,6, 5,6,0)             \
117 -       || LTTNG_KERNEL_RANGE(5,4,22, 5,5,0)
118 +       || LTTNG_KERNEL_RANGE(5,4,22, 5,5,0)            \
119 +       || LTTNG_UBUNTU_KERNEL_RANGE(5,0,21,46, 5,1,0,0)
120  LTTNG_TRACEPOINT_EVENT(rcu_dyntick,
121  
122         TP_PROTO(const char *polarity, long oldnesting, long newnesting, int dynticks),
123 diff --git a/instrumentation/events/lttng-module/writeback.h b/instrumentation/events/lttng-module/writeback.h
124 index affb4eb..0ce4915 100644
125 --- a/instrumentation/events/lttng-module/writeback.h
126 +++ b/instrumentation/events/lttng-module/writeback.h
127 @@ -46,7 +46,21 @@ static inline struct backing_dev_info *lttng_inode_to_bdi(struct inode *inode)
128  
129  #endif
130  
131 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
132 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0))
133 +#define show_inode_state(state)                                        \
134 +       __print_flags(state, "|",                               \
135 +               {I_DIRTY_SYNC,          "I_DIRTY_SYNC"},        \
136 +               {I_DIRTY_DATASYNC,      "I_DIRTY_DATASYNC"},    \
137 +               {I_DIRTY_PAGES,         "I_DIRTY_PAGES"},       \
138 +               {I_NEW,                 "I_NEW"},               \
139 +               {I_WILL_FREE,           "I_WILL_FREE"},         \
140 +               {I_FREEING,             "I_FREEING"},           \
141 +               {I_CLEAR,               "I_CLEAR"},             \
142 +               {I_SYNC,                "I_SYNC"},              \
143 +               {I_DIRTY_TIME,          "I_DIRTY_TIME"},        \
144 +               {I_REFERENCED,          "I_REFERENCED"}         \
145 +       )
146 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0))
147  #define show_inode_state(state)                                        \
148         __print_flags(state, "|",                               \
149                 {I_DIRTY_SYNC,          "I_DIRTY_SYNC"},        \
150 @@ -370,34 +384,55 @@ LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_balance_dirty_wait, writeback_wbc_balanc
151  #endif
152  LTTNG_TRACEPOINT_EVENT_WBC_INSTANCE(wbc_writepage, writeback_wbc_writepage)
153  
154 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
155 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) || \
156 +       LTTNG_KERNEL_RANGE(5,8,6, 5,9,0) || \
157 +       LTTNG_KERNEL_RANGE(5,4,62, 5,5,0) || \
158 +       LTTNG_KERNEL_RANGE(4,19,143, 4,20,0) || \
159 +       LTTNG_KERNEL_RANGE(4,14,196, 4,15,0) || \
160 +       LTTNG_KERNEL_RANGE(4,9,235, 4,10,0) || \
161 +       LTTNG_KERNEL_RANGE(4,4,235, 4,5,0) || \
162 +       LTTNG_UBUNTU_KERNEL_RANGE(4,15,18,119, 4,16,0,0))
163 +LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
164 +       TP_PROTO(struct bdi_writeback *wb,
165 +                struct wb_writeback_work *work,
166 +                unsigned long dirtied_before,
167 +                int moved),
168 +       TP_ARGS(wb, work, dirtied_before, moved),
169 +       TP_FIELDS(
170 +               ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
171 +               ctf_integer(unsigned long, older, dirtied_before)
172 +               ctf_integer(int, moved, moved)
173 +       )
174 +)
175 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
176  LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
177         TP_PROTO(struct bdi_writeback *wb,
178 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
179                  struct wb_writeback_work *work,
180 -#else
181 -                unsigned long *older_than_this,
182 -#endif
183                  int moved),
184 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
185         TP_ARGS(wb, work, moved),
186 -#else
187 +       TP_FIELDS(
188 +               ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
189 +               ctf_integer(int, moved, moved)
190 +       )
191 +)
192 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
193 +LTTNG_TRACEPOINT_EVENT(writeback_queue_io,
194 +       TP_PROTO(struct bdi_writeback *wb,
195 +                unsigned long *older_than_this,
196 +                int moved),
197         TP_ARGS(wb, older_than_this, moved),
198 -#endif
199         TP_FIELDS(
200                 ctf_array_text(char, name, dev_name(wb->bdi->dev), 32)
201 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
202 -#else
203                 ctf_integer(unsigned long, older,
204                         older_than_this ? *older_than_this : 0)
205                 ctf_integer(long, age,
206                         older_than_this ?
207                                 (jiffies - *older_than_this) * 1000 / HZ
208                                 : -1)
209 -#endif
210                 ctf_integer(int, moved, moved)
211         )
212  )
213 +#endif
214  
215  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,8,0))
216  LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
217 @@ -446,7 +481,7 @@ LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
218                 ctf_integer(unsigned long, dirty_limit, global_dirty_limit)
219         )
220  )
221 -#else
222 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
223  LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
224  
225         writeback_global_dirty_state,
226 @@ -471,7 +506,6 @@ LTTNG_TRACEPOINT_EVENT_MAP(global_dirty_state,
227         )
228  )
229  #endif
230 -#endif
231  
232  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
233  
234 diff --git a/lib/ringbuffer/backend.h b/lib/ringbuffer/backend.h
235 index da937f2..43e1d47 100644
236 --- a/lib/ringbuffer/backend.h
237 +++ b/lib/ringbuffer/backend.h
238 @@ -156,7 +156,7 @@ size_t lib_ring_buffer_do_strcpy(const struct lib_ring_buffer_config *config,
239                  * Only read source character once, in case it is
240                  * modified concurrently.
241                  */
242 -               c = READ_ONCE(src[count]);
243 +               c = LTTNG_READ_ONCE(src[count]);
244                 if (!c)
245                         break;
246                 lib_ring_buffer_do_copy(config, &dest[count], &c, 1);
247 diff --git a/lib/ringbuffer/backend_internal.h b/lib/ringbuffer/backend_internal.h
248 index 2d6a345..1226fd8 100644
249 --- a/lib/ringbuffer/backend_internal.h
250 +++ b/lib/ringbuffer/backend_internal.h
251 @@ -367,7 +367,7 @@ void lib_ring_buffer_clear_noref(const struct lib_ring_buffer_config *config,
252          * Performing a volatile access to read the sb_pages, because we want to
253          * read a coherent version of the pointer and the associated noref flag.
254          */
255 -       id = READ_ONCE(bufb->buf_wsb[idx].id);
256 +       id = LTTNG_READ_ONCE(bufb->buf_wsb[idx].id);
257         for (;;) {
258                 /* This check is called on the fast path for each record. */
259                 if (likely(!subbuffer_id_is_noref(config, id))) {
260 diff --git a/lib/ringbuffer/frontend.h b/lib/ringbuffer/frontend.h
261 index 6f516d9..41382fe 100644
262 --- a/lib/ringbuffer/frontend.h
263 +++ b/lib/ringbuffer/frontend.h
264 @@ -79,7 +79,7 @@ void *channel_destroy(struct channel *chan);
265  #define for_each_channel_cpu(cpu, chan)                                        \
266         for ((cpu) = -1;                                                \
267                 ({ (cpu) = cpumask_next(cpu, (chan)->backend.cpumask);  \
268 -                  smp_read_barrier_depends(); (cpu) < nr_cpu_ids; });)
269 +                  smp_rmb(); (cpu) < nr_cpu_ids; });)
270  
271  extern struct lib_ring_buffer *channel_get_ring_buffer(
272                                 const struct lib_ring_buffer_config *config,
273 @@ -155,7 +155,7 @@ static inline
274  int lib_ring_buffer_is_finalized(const struct lib_ring_buffer_config *config,
275                                  struct lib_ring_buffer *buf)
276  {
277 -       int finalized = READ_ONCE(buf->finalized);
278 +       int finalized = LTTNG_READ_ONCE(buf->finalized);
279         /*
280          * Read finalized before counters.
281          */
282 diff --git a/lib/ringbuffer/ring_buffer_frontend.c b/lib/ringbuffer/ring_buffer_frontend.c
283 index 3cab365..4980d20 100644
284 --- a/lib/ringbuffer/ring_buffer_frontend.c
285 +++ b/lib/ringbuffer/ring_buffer_frontend.c
286 @@ -1074,7 +1074,7 @@ int lib_ring_buffer_snapshot(struct lib_ring_buffer *buf,
287         int finalized;
288  
289  retry:
290 -       finalized = READ_ONCE(buf->finalized);
291 +       finalized = LTTNG_READ_ONCE(buf->finalized);
292         /*
293          * Read finalized before counters.
294          */
295 @@ -1245,7 +1245,7 @@ int lib_ring_buffer_get_subbuf(struct lib_ring_buffer *buf,
296                 return -EBUSY;
297         }
298  retry:
299 -       finalized = READ_ONCE(buf->finalized);
300 +       finalized = LTTNG_READ_ONCE(buf->finalized);
301         /*
302          * Read finalized before counters.
303          */
304 diff --git a/lib/ringbuffer/ring_buffer_iterator.c b/lib/ringbuffer/ring_buffer_iterator.c
305 index d25db72..7b4f20a 100644
306 --- a/lib/ringbuffer/ring_buffer_iterator.c
307 +++ b/lib/ringbuffer/ring_buffer_iterator.c
308 @@ -46,7 +46,7 @@ restart:
309         switch (iter->state) {
310         case ITER_GET_SUBBUF:
311                 ret = lib_ring_buffer_get_next_subbuf(buf);
312 -               if (ret && !READ_ONCE(buf->finalized)
313 +               if (ret && !LTTNG_READ_ONCE(buf->finalized)
314                     && config->alloc == RING_BUFFER_ALLOC_GLOBAL) {
315                         /*
316                          * Use "pull" scheme for global buffers. The reader
317 diff --git a/lttng-abi.c b/lttng-abi.c
318 index 64ea99d..b33879d 100644
319 --- a/lttng-abi.c
320 +++ b/lttng-abi.c
321 @@ -1264,6 +1264,46 @@ nomem:
322         return ret;
323  }
324  
325 +static
326 +int lttng_abi_validate_event_param(struct lttng_kernel_event *event_param)
327 +{
328 +       /* Limit ABI to implemented features. */
329 +       switch (event_param->instrumentation) {
330 +       case LTTNG_KERNEL_SYSCALL:
331 +               switch (event_param->u.syscall.entryexit) {
332 +               case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
333 +                       break;
334 +               default:
335 +                       return -EINVAL;
336 +               }
337 +               switch (event_param->u.syscall.abi) {
338 +               case LTTNG_KERNEL_SYSCALL_ABI_ALL:
339 +                       break;
340 +               default:
341 +                       return -EINVAL;
342 +               }
343 +               switch (event_param->u.syscall.match) {
344 +               case LTTNG_SYSCALL_MATCH_NAME:
345 +                       break;
346 +               default:
347 +                       return -EINVAL;
348 +               }
349 +               break;
350 +
351 +       case LTTNG_KERNEL_TRACEPOINT:   /* Fallthrough */
352 +       case LTTNG_KERNEL_KPROBE:       /* Fallthrough */
353 +       case LTTNG_KERNEL_KRETPROBE:    /* Fallthrough */
354 +       case LTTNG_KERNEL_NOOP:         /* Fallthrough */
355 +       case LTTNG_KERNEL_UPROBE:
356 +               break;
357 +
358 +       case LTTNG_KERNEL_FUNCTION:     /* Fallthrough */
359 +       default:
360 +               return -EINVAL;
361 +       }
362 +       return 0;
363 +}
364 +
365  static
366  int lttng_abi_create_event(struct file *channel_file,
367                            struct lttng_kernel_event *event_param)
368 @@ -1305,6 +1345,9 @@ int lttng_abi_create_event(struct file *channel_file,
369                 ret = -EOVERFLOW;
370                 goto refcount_error;
371         }
372 +       ret = lttng_abi_validate_event_param(event_param);
373 +       if (ret)
374 +               goto event_error;
375         if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
376                         || event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
377                 struct lttng_enabler *enabler;
378 diff --git a/lttng-abi.h b/lttng-abi.h
379 index 1d356ab..51d60e5 100644
380 --- a/lttng-abi.h
381 +++ b/lttng-abi.h
382 @@ -90,6 +90,31 @@ struct lttng_kernel_event_callsite {
383         } u;
384  } __attribute__((packed));
385  
386 +enum lttng_kernel_syscall_entryexit {
387 +       LTTNG_KERNEL_SYSCALL_ENTRYEXIT = 0,
388 +       LTTNG_KERNEL_SYSCALL_ENTRY = 1,         /* Not implemented. */
389 +       LTTNG_KERNEL_SYSCALL_EXIT = 2,          /* Not implemented. */
390 +};
391 +
392 +enum lttng_kernel_syscall_abi {
393 +       LTTNG_KERNEL_SYSCALL_ABI_ALL = 0,
394 +       LTTNG_KERNEL_SYSCALL_ABI_NATIVE = 1,    /* Not implemented. */
395 +       LTTNG_KERNEL_SYSCALL_ABI_COMPAT = 2,    /* Not implemented. */
396 +};
397 +
398 +enum lttng_kernel_syscall_match {
399 +       LTTNG_SYSCALL_MATCH_NAME = 0,
400 +       LTTNG_SYSCALL_MATCH_NR = 1,             /* Not implemented. */
401 +};
402 +
403 +struct lttng_kernel_syscall {
404 +       uint8_t entryexit;      /* enum lttng_kernel_syscall_entryexit */
405 +       uint8_t abi;            /* enum lttng_kernel_syscall_abi */
406 +       uint8_t match;          /* enum lttng_kernel_syscall_match */
407 +       uint8_t padding;
408 +       uint32_t nr;            /* For LTTNG_SYSCALL_MATCH_NR */
409 +} __attribute__((packed));
410 +
411  /*
412   * For syscall tracing, name = "*" means "enable all".
413   */
414 @@ -106,6 +131,7 @@ struct lttng_kernel_event {
415                 struct lttng_kernel_kprobe kprobe;
416                 struct lttng_kernel_function_tracer ftrace;
417                 struct lttng_kernel_uprobe uprobe;
418 +               struct lttng_kernel_syscall syscall;
419                 char padding[LTTNG_KERNEL_EVENT_PADDING2];
420         } u;
421  } __attribute__((packed));
422 diff --git a/lttng-events.c b/lttng-events.c
423 index be7e389..4c0b04a 100644
424 --- a/lttng-events.c
425 +++ b/lttng-events.c
426 @@ -201,6 +201,10 @@ void lttng_session_destroy(struct lttng_session *session)
427                 WARN_ON(ret);
428         }
429         synchronize_trace();    /* Wait for in-flight events to complete */
430 +       list_for_each_entry(chan, &session->chan, list) {
431 +               ret = lttng_syscalls_destroy(chan);
432 +               WARN_ON(ret);
433 +       }
434         list_for_each_entry_safe(enabler, tmpenabler,
435                         &session->enablers_head, node)
436                 lttng_enabler_destroy(enabler);
437 @@ -740,6 +744,28 @@ struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
438                 event->enabled = 0;
439                 event->registered = 0;
440                 event->desc = event_desc;
441 +               switch (event_param->u.syscall.entryexit) {
442 +               case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
443 +                       ret = -EINVAL;
444 +                       goto register_error;
445 +               case LTTNG_KERNEL_SYSCALL_ENTRY:
446 +                       event->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
447 +                       break;
448 +               case LTTNG_KERNEL_SYSCALL_EXIT:
449 +                       event->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
450 +                       break;
451 +               }
452 +               switch (event_param->u.syscall.abi) {
453 +               case LTTNG_KERNEL_SYSCALL_ABI_ALL:
454 +                       ret = -EINVAL;
455 +                       goto register_error;
456 +               case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
457 +                       event->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
458 +                       break;
459 +               case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
460 +                       event->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
461 +                       break;
462 +               }
463                 if (!event->desc) {
464                         ret = -EINVAL;
465                         goto register_error;
466 @@ -826,8 +852,7 @@ void register_event(struct lttng_event *event)
467                                                   event);
468                 break;
469         case LTTNG_KERNEL_SYSCALL:
470 -               ret = lttng_syscall_filter_enable(event->chan,
471 -                       desc->name);
472 +               ret = lttng_syscall_filter_enable(event->chan, event);
473                 break;
474         case LTTNG_KERNEL_KPROBE:
475         case LTTNG_KERNEL_UPROBE:
476 @@ -870,8 +895,7 @@ int _lttng_event_unregister(struct lttng_event *event)
477                 ret = 0;
478                 break;
479         case LTTNG_KERNEL_SYSCALL:
480 -               ret = lttng_syscall_filter_disable(event->chan,
481 -                       desc->name);
482 +               ret = lttng_syscall_filter_disable(event->chan, event);
483                 break;
484         case LTTNG_KERNEL_NOOP:
485                 ret = 0;
486 @@ -1203,39 +1227,87 @@ int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
487                 struct lttng_enabler *enabler)
488  {
489         const char *desc_name, *enabler_name;
490 +       bool compat = false, entry = false;
491  
492         enabler_name = enabler->event_param.name;
493         switch (enabler->event_param.instrumentation) {
494         case LTTNG_KERNEL_TRACEPOINT:
495                 desc_name = desc->name;
496 +               switch (enabler->type) {
497 +               case LTTNG_ENABLER_STAR_GLOB:
498 +                       return lttng_match_enabler_star_glob(desc_name, enabler_name);
499 +               case LTTNG_ENABLER_NAME:
500 +                       return lttng_match_enabler_name(desc_name, enabler_name);
501 +               default:
502 +                       return -EINVAL;
503 +               }
504                 break;
505         case LTTNG_KERNEL_SYSCALL:
506                 desc_name = desc->name;
507 -               if (!strncmp(desc_name, "compat_", strlen("compat_")))
508 +               if (!strncmp(desc_name, "compat_", strlen("compat_"))) {
509                         desc_name += strlen("compat_");
510 +                       compat = true;
511 +               }
512                 if (!strncmp(desc_name, "syscall_exit_",
513                                 strlen("syscall_exit_"))) {
514                         desc_name += strlen("syscall_exit_");
515                 } else if (!strncmp(desc_name, "syscall_entry_",
516                                 strlen("syscall_entry_"))) {
517                         desc_name += strlen("syscall_entry_");
518 +                       entry = true;
519                 } else {
520                         WARN_ON_ONCE(1);
521                         return -EINVAL;
522                 }
523 +               switch (enabler->event_param.u.syscall.entryexit) {
524 +               case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
525 +                       break;
526 +               case LTTNG_KERNEL_SYSCALL_ENTRY:
527 +                       if (!entry)
528 +                               return 0;
529 +                       break;
530 +               case LTTNG_KERNEL_SYSCALL_EXIT:
531 +                       if (entry)
532 +                               return 0;
533 +                       break;
534 +               default:
535 +                       return -EINVAL;
536 +               }
537 +               switch (enabler->event_param.u.syscall.abi) {
538 +               case LTTNG_KERNEL_SYSCALL_ABI_ALL:
539 +                       break;
540 +               case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
541 +                       if (compat)
542 +                               return 0;
543 +                       break;
544 +               case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
545 +                       if (!compat)
546 +                               return 0;
547 +                       break;
548 +               default:
549 +                       return -EINVAL;
550 +               }
551 +               switch (enabler->event_param.u.syscall.match) {
552 +               case LTTNG_SYSCALL_MATCH_NAME:
553 +                       switch (enabler->type) {
554 +                       case LTTNG_ENABLER_STAR_GLOB:
555 +                               return lttng_match_enabler_star_glob(desc_name, enabler_name);
556 +                       case LTTNG_ENABLER_NAME:
557 +                               return lttng_match_enabler_name(desc_name, enabler_name);
558 +                       default:
559 +                               return -EINVAL;
560 +                       }
561 +                       break;
562 +               case LTTNG_SYSCALL_MATCH_NR:
563 +                       return -EINVAL; /* Not implemented. */
564 +               default:
565 +                       return -EINVAL;
566 +               }
567                 break;
568         default:
569                 WARN_ON_ONCE(1);
570                 return -EINVAL;
571         }
572 -       switch (enabler->type) {
573 -       case LTTNG_ENABLER_STAR_GLOB:
574 -               return lttng_match_enabler_star_glob(desc_name, enabler_name);
575 -       case LTTNG_ENABLER_NAME:
576 -               return lttng_match_enabler_name(desc_name, enabler_name);
577 -       default:
578 -               return -EINVAL;
579 -       }
580  }
581  
582  static
583 @@ -1361,9 +1433,21 @@ void lttng_create_event_if_missing(struct lttng_enabler *enabler)
584  static
585  int lttng_enabler_ref_events(struct lttng_enabler *enabler)
586  {
587 -       struct lttng_session *session = enabler->chan->session;
588 +       struct lttng_channel *chan = enabler->chan;
589 +       struct lttng_session *session = chan->session;
590         struct lttng_event *event;
591  
592 +       if (enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
593 +                       enabler->event_param.u.syscall.entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT &&
594 +                       enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
595 +                       enabler->event_param.u.syscall.match == LTTNG_SYSCALL_MATCH_NAME &&
596 +                       !strcmp(enabler->event_param.name, "*")) {
597 +               if (enabler->enabled)
598 +                       WRITE_ONCE(chan->syscall_all, 1);
599 +               else
600 +                       WRITE_ONCE(chan->syscall_all, 0);
601 +       }
602 +
603         /* First ensure that probe events are created for this enabler. */
604         lttng_create_event_if_missing(enabler);
605  
606 @@ -1719,7 +1803,7 @@ int lttng_metadata_printf(struct lttng_session *session,
607         size_t len;
608         va_list ap;
609  
610 -       WARN_ON_ONCE(!READ_ONCE(session->active));
611 +       WARN_ON_ONCE(!LTTNG_READ_ONCE(session->active));
612  
613         va_start(ap, fmt);
614         str = kvasprintf(GFP_KERNEL, fmt, ap);
615 @@ -2305,7 +2389,7 @@ int _lttng_event_metadata_statedump(struct lttng_session *session,
616  {
617         int ret = 0;
618  
619 -       if (event->metadata_dumped || !READ_ONCE(session->active))
620 +       if (event->metadata_dumped || !LTTNG_READ_ONCE(session->active))
621                 return 0;
622         if (chan->channel_type == METADATA_CHANNEL)
623                 return 0;
624 @@ -2377,7 +2461,7 @@ int _lttng_channel_metadata_statedump(struct lttng_session *session,
625  {
626         int ret = 0;
627  
628 -       if (chan->metadata_dumped || !READ_ONCE(session->active))
629 +       if (chan->metadata_dumped || !LTTNG_READ_ONCE(session->active))
630                 return 0;
631  
632         if (chan->channel_type == METADATA_CHANNEL)
633 @@ -2604,7 +2688,7 @@ int _lttng_session_metadata_statedump(struct lttng_session *session)
634         struct lttng_event *event;
635         int ret = 0;
636  
637 -       if (!READ_ONCE(session->active))
638 +       if (!LTTNG_READ_ONCE(session->active))
639                 return 0;
640  
641         lttng_metadata_begin(session);
642 diff --git a/lttng-events.h b/lttng-events.h
643 index a36a312..d4d9976 100644
644 --- a/lttng-events.h
645 +++ b/lttng-events.h
646 @@ -292,6 +292,16 @@ struct lttng_uprobe_handler {
647         struct list_head node;
648  };
649  
650 +enum lttng_syscall_entryexit {
651 +       LTTNG_SYSCALL_ENTRY,
652 +       LTTNG_SYSCALL_EXIT,
653 +};
654 +
655 +enum lttng_syscall_abi {
656 +       LTTNG_SYSCALL_ABI_NATIVE,
657 +       LTTNG_SYSCALL_ABI_COMPAT,
658 +};
659 +
660  /*
661   * lttng_event structure is referred to by the tracing fast path. It must be
662   * kept small.
663 @@ -318,6 +328,11 @@ struct lttng_event {
664                         struct inode *inode;
665                         struct list_head head;
666                 } uprobe;
667 +               struct {
668 +                       char *syscall_name;
669 +                       enum lttng_syscall_entryexit entryexit;
670 +                       enum lttng_syscall_abi abi;
671 +               } syscall;
672         } u;
673         struct list_head list;          /* Event list in session */
674         unsigned int metadata_dumped:1;
675 @@ -457,10 +472,10 @@ struct lttng_channel {
676         struct lttng_syscall_filter *sc_filter;
677         int header_type;                /* 0: unset, 1: compact, 2: large */
678         enum channel_type channel_type;
679 +       int syscall_all;
680         unsigned int metadata_dumped:1,
681                 sys_enter_registered:1,
682                 sys_exit_registered:1,
683 -               syscall_all:1,
684                 tstate:1;               /* Transient enable state */
685  };
686  
687 @@ -653,10 +668,11 @@ void lttng_clock_unref(void);
688  #if defined(CONFIG_HAVE_SYSCALL_TRACEPOINTS)
689  int lttng_syscalls_register(struct lttng_channel *chan, void *filter);
690  int lttng_syscalls_unregister(struct lttng_channel *chan);
691 +int lttng_syscalls_destroy(struct lttng_channel *chan);
692  int lttng_syscall_filter_enable(struct lttng_channel *chan,
693 -               const char *name);
694 +               struct lttng_event *event);
695  int lttng_syscall_filter_disable(struct lttng_channel *chan,
696 -               const char *name);
697 +               struct lttng_event *event);
698  long lttng_channel_syscall_mask(struct lttng_channel *channel,
699                 struct lttng_kernel_syscall_mask __user *usyscall_mask);
700  #else
701 @@ -670,14 +686,19 @@ static inline int lttng_syscalls_unregister(struct lttng_channel *chan)
702         return 0;
703  }
704  
705 +static inline int lttng_syscalls_destroy(struct lttng_channel *chan)
706 +{
707 +       return 0;
708 +}
709 +
710  static inline int lttng_syscall_filter_enable(struct lttng_channel *chan,
711 -               const char *name)
712 +               struct lttng_event *event);
713  {
714         return -ENOSYS;
715  }
716  
717  static inline int lttng_syscall_filter_disable(struct lttng_channel *chan,
718 -               const char *name)
719 +               struct lttng_event *event);
720  {
721         return -ENOSYS;
722  }
723 diff --git a/lttng-syscalls.c b/lttng-syscalls.c
724 index 97f1ba9..26cead6 100644
725 --- a/lttng-syscalls.c
726 +++ b/lttng-syscalls.c
727 @@ -367,8 +367,10 @@ const struct trace_syscall_entry compat_sc_exit_table[] = {
728  #undef CREATE_SYSCALL_TABLE
729  
730  struct lttng_syscall_filter {
731 -       DECLARE_BITMAP(sc, NR_syscalls);
732 -       DECLARE_BITMAP(sc_compat, NR_compat_syscalls);
733 +       DECLARE_BITMAP(sc_entry, NR_syscalls);
734 +       DECLARE_BITMAP(sc_exit, NR_syscalls);
735 +       DECLARE_BITMAP(sc_compat_entry, NR_compat_syscalls);
736 +       DECLARE_BITMAP(sc_compat_exit, NR_compat_syscalls);
737  };
738  
739  static void syscall_entry_unknown(struct lttng_event *event,
740 @@ -391,29 +393,23 @@ void syscall_entry_probe(void *__data, struct pt_regs *regs, long id)
741         size_t table_len;
742  
743         if (unlikely(in_compat_syscall())) {
744 -               struct lttng_syscall_filter *filter;
745 -
746 -               filter = lttng_rcu_dereference(chan->sc_filter);
747 -               if (filter) {
748 -                       if (id < 0 || id >= NR_compat_syscalls
749 -                               || !test_bit(id, filter->sc_compat)) {
750 -                               /* System call filtered out. */
751 -                               return;
752 -                       }
753 +               struct lttng_syscall_filter *filter = chan->sc_filter;
754 +
755 +               if (id < 0 || id >= NR_compat_syscalls
756 +                       || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_compat_entry))) {
757 +                       /* System call filtered out. */
758 +                       return;
759                 }
760                 table = compat_sc_table;
761                 table_len = ARRAY_SIZE(compat_sc_table);
762                 unknown_event = chan->sc_compat_unknown;
763         } else {
764 -               struct lttng_syscall_filter *filter;
765 -
766 -               filter = lttng_rcu_dereference(chan->sc_filter);
767 -               if (filter) {
768 -                       if (id < 0 || id >= NR_syscalls
769 -                               || !test_bit(id, filter->sc)) {
770 -                               /* System call filtered out. */
771 -                               return;
772 -                       }
773 +               struct lttng_syscall_filter *filter = chan->sc_filter;
774 +
775 +               if (id < 0 || id >= NR_syscalls
776 +                       || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_entry))) {
777 +                       /* System call filtered out. */
778 +                       return;
779                 }
780                 table = sc_table;
781                 table_len = ARRAY_SIZE(sc_table);
782 @@ -545,29 +541,23 @@ void syscall_exit_probe(void *__data, struct pt_regs *regs, long ret)
783  
784         id = syscall_get_nr(current, regs);
785         if (unlikely(in_compat_syscall())) {
786 -               struct lttng_syscall_filter *filter;
787 -
788 -               filter = lttng_rcu_dereference(chan->sc_filter);
789 -               if (filter) {
790 -                       if (id < 0 || id >= NR_compat_syscalls
791 -                               || !test_bit(id, filter->sc_compat)) {
792 -                               /* System call filtered out. */
793 -                               return;
794 -                       }
795 +               struct lttng_syscall_filter *filter = chan->sc_filter;
796 +
797 +               if (id < 0 || id >= NR_compat_syscalls
798 +                       || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_compat_exit))) {
799 +                       /* System call filtered out. */
800 +                       return;
801                 }
802                 table = compat_sc_exit_table;
803                 table_len = ARRAY_SIZE(compat_sc_exit_table);
804                 unknown_event = chan->compat_sc_exit_unknown;
805         } else {
806 -               struct lttng_syscall_filter *filter;
807 -
808 -               filter = lttng_rcu_dereference(chan->sc_filter);
809 -               if (filter) {
810 -                       if (id < 0 || id >= NR_syscalls
811 -                               || !test_bit(id, filter->sc)) {
812 -                               /* System call filtered out. */
813 -                               return;
814 -                       }
815 +               struct lttng_syscall_filter *filter = chan->sc_filter;
816 +
817 +               if (id < 0 || id >= NR_syscalls
818 +                       || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_exit))) {
819 +                       /* System call filtered out. */
820 +                       return;
821                 }
822                 table = sc_exit_table;
823                 table_len = ARRAY_SIZE(sc_exit_table);
824 @@ -713,27 +703,23 @@ int fill_table(const struct trace_syscall_entry *table, size_t table_len,
825                 memset(&ev, 0, sizeof(ev));
826                 switch (type) {
827                 case SC_TYPE_ENTRY:
828 -                       strncpy(ev.name, SYSCALL_ENTRY_STR,
829 -                               LTTNG_KERNEL_SYM_NAME_LEN);
830 +                       ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
831 +                       ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
832                         break;
833                 case SC_TYPE_EXIT:
834 -                       strncpy(ev.name, SYSCALL_EXIT_STR,
835 -                               LTTNG_KERNEL_SYM_NAME_LEN);
836 +                       ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
837 +                       ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
838                         break;
839                 case SC_TYPE_COMPAT_ENTRY:
840 -                       strncpy(ev.name, COMPAT_SYSCALL_ENTRY_STR,
841 -                               LTTNG_KERNEL_SYM_NAME_LEN);
842 +                       ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
843 +                       ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
844                         break;
845                 case SC_TYPE_COMPAT_EXIT:
846 -                       strncpy(ev.name, COMPAT_SYSCALL_EXIT_STR,
847 -                               LTTNG_KERNEL_SYM_NAME_LEN);
848 -                       break;
849 -               default:
850 -                       BUG_ON(1);
851 +                       ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
852 +                       ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
853                         break;
854                 }
855 -               strncat(ev.name, desc->name,
856 -                       LTTNG_KERNEL_SYM_NAME_LEN - strlen(ev.name) - 1);
857 +               strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
858                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
859                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
860                 chan_table[i] = _lttng_event_create(chan, &ev, filter,
861 @@ -803,6 +789,8 @@ int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
862                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
863                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
864                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
865 +               ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
866 +               ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
867                 chan->sc_unknown = _lttng_event_create(chan, &ev, filter,
868                                                 desc,
869                                                 ev.instrumentation);
870 @@ -820,6 +808,8 @@ int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
871                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
872                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
873                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
874 +               ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
875 +               ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
876                 chan->sc_compat_unknown = _lttng_event_create(chan, &ev, filter,
877                                                 desc,
878                                                 ev.instrumentation);
879 @@ -837,6 +827,8 @@ int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
880                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
881                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
882                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
883 +               ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
884 +               ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
885                 chan->compat_sc_exit_unknown = _lttng_event_create(chan, &ev,
886                                                 filter, desc,
887                                                 ev.instrumentation);
888 @@ -854,6 +846,8 @@ int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
889                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
890                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
891                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
892 +               ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
893 +               ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
894                 chan->sc_exit_unknown = _lttng_event_create(chan, &ev, filter,
895                                                 desc, ev.instrumentation);
896                 WARN_ON_ONCE(!chan->sc_exit_unknown);
897 @@ -883,6 +877,14 @@ int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
898         if (ret)
899                 return ret;
900  #endif
901 +
902 +       if (!chan->sc_filter) {
903 +               chan->sc_filter = kzalloc(sizeof(struct lttng_syscall_filter),
904 +                               GFP_KERNEL);
905 +               if (!chan->sc_filter)
906 +                       return -ENOMEM;
907 +       }
908 +
909         if (!chan->sys_enter_registered) {
910                 ret = lttng_wrapper_tracepoint_probe_register("sys_enter",
911                                 (void *) syscall_entry_probe, chan);
912 @@ -930,7 +932,11 @@ int lttng_syscalls_unregister(struct lttng_channel *chan)
913                         return ret;
914                 chan->sys_exit_registered = 0;
915         }
916 -       /* lttng_event destroy will be performed by lttng_session_destroy() */
917 +       return 0;
918 +}
919 +
920 +int lttng_syscalls_destroy(struct lttng_channel *chan)
921 +{
922         kfree(chan->sc_table);
923         kfree(chan->sc_exit_table);
924  #ifdef CONFIG_COMPAT
925 @@ -993,136 +999,150 @@ uint32_t get_sc_tables_len(void)
926         return ARRAY_SIZE(sc_table) + ARRAY_SIZE(compat_sc_table);
927  }
928  
929 -int lttng_syscall_filter_enable(struct lttng_channel *chan,
930 -               const char *name)
931 +static
932 +const char *get_syscall_name(struct lttng_event *event)
933  {
934 -       int syscall_nr, compat_syscall_nr, ret;
935 -       struct lttng_syscall_filter *filter;
936 +       size_t prefix_len = 0;
937  
938 -       WARN_ON_ONCE(!chan->sc_table);
939 +       WARN_ON_ONCE(event->instrumentation != LTTNG_KERNEL_SYSCALL);
940  
941 -       if (!name) {
942 -               /* Enable all system calls by removing filter */
943 -               if (chan->sc_filter) {
944 -                       filter = chan->sc_filter;
945 -                       rcu_assign_pointer(chan->sc_filter, NULL);
946 -                       synchronize_trace();
947 -                       kfree(filter);
948 +       switch (event->u.syscall.entryexit) {
949 +       case LTTNG_SYSCALL_ENTRY:
950 +               switch (event->u.syscall.abi) {
951 +               case LTTNG_SYSCALL_ABI_NATIVE:
952 +                       prefix_len = strlen(SYSCALL_ENTRY_STR);
953 +                       break;
954 +               case LTTNG_SYSCALL_ABI_COMPAT:
955 +                       prefix_len = strlen(COMPAT_SYSCALL_ENTRY_STR);
956 +                       break;
957                 }
958 -               chan->syscall_all = 1;
959 -               return 0;
960 -       }
961 -
962 -       if (!chan->sc_filter) {
963 -               if (chan->syscall_all) {
964 -                       /*
965 -                        * All syscalls are already enabled.
966 -                        */
967 -                       return -EEXIST;
968 +               break;
969 +       case LTTNG_SYSCALL_EXIT:
970 +               switch (event->u.syscall.abi) {
971 +               case LTTNG_SYSCALL_ABI_NATIVE:
972 +                       prefix_len = strlen(SYSCALL_EXIT_STR);
973 +                       break;
974 +               case LTTNG_SYSCALL_ABI_COMPAT:
975 +                       prefix_len = strlen(COMPAT_SYSCALL_EXIT_STR);
976 +                       break;
977                 }
978 -               filter = kzalloc(sizeof(struct lttng_syscall_filter),
979 -                               GFP_KERNEL);
980 -               if (!filter)
981 -                       return -ENOMEM;
982 -       } else {
983 -               filter = chan->sc_filter;
984 +               break;
985         }
986 -       syscall_nr = get_syscall_nr(name);
987 -       compat_syscall_nr = get_compat_syscall_nr(name);
988 -       if (syscall_nr < 0 && compat_syscall_nr < 0) {
989 -               ret = -ENOENT;
990 -               goto error;
991 +       WARN_ON_ONCE(prefix_len == 0);
992 +       return event->desc->name + prefix_len;
993 +}
994 +
995 +int lttng_syscall_filter_enable(struct lttng_channel *chan,
996 +               struct lttng_event *event)
997 +{
998 +       struct lttng_syscall_filter *filter = chan->sc_filter;
999 +       const char *syscall_name;
1000 +       unsigned long *bitmap;
1001 +       int syscall_nr;
1002 +
1003 +       WARN_ON_ONCE(!chan->sc_table);
1004 +
1005 +       syscall_name = get_syscall_name(event);
1006 +
1007 +       switch (event->u.syscall.abi) {
1008 +       case LTTNG_SYSCALL_ABI_NATIVE:
1009 +               syscall_nr = get_syscall_nr(syscall_name);
1010 +               break;
1011 +       case LTTNG_SYSCALL_ABI_COMPAT:
1012 +               syscall_nr = get_compat_syscall_nr(syscall_name);
1013 +               break;
1014 +       default:
1015 +               return -EINVAL;
1016         }
1017 -       if (syscall_nr >= 0) {
1018 -               if (test_bit(syscall_nr, filter->sc)) {
1019 -                       ret = -EEXIST;
1020 -                       goto error;
1021 +       if (syscall_nr < 0)
1022 +               return -ENOENT;
1023 +
1024 +
1025 +       switch (event->u.syscall.entryexit) {
1026 +       case LTTNG_SYSCALL_ENTRY:
1027 +               switch (event->u.syscall.abi) {
1028 +               case LTTNG_SYSCALL_ABI_NATIVE:
1029 +                       bitmap = filter->sc_entry;
1030 +                       break;
1031 +               case LTTNG_SYSCALL_ABI_COMPAT:
1032 +                       bitmap = filter->sc_compat_entry;
1033 +                       break;
1034                 }
1035 -               bitmap_set(filter->sc, syscall_nr, 1);
1036 -       }
1037 -       if (compat_syscall_nr >= 0) {
1038 -               if (test_bit(compat_syscall_nr, filter->sc_compat)) {
1039 -                       ret = -EEXIST;
1040 -                       goto error;
1041 +               break;
1042 +       case LTTNG_SYSCALL_EXIT:
1043 +               switch (event->u.syscall.abi) {
1044 +               case LTTNG_SYSCALL_ABI_NATIVE:
1045 +                       bitmap = filter->sc_exit;
1046 +                       break;
1047 +               case LTTNG_SYSCALL_ABI_COMPAT:
1048 +                       bitmap = filter->sc_compat_exit;
1049 +                       break;
1050                 }
1051 -               bitmap_set(filter->sc_compat, compat_syscall_nr, 1);
1052 +               break;
1053 +       default:
1054 +               return -EINVAL;
1055         }
1056 -       if (!chan->sc_filter)
1057 -               rcu_assign_pointer(chan->sc_filter, filter);
1058 +       if (test_bit(syscall_nr, bitmap))
1059 +               return -EEXIST;
1060 +       bitmap_set(bitmap, syscall_nr, 1);
1061         return 0;
1062 -
1063 -error:
1064 -       if (!chan->sc_filter)
1065 -               kfree(filter);
1066 -       return ret;
1067  }
1068  
1069  int lttng_syscall_filter_disable(struct lttng_channel *chan,
1070 -               const char *name)
1071 +               struct lttng_event *event)
1072  {
1073 -       int syscall_nr, compat_syscall_nr, ret;
1074 -       struct lttng_syscall_filter *filter;
1075 +       struct lttng_syscall_filter *filter = chan->sc_filter;
1076 +       const char *syscall_name;
1077 +       unsigned long *bitmap;
1078 +       int syscall_nr;
1079  
1080         WARN_ON_ONCE(!chan->sc_table);
1081  
1082 -       if (!chan->sc_filter) {
1083 -               if (!chan->syscall_all)
1084 -                       return -EEXIST;
1085 -               filter = kzalloc(sizeof(struct lttng_syscall_filter),
1086 -                               GFP_KERNEL);
1087 -               if (!filter)
1088 -                       return -ENOMEM;
1089 -               /* Trace all system calls, then apply disable. */
1090 -               bitmap_set(filter->sc, 0, NR_syscalls);
1091 -               bitmap_set(filter->sc_compat, 0, NR_compat_syscalls);
1092 -       } else {
1093 -               filter = chan->sc_filter;
1094 +       syscall_name = get_syscall_name(event);
1095 +
1096 +       switch (event->u.syscall.abi) {
1097 +       case LTTNG_SYSCALL_ABI_NATIVE:
1098 +               syscall_nr = get_syscall_nr(syscall_name);
1099 +               break;
1100 +       case LTTNG_SYSCALL_ABI_COMPAT:
1101 +               syscall_nr = get_compat_syscall_nr(syscall_name);
1102 +               break;
1103 +       default:
1104 +               return -EINVAL;
1105         }
1106 +       if (syscall_nr < 0)
1107 +               return -ENOENT;
1108  
1109 -       if (!name) {
1110 -               /* Fail if all syscalls are already disabled. */
1111 -               if (bitmap_empty(filter->sc, NR_syscalls)
1112 -                       && bitmap_empty(filter->sc_compat,
1113 -                               NR_compat_syscalls)) {
1114 -                       ret = -EEXIST;
1115 -                       goto error;
1116 -               }
1117  
1118 -               /* Disable all system calls */
1119 -               bitmap_clear(filter->sc, 0, NR_syscalls);
1120 -               bitmap_clear(filter->sc_compat, 0, NR_compat_syscalls);
1121 -               goto apply_filter;
1122 -       }
1123 -       syscall_nr = get_syscall_nr(name);
1124 -       compat_syscall_nr = get_compat_syscall_nr(name);
1125 -       if (syscall_nr < 0 && compat_syscall_nr < 0) {
1126 -               ret = -ENOENT;
1127 -               goto error;
1128 -       }
1129 -       if (syscall_nr >= 0) {
1130 -               if (!test_bit(syscall_nr, filter->sc)) {
1131 -                       ret = -EEXIST;
1132 -                       goto error;
1133 +       switch (event->u.syscall.entryexit) {
1134 +       case LTTNG_SYSCALL_ENTRY:
1135 +               switch (event->u.syscall.abi) {
1136 +               case LTTNG_SYSCALL_ABI_NATIVE:
1137 +                       bitmap = filter->sc_entry;
1138 +                       break;
1139 +               case LTTNG_SYSCALL_ABI_COMPAT:
1140 +                       bitmap = filter->sc_compat_entry;
1141 +                       break;
1142                 }
1143 -               bitmap_clear(filter->sc, syscall_nr, 1);
1144 -       }
1145 -       if (compat_syscall_nr >= 0) {
1146 -               if (!test_bit(compat_syscall_nr, filter->sc_compat)) {
1147 -                       ret = -EEXIST;
1148 -                       goto error;
1149 +               break;
1150 +       case LTTNG_SYSCALL_EXIT:
1151 +               switch (event->u.syscall.abi) {
1152 +               case LTTNG_SYSCALL_ABI_NATIVE:
1153 +                       bitmap = filter->sc_exit;
1154 +                       break;
1155 +               case LTTNG_SYSCALL_ABI_COMPAT:
1156 +                       bitmap = filter->sc_compat_exit;
1157 +                       break;
1158                 }
1159 -               bitmap_clear(filter->sc_compat, compat_syscall_nr, 1);
1160 +               break;
1161 +       default:
1162 +               return -EINVAL;
1163         }
1164 -apply_filter:
1165 -       if (!chan->sc_filter)
1166 -               rcu_assign_pointer(chan->sc_filter, filter);
1167 -       chan->syscall_all = 0;
1168 -       return 0;
1169 +       if (!test_bit(syscall_nr, bitmap))
1170 +               return -EEXIST;
1171 +       bitmap_clear(bitmap, syscall_nr, 1);
1172  
1173 -error:
1174 -       if (!chan->sc_filter)
1175 -               kfree(filter);
1176 -       return ret;
1177 +       return 0;
1178  }
1179  
1180  static
1181 @@ -1236,6 +1256,9 @@ const struct file_operations lttng_syscall_list_fops = {
1182         .release = seq_release,
1183  };
1184  
1185 +/*
1186 + * A syscall is enabled if it is traced for either entry or exit.
1187 + */
1188  long lttng_channel_syscall_mask(struct lttng_channel *channel,
1189                 struct lttng_kernel_syscall_mask __user *usyscall_mask)
1190  {
1191 @@ -1262,8 +1285,9 @@ long lttng_channel_syscall_mask(struct lttng_channel *channel,
1192                 char state;
1193  
1194                 if (channel->sc_table) {
1195 -                       if (filter)
1196 -                               state = test_bit(bit, filter->sc);
1197 +                       if (!READ_ONCE(channel->syscall_all) && filter)
1198 +                               state = test_bit(bit, filter->sc_entry)
1199 +                                       || test_bit(bit, filter->sc_exit);
1200                         else
1201                                 state = 1;
1202                 } else {
1203 @@ -1275,9 +1299,11 @@ long lttng_channel_syscall_mask(struct lttng_channel *channel,
1204                 char state;
1205  
1206                 if (channel->compat_sc_table) {
1207 -                       if (filter)
1208 +                       if (!READ_ONCE(channel->syscall_all) && filter)
1209                                 state = test_bit(bit - ARRAY_SIZE(sc_table),
1210 -                                               filter->sc_compat);
1211 +                                               filter->sc_compat_entry)
1212 +                                       || test_bit(bit - ARRAY_SIZE(sc_table),
1213 +                                               filter->sc_compat_exit);
1214                         else
1215                                 state = 1;
1216                 } else {
1217 diff --git a/probes/lttng-kprobes.c b/probes/lttng-kprobes.c
1218 index a44eaa1..38fb72e 100644
1219 --- a/probes/lttng-kprobes.c
1220 +++ b/probes/lttng-kprobes.c
1221 @@ -31,11 +31,11 @@ int lttng_kprobes_handler_pre(struct kprobe *p, struct pt_regs *regs)
1222         int ret;
1223         unsigned long data = (unsigned long) p->addr;
1224  
1225 -       if (unlikely(!READ_ONCE(chan->session->active)))
1226 +       if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
1227                 return 0;
1228 -       if (unlikely(!READ_ONCE(chan->enabled)))
1229 +       if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
1230                 return 0;
1231 -       if (unlikely(!READ_ONCE(event->enabled)))
1232 +       if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
1233                 return 0;
1234  
1235         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx, sizeof(data),
1236 diff --git a/probes/lttng-kretprobes.c b/probes/lttng-kretprobes.c
1237 index ab98ff2..a6bcd21 100644
1238 --- a/probes/lttng-kretprobes.c
1239 +++ b/probes/lttng-kretprobes.c
1240 @@ -51,11 +51,11 @@ int _lttng_kretprobes_handler(struct kretprobe_instance *krpi,
1241                 unsigned long parent_ip;
1242         } payload;
1243  
1244 -       if (unlikely(!READ_ONCE(chan->session->active)))
1245 +       if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
1246                 return 0;
1247 -       if (unlikely(!READ_ONCE(chan->enabled)))
1248 +       if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
1249                 return 0;
1250 -       if (unlikely(!READ_ONCE(event->enabled)))
1251 +       if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
1252                 return 0;
1253  
1254         payload.ip = (unsigned long) krpi->rp->kp.addr;
1255 diff --git a/probes/lttng-probe-kvm-x86-mmu.c b/probes/lttng-probe-kvm-x86-mmu.c
1256 index 37384a2..8f98186 100644
1257 --- a/probes/lttng-probe-kvm-x86-mmu.c
1258 +++ b/probes/lttng-probe-kvm-x86-mmu.c
1259 @@ -24,7 +24,12 @@
1260   */
1261  #include <wrapper/tracepoint.h>
1262  
1263 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0))
1264 +#include <../../arch/x86/kvm/mmu/mmu_internal.h>
1265 +#include <../../arch/x86/kvm/mmu/mmutrace.h>
1266 +#else
1267  #include <../../arch/x86/kvm/mmutrace.h>
1268 +#endif
1269  
1270  #undef TRACE_INCLUDE_PATH
1271  #undef TRACE_INCLUDE_FILE
1272 diff --git a/probes/lttng-tracepoint-event-impl.h b/probes/lttng-tracepoint-event-impl.h
1273 index 77b8638..72a669e 100644
1274 --- a/probes/lttng-tracepoint-event-impl.h
1275 +++ b/probes/lttng-tracepoint-event-impl.h
1276 @@ -1132,11 +1132,11 @@ static void __event_probe__##_name(void *__data, _proto)                      \
1277                                                                               \
1278         if (!_TP_SESSION_CHECK(session, __session))                           \
1279                 return;                                                       \
1280 -       if (unlikely(!READ_ONCE(__session->active)))                          \
1281 +       if (unlikely(!LTTNG_READ_ONCE(__session->active)))                    \
1282                 return;                                                       \
1283 -       if (unlikely(!READ_ONCE(__chan->enabled)))                            \
1284 +       if (unlikely(!LTTNG_READ_ONCE(__chan->enabled)))                      \
1285                 return;                                                       \
1286 -       if (unlikely(!READ_ONCE(__event->enabled)))                           \
1287 +       if (unlikely(!LTTNG_READ_ONCE(__event->enabled)))                     \
1288                 return;                                                       \
1289         __lf = lttng_rcu_dereference(__session->pid_tracker.p);               \
1290         if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid)))    \
1291 @@ -1225,11 +1225,11 @@ static void __event_probe__##_name(void *__data)                              \
1292                                                                               \
1293         if (!_TP_SESSION_CHECK(session, __session))                           \
1294                 return;                                                       \
1295 -       if (unlikely(!READ_ONCE(__session->active)))                          \
1296 +       if (unlikely(!LTTNG_READ_ONCE(__session->active)))                    \
1297                 return;                                                       \
1298 -       if (unlikely(!READ_ONCE(__chan->enabled)))                            \
1299 +       if (unlikely(!LTTNG_READ_ONCE(__chan->enabled)))                      \
1300                 return;                                                       \
1301 -       if (unlikely(!READ_ONCE(__event->enabled)))                           \
1302 +       if (unlikely(!LTTNG_READ_ONCE(__event->enabled)))                     \
1303                 return;                                                       \
1304         __lf = lttng_rcu_dereference(__session->pid_tracker.p);               \
1305         if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid)))    \
1306 diff --git a/probes/lttng-uprobes.c b/probes/lttng-uprobes.c
1307 index bc10128..bda1d9b 100644
1308 --- a/probes/lttng-uprobes.c
1309 +++ b/probes/lttng-uprobes.c
1310 @@ -40,11 +40,11 @@ int lttng_uprobes_handler_pre(struct uprobe_consumer *uc, struct pt_regs *regs)
1311                 unsigned long ip;
1312         } payload;
1313  
1314 -       if (unlikely(!READ_ONCE(chan->session->active)))
1315 +       if (unlikely(!LTTNG_READ_ONCE(chan->session->active)))
1316                 return 0;
1317 -       if (unlikely(!READ_ONCE(chan->enabled)))
1318 +       if (unlikely(!LTTNG_READ_ONCE(chan->enabled)))
1319                 return 0;
1320 -       if (unlikely(!READ_ONCE(event->enabled)))
1321 +       if (unlikely(!LTTNG_READ_ONCE(event->enabled)))
1322                 return 0;
1323  
1324         lib_ring_buffer_ctx_init(&ctx, chan->chan, &lttng_probe_ctx,
1325 diff --git a/wrapper/compiler.h b/wrapper/compiler.h
1326 index 1496f33..b9f8c51 100644
1327 --- a/wrapper/compiler.h
1328 +++ b/wrapper/compiler.h
1329 @@ -9,6 +9,7 @@
1330  #define _LTTNG_WRAPPER_COMPILER_H
1331  
1332  #include <linux/compiler.h>
1333 +#include <linux/version.h>
1334  
1335  /*
1336   * Don't allow compiling with buggy compiler.
1337 @@ -39,4 +40,21 @@
1338  # define WRITE_ONCE(x, val)    ({ ACCESS_ONCE(x) = val; })
1339  #endif
1340  
1341 +/*
1342 + * In v4.15 a smp read barrier was added to READ_ONCE to replace
1343 + * lockless_dereference(), replicate this behavior on prior kernels
1344 + * and remove calls to smp_read_barrier_depends which was dropped
1345 + * in v5.9.
1346 + */
1347 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
1348 +#define LTTNG_READ_ONCE(x)     READ_ONCE(x)
1349 +#else
1350 +#define LTTNG_READ_ONCE(x)                     \
1351 +({                                             \
1352 +       typeof(x) __val = READ_ONCE(x);         \
1353 +       smp_read_barrier_depends();             \
1354 +       __val;                                  \
1355 +})
1356 +#endif
1357 +
1358  #endif /* _LTTNG_WRAPPER_COMPILER_H */
1359 diff --git a/wrapper/trace-clock.h b/wrapper/trace-clock.h
1360 index 9f4e366..187fc82 100644
1361 --- a/wrapper/trace-clock.h
1362 +++ b/wrapper/trace-clock.h
1363 @@ -160,33 +160,30 @@ static inline void put_trace_clock(void)
1364  
1365  static inline u64 trace_clock_read64(void)
1366  {
1367 -       struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
1368 +       struct lttng_trace_clock *ltc = LTTNG_READ_ONCE(lttng_trace_clock);
1369  
1370         if (likely(!ltc)) {
1371                 return trace_clock_read64_monotonic();
1372         } else {
1373 -               read_barrier_depends(); /* load ltc before content */
1374                 return ltc->read64();
1375         }
1376  }
1377  
1378  static inline u64 trace_clock_freq(void)
1379  {
1380 -       struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
1381 +       struct lttng_trace_clock *ltc = LTTNG_READ_ONCE(lttng_trace_clock);
1382  
1383         if (!ltc) {
1384                 return trace_clock_freq_monotonic();
1385         } else {
1386 -               read_barrier_depends(); /* load ltc before content */
1387                 return ltc->freq();
1388         }
1389  }
1390  
1391  static inline int trace_clock_uuid(char *uuid)
1392  {
1393 -       struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
1394 +       struct lttng_trace_clock *ltc = LTTNG_READ_ONCE(lttng_trace_clock);
1395  
1396 -       read_barrier_depends(); /* load ltc before content */
1397         /* Use default UUID cb when NULL */
1398         if (!ltc || !ltc->uuid) {
1399                 return trace_clock_uuid_monotonic(uuid);
1400 @@ -197,24 +194,22 @@ static inline int trace_clock_uuid(char *uuid)
1401  
1402  static inline const char *trace_clock_name(void)
1403  {
1404 -       struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
1405 +       struct lttng_trace_clock *ltc = LTTNG_READ_ONCE(lttng_trace_clock);
1406  
1407         if (!ltc) {
1408                 return trace_clock_name_monotonic();
1409         } else {
1410 -               read_barrier_depends(); /* load ltc before content */
1411                 return ltc->name();
1412         }
1413  }
1414  
1415  static inline const char *trace_clock_description(void)
1416  {
1417 -       struct lttng_trace_clock *ltc = READ_ONCE(lttng_trace_clock);
1418 +       struct lttng_trace_clock *ltc = LTTNG_READ_ONCE(lttng_trace_clock);
1419  
1420         if (!ltc) {
1421                 return trace_clock_description_monotonic();
1422         } else {
1423 -               read_barrier_depends(); /* load ltc before content */
1424                 return ltc->description();
1425         }
1426  }
This page took 0.325094 seconds and 2 git commands to generate.