- up to 2.2.13 + latest fixes
[packages/lttng-modules.git] / git.patch
1 diff --git a/.gitattributes b/.gitattributes
2 new file mode 100644
3 index 00000000..7839355a
4 --- /dev/null
5 +++ b/.gitattributes
6 @@ -0,0 +1,3 @@
7 +.gitattributes export-ignore
8 +.gitignore export-ignore
9 +.gitreview export-ignore
10 diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h b/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
11 index e5470400..cdf0609f 100644
12 --- a/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
13 +++ b/instrumentation/events/lttng-module/arch/x86/kvm/mmutrace.h
14 @@ -163,7 +163,25 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(kvm_mmu_page_class, kvm_mmu_prepare_zap_page,
15         TP_ARGS(sp)
16  )
17  
18 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
19 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
20 +
21 +LTTNG_TRACEPOINT_EVENT_MAP(
22 +       mark_mmio_spte,
23 +
24 +       kvm_mmu_mark_mmio_spte,
25 +
26 +       TP_PROTO(u64 *sptep, gfn_t gfn, u64 spte),
27 +       TP_ARGS(sptep, gfn, spte),
28 +
29 +       TP_FIELDS(
30 +               ctf_integer_hex(void *, sptep, sptep)
31 +               ctf_integer(gfn_t, gfn, gfn)
32 +               ctf_integer(unsigned, access, spte & ACC_ALL)
33 +               ctf_integer(unsigned int, gen, get_mmio_spte_generation(spte))
34 +       )
35 +)
36 +
37 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
38  
39  LTTNG_TRACEPOINT_EVENT_MAP(
40         mark_mmio_spte,
41 @@ -215,7 +233,27 @@ LTTNG_TRACEPOINT_EVENT_MAP(
42         )
43  )
44  
45 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0) || \
46 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
47 +LTTNG_TRACEPOINT_EVENT_MAP(
48 +       fast_page_fault,
49 +
50 +       kvm_mmu_fast_page_fault,
51 +
52 +       TP_PROTO(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u32 error_code,
53 +                u64 *sptep, u64 old_spte, int ret),
54 +       TP_ARGS(vcpu, cr2_or_gpa, error_code, sptep, old_spte, ret),
55 +
56 +       TP_FIELDS(
57 +               ctf_integer(int, vcpu_id, vcpu->vcpu_id)
58 +               ctf_integer(gpa_t, cr2_or_gpa, cr2_or_gpa)
59 +               ctf_integer(u32, error_code, error_code)
60 +               ctf_integer_hex(u64 *, sptep, sptep)
61 +               ctf_integer(u64, old_spte, old_spte)
62 +               ctf_integer(u64, new_spte, *sptep)
63 +               ctf_integer(int, ret, ret)
64 +       )
65 +)
66 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0) || \
67         LTTNG_KERNEL_RANGE(4,19,103, 4,20,0) || \
68         LTTNG_KERNEL_RANGE(5,4,19, 5,5,0) || \
69         LTTNG_KERNEL_RANGE(5,5,3, 5,6,0) || \
70 diff --git a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h b/instrumentation/events/lttng-module/arch/x86/kvm/trace.h
71 index 4416ae02..0917b51f 100644
72 --- a/instrumentation/events/lttng-module/arch/x86/kvm/trace.h
73 +++ b/instrumentation/events/lttng-module/arch/x86/kvm/trace.h
74 @@ -115,6 +115,37 @@ LTTNG_TRACEPOINT_EVENT_MAP(kvm_apic, kvm_x86_apic,
75  /*
76   * Tracepoint for kvm guest exit:
77   */
78 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
79 +LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit,
80 +       TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa),
81 +       TP_ARGS(exit_reason, vcpu, isa),
82 +
83 +       TP_locvar(
84 +               u64 info1, info2;
85 +               u32 intr_info, error_code;
86 +       ),
87 +
88 +       TP_code_pre(
89 +               kvm_x86_ops.get_exit_info(vcpu, &tp_locvar->info1,
90 +                               &tp_locvar->info2,
91 +                               &tp_locvar->intr_info,
92 +                               &tp_locvar->error_code);
93 +       ),
94 +
95 +       TP_FIELDS(
96 +               ctf_integer(unsigned int, exit_reason, exit_reason)
97 +               ctf_integer(unsigned long, guest_rip, kvm_rip_read(vcpu))
98 +               ctf_integer(u32, isa, isa)
99 +               ctf_integer(u64, info1, tp_locvar->info1)
100 +               ctf_integer(u64, info2, tp_locvar->info2)
101 +               ctf_integer(u32, intr_info, tp_locvar->intr_info)
102 +               ctf_integer(u32, error_code, tp_locvar->error_code)
103 +               ctf_integer(unsigned int, vcpu_id, vcpu->vcpu_id)
104 +       ),
105 +
106 +       TP_code_post()
107 +)
108 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,7,0))
109  LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit,
110         TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa),
111         TP_ARGS(exit_reason, vcpu, isa),
112 @@ -124,13 +155,32 @@ LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit,
113         ),
114  
115         TP_code_pre(
116 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,7,0))
117                 kvm_x86_ops.get_exit_info(vcpu, &tp_locvar->info1,
118                                 &tp_locvar->info2);
119 +       ),
120 +
121 +       TP_FIELDS(
122 +               ctf_integer(unsigned int, exit_reason, exit_reason)
123 +               ctf_integer(unsigned long, guest_rip, kvm_rip_read(vcpu))
124 +               ctf_integer(u32, isa, isa)
125 +               ctf_integer(u64, info1, tp_locvar->info1)
126 +               ctf_integer(u64, info2, tp_locvar->info2)
127 +       ),
128 +
129 +       TP_code_post()
130 +)
131  #else
132 +LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit,
133 +       TP_PROTO(unsigned int exit_reason, struct kvm_vcpu *vcpu, u32 isa),
134 +       TP_ARGS(exit_reason, vcpu, isa),
135 +
136 +       TP_locvar(
137 +               u64 info1, info2;
138 +       ),
139 +
140 +       TP_code_pre(
141                 kvm_x86_ops->get_exit_info(vcpu, &tp_locvar->info1,
142                                 &tp_locvar->info2);
143 -#endif
144         ),
145  
146         TP_FIELDS(
147 @@ -143,6 +193,7 @@ LTTNG_TRACEPOINT_EVENT_CODE_MAP(kvm_exit, kvm_x86_exit,
148  
149         TP_code_post()
150  )
151 +#endif
152  
153  /*
154   * Tracepoint for kvm interrupt injection:
155 diff --git a/instrumentation/events/lttng-module/btrfs.h b/instrumentation/events/lttng-module/btrfs.h
156 index 7b290085..efe7af96 100644
157 --- a/instrumentation/events/lttng-module/btrfs.h
158 +++ b/instrumentation/events/lttng-module/btrfs.h
159 @@ -346,7 +346,29 @@ LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist,
160  )
161  #endif
162  
163 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
164 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
165 +LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
166 +
167 +       TP_PROTO(const struct btrfs_inode *inode,
168 +                const struct btrfs_ordered_extent *ordered),
169 +
170 +       TP_ARGS(inode, ordered),
171 +
172 +       TP_FIELDS(
173 +               ctf_array(u8, fsid, inode->root->lttng_fs_info_fsid, BTRFS_UUID_SIZE)
174 +               ctf_integer(ino_t, ino, btrfs_ino(inode))
175 +               ctf_integer(u64, file_offset, ordered->file_offset)
176 +               ctf_integer(u64, start, ordered->disk_bytenr)
177 +               ctf_integer(u64, len, ordered->num_bytes)
178 +               ctf_integer(u64, disk_len, ordered->disk_num_bytes)
179 +               ctf_integer(u64, bytes_left, ordered->bytes_left)
180 +               ctf_integer(unsigned long, flags, ordered->flags)
181 +               ctf_integer(int, compress_type, ordered->compress_type)
182 +               ctf_integer(int, refs, refcount_read(&ordered->refs))
183 +               ctf_integer(u64, root_objectid, inode->root->root_key.objectid)
184 +       )
185 +)
186 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
187  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
188  
189         TP_PROTO(const struct inode *inode,
190 @@ -458,7 +480,39 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
191  )
192  #endif
193  
194 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
195 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
196 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
197 +
198 +       TP_PROTO(const struct btrfs_inode *inode,
199 +                const struct btrfs_ordered_extent *ordered),
200 +
201 +       TP_ARGS(inode, ordered)
202 +)
203 +
204 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
205 +
206 +       TP_PROTO(const struct btrfs_inode *inode,
207 +                const struct btrfs_ordered_extent *ordered),
208 +
209 +       TP_ARGS(inode, ordered)
210 +)
211 +
212 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
213 +
214 +       TP_PROTO(const struct btrfs_inode *inode,
215 +                const struct btrfs_ordered_extent *ordered),
216 +
217 +       TP_ARGS(inode, ordered)
218 +)
219 +
220 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
221 +
222 +       TP_PROTO(const struct btrfs_inode *inode,
223 +                const struct btrfs_ordered_extent *ordered),
224 +
225 +       TP_ARGS(inode, ordered)
226 +)
227 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
228         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
229         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
230         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
231 @@ -494,7 +548,41 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
232  
233         TP_ARGS(inode, ordered)
234  )
235 +#else
236 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
237 +
238 +       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
239 +
240 +       TP_ARGS(inode, ordered)
241 +)
242 +
243 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
244 +
245 +       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
246  
247 +       TP_ARGS(inode, ordered)
248 +)
249 +
250 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
251 +
252 +       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
253 +
254 +       TP_ARGS(inode, ordered)
255 +)
256 +
257 +LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
258 +
259 +       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
260 +
261 +       TP_ARGS(inode, ordered)
262 +)
263 +#endif
264 +
265 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
266 +       LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
267 +       LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
268 +       LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
269 +       LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
270  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
271  
272         TP_PROTO(const struct page *page, const struct inode *inode,
273 @@ -563,34 +651,6 @@ LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
274         )
275  )
276  #else
277 -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
278 -
279 -       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
280 -
281 -       TP_ARGS(inode, ordered)
282 -)
283 -
284 -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
285 -
286 -       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
287 -
288 -       TP_ARGS(inode, ordered)
289 -)
290 -
291 -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
292 -
293 -       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
294 -
295 -       TP_ARGS(inode, ordered)
296 -)
297 -
298 -LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
299 -
300 -       TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
301 -
302 -       TP_ARGS(inode, ordered)
303 -)
304 -
305  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
306  
307         TP_PROTO(struct page *page, struct inode *inode,
308 @@ -1856,7 +1916,48 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_f
309  
310  #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
311  
312 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
313 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0) || \
314 +       LTTNG_KERNEL_RANGE(5,9,5, 5,10,0) || \
315 +       LTTNG_KERNEL_RANGE(5,4,78, 5,5,0))
316 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
317 +
318 +       btrfs_find_free_extent,
319 +
320 +       TP_PROTO(const struct btrfs_root *root, u64 num_bytes, u64 empty_size,
321 +                u64 data),
322 +
323 +       TP_ARGS(root, num_bytes, empty_size, data),
324 +
325 +       TP_FIELDS(
326 +               ctf_array(u8, fsid, root->lttng_fs_info_fsid, BTRFS_UUID_SIZE)
327 +               ctf_integer(u64, root_objectid, root->root_key.objectid)
328 +               ctf_integer(u64, num_bytes, num_bytes)
329 +               ctf_integer(u64, empty_size, empty_size)
330 +               ctf_integer(u64, data, data)
331 +       )
332 +)
333 +
334 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
335 +
336 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
337 +
338 +       btrfs_find_free_extent,
339 +
340 +       TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
341 +                u64 data),
342 +
343 +       TP_ARGS(fs_info, num_bytes, empty_size, data),
344 +
345 +       TP_FIELDS(
346 +               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
347 +               ctf_integer(u64, num_bytes, num_bytes)
348 +               ctf_integer(u64, empty_size, empty_size)
349 +               ctf_integer(u64, data, data)
350 +       )
351 +)
352 +
353 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,18,0))
354 +
355  LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
356  
357         btrfs_find_free_extent,
358 @@ -1874,6 +1975,86 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
359         )
360  )
361  
362 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
363 +
364 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
365 +
366 +       btrfs_find_free_extent,
367 +
368 +       TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
369 +                u64 data),
370 +
371 +       TP_ARGS(fs_info, num_bytes, empty_size, data),
372 +
373 +       TP_FIELDS(
374 +               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
375 +               ctf_integer(u64, num_bytes, num_bytes)
376 +               ctf_integer(u64, empty_size, empty_size)
377 +               ctf_integer(u64, data, data)
378 +       )
379 +)
380 +
381 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
382 +
383 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
384 +
385 +       btrfs_find_free_extent,
386 +
387 +       TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
388 +                u64 data),
389 +
390 +       TP_ARGS(fs_info, num_bytes, empty_size, data),
391 +
392 +       TP_FIELDS(
393 +               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
394 +               ctf_integer(u64, num_bytes, num_bytes)
395 +               ctf_integer(u64, empty_size, empty_size)
396 +               ctf_integer(u64, data, data)
397 +       )
398 +)
399 +
400 +#elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
401 +       LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
402 +       LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
403 +       LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
404 +
405 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
406 +
407 +       btrfs_find_free_extent,
408 +
409 +       TP_PROTO(const struct btrfs_root *root, u64 num_bytes, u64 empty_size,
410 +                u64 data),
411 +
412 +       TP_ARGS(root, num_bytes, empty_size, data),
413 +
414 +       TP_FIELDS(
415 +               ctf_integer(u64, root_objectid, root->root_key.objectid)
416 +               ctf_integer(u64, num_bytes, num_bytes)
417 +               ctf_integer(u64, empty_size, empty_size)
418 +               ctf_integer(u64, data, data)
419 +       )
420 +)
421 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
422 +
423 +LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
424 +
425 +       btrfs_find_free_extent,
426 +
427 +       TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
428 +                u64 data),
429 +
430 +       TP_ARGS(root, num_bytes, empty_size, data),
431 +
432 +       TP_FIELDS(
433 +               ctf_integer(u64, root_objectid, root->root_key.objectid)
434 +               ctf_integer(u64, num_bytes, num_bytes)
435 +               ctf_integer(u64, empty_size, empty_size)
436 +               ctf_integer(u64, data, data)
437 +       )
438 +)
439 +#endif
440 +
441 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
442  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
443  
444         TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
445 @@ -1907,22 +2088,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
446  )
447  
448  #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,18,0))
449 -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
450 -
451 -       btrfs_find_free_extent,
452 -
453 -       TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
454 -                u64 data),
455 -
456 -       TP_ARGS(fs_info, num_bytes, empty_size, data),
457 -
458 -       TP_FIELDS(
459 -               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
460 -               ctf_integer(u64, num_bytes, num_bytes)
461 -               ctf_integer(u64, empty_size, empty_size)
462 -               ctf_integer(u64, data, data)
463 -       )
464 -)
465  
466  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
467  
468 @@ -1957,22 +2122,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
469  )
470  
471  #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
472 -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
473 -
474 -       btrfs_find_free_extent,
475 -
476 -       TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
477 -                u64 data),
478 -
479 -       TP_ARGS(fs_info, num_bytes, empty_size, data),
480 -
481 -       TP_FIELDS(
482 -               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
483 -               ctf_integer(u64, num_bytes, num_bytes)
484 -               ctf_integer(u64, empty_size, empty_size)
485 -               ctf_integer(u64, data, data)
486 -       )
487 -)
488  
489  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
490  
491 @@ -2011,23 +2160,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
492  
493  #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
494  
495 -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
496 -
497 -       btrfs_find_free_extent,
498 -
499 -       TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
500 -                u64 data),
501 -
502 -       TP_ARGS(fs_info, num_bytes, empty_size, data),
503 -
504 -       TP_FIELDS(
505 -               ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
506 -               ctf_integer(u64, num_bytes, num_bytes)
507 -               ctf_integer(u64, empty_size, empty_size)
508 -               ctf_integer(u64, data, data)
509 -       )
510 -)
511 -
512  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
513  
514         TP_PROTO(struct btrfs_fs_info *fs_info,
515 @@ -2066,23 +2198,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
516         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
517         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
518  
519 -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
520 -
521 -       btrfs_find_free_extent,
522 -
523 -       TP_PROTO(const struct btrfs_root *root, u64 num_bytes, u64 empty_size,
524 -                u64 data),
525 -
526 -       TP_ARGS(root, num_bytes, empty_size, data),
527 -
528 -       TP_FIELDS(
529 -               ctf_integer(u64, root_objectid, root->root_key.objectid)
530 -               ctf_integer(u64, num_bytes, num_bytes)
531 -               ctf_integer(u64, empty_size, empty_size)
532 -               ctf_integer(u64, data, data)
533 -       )
534 -)
535 -
536  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
537  
538         TP_PROTO(const struct btrfs_root *root,
539 @@ -2120,23 +2235,6 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_clus
540  
541  #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
542  
543 -LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
544 -
545 -       btrfs_find_free_extent,
546 -
547 -       TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
548 -                u64 data),
549 -
550 -       TP_ARGS(root, num_bytes, empty_size, data),
551 -
552 -       TP_FIELDS(
553 -               ctf_integer(u64, root_objectid, root->root_key.objectid)
554 -               ctf_integer(u64, num_bytes, num_bytes)
555 -               ctf_integer(u64, empty_size, empty_size)
556 -               ctf_integer(u64, data, data)
557 -       )
558 -)
559 -
560  LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
561  
562         TP_PROTO(struct btrfs_root *root,
563 diff --git a/instrumentation/events/lttng-module/ext4.h b/instrumentation/events/lttng-module/ext4.h
564 index b172c8d9..6e74abad 100644
565 --- a/instrumentation/events/lttng-module/ext4.h
566 +++ b/instrumentation/events/lttng-module/ext4.h
567 @@ -1274,6 +1274,18 @@ LTTNG_TRACEPOINT_EVENT(ext4_ext_load_extent,
568         )
569  )
570  
571 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
572 +LTTNG_TRACEPOINT_EVENT(ext4_load_inode,
573 +       TP_PROTO(struct super_block *sb, unsigned long ino),
574 +
575 +       TP_ARGS(sb, ino),
576 +
577 +       TP_FIELDS(
578 +               ctf_integer(dev_t, dev, sb->s_dev)
579 +               ctf_integer(ino_t, ino, ino)
580 +       )
581 +)
582 +#else
583  LTTNG_TRACEPOINT_EVENT(ext4_load_inode,
584         TP_PROTO(struct inode *inode),
585  
586 @@ -1284,6 +1296,7 @@ LTTNG_TRACEPOINT_EVENT(ext4_load_inode,
587                 ctf_integer(ino_t, ino, inode->i_ino)
588         )
589  )
590 +#endif
591  
592  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
593  
594 @@ -1895,6 +1908,34 @@ LTTNG_TRACEPOINT_EVENT(ext4_es_shrink_exit,
595  
596  #endif
597  
598 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
599 +LTTNG_TRACEPOINT_EVENT(ext4_fc_replay_scan,
600 +       TP_PROTO(struct super_block *sb, int error, int off),
601 +
602 +       TP_ARGS(sb, error, off),
603 +
604 +       TP_FIELDS(
605 +               ctf_integer(dev_t, dev, sb->s_dev)
606 +               ctf_integer(int, error, error)
607 +               ctf_integer(int, off, off)
608 +       )
609 +)
610 +
611 +LTTNG_TRACEPOINT_EVENT(ext4_fc_replay,
612 +       TP_PROTO(struct super_block *sb, int tag, int ino, int priv1, int priv2),
613 +
614 +       TP_ARGS(sb, tag, ino, priv1, priv2),
615 +
616 +       TP_FIELDS(
617 +               ctf_integer(dev_t, dev, sb->s_dev)
618 +               ctf_integer(int, tag, tag)
619 +               ctf_integer(int, ino, ino)
620 +               ctf_integer(int, priv1, priv1)
621 +               ctf_integer(int, priv2, priv2)
622 +       )
623 +)
624 +#endif
625 +
626  #endif /* LTTNG_TRACE_EXT4_H */
627  
628  /* This part must be outside protection */
629 diff --git a/lttng-events.h b/lttng-events.h
630 index d4d99766..e47c1478 100644
631 --- a/lttng-events.h
632 +++ b/lttng-events.h
633 @@ -16,6 +16,7 @@
634  #include <linux/kref.h>
635  #include <lttng-cpuhotplug.h>
636  #include <linux/uuid.h>
637 +#include <linux/irq_work.h>
638  #include <wrapper/uprobes.h>
639  #include <lttng-tracer.h>
640  #include <lttng-abi.h>
641 diff --git a/lttng-filter-interpreter.c b/lttng-filter-interpreter.c
642 index 21169f01..5d572437 100644
643 --- a/lttng-filter-interpreter.c
644 +++ b/lttng-filter-interpreter.c
645 @@ -8,7 +8,7 @@
646   */
647  
648  #include <wrapper/uaccess.h>
649 -#include <wrapper/frame.h>
650 +#include <wrapper/objtool.h>
651  #include <wrapper/types.h>
652  #include <linux/swab.h>
653  
654 diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c
655 index a6fa71a5..cf803a73 100644
656 --- a/lttng-statedump-impl.c
657 +++ b/lttng-statedump-impl.c
658 @@ -55,26 +55,94 @@
659  #define LTTNG_INSTRUMENTATION
660  #include <instrumentation/events/lttng-module/lttng-statedump.h>
661  
662 -DEFINE_TRACE(lttng_statedump_block_device);
663 -DEFINE_TRACE(lttng_statedump_end);
664 -DEFINE_TRACE(lttng_statedump_interrupt);
665 -DEFINE_TRACE(lttng_statedump_file_descriptor);
666 -DEFINE_TRACE(lttng_statedump_start);
667 -DEFINE_TRACE(lttng_statedump_process_state);
668 -DEFINE_TRACE(lttng_statedump_process_pid_ns);
669 +LTTNG_DEFINE_TRACE(lttng_statedump_block_device,
670 +       TP_PROTO(struct lttng_session *session,
671 +               dev_t dev, const char *diskname),
672 +       TP_ARGS(session, dev, diskname));
673 +
674 +LTTNG_DEFINE_TRACE(lttng_statedump_end,
675 +       TP_PROTO(struct lttng_session *session),
676 +       TP_ARGS(session));
677 +
678 +LTTNG_DEFINE_TRACE(lttng_statedump_interrupt,
679 +       TP_PROTO(struct lttng_session *session,
680 +               unsigned int irq, const char *chip_name,
681 +               struct irqaction *action),
682 +       TP_ARGS(session, irq, chip_name, action));
683 +
684 +LTTNG_DEFINE_TRACE(lttng_statedump_file_descriptor,
685 +       TP_PROTO(struct lttng_session *session,
686 +               struct files_struct *files,
687 +               int fd, const char *filename,
688 +               unsigned int flags, fmode_t fmode),
689 +       TP_ARGS(session, files, fd, filename, flags, fmode));
690 +
691 +LTTNG_DEFINE_TRACE(lttng_statedump_start,
692 +       TP_PROTO(struct lttng_session *session),
693 +       TP_ARGS(session));
694 +
695 +LTTNG_DEFINE_TRACE(lttng_statedump_process_state,
696 +       TP_PROTO(struct lttng_session *session,
697 +               struct task_struct *p,
698 +               int type, int mode, int submode, int status,
699 +               struct files_struct *files),
700 +       TP_ARGS(session, p, type, mode, submode, status, files));
701 +
702 +LTTNG_DEFINE_TRACE(lttng_statedump_process_pid_ns,
703 +       TP_PROTO(struct lttng_session *session,
704 +               struct task_struct *p,
705 +               struct pid_namespace *pid_ns),
706 +       TP_ARGS(session, p, pid_ns));
707 +
708  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,6,0))
709 -DEFINE_TRACE(lttng_statedump_process_cgroup_ns);
710 +LTTNG_DEFINE_TRACE(lttng_statedump_process_cgroup_ns,
711 +       TP_PROTO(struct lttng_session *session,
712 +               struct task_struct *p,
713 +               struct cgroup_namespace *cgroup_ns),
714 +       TP_ARGS(session, p, cgroup_ns));
715  #endif
716 -DEFINE_TRACE(lttng_statedump_process_ipc_ns);
717 +
718 +LTTNG_DEFINE_TRACE(lttng_statedump_process_ipc_ns,
719 +       TP_PROTO(struct lttng_session *session,
720 +               struct task_struct *p,
721 +               struct ipc_namespace *ipc_ns),
722 +       TP_ARGS(session, p, ipc_ns));
723 +
724  #ifndef LTTNG_MNT_NS_MISSING_HEADER
725 -DEFINE_TRACE(lttng_statedump_process_mnt_ns);
726 +LTTNG_DEFINE_TRACE(lttng_statedump_process_mnt_ns,
727 +       TP_PROTO(struct lttng_session *session,
728 +               struct task_struct *p,
729 +               struct mnt_namespace *mnt_ns),
730 +       TP_ARGS(session, p, mnt_ns));
731  #endif
732 -DEFINE_TRACE(lttng_statedump_process_net_ns);
733 -DEFINE_TRACE(lttng_statedump_process_user_ns);
734 -DEFINE_TRACE(lttng_statedump_process_uts_ns);
735 -DEFINE_TRACE(lttng_statedump_network_interface);
736 +
737 +LTTNG_DEFINE_TRACE(lttng_statedump_process_net_ns,
738 +       TP_PROTO(struct lttng_session *session,
739 +               struct task_struct *p,
740 +               struct net *net_ns),
741 +       TP_ARGS(session, p, net_ns));
742 +
743 +LTTNG_DEFINE_TRACE(lttng_statedump_process_user_ns,
744 +       TP_PROTO(struct lttng_session *session,
745 +               struct task_struct *p,
746 +               struct user_namespace *user_ns),
747 +       TP_ARGS(session, p, user_ns));
748 +
749 +LTTNG_DEFINE_TRACE(lttng_statedump_process_uts_ns,
750 +       TP_PROTO(struct lttng_session *session,
751 +               struct task_struct *p,
752 +               struct uts_namespace *uts_ns),
753 +       TP_ARGS(session, p, uts_ns));
754 +
755 +LTTNG_DEFINE_TRACE(lttng_statedump_network_interface,
756 +       TP_PROTO(struct lttng_session *session,
757 +               struct net_device *dev, struct in_ifaddr *ifa),
758 +       TP_ARGS(session, dev, ifa));
759 +
760  #ifdef LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY
761 -DEFINE_TRACE(lttng_statedump_cpu_topology);
762 +LTTNG_DEFINE_TRACE(lttng_statedump_cpu_topology,
763 +       TP_PROTO(struct lttng_session *session, struct cpuinfo_x86 *c),
764 +       TP_ARGS(session, c));
765  #endif
766  
767  struct lttng_fd_ctx {
768 diff --git a/lttng-syscalls.c b/lttng-syscalls.c
769 index 49c0d81b..b43dd570 100644
770 --- a/lttng-syscalls.c
771 +++ b/lttng-syscalls.c
772 @@ -719,7 +719,7 @@ int fill_table(const struct trace_syscall_entry *table, size_t table_len,
773                         ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
774                         break;
775                 }
776 -               strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
777 +               strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN - 1);
778                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
779                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
780                 chan_table[i] = _lttng_event_create(chan, &ev, filter,
781 diff --git a/lttng-tracker-id.c b/lttng-tracker-id.c
782 index 9a4b98b2..327ae346 100644
783 --- a/lttng-tracker-id.c
784 +++ b/lttng-tracker-id.c
785 @@ -75,6 +75,7 @@ int lttng_id_tracker_add(struct lttng_id_tracker *lf, int id)
786         struct lttng_id_tracker_rcu *p = lf->p;
787         uint32_t hash = hash_32(id, 32);
788         bool allocated = false;
789 +       int ret;
790  
791         if (!p) {
792                 p = lttng_id_tracker_rcu_create();
793 @@ -84,18 +85,28 @@ int lttng_id_tracker_add(struct lttng_id_tracker *lf, int id)
794         }
795         head = &p->id_hash[hash & (LTTNG_ID_TABLE_SIZE - 1)];
796         lttng_hlist_for_each_entry(e, head, hlist) {
797 -               if (id == e->id)
798 -                       return -EEXIST;
799 +               if (id == e->id) {
800 +                       ret = -EEXIST;
801 +                       goto error;
802 +               }
803         }
804         e = kmalloc(sizeof(struct lttng_id_hash_node), GFP_KERNEL);
805 -       if (!e)
806 -               return -ENOMEM;
807 +       if (!e) {
808 +               ret = -ENOMEM;
809 +               goto error;
810 +       }
811         e->id = id;
812         hlist_add_head_rcu(&e->hlist, head);
813         if (allocated) {
814                 rcu_assign_pointer(lf->p, p);
815         }
816         return 0;
817 +
818 +error:
819 +       if (allocated) {
820 +               kfree(p);
821 +       }
822 +       return ret;
823  }
824  
825  static
826 diff --git a/probes/lttng-probe-kvm-x86-mmu.c b/probes/lttng-probe-kvm-x86-mmu.c
827 index 8f981865..5043c776 100644
828 --- a/probes/lttng-probe-kvm-x86-mmu.c
829 +++ b/probes/lttng-probe-kvm-x86-mmu.c
830 @@ -31,6 +31,11 @@
831  #include <../../arch/x86/kvm/mmutrace.h>
832  #endif
833  
834 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
835 +#include <../arch/x86/kvm/mmu.h>
836 +#include <../arch/x86/kvm/mmu/spte.h>
837 +#endif
838 +
839  #undef TRACE_INCLUDE_PATH
840  #undef TRACE_INCLUDE_FILE
841  
842 diff --git a/probes/lttng.c b/probes/lttng.c
843 index 05bc1388..7ddaa69f 100644
844 --- a/probes/lttng.c
845 +++ b/probes/lttng.c
846 @@ -8,7 +8,7 @@
847   */
848  
849  #include <linux/module.h>
850 -#include <linux/tracepoint.h>
851 +#include <wrapper/tracepoint.h>
852  #include <linux/uaccess.h>
853  #include <linux/gfp.h>
854  #include <linux/fs.h>
855 @@ -32,7 +32,10 @@
856  #define LTTNG_LOGGER_COUNT_MAX 1024
857  #define LTTNG_LOGGER_FILE      "lttng-logger"
858  
859 -DEFINE_TRACE(lttng_logger);
860 +LTTNG_DEFINE_TRACE(lttng_logger,
861 +       PARAMS(const char __user *text, size_t len),
862 +       PARAMS(text, len)
863 +);
864  
865  static struct proc_dir_entry *lttng_logger_dentry;
866  
867 diff --git a/scripts/maintainer/do-release.sh b/scripts/maintainer/do-release.sh
868 new file mode 100755
869 index 00000000..5e94e136
870 --- /dev/null
871 +++ b/scripts/maintainer/do-release.sh
872 @@ -0,0 +1,110 @@
873 +#!/bin/bash
874 +
875 +set -eu
876 +set -o pipefail
877 +
878 +# invoke with do-release 2.N.M, or 2.N.M-rcXX
879 +
880 +# Default maintainer values
881 +SRCDIR="${HOME}/git/lttng-modules"
882 +# The output files are created in ${HOME}/stable/
883 +OUTPUTDIR="${HOME}/stable"
884 +SIGN="yes"
885 +VERBOSE=""
886 +
887 +usage() {
888 +       echo "Usage: do-release.sh [OPTION]... RELEASE"
889 +       echo
890 +       echo "Mandatory arguments to long options are mandatory for short options too."
891 +       echo "  -s, --srcdir DIR               source directory"
892 +       echo "  -o, --outputdir DIR            output directory, must exist"
893 +       echo "  -n, --no-sign                  don't GPG sign the output archive"
894 +       echo "  -v, --verbose                  verbose command output"
895 +}
896 +
897 +POS_ARGS=()
898 +while [[ $# -gt 0 ]]
899 +do
900 +       arg="$1"
901 +
902 +       case $arg in
903 +       -n|--no-sign)
904 +               SIGN="no"
905 +               shift 1
906 +       ;;
907 +
908 +       -s|--srcdir)
909 +               SRCDIR="$2"
910 +               shift 2
911 +       ;;
912 +
913 +       -o|--outputdir)
914 +               OUTPUTDIR="$2"
915 +               shift 2
916 +       ;;
917 +
918 +       -v|--verbose)
919 +               VERBOSE="-v"
920 +               shift 1
921 +       ;;
922 +
923 +       # Catch unknown arguments
924 +       -*)
925 +               usage
926 +               exit 1
927 +       ;;
928 +
929 +       *)
930 +       POS_ARGS+=("$1")
931 +       shift
932 +       ;;
933 +       esac
934 +done
935 +set -- "${POS_ARGS[@]}"
936 +
937 +REL=${1:-}
938 +
939 +if [ x"${REL}" = x"" ]; then
940 +       usage
941 +       exit 1;
942 +fi
943 +
944 +echo "Doing LTTng modules release ${REL}"
945 +echo "  Source dir: ${SRCDIR}"
946 +echo "  Output dir: ${OUTPUTDIR}"
947 +echo "  GPG sign: ${SIGN}"
948 +
949 +# Make sure the output directory exists
950 +if [ ! -d "${OUTPUTDIR}" ]; then
951 +       echo "Output directory '${OUTPUTDIR}' doesn't exist."
952 +       exit 1
953 +fi
954 +
955 +# Make sure the source directory is a git repository
956 +if [ ! -r "${SRCDIR}/.git/config" ]; then
957 +       echo "Source directory '${SRCDIR}' isn't a git repository."
958 +       exit 1
959 +fi
960 +
961 +# Set the git repo directory for all further git commands
962 +export GIT_DIR="${SRCDIR}/.git/"
963 +
964 +# Check if the release tag exists
965 +if ! git rev-parse "refs/tags/v${REL}" >/dev/null 2>&1; then
966 +       echo "Release tag 'v${REL}' doesn't exist."
967 +       exit 1
968 +fi
969 +
970 +# Generate the compressed tar archive, the git attributes from the tag will be used.
971 +git archive $VERBOSE --format=tar --prefix="lttng-modules-${REL}/" "v${REL}" | bzip2 > "${OUTPUTDIR}/lttng-modules-${REL}.tar.bz2"
972 +
973 +pushd "${OUTPUTDIR}" >/dev/null
974 +# Generate the hashes
975 +md5sum "lttng-modules-${REL}.tar.bz2" > "lttng-modules-${REL}.tar.bz2.md5"
976 +sha256sum "lttng-modules-${REL}.tar.bz2" > "lttng-modules-${REL}.tar.bz2.sha256"
977 +
978 +if [ "x${SIGN}" = "xyes" ]; then
979 +       # Sign with the default key
980 +       gpg --armor -b "lttng-modules-${REL}.tar.bz2"
981 +fi
982 +popd >/dev/null
983 diff --git a/tests/probes/lttng-test.c b/tests/probes/lttng-test.c
984 index b450e7d7..a4fa0645 100644
985 --- a/tests/probes/lttng-test.c
986 +++ b/tests/probes/lttng-test.c
987 @@ -25,7 +25,12 @@
988  #define LTTNG_INSTRUMENTATION
989  #include <instrumentation/events/lttng-module/lttng-test.h>
990  
991 -DEFINE_TRACE(lttng_test_filter_event);
992 +LTTNG_DEFINE_TRACE(lttng_test_filter_event,
993 +       PARAMS(int anint, int netint, long *values,
994 +               char *text, size_t textlen,
995 +               char *etext, uint32_t * net_values),
996 +       PARAMS(anint, netint, values, text, textlen, etext, net_values)
997 +);
998  
999  #define LTTNG_TEST_FILTER_EVENT_FILE   "lttng-test-filter-event"
1000  
1001 diff --git a/wrapper/frame.h b/wrapper/objtool.h
1002 similarity index 50%
1003 rename from wrapper/frame.h
1004 rename to wrapper/objtool.h
1005 index 6e6dc811..3b997cae 100644
1006 --- a/wrapper/frame.h
1007 +++ b/wrapper/objtool.h
1008 @@ -1,18 +1,23 @@
1009 -/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
1010 +/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
1011   *
1012 - * wrapper/frame.h
1013 + * wrapper/objtool.h
1014   *
1015   * Copyright (C) 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
1016   */
1017  
1018 -#ifndef _LTTNG_WRAPPER_FRAME_H
1019 -#define _LTTNG_WRAPPER_FRAME_H
1020 +#ifndef _LTTNG_WRAPPER_OBJTOOL_H
1021 +#define _LTTNG_WRAPPER_OBJTOOL_H
1022  
1023  #include <linux/version.h>
1024  
1025 -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,6,0))
1026 -
1027 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
1028 +#include <linux/objtool.h>
1029 +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,6,0))
1030  #include <linux/frame.h>
1031 +#endif
1032 +
1033 +
1034 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,6,0))
1035  
1036  #define LTTNG_STACK_FRAME_NON_STANDARD(func) \
1037         STACK_FRAME_NON_STANDARD(func)
1038 @@ -23,4 +28,4 @@
1039  
1040  #endif
1041  
1042 -#endif /* _LTTNG_WRAPPER_FRAME_H */
1043 +#endif /* _LTTNG_WRAPPER_OBJTOOL_H */
1044 diff --git a/wrapper/tracepoint.h b/wrapper/tracepoint.h
1045 index c4ba0123..bc19d8c1 100644
1046 --- a/wrapper/tracepoint.h
1047 +++ b/wrapper/tracepoint.h
1048 @@ -14,6 +14,14 @@
1049  #include <linux/tracepoint.h>
1050  #include <linux/module.h>
1051  
1052 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,10,0))
1053 +#define LTTNG_DEFINE_TRACE(name, proto, args)          \
1054 +       DEFINE_TRACE(name, PARAMS(proto), PARAMS(args))
1055 +#else
1056 +#define LTTNG_DEFINE_TRACE(name, proto, args)          \
1057 +       DEFINE_TRACE(name)
1058 +#endif
1059 +
1060  #ifndef HAVE_KABI_2635_TRACEPOINT
1061  
1062  #define kabi_2635_tracepoint_probe_register tracepoint_probe_register
This page took 0.316346 seconds and 3 git commands to generate.