]> git.pld-linux.org Git - packages/lttng-modules.git/blame - kernel-5.0.patch
projects / packages / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- rel 2
[packages/lttng-modules.git] / kernel-5.0.patch
CommitLineData
ac989bda
JR		 1From 80bb26003945e96a8ade9c8788dab9b2e08cbc08 Mon Sep 17 00:00:00 2001
2From: Michael Jeanson <mjeanson@efficios.com>
3Date: Wed, 9 Jan 2019 14:59:15 -0500
4Subject: [PATCH] Fix: Remove 'type' argument from access_ok() function (v5.0)
5
6See upstream commit :
7
8 commit 96d4f267e40f9509e8a66e2b39e8b95655617693
9 Author: Linus Torvalds <torvalds@linux-foundation.org>
10 Date: Thu Jan 3 18:57:57 2019 -0800
11
12 Remove 'type' argument from access_ok() function
13
14 Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
15 of the user address range verification function since we got rid of the
16 old racy i386-only code to walk page tables by hand.
17
18 It existed because the original 80386 would not honor the write protect
19 bit when in kernel mode, so you had to do COW by hand before doing any
20 user access. But we haven't supported that in a long time, and these
21 days the 'type' argument is a purely historical artifact.
22
23 A discussion about extending 'user_access_begin()' to do the range
24 checking resulted this patch, because there is no way we're going to
25 move the old VERIFY_xyz interface to that model. And it's best done at
26 the end of the merge window when I've done most of my merges, so let's
27 just get this done once and for all.
28
29 This patch was mostly done with a sed-script, with manual fix-ups for
30 the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.
31
32 There were a couple of notable cases:
33
34 - csky still had the old "verify_area()" name as an alias.
35
36 - the iter_iov code had magical hardcoded knowledge of the actual
37 values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
38 really used it)
39
40 - microblaze used the type argument for a debug printout
41
42 but other than those oddities this should be a total no-op patch.
43
44 I tried to fix up all architectures, did fairly extensive grepping for
45 access_ok() uses, and the changes are trivial, but I may have missed
46 something. Any missed conversion should be trivially fixable, though.
47
48Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
49Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
50---
51 lib/ringbuffer/backend.h | 8 ++++----
52 lib/ringbuffer/ring_buffer_iterator.c | 3 ++-
53 lttng-filter-interpreter.c | 4 ++--
54 probes/lttng-probe-user.c | 3 ++-
55 wrapper/uaccess.h | 28 +++++++++++++++++++++++++++
56 5 files changed, 38 insertions(+), 8 deletions(-)
57 create mode 100644 wrapper/uaccess.h
58
59diff --git a/lib/ringbuffer/backend.h b/lib/ringbuffer/backend.h
60index 501fad48..da937f29 100644
61--- a/lib/ringbuffer/backend.h
62+++ b/lib/ringbuffer/backend.h
63@@ -21,7 +21,7 @@
64 #include <linux/list.h>
65 #include <linux/fs.h>
66 #include <linux/mm.h>
67-#include <linux/uaccess.h>
68+#include <wrapper/uaccess.h>
69
70 /* Internal helpers */
71 #include <wrapper/ringbuffer/backend_internal.h>
72@@ -289,7 +289,7 @@ void lib_ring_buffer_copy_from_user_inatomic(const struct lib_ring_buffer_config
73
74 set_fs(KERNEL_DS);
75 pagefault_disable();
76- if (unlikely(!access_ok(VERIFY_READ, src, len)))
77+ if (unlikely(!lttng_access_ok(VERIFY_READ, src, len)))
78 goto fill_buffer;
79
80 if (likely(pagecpy == len)) {
81@@ -359,7 +359,7 @@ void lib_ring_buffer_strcpy_from_user_inatomic(const struct lib_ring_buffer_conf
82
83 set_fs(KERNEL_DS);
84 pagefault_disable();
85- if (unlikely(!access_ok(VERIFY_READ, src, len)))
86+ if (unlikely(!lttng_access_ok(VERIFY_READ, src, len)))
87 goto fill_buffer;
88
89 if (likely(pagecpy == len)) {
90@@ -449,7 +449,7 @@ unsigned long lib_ring_buffer_copy_from_user_check_nofault(void *dest,
91 unsigned long ret;
92 mm_segment_t old_fs;
93
94- if (!access_ok(VERIFY_READ, src, len))
95+ if (!lttng_access_ok(VERIFY_READ, src, len))
96 return 1;
97 old_fs = get_fs();
98 set_fs(KERNEL_DS);
99diff --git a/lib/ringbuffer/ring_buffer_iterator.c b/lib/ringbuffer/ring_buffer_iterator.c
100index 9efe4919..d25db725 100644
101--- a/lib/ringbuffer/ring_buffer_iterator.c
102+++ b/lib/ringbuffer/ring_buffer_iterator.c
103@@ -11,6 +11,7 @@
104
105 #include <wrapper/ringbuffer/iterator.h>
106 #include <wrapper/file.h>
107+#include <wrapper/uaccess.h>
108 #include <linux/jiffies.h>
109 #include <linux/delay.h>
110 #include <linux/module.h>
111@@ -605,7 +606,7 @@ ssize_t channel_ring_buffer_file_read(struct file *filp,
112 ssize_t len;
113
114 might_sleep();
115- if (!access_ok(VERIFY_WRITE, user_buf, count))
116+ if (!lttng_access_ok(VERIFY_WRITE, user_buf, count))
117 return -EFAULT;
118
119 /* Finish copy of previous record */
120diff --git a/lttng-filter-interpreter.c b/lttng-filter-interpreter.c
121index bf695497..3dad6cc6 100644
122--- a/lttng-filter-interpreter.c
123+++ b/lttng-filter-interpreter.c
124@@ -7,7 +7,7 @@
125 * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
126 */
127
128-#include <linux/uaccess.h>
129+#include <wrapper/uaccess.h>
130 #include <wrapper/frame.h>
131 #include <wrapper/types.h>
132 #include <linux/swab.h>
133@@ -30,7 +30,7 @@ char get_char(struct estack_entry *reg, size_t offset)
134 char c;
135
136 /* Handle invalid access as end of string. */
137- if (unlikely(!access_ok(VERIFY_READ,
138+ if (unlikely(!lttng_access_ok(VERIFY_READ,
139 reg->u.s.user_str + offset,
140 sizeof(c))))
141 return '\0';
142diff --git a/probes/lttng-probe-user.c b/probes/lttng-probe-user.c
143index 4162a7e4..0d1f95fe 100644
144--- a/probes/lttng-probe-user.c
145+++ b/probes/lttng-probe-user.c
146@@ -7,6 +7,7 @@
147
148 #include <linux/uaccess.h>
149 #include <linux/module.h>
150+#include <wrapper/uaccess.h>
151 #include <probes/lttng-probe-user.h>
152
153 /*
154@@ -30,7 +31,7 @@ long lttng_strlen_user_inatomic(const char *addr)
155 char v;
156 unsigned long ret;
157
158- if (unlikely(!access_ok(VERIFY_READ,
159+ if (unlikely(!lttng_access_ok(VERIFY_READ,
160 (__force const char __user *) addr,
161 sizeof(v))))
162 break;
163diff --git a/wrapper/uaccess.h b/wrapper/uaccess.h
164new file mode 100644
165index 00000000..c56427c5
166--- /dev/null
167+++ b/wrapper/uaccess.h
168@@ -0,0 +1,28 @@
169+/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
170+ *
171+ * wrapper/uaccess.h
172+ *
173+ * wrapper around linux/uaccess.h.
174+ *
175+ * Copyright (C) 2019 Michael Jeanson <mjeanson@efficios.com>
176+ */
177+
178+#ifndef _LTTNG_WRAPPER_UACCESS_H
179+#define _LTTNG_WRAPPER_UACCESS_H
180+
181+#include <linux/uaccess.h>
182+#include <lttng-kernel-version.h>
183+
184+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0))
185+
186+#define VERIFY_READ 0
187+#define VERIFY_WRITE 1
188+#define lttng_access_ok(type, addr, size) access_ok(addr, size)
189+
190+#else /* LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0) */
191+
192+#define lttng_access_ok(type, addr, size) access_ok(type, addr, size)
193+
194+#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0) */
195+
196+#endif /* _LTTNG_WRAPPER_UACCESS_H */
197diff --git a/instrumentation/events/lttng-module/btrfs.h b/instrumentation/events/lttng-module/btrfs.h
198index 4dfbf5b..c548cf2 100644
199--- a/instrumentation/events/lttng-module/btrfs.h
200+++ b/instrumentation/events/lttng-module/btrfs.h
201@@ -1,3 +1,4 @@
202+/* SPDX-License-Identifier: GPL-2.0 */
203 #undef TRACE_SYSTEM
204 #define TRACE_SYSTEM btrfs
205
206@@ -32,6 +33,12 @@ struct extent_state;
207
208 #define BTRFS_UUID_SIZE 16
209
210+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0))
211+#define lttng_fs_info_fsid fs_info->fs_devices->fsid
212+#else
213+#define lttng_fs_info_fsid fs_info->fsid
214+#endif
215+
216 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
217 LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
218 LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
219@@ -279,6 +286,43 @@ LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
220
221 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
222
223+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,18,0))
224+LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist,
225+
226+ TP_PROTO(struct btrfs_fs_info *fs_info,
227+ const struct extent_map *existing, const struct extent_map *map,
228+ u64 start, u64 len),
229+
230+ TP_ARGS(fs_info, existing, map, start, len),
231+
232+ TP_FIELDS(
233+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
234+ ctf_integer(u64, e_start, existing->start)
235+ ctf_integer(u64, e_len, existing->len)
236+ ctf_integer(u64, map_start, map->start)
237+ ctf_integer(u64, map_len, map->len)
238+ ctf_integer(u64, start, start)
239+ ctf_integer(u64, len, len)
240+ )
241+)
242+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
243+LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist,
244+
245+ TP_PROTO(const struct extent_map *existing, const struct extent_map *map, u64 start, u64 len),
246+
247+ TP_ARGS(existing, map, start, len),
248+
249+ TP_FIELDS(
250+ ctf_integer(u64, e_start, existing->start)
251+ ctf_integer(u64, e_len, existing->len)
252+ ctf_integer(u64, map_start, map->start)
253+ ctf_integer(u64, map_len, map->len)
254+ ctf_integer(u64, start, start)
255+ ctf_integer(u64, len, len)
256+ )
257+)
258+#endif
259+
260 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
261 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
262
263@@ -629,7 +673,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
264 TP_ARGS(fs_info, block_group, create),
265
266 TP_FIELDS(
267- ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
268+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
269 ctf_integer(u64, offset, block_group->key.objectid)
270 ctf_integer(u64, size, block_group->key.offset)
271 ctf_integer(u64, flags, block_group->flags)
272@@ -647,7 +691,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
273 TP_ARGS(fs_info, block_group, create),
274
275 TP_FIELDS(
276- ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
277+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
278 ctf_integer(u64, offset, block_group->key.objectid)
279 ctf_integer(u64, size, block_group->key.offset)
280 ctf_integer(u64, flags, block_group->flags)
281@@ -658,8 +702,15 @@ LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
282 )
283 #endif
284
285-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
286-LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
287+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
288+ LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
289+ LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
290+ LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
291+ LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,4,103,7,0,0) || \
292+ LTTNG_SLE_KERNEL_RANGE(4,4,114,94,0,0, 4,4,114,95,0,0) || \
293+ LTTNG_SLE_KERNEL_RANGE(4,4,120,94,0,0, 4,4,120,95,0,0) || \
294+ LTTNG_SLE_KERNEL_RANGE(4,4,126,94,0,0, 4,5,0,0,0,0))
295+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref,
296
297 TP_PROTO(const struct btrfs_fs_info *fs_info,
298 const struct btrfs_delayed_ref_node *ref,
299@@ -669,6 +720,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
300 TP_ARGS(fs_info, ref, full_ref, action),
301
302 TP_FIELDS(
303+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
304 ctf_integer(u64, bytenr, ref->bytenr)
305 ctf_integer(u64, num_bytes, ref->num_bytes)
306 ctf_integer(int, action, action)
307@@ -679,8 +731,36 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
308 ctf_integer(u64, seq, ref->seq)
309 )
310 )
311+
312+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
313+
314+ add_delayed_tree_ref,
315+
316+ btrfs_add_delayed_tree_ref,
317+
318+ TP_PROTO(const struct btrfs_fs_info *fs_info,
319+ const struct btrfs_delayed_ref_node *ref,
320+ const struct btrfs_delayed_tree_ref *full_ref,
321+ int action),
322+
323+ TP_ARGS(fs_info, ref, full_ref, action)
324+)
325+
326+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
327+
328+ run_delayed_tree_ref,
329+
330+ btrfs_run_delayed_tree_ref,
331+
332+ TP_PROTO(const struct btrfs_fs_info *fs_info,
333+ const struct btrfs_delayed_ref_node *ref,
334+ const struct btrfs_delayed_tree_ref *full_ref,
335+ int action),
336+
337+ TP_ARGS(fs_info, ref, full_ref, action)
338+)
339 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
340-LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
341+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref,
342
343 TP_PROTO(struct btrfs_fs_info *fs_info,
344 struct btrfs_delayed_ref_node *ref,
345@@ -690,6 +770,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
346 TP_ARGS(fs_info, ref, full_ref, action),
347
348 TP_FIELDS(
349+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
350 ctf_integer(u64, bytenr, ref->bytenr)
351 ctf_integer(u64, num_bytes, ref->num_bytes)
352 ctf_integer(int, action, action)
353@@ -700,7 +781,127 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
354 ctf_integer(u64, seq, ref->seq)
355 )
356 )
357-#else
358+
359+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
360+
361+ add_delayed_tree_ref,
362+
363+ btrfs_add_delayed_tree_ref,
364+
365+ TP_PROTO(struct btrfs_fs_info *fs_info,
366+ struct btrfs_delayed_ref_node *ref,
367+ struct btrfs_delayed_tree_ref *full_ref,
368+ int action),
369+
370+ TP_ARGS(fs_info, ref, full_ref, action)
371+)
372+
373+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
374+
375+ run_delayed_tree_ref,
376+
377+ btrfs_run_delayed_tree_ref,
378+
379+ TP_PROTO(struct btrfs_fs_info *fs_info,
380+ struct btrfs_delayed_ref_node *ref,
381+ struct btrfs_delayed_tree_ref *full_ref,
382+ int action),
383+
384+ TP_ARGS(fs_info, ref, full_ref, action)
385+)
386+#elif (LTTNG_SLE_KERNEL_RANGE(4,4,103,92,0,0, 4,5,0,0,0,0))
387+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref,
388+
389+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
390+ const struct btrfs_delayed_tree_ref *full_ref,
391+ int action),
392+
393+ TP_ARGS(ref, full_ref, action),
394+
395+ TP_FIELDS(
396+ ctf_integer(u64, bytenr, ref->bytenr)
397+ ctf_integer(u64, num_bytes, ref->num_bytes)
398+ ctf_integer(int, action, action)
399+ ctf_integer(u64, parent, full_ref->parent)
400+ ctf_integer(u64, ref_root, full_ref->root)
401+ ctf_integer(int, level, full_ref->level)
402+ ctf_integer(int, type, ref->type)
403+ ctf_integer(u64, seq, ref->seq)
404+ )
405+)
406+
407+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
408+
409+ add_delayed_tree_ref,
410+
411+ btrfs_add_delayed_tree_ref,
412+
413+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
414+ const struct btrfs_delayed_tree_ref *full_ref,
415+ int action),
416+
417+ TP_ARGS(ref, full_ref, action)
418+)
419+
420+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
421+
422+ run_delayed_tree_ref,
423+
424+ btrfs_run_delayed_tree_ref,
425+
426+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
427+ const struct btrfs_delayed_tree_ref *full_ref,
428+ int action),
429+
430+ TP_ARGS(ref, full_ref, action)
431+)
432+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
433+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_tree_ref,
434+
435+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
436+ struct btrfs_delayed_tree_ref *full_ref,
437+ int action),
438+
439+ TP_ARGS(ref, full_ref, action),
440+
441+ TP_FIELDS(
442+ ctf_integer(u64, bytenr, ref->bytenr)
443+ ctf_integer(u64, num_bytes, ref->num_bytes)
444+ ctf_integer(int, action, action)
445+ ctf_integer(u64, parent, full_ref->parent)
446+ ctf_integer(u64, ref_root, full_ref->root)
447+ ctf_integer(int, level, full_ref->level)
448+ ctf_integer(int, type, ref->type)
449+ ctf_integer(u64, seq, ref->seq)
450+ )
451+)
452+
453+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
454+
455+ add_delayed_tree_ref,
456+
457+ btrfs_add_delayed_tree_ref,
458+
459+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
460+ struct btrfs_delayed_tree_ref *full_ref,
461+ int action),
462+
463+ TP_ARGS(ref, full_ref, action)
464+)
465+
466+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_tree_ref,
467+
468+ run_delayed_tree_ref,
469+
470+ btrfs_run_delayed_tree_ref,
471+
472+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
473+ struct btrfs_delayed_tree_ref *full_ref,
474+ int action),
475+
476+ TP_ARGS(ref, full_ref, action)
477+)
478+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
479 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
480
481 TP_PROTO(struct btrfs_delayed_ref_node *ref,
482@@ -717,13 +918,234 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
483 ctf_integer(u64, ref_root, full_ref->root)
484 ctf_integer(int, level, full_ref->level)
485 ctf_integer(int, type, ref->type)
486-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
487 ctf_integer(u64, seq, ref->seq)
488-#endif
489+ )
490+)
491+#else
492+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
493+
494+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
495+ struct btrfs_delayed_tree_ref *full_ref,
496+ int action),
497+
498+ TP_ARGS(ref, full_ref, action),
499+
500+ TP_FIELDS(
501+ ctf_integer(u64, bytenr, ref->bytenr)
502+ ctf_integer(u64, num_bytes, ref->num_bytes)
503+ ctf_integer(int, action, action)
504+ ctf_integer(u64, parent, full_ref->parent)
505+ ctf_integer(u64, ref_root, full_ref->root)
506+ ctf_integer(int, level, full_ref->level)
507+ ctf_integer(int, type, ref->type)
508 )
509 )
510 #endif
511
512+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
513+ LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
514+ LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
515+ LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
516+ LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,4,103,7,0,0) || \
517+ LTTNG_SLE_KERNEL_RANGE(4,4,114,94,0,0, 4,4,114,95,0,0) || \
518+ LTTNG_SLE_KERNEL_RANGE(4,4,120,94,0,0, 4,4,120,95,0,0) || \
519+ LTTNG_SLE_KERNEL_RANGE(4,4,126,94,0,0, 4,5,0,0,0,0))
520+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref,
521+
522+ TP_PROTO(const struct btrfs_fs_info *fs_info,
523+ const struct btrfs_delayed_ref_node *ref,
524+ const struct btrfs_delayed_data_ref *full_ref,
525+ int action),
526+
527+ TP_ARGS(fs_info, ref, full_ref, action),
528+
529+ TP_FIELDS(
530+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
531+ ctf_integer(u64, bytenr, ref->bytenr)
532+ ctf_integer(u64, num_bytes, ref->num_bytes)
533+ ctf_integer(int, action, action)
534+ ctf_integer(u64, parent, full_ref->parent)
535+ ctf_integer(u64, ref_root, full_ref->root)
536+ ctf_integer(u64, owner, full_ref->objectid)
537+ ctf_integer(u64, offset, full_ref->offset)
538+ ctf_integer(int, type, ref->type)
539+ ctf_integer(u64, seq, ref->seq)
540+ )
541+)
542+
543+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
544+
545+ add_delayed_data_ref,
546+
547+ btrfs_add_delayed_data_ref,
548+
549+ TP_PROTO(const struct btrfs_fs_info *fs_info,
550+ const struct btrfs_delayed_ref_node *ref,
551+ const struct btrfs_delayed_data_ref *full_ref,
552+ int action),
553+
554+ TP_ARGS(fs_info, ref, full_ref, action)
555+)
556+
557+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
558+
559+ run_delayed_data_ref,
560+
561+ btrfs_run_delayed_data_ref,
562+
563+ TP_PROTO(const struct btrfs_fs_info *fs_info,
564+ const struct btrfs_delayed_ref_node *ref,
565+ const struct btrfs_delayed_data_ref *full_ref,
566+ int action),
567+
568+ TP_ARGS(fs_info, ref, full_ref, action)
569+)
570+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
571+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref,
572+
573+ TP_PROTO(struct btrfs_fs_info *fs_info,
574+ struct btrfs_delayed_ref_node *ref,
575+ struct btrfs_delayed_data_ref *full_ref,
576+ int action),
577+
578+ TP_ARGS(fs_info, ref, full_ref, action),
579+
580+ TP_FIELDS(
581+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
582+ ctf_integer(u64, bytenr, ref->bytenr)
583+ ctf_integer(u64, num_bytes, ref->num_bytes)
584+ ctf_integer(int, action, action)
585+ ctf_integer(u64, parent, full_ref->parent)
586+ ctf_integer(u64, ref_root, full_ref->root)
587+ ctf_integer(u64, owner, full_ref->objectid)
588+ ctf_integer(u64, offset, full_ref->offset)
589+ ctf_integer(int, type, ref->type)
590+ ctf_integer(u64, seq, ref->seq)
591+ )
592+)
593+
594+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
595+
596+ add_delayed_data_ref,
597+
598+ btrfs_add_delayed_data_ref,
599+
600+ TP_PROTO(struct btrfs_fs_info *fs_info,
601+ struct btrfs_delayed_ref_node *ref,
602+ struct btrfs_delayed_data_ref *full_ref,
603+ int action),
604+
605+ TP_ARGS(fs_info, ref, full_ref, action)
606+)
607+
608+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
609+
610+ run_delayed_data_ref,
611+
612+ btrfs_run_delayed_data_ref,
613+
614+ TP_PROTO(struct btrfs_fs_info *fs_info,
615+ struct btrfs_delayed_ref_node *ref,
616+ struct btrfs_delayed_data_ref *full_ref,
617+ int action),
618+
619+ TP_ARGS(fs_info, ref, full_ref, action)
620+)
621+#elif (LTTNG_SLE_KERNEL_RANGE(4,4,103,92,0,0, 4,5,0,0,0,0))
622+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref,
623+
624+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
625+ const struct btrfs_delayed_data_ref *full_ref,
626+ int action),
627+
628+ TP_ARGS(ref, full_ref, action),
629+
630+ TP_FIELDS(
631+ ctf_integer(u64, bytenr, ref->bytenr)
632+ ctf_integer(u64, num_bytes, ref->num_bytes)
633+ ctf_integer(int, action, action)
634+ ctf_integer(u64, parent, full_ref->parent)
635+ ctf_integer(u64, ref_root, full_ref->root)
636+ ctf_integer(u64, owner, full_ref->objectid)
637+ ctf_integer(u64, offset, full_ref->offset)
638+ ctf_integer(int, type, ref->type)
639+ ctf_integer(u64, seq, ref->seq)
640+ )
641+)
642+
643+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
644+
645+ add_delayed_data_ref,
646+
647+ btrfs_add_delayed_data_ref,
648+
649+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
650+ const struct btrfs_delayed_data_ref *full_ref,
651+ int action),
652+
653+ TP_ARGS(fs_info, ref, full_ref, action)
654+)
655+
656+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
657+
658+ run_delayed_data_ref,
659+
660+ btrfs_run_delayed_data_ref,
661+
662+ TP_PROTO(const struct btrfs_delayed_ref_node *ref,
663+ const struct btrfs_delayed_data_ref *full_ref,
664+ int action),
665+
666+ TP_ARGS(fs_info, ref, full_ref, action)
667+)
668+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
669+LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_data_ref,
670+
671+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
672+ struct btrfs_delayed_data_ref *full_ref,
673+ int action),
674+
675+ TP_ARGS(ref, full_ref, action),
676+
677+ TP_FIELDS(
678+ ctf_integer(u64, bytenr, ref->bytenr)
679+ ctf_integer(u64, num_bytes, ref->num_bytes)
680+ ctf_integer(int, action, action)
681+ ctf_integer(u64, parent, full_ref->parent)
682+ ctf_integer(u64, ref_root, full_ref->root)
683+ ctf_integer(u64, owner, full_ref->objectid)
684+ ctf_integer(u64, offset, full_ref->offset)
685+ ctf_integer(int, type, ref->type)
686+ ctf_integer(u64, seq, ref->seq)
687+ )
688+)
689+
690+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
691+
692+ add_delayed_data_ref,
693+
694+ btrfs_add_delayed_data_ref,
695+
696+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
697+ struct btrfs_delayed_data_ref *full_ref,
698+ int action),
699+
700+ TP_ARGS(fs_info, ref, full_ref, action)
701+)
702+
703+LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_data_ref,
704+
705+ run_delayed_data_ref,
706+
707+ btrfs_run_delayed_data_ref,
708+
709+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
710+ struct btrfs_delayed_data_ref *full_ref,
711+ int action),
712+
713+ TP_ARGS(fs_info, ref, full_ref, action)
714+)
715+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
716 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_data_ref,
717
718 TP_PROTO(struct btrfs_delayed_ref_node *ref,
719@@ -741,11 +1163,30 @@ LTTNG_TRACEPOINT_EVENT(btrfs_delayed_data_ref,
720 ctf_integer(u64, owner, full_ref->objectid)
721 ctf_integer(u64, offset, full_ref->offset)
722 ctf_integer(int, type, ref->type)
723-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
724 ctf_integer(u64, seq, ref->seq)
725-#endif
726 )
727 )
728+#else
729+LTTNG_TRACEPOINT_EVENT(btrfs_delayed_data_ref,
730+
731+ TP_PROTO(struct btrfs_delayed_ref_node *ref,
732+ struct btrfs_delayed_data_ref *full_ref,
733+ int action),
734+
735+ TP_ARGS(ref, full_ref, action),
736+
737+ TP_FIELDS(
738+ ctf_integer(u64, bytenr, ref->bytenr)
739+ ctf_integer(u64, num_bytes, ref->num_bytes)
740+ ctf_integer(int, action, action)
741+ ctf_integer(u64, parent, full_ref->parent)
742+ ctf_integer(u64, ref_root, full_ref->root)
743+ ctf_integer(u64, owner, full_ref->objectid)
744+ ctf_integer(u64, offset, full_ref->offset)
745+ ctf_integer(int, type, ref->type)
746+ )
747+)
748+#endif
749
750 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
751 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
752@@ -1015,18 +1456,18 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
753
754 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_alloc,
755
756- TP_PROTO(const struct btrfs_fs_info *info, const struct map_lookup *map,
757+ TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
758 u64 offset, u64 size),
759
760- TP_ARGS(info, map, offset, size)
761+ TP_ARGS(fs_info, map, offset, size)
762 )
763
764 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_free,
765
766- TP_PROTO(const struct btrfs_fs_info *info, const struct map_lookup *map,
767+ TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
768 u64 offset, u64 size),
769
770- TP_ARGS(info, map, offset, size)
771+ TP_ARGS(fs_info, map, offset, size)
772 )
773
774 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
775@@ -1050,18 +1491,18 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
776
777 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_alloc,
778
779- TP_PROTO(struct btrfs_fs_info *info, struct map_lookup *map,
780+ TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
781 u64 offset, u64 size),
782
783- TP_ARGS(info, map, offset, size)
784+ TP_ARGS(fs_info, map, offset, size)
785 )
786
787 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk, btrfs_chunk_free,
788
789- TP_PROTO(struct btrfs_fs_info *info, struct map_lookup *map,
790+ TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
791 u64 offset, u64 size),
792
793- TP_ARGS(info, map, offset, size)
794+ TP_ARGS(fs_info, map, offset, size)
795 )
796
797 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
798@@ -1192,7 +1633,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
799 TP_ARGS(fs_info, type, val, bytes, reserve),
800
801 TP_FIELDS(
802- ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
803+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
804 ctf_string(type, type)
805 ctf_integer(u64, val, val)
806 ctf_integer(u64, bytes, bytes)
807@@ -1208,7 +1649,7 @@ LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
808 TP_ARGS(fs_info, type, val, bytes, reserve),
809
810 TP_FIELDS(
811- ctf_array(u8, fsid, fs_info->fsid, BTRFS_UUID_SIZE)
812+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
813 ctf_string(type, type)
814 ctf_integer(u64, val, val)
815 ctf_integer(u64, bytes, bytes)
816@@ -1221,9 +1662,9 @@ LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
817
818 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
819
820- TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
821+ TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
822
823- TP_ARGS(info, start, len),
824+ TP_ARGS(fs_info, start, len),
825
826 TP_FIELDS(
827 ctf_integer(u64, start, start)
828@@ -1233,25 +1674,25 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
829
830 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
831
832- TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
833+ TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
834
835- TP_ARGS(info, start, len)
836+ TP_ARGS(fs_info, start, len)
837 )
838
839 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_free,
840
841- TP_PROTO(const struct btrfs_fs_info *info, u64 start, u64 len),
842+ TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
843
844- TP_ARGS(info, start, len)
845+ TP_ARGS(fs_info, start, len)
846 )
847
848 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
849
850 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
851
852- TP_PROTO(struct btrfs_fs_info *info, u64 start, u64 len),
853+ TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
854
855- TP_ARGS(info, start, len),
856+ TP_ARGS(fs_info, start, len),
857
858 TP_FIELDS(
859 ctf_integer(u64, start, start)
860@@ -1261,16 +1702,16 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
861
862 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
863
864- TP_PROTO(struct btrfs_fs_info *info, u64 start, u64 len),
865+ TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
866
867- TP_ARGS(info, start, len)
868+ TP_ARGS(fs_info, start, len)
869 )
870
871 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent, btrfs_reserved_extent_free,
872
873- TP_PROTO(struct btrfs_fs_info *info, u64 start, u64 len),
874+ TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
875
876- TP_ARGS(info, start, len)
877+ TP_ARGS(fs_info, start, len)
878 )
879
880 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
881@@ -1341,13 +1782,13 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
882
883 btrfs_find_free_extent,
884
885- TP_PROTO(const struct btrfs_fs_info *info, u64 num_bytes, u64 empty_size,
886+ TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
887 u64 data),
888
889- TP_ARGS(info, num_bytes, empty_size, data),
890+ TP_ARGS(fs_info, num_bytes, empty_size, data),
891
892 TP_FIELDS(
893- ctf_array(u8, fsid, info->fsid, BTRFS_UUID_SIZE)
894+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
895 ctf_integer(u64, num_bytes, num_bytes)
896 ctf_integer(u64, empty_size, empty_size)
897 ctf_integer(u64, data, data)
898@@ -1362,7 +1803,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
899 TP_ARGS(block_group, start, len),
900
901 TP_FIELDS(
902- ctf_array(u8, fsid, block_group->fs_info->fsid, BTRFS_UUID_SIZE)
903+ ctf_array(u8, fsid, block_group->lttng_fs_info_fsid, BTRFS_UUID_SIZE)
904 ctf_integer(u64, bg_objectid, block_group->key.objectid)
905 ctf_integer(u64, flags, block_group->flags)
906 ctf_integer(u64, start, start)
907@@ -1391,13 +1832,13 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
908
909 btrfs_find_free_extent,
910
911- TP_PROTO(const struct btrfs_fs_info *info, u64 num_bytes, u64 empty_size,
912+ TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
913 u64 data),
914
915- TP_ARGS(info, num_bytes, empty_size, data),
916+ TP_ARGS(fs_info, num_bytes, empty_size, data),
917
918 TP_FIELDS(
919- ctf_array(u8, fsid, info->fsid, BTRFS_UUID_SIZE)
920+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
921 ctf_integer(u64, num_bytes, num_bytes)
922 ctf_integer(u64, empty_size, empty_size)
923 ctf_integer(u64, data, data)
924@@ -1406,14 +1847,14 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
925
926 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
927
928- TP_PROTO(const struct btrfs_fs_info *info,
929+ TP_PROTO(const struct btrfs_fs_info *fs_info,
930 const struct btrfs_block_group_cache *block_group, u64 start,
931 u64 len),
932
933- TP_ARGS(info, block_group, start, len),
934+ TP_ARGS(fs_info, block_group, start, len),
935
936 TP_FIELDS(
937- ctf_array(u8, fsid, info->fsid, BTRFS_UUID_SIZE)
938+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
939 ctf_integer(u64, bg_objectid, block_group->key.objectid)
940 ctf_integer(u64, flags, block_group->flags)
941 ctf_integer(u64, start, start)
942@@ -1423,20 +1864,20 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
943
944 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
945
946- TP_PROTO(const struct btrfs_fs_info *info,
947+ TP_PROTO(const struct btrfs_fs_info *fs_info,
948 const struct btrfs_block_group_cache *block_group, u64 start,
949 u64 len),
950
951- TP_ARGS(info, block_group, start, len)
952+ TP_ARGS(fs_info, block_group, start, len)
953 )
954
955 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
956
957- TP_PROTO(const struct btrfs_fs_info *info,
958+ TP_PROTO(const struct btrfs_fs_info *fs_info,
959 const struct btrfs_block_group_cache *block_group, u64 start,
960 u64 len),
961
962- TP_ARGS(info, block_group, start, len)
963+ TP_ARGS(fs_info, block_group, start, len)
964 )
965
966 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
967@@ -1445,13 +1886,13 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
968
969 btrfs_find_free_extent,
970
971- TP_PROTO(struct btrfs_fs_info *info, u64 num_bytes, u64 empty_size,
972+ TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
973 u64 data),
974
975- TP_ARGS(info, num_bytes, empty_size, data),
976+ TP_ARGS(fs_info, num_bytes, empty_size, data),
977
978 TP_FIELDS(
979- ctf_array(u8, fsid, info->fsid, BTRFS_UUID_SIZE)
980+ ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
981 ctf_integer(u64, num_bytes, num_bytes)
982 ctf_integer(u64, empty_size, empty_size)
983 ctf_integer(u64, data, data)
984@@ -1460,11 +1901,11 @@ LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
985
986 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
987
988- TP_PROTO(struct btrfs_fs_info *info,
989+ TP_PROTO(struct btrfs_fs_info *fs_info,
990 struct btrfs_block_group_cache *block_group, u64 start,
991 u64 len),
992
993- TP_ARGS(info, block_group, start, len),
994+ TP_ARGS(fs_info, block_group, start, len),
995
996 TP_FIELDS(
997 ctf_integer(u64, bg_objectid, block_group->key.objectid)
998@@ -1476,20 +1917,20 @@ LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
999
1000 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1001
1002- TP_PROTO(struct btrfs_fs_info *info,
1003+ TP_PROTO(struct btrfs_fs_info *fs_info,
1004 struct btrfs_block_group_cache *block_group, u64 start,
1005 u64 len),
1006
1007- TP_ARGS(info, block_group, start, len)
1008+ TP_ARGS(fs_info, block_group, start, len)
1009 )
1010
1011 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1012
1013- TP_PROTO(struct btrfs_fs_info *info,
1014+ TP_PROTO(struct btrfs_fs_info *fs_info,
1015 struct btrfs_block_group_cache *block_group, u64 start,
1016 u64 len),
1017
1018- TP_ARGS(info, block_group, start, len)
1019+ TP_ARGS(fs_info, block_group, start, len)
1020 )
1021 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1022 LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1023diff --git a/instrumentation/events/lttng-module/rpc.h b/instrumentation/events/lttng-module/rpc.h
1024index b9e45fe..3798e8e 100644
1025--- a/instrumentation/events/lttng-module/rpc.h
1026+++ b/instrumentation/events/lttng-module/rpc.h
1027@@ -1,3 +1,4 @@
1028+/* SPDX-License-Identifier: GPL-2.0 */
1029 #undef TRACE_SYSTEM
1030 #define TRACE_SYSTEM rpc
1031
1032@@ -8,6 +9,57 @@
1033 #include <linux/sunrpc/sched.h>
1034 #include <linux/sunrpc/clnt.h>
1035
1036+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0))
1037+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status,
1038+
1039+ TP_PROTO(const struct rpc_task *task),
1040+
1041+ TP_ARGS(task),
1042+
1043+ TP_FIELDS(
1044+ ctf_integer(unsigned int, task_id, task->tk_pid)
1045+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1046+ ctf_integer(int, status, task->tk_status)
1047+ )
1048+)
1049+
1050+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_call_status,
1051+ TP_PROTO(const struct rpc_task *task),
1052+
1053+ TP_ARGS(task)
1054+)
1055+
1056+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status,
1057+ TP_PROTO(const struct rpc_task *task),
1058+
1059+ TP_ARGS(task)
1060+)
1061+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
1062+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status,
1063+
1064+ TP_PROTO(struct rpc_task *task),
1065+
1066+ TP_ARGS(task),
1067+
1068+ TP_FIELDS(
1069+ ctf_integer(unsigned int, task_id, task->tk_pid)
1070+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1071+ ctf_integer(int, status, task->tk_status)
1072+ )
1073+)
1074+
1075+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_call_status,
1076+ TP_PROTO(struct rpc_task *task),
1077+
1078+ TP_ARGS(task)
1079+)
1080+
1081+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status,
1082+ TP_PROTO(struct rpc_task *task),
1083+
1084+ TP_ARGS(task)
1085+)
1086+#else
1087 LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_status,
1088
1089 TP_PROTO(struct rpc_task *task),
1090@@ -32,20 +84,53 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_bind_status,
1091
1092 TP_ARGS(task)
1093 )
1094+#endif
1095
1096-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
1097+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0))
1098+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_status, rpc_connect_status,
1099+ TP_PROTO(const struct rpc_task *task),
1100+
1101+ TP_ARGS(task)
1102+)
1103+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
1104 LTTNG_TRACEPOINT_EVENT(rpc_connect_status,
1105 TP_PROTO(const struct rpc_task *task),
1106
1107 TP_ARGS(task),
1108
1109+ TP_FIELDS(
1110+ ctf_integer(unsigned int, task_id, task->tk_pid)
1111+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1112+ ctf_integer(int, status, task->tk_status)
1113+ )
1114+)
1115+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
1116+LTTNG_TRACEPOINT_EVENT(rpc_connect_status,
1117+ TP_PROTO(struct rpc_task *task, int status),
1118+
1119+ TP_ARGS(task, status),
1120+
1121+ TP_FIELDS(
1122+ ctf_integer(unsigned int, task_id, task->tk_pid)
1123+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1124+ ctf_integer(int, status, status)
1125+ )
1126+)
1127+#else
1128+LTTNG_TRACEPOINT_EVENT(rpc_connect_status,
1129+ TP_PROTO(struct rpc_task *task, int status),
1130+
1131+ TP_ARGS(task, status),
1132+
1133 TP_FIELDS(
1134 ctf_integer_hex(const struct rpc_task *, task, task)
1135 ctf_integer_hex(const struct rpc_clnt *, clnt, task->tk_client)
1136- ctf_integer(int, status, task->tk_status)
1137+ ctf_integer(int, status, status)
1138 )
1139 )
1140+#endif
1141
1142+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
1143 LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running,
1144
1145 TP_PROTO(const struct rpc_task *task, const void *action),
1146@@ -53,8 +138,8 @@ LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running,
1147 TP_ARGS(task, action),
1148
1149 TP_FIELDS(
1150- ctf_integer_hex(const struct rpc_clnt *, clnt, task->tk_client)
1151- ctf_integer_hex(const struct rpc_task *, task, task)
1152+ ctf_integer(unsigned int, task_id, task->tk_pid)
1153+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1154 ctf_integer_hex(const void *, action, action)
1155 ctf_integer(unsigned long, runstate, task->tk_runstate)
1156 ctf_integer(int, status, task->tk_status)
1157@@ -90,8 +175,8 @@ LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_queued,
1158 TP_ARGS(task, q),
1159
1160 TP_FIELDS(
1161- ctf_integer_hex(const struct rpc_clnt *, clnt, task->tk_client)
1162- ctf_integer_hex(const struct rpc_task *, task, task)
1163+ ctf_integer(unsigned int, task_id, task->tk_pid)
1164+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1165 ctf_integer(unsigned long, timeout, task->tk_timeout)
1166 ctf_integer(unsigned long, runstate, task->tk_runstate)
1167 ctf_integer(int, status, task->tk_status)
1168@@ -114,19 +199,76 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_wakeup,
1169 TP_ARGS(task, q)
1170 )
1171
1172-#else
1173-LTTNG_TRACEPOINT_EVENT(rpc_connect_status,
1174- TP_PROTO(struct rpc_task *task, int status),
1175+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
1176+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running,
1177
1178- TP_ARGS(task, status),
1179+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
1180+
1181+ TP_ARGS(clnt, task, action),
1182
1183 TP_FIELDS(
1184- ctf_integer_hex(const struct rpc_task *, task, task)
1185- ctf_integer_hex(const struct rpc_clnt *, clnt, task->tk_client)
1186- ctf_integer(int, status, status)
1187+ ctf_integer(unsigned int, task_id, task->tk_pid)
1188+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1189+ ctf_integer_hex(const void *, action, action)
1190+ ctf_integer(unsigned long, runstate, task->tk_runstate)
1191+ ctf_integer(int, status, task->tk_status)
1192+ ctf_integer(unsigned short, flags, task->tk_flags)
1193+ )
1194+)
1195+
1196+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_begin,
1197+
1198+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
1199+
1200+ TP_ARGS(clnt, task, action)
1201+)
1202+
1203+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_run_action,
1204+
1205+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
1206+
1207+ TP_ARGS(clnt, task, action)
1208+)
1209+
1210+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_running, rpc_task_complete,
1211+
1212+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
1213+
1214+ TP_ARGS(clnt, task, action)
1215+)
1216+
1217+LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_queued,
1218+
1219+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
1220+
1221+ TP_ARGS(clnt, task, q),
1222+
1223+ TP_FIELDS(
1224+ ctf_integer(unsigned int, task_id, task->tk_pid)
1225+ ctf_integer(unsigned int, client_id, task->tk_client->cl_clid)
1226+ ctf_integer(unsigned long, timeout, task->tk_timeout)
1227+ ctf_integer(unsigned long, runstate, task->tk_runstate)
1228+ ctf_integer(int, status, task->tk_status)
1229+ ctf_integer(unsigned short, flags, task->tk_flags)
1230+ ctf_string(q_name, rpc_qname(q))
1231 )
1232 )
1233
1234+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_sleep,
1235+
1236+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
1237+
1238+ TP_ARGS(clnt, task, q)
1239+)
1240+
1241+LTTNG_TRACEPOINT_EVENT_INSTANCE(rpc_task_queued, rpc_task_wakeup,
1242+
1243+ TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
1244+
1245+ TP_ARGS(clnt, task, q)
1246+)
1247+
1248+#else
1249 LTTNG_TRACEPOINT_EVENT_CLASS(rpc_task_running,
1250
1251 TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
LTTng 2.x kernel modules
This page took 0.876561 seconds and 4 git commands to generate.