1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * If TRACE_SYSTEM is defined, that will be the directory created |
4 | * in the ftrace directory under /sys/kernel/tracing/events/<system> |
5 | * |
6 | * The define_trace.h below will also look for a file name of |
7 | * TRACE_SYSTEM.h where TRACE_SYSTEM is what is defined here. |
8 | * In this case, it would look for sample-trace.h |
9 | * |
10 | * If the header name will be different than the system name |
11 | * (as in this case), then you can override the header name that |
12 | * define_trace.h will look up by defining TRACE_INCLUDE_FILE |
13 | * |
14 | * This file is called trace-events-sample.h but we want the system |
15 | * to be called "sample-trace". Therefore we must define the name of this |
16 | * file: |
17 | * |
18 | * #define TRACE_INCLUDE_FILE trace-events-sample |
19 | * |
20 | * As we do an the bottom of this file. |
21 | * |
22 | * Notice that TRACE_SYSTEM should be defined outside of #if |
23 | * protection, just like TRACE_INCLUDE_FILE. |
24 | */ |
25 | #undef TRACE_SYSTEM |
26 | #define TRACE_SYSTEM sample-trace |
27 | |
28 | /* |
29 | * TRACE_SYSTEM is expected to be a C valid variable (alpha-numeric |
30 | * and underscore), although it may start with numbers. If for some |
31 | * reason it is not, you need to add the following lines: |
32 | */ |
33 | #undef TRACE_SYSTEM_VAR |
34 | #define TRACE_SYSTEM_VAR sample_trace |
35 | /* |
36 | * But the above is only needed if TRACE_SYSTEM is not alpha-numeric |
37 | * and underscored. By default, TRACE_SYSTEM_VAR will be equal to |
38 | * TRACE_SYSTEM. As TRACE_SYSTEM_VAR must be alpha-numeric, if |
39 | * TRACE_SYSTEM is not, then TRACE_SYSTEM_VAR must be defined with |
40 | * only alpha-numeric and underscores. |
41 | * |
42 | * The TRACE_SYSTEM_VAR is only used internally and not visible to |
43 | * user space. |
44 | */ |
45 | |
46 | /* |
47 | * Notice that this file is not protected like a normal header. |
48 | * We also must allow for rereading of this file. The |
49 | * |
50 | * || defined(TRACE_HEADER_MULTI_READ) |
51 | * |
52 | * serves this purpose. |
53 | */ |
54 | #if !defined(_TRACE_EVENT_SAMPLE_H) || defined(TRACE_HEADER_MULTI_READ) |
55 | #define _TRACE_EVENT_SAMPLE_H |
56 | |
57 | /* |
58 | * All trace headers should include tracepoint.h, until we finally |
59 | * make it into a standard header. |
60 | */ |
61 | #include <linux/tracepoint.h> |
62 | |
63 | /* |
64 | * The TRACE_EVENT macro is broken up into 5 parts. |
65 | * |
66 | * name: name of the trace point. This is also how to enable the tracepoint. |
67 | * A function called trace_foo_bar() will be created. |
68 | * |
69 | * proto: the prototype of the function trace_foo_bar() |
70 | * Here it is trace_foo_bar(char *foo, int bar). |
71 | * |
72 | * args: must match the arguments in the prototype. |
73 | * Here it is simply "foo, bar". |
74 | * |
75 | * struct: This defines the way the data will be stored in the ring buffer. |
76 | * The items declared here become part of a special structure |
77 | * called "__entry", which can be used in the fast_assign part of the |
78 | * TRACE_EVENT macro. |
79 | * |
80 | * Here are the currently defined types you can use: |
81 | * |
82 | * __field : Is broken up into type and name. Where type can be any |
83 | * primitive type (integer, long or pointer). |
84 | * |
85 | * __field(int, foo) |
86 | * |
87 | * __entry->foo = 5; |
88 | * |
89 | * __field_struct : This can be any static complex data type (struct, union |
90 | * but not an array). Be careful using complex types, as each |
91 | * event is limited in size, and copying large amounts of data |
92 | * into the ring buffer can slow things down. |
93 | * |
94 | * __field_struct(struct bar, foo) |
95 | * |
96 | * __entry->bar.x = y; |
97 | |
98 | * __array: There are three fields (type, name, size). The type is the |
99 | * type of elements in the array, the name is the name of the array. |
100 | * size is the number of items in the array (not the total size). |
101 | * |
102 | * __array( char, foo, 10) is the same as saying: char foo[10]; |
103 | * |
104 | * Assigning arrays can be done like any array: |
105 | * |
106 | * __entry->foo[0] = 'a'; |
107 | * |
108 | * memcpy(__entry->foo, bar, 10); |
109 | * |
110 | * __dynamic_array: This is similar to array, but can vary its size from |
111 | * instance to instance of the tracepoint being called. |
112 | * Like __array, this too has three elements (type, name, size); |
113 | * type is the type of the element, name is the name of the array. |
114 | * The size is different than __array. It is not a static number, |
115 | * but the algorithm to figure out the length of the array for the |
116 | * specific instance of tracepoint. Again, size is the number of |
117 | * items in the array, not the total length in bytes. |
118 | * |
119 | * __dynamic_array( int, foo, bar) is similar to: int foo[bar]; |
120 | * |
121 | * Note, unlike arrays, you must use the __get_dynamic_array() macro |
122 | * to access the array. |
123 | * |
124 | * memcpy(__get_dynamic_array(foo), bar, 10); |
125 | * |
126 | * Notice, that "__entry" is not needed here. |
127 | * |
128 | * __string: This is a special kind of __dynamic_array. It expects to |
129 | * have a null terminated character array passed to it (it allows |
130 | * for NULL too, which would be converted into "(null)"). __string |
131 | * takes two parameter (name, src), where name is the name of |
132 | * the string saved, and src is the string to copy into the |
133 | * ring buffer. |
134 | * |
135 | * __string(foo, bar) is similar to: strcpy(foo, bar) |
136 | * |
137 | * To assign a string, use the helper macro __assign_str(). |
138 | * |
139 | * __assign_str(foo, bar); |
140 | * |
141 | * In most cases, the __assign_str() macro will take the same |
142 | * parameters as the __string() macro had to declare the string. |
143 | * |
144 | * __vstring: This is similar to __string() but instead of taking a |
145 | * dynamic length, it takes a variable list va_list 'va' variable. |
146 | * Some event callers already have a message from parameters saved |
147 | * in a va_list. Passing in the format and the va_list variable |
148 | * will save just enough on the ring buffer for that string. |
149 | * Note, the va variable used is a pointer to a va_list, not |
150 | * to the va_list directly. |
151 | * |
152 | * (va_list *va) |
153 | * |
154 | * __vstring(foo, fmt, va) is similar to: vsnprintf(foo, fmt, va) |
155 | * |
156 | * To assign the string, use the helper macro __assign_vstr(). |
157 | * |
158 | * __assign_vstr(foo, fmt, va); |
159 | * |
160 | * In most cases, the __assign_vstr() macro will take the same |
161 | * parameters as the __vstring() macro had to declare the string. |
162 | * Use __get_str() to retrieve the __vstring() just like it would for |
163 | * __string(). |
164 | * |
165 | * __string_len: This is a helper to a __dynamic_array, but it understands |
166 | * that the array has characters in it, it will allocate 'len' + 1 bytes |
167 | * in the ring buffer and add a '\0' to the string. This is |
168 | * useful if the string being saved has no terminating '\0' byte. |
169 | * It requires that the length of the string is known as it acts |
170 | * like a memcpy(). |
171 | * |
172 | * Declared with: |
173 | * |
174 | * __string_len(foo, bar, len) |
175 | * |
176 | * To assign this string, use the helper macro __assign_str(). |
177 | * The length is saved via the __string_len() and is retrieved in |
178 | * __assign_str(). |
179 | * |
180 | * __assign_str(foo, bar); |
181 | * |
182 | * Then len + 1 is allocated to the ring buffer, and a nul terminating |
183 | * byte is added. This is similar to: |
184 | * |
185 | * memcpy(__get_str(foo), bar, len); |
186 | * __get_str(foo)[len] = 0; |
187 | * |
188 | * The advantage of using this over __dynamic_array, is that it |
189 | * takes care of allocating the extra byte on the ring buffer |
190 | * for the '\0' terminating byte, and __get_str(foo) can be used |
191 | * in the TP_printk(). |
192 | * |
193 | * __bitmask: This is another kind of __dynamic_array, but it expects |
194 | * an array of longs, and the number of bits to parse. It takes |
195 | * two parameters (name, nr_bits), where name is the name of the |
196 | * bitmask to save, and the nr_bits is the number of bits to record. |
197 | * |
198 | * __bitmask(target_cpu, nr_cpumask_bits) |
199 | * |
200 | * To assign a bitmask, use the __assign_bitmask() helper macro. |
201 | * |
202 | * __assign_bitmask(target_cpus, cpumask_bits(bar), nr_cpumask_bits); |
203 | * |
204 | * __cpumask: This is pretty much the same as __bitmask but is specific for |
205 | * CPU masks. The type displayed to the user via the format files will |
206 | * be "cpumaks_t" such that user space may deal with them differently |
207 | * if they choose to do so, and the bits is always set to nr_cpumask_bits. |
208 | * |
209 | * __cpumask(target_cpu) |
210 | * |
211 | * To assign a cpumask, use the __assign_cpumask() helper macro. |
212 | * |
213 | * __assign_cpumask(target_cpus, cpumask_bits(bar)); |
214 | * |
215 | * fast_assign: This is a C like function that is used to store the items |
216 | * into the ring buffer. A special variable called "__entry" will be the |
217 | * structure that points into the ring buffer and has the same fields as |
218 | * described by the struct part of TRACE_EVENT above. |
219 | * |
220 | * printk: This is a way to print out the data in pretty print. This is |
221 | * useful if the system crashes and you are logging via a serial line, |
222 | * the data can be printed to the console using this "printk" method. |
223 | * This is also used to print out the data from the trace files. |
224 | * Again, the __entry macro is used to access the data from the ring buffer. |
225 | * |
226 | * Note, __dynamic_array, __string, __bitmask and __cpumask require special |
227 | * helpers to access the data. |
228 | * |
229 | * For __dynamic_array(int, foo, bar) use __get_dynamic_array(foo) |
230 | * Use __get_dynamic_array_len(foo) to get the length of the array |
231 | * saved. Note, __get_dynamic_array_len() returns the total allocated |
232 | * length of the dynamic array; __print_array() expects the second |
233 | * parameter to be the number of elements. To get that, the array length |
234 | * needs to be divided by the element size. |
235 | * |
236 | * For __string(foo, bar) use __get_str(foo) |
237 | * |
238 | * For __bitmask(target_cpus, nr_cpumask_bits) use __get_bitmask(target_cpus) |
239 | * |
240 | * For __cpumask(target_cpus) use __get_cpumask(target_cpus) |
241 | * |
242 | * |
243 | * Note, that for both the assign and the printk, __entry is the handler |
244 | * to the data structure in the ring buffer, and is defined by the |
245 | * TP_STRUCT__entry. |
246 | */ |
247 | |
248 | /* |
249 | * It is OK to have helper functions in the file, but they need to be protected |
250 | * from being defined more than once. Remember, this file gets included more |
251 | * than once. |
252 | */ |
253 | #ifndef __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS |
254 | #define __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS |
255 | static inline int __length_of(const int *list) |
256 | { |
257 | int i; |
258 | |
259 | if (!list) |
260 | return 0; |
261 | |
262 | for (i = 0; list[i]; i++) |
263 | ; |
264 | return i; |
265 | } |
266 | |
267 | enum { |
268 | TRACE_SAMPLE_FOO = 2, |
269 | TRACE_SAMPLE_BAR = 4, |
270 | TRACE_SAMPLE_ZOO = 8, |
271 | }; |
272 | #endif |
273 | |
274 | /* |
275 | * If enums are used in the TP_printk(), their names will be shown in |
276 | * format files and not their values. This can cause problems with user |
277 | * space programs that parse the format files to know how to translate |
278 | * the raw binary trace output into human readable text. |
279 | * |
280 | * To help out user space programs, any enum that is used in the TP_printk() |
281 | * should be defined by TRACE_DEFINE_ENUM() macro. All that is needed to |
282 | * be done is to add this macro with the enum within it in the trace |
283 | * header file, and it will be converted in the output. |
284 | */ |
285 | |
286 | TRACE_DEFINE_ENUM(TRACE_SAMPLE_FOO); |
287 | TRACE_DEFINE_ENUM(TRACE_SAMPLE_BAR); |
288 | TRACE_DEFINE_ENUM(TRACE_SAMPLE_ZOO); |
289 | |
290 | TRACE_EVENT(foo_bar, |
291 | |
292 | TP_PROTO(const char *foo, int bar, const int *lst, |
293 | const char *string, const struct cpumask *mask, |
294 | const char *fmt, va_list *va), |
295 | |
296 | TP_ARGS(foo, bar, lst, string, mask, fmt, va), |
297 | |
298 | TP_STRUCT__entry( |
299 | __array( char, foo, 10 ) |
300 | __field( int, bar ) |
301 | __dynamic_array(int, list, __length_of(lst)) |
302 | __string( str, string ) |
303 | __bitmask( cpus, num_possible_cpus() ) |
304 | __cpumask( cpum ) |
305 | __vstring( vstr, fmt, va ) |
306 | __string_len( lstr, foo, bar / 2 < strlen(foo) ? bar / 2 : strlen(foo) ) |
307 | ), |
308 | |
309 | TP_fast_assign( |
310 | strscpy(__entry->foo, foo, 10); |
311 | __entry->bar = bar; |
312 | memcpy(__get_dynamic_array(list), lst, |
313 | __length_of(lst) * sizeof(int)); |
314 | __assign_str(str, string); |
315 | __assign_str(lstr, foo); |
316 | __assign_vstr(vstr, fmt, va); |
317 | __assign_bitmask(cpus, cpumask_bits(mask), num_possible_cpus()); |
318 | __assign_cpumask(cpum, cpumask_bits(mask)); |
319 | ), |
320 | |
321 | TP_printk("foo %s %d %s %s %s %s %s (%s) (%s) %s" , __entry->foo, __entry->bar, |
322 | |
323 | /* |
324 | * Notice here the use of some helper functions. This includes: |
325 | * |
326 | * __print_symbolic( variable, { value, "string" }, ... ), |
327 | * |
328 | * The variable is tested against each value of the { } pair. If |
329 | * the variable matches one of the values, then it will print the |
330 | * string in that pair. If non are matched, it returns a string |
331 | * version of the number (if __entry->bar == 7 then "7" is returned). |
332 | */ |
333 | __print_symbolic(__entry->bar, |
334 | { 0, "zero" }, |
335 | { TRACE_SAMPLE_FOO, "TWO" }, |
336 | { TRACE_SAMPLE_BAR, "FOUR" }, |
337 | { TRACE_SAMPLE_ZOO, "EIGHT" }, |
338 | { 10, "TEN" } |
339 | ), |
340 | |
341 | /* |
342 | * __print_flags( variable, "delim", { value, "flag" }, ... ), |
343 | * |
344 | * This is similar to __print_symbolic, except that it tests the bits |
345 | * of the value. If ((FLAG & variable) == FLAG) then the string is |
346 | * printed. If more than one flag matches, then each one that does is |
347 | * also printed with delim in between them. |
348 | * If not all bits are accounted for, then the not found bits will be |
349 | * added in hex format: 0x506 will show BIT2|BIT4|0x500 |
350 | */ |
351 | __print_flags(__entry->bar, "|" , |
352 | { 1, "BIT1" }, |
353 | { 2, "BIT2" }, |
354 | { 4, "BIT3" }, |
355 | { 8, "BIT4" } |
356 | ), |
357 | /* |
358 | * __print_array( array, len, element_size ) |
359 | * |
360 | * This prints out the array that is defined by __array in a nice format. |
361 | */ |
362 | __print_array(__get_dynamic_array(list), |
363 | __get_dynamic_array_len(list) / sizeof(int), |
364 | sizeof(int)), |
365 | __get_str(str), __get_str(lstr), |
366 | __get_bitmask(cpus), __get_cpumask(cpum), |
367 | __get_str(vstr)) |
368 | ); |
369 | |
370 | /* |
371 | * There may be a case where a tracepoint should only be called if |
372 | * some condition is set. Otherwise the tracepoint should not be called. |
373 | * But to do something like: |
374 | * |
375 | * if (cond) |
376 | * trace_foo(); |
377 | * |
378 | * Would cause a little overhead when tracing is not enabled, and that |
379 | * overhead, even if small, is not something we want. As tracepoints |
380 | * use static branch (aka jump_labels), where no branch is taken to |
381 | * skip the tracepoint when not enabled, and a jmp is placed to jump |
382 | * to the tracepoint code when it is enabled, having a if statement |
383 | * nullifies that optimization. It would be nice to place that |
384 | * condition within the static branch. This is where TRACE_EVENT_CONDITION |
385 | * comes in. |
386 | * |
387 | * TRACE_EVENT_CONDITION() is just like TRACE_EVENT, except it adds another |
388 | * parameter just after args. Where TRACE_EVENT has: |
389 | * |
390 | * TRACE_EVENT(name, proto, args, struct, assign, printk) |
391 | * |
392 | * the CONDITION version has: |
393 | * |
394 | * TRACE_EVENT_CONDITION(name, proto, args, cond, struct, assign, printk) |
395 | * |
396 | * Everything is the same as TRACE_EVENT except for the new cond. Think |
397 | * of the cond variable as: |
398 | * |
399 | * if (cond) |
400 | * trace_foo_bar_with_cond(); |
401 | * |
402 | * Except that the logic for the if branch is placed after the static branch. |
403 | * That is, the if statement that processes the condition will not be |
404 | * executed unless that traecpoint is enabled. Otherwise it still remains |
405 | * a nop. |
406 | */ |
407 | TRACE_EVENT_CONDITION(foo_bar_with_cond, |
408 | |
409 | TP_PROTO(const char *foo, int bar), |
410 | |
411 | TP_ARGS(foo, bar), |
412 | |
413 | TP_CONDITION(!(bar % 10)), |
414 | |
415 | TP_STRUCT__entry( |
416 | __string( foo, foo ) |
417 | __field( int, bar ) |
418 | ), |
419 | |
420 | TP_fast_assign( |
421 | __assign_str(foo, foo); |
422 | __entry->bar = bar; |
423 | ), |
424 | |
425 | TP_printk("foo %s %d" , __get_str(foo), __entry->bar) |
426 | ); |
427 | |
428 | int foo_bar_reg(void); |
429 | void foo_bar_unreg(void); |
430 | |
431 | /* |
432 | * Now in the case that some function needs to be called when the |
433 | * tracepoint is enabled and/or when it is disabled, the |
434 | * TRACE_EVENT_FN() serves this purpose. This is just like TRACE_EVENT() |
435 | * but adds two more parameters at the end: |
436 | * |
437 | * TRACE_EVENT_FN( name, proto, args, struct, assign, printk, reg, unreg) |
438 | * |
439 | * reg and unreg are functions with the prototype of: |
440 | * |
441 | * void reg(void) |
442 | * |
443 | * The reg function gets called before the tracepoint is enabled, and |
444 | * the unreg function gets called after the tracepoint is disabled. |
445 | * |
446 | * Note, reg and unreg are allowed to be NULL. If you only need to |
447 | * call a function before enabling, or after disabling, just set one |
448 | * function and pass in NULL for the other parameter. |
449 | */ |
450 | TRACE_EVENT_FN(foo_bar_with_fn, |
451 | |
452 | TP_PROTO(const char *foo, int bar), |
453 | |
454 | TP_ARGS(foo, bar), |
455 | |
456 | TP_STRUCT__entry( |
457 | __string( foo, foo ) |
458 | __field( int, bar ) |
459 | ), |
460 | |
461 | TP_fast_assign( |
462 | __assign_str(foo, foo); |
463 | __entry->bar = bar; |
464 | ), |
465 | |
466 | TP_printk("foo %s %d" , __get_str(foo), __entry->bar), |
467 | |
468 | foo_bar_reg, foo_bar_unreg |
469 | ); |
470 | |
471 | /* |
472 | * Each TRACE_EVENT macro creates several helper functions to produce |
473 | * the code to add the tracepoint, create the files in the trace |
474 | * directory, hook it to perf, assign the values and to print out |
475 | * the raw data from the ring buffer. To prevent too much bloat, |
476 | * if there are more than one tracepoint that uses the same format |
477 | * for the proto, args, struct, assign and printk, and only the name |
478 | * is different, it is highly recommended to use the DECLARE_EVENT_CLASS |
479 | * |
480 | * DECLARE_EVENT_CLASS() macro creates most of the functions for the |
481 | * tracepoint. Then DEFINE_EVENT() is use to hook a tracepoint to those |
482 | * functions. This DEFINE_EVENT() is an instance of the class and can |
483 | * be enabled and disabled separately from other events (either TRACE_EVENT |
484 | * or other DEFINE_EVENT()s). |
485 | * |
486 | * Note, TRACE_EVENT() itself is simply defined as: |
487 | * |
488 | * #define TRACE_EVENT(name, proto, args, tstruct, assign, printk) \ |
489 | * DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, printk); \ |
490 | * DEFINE_EVENT(name, name, proto, args) |
491 | * |
492 | * The DEFINE_EVENT() also can be declared with conditions and reg functions: |
493 | * |
494 | * DEFINE_EVENT_CONDITION(template, name, proto, args, cond); |
495 | * DEFINE_EVENT_FN(template, name, proto, args, reg, unreg); |
496 | */ |
497 | DECLARE_EVENT_CLASS(foo_template, |
498 | |
499 | TP_PROTO(const char *foo, int bar), |
500 | |
501 | TP_ARGS(foo, bar), |
502 | |
503 | TP_STRUCT__entry( |
504 | __string( foo, foo ) |
505 | __field( int, bar ) |
506 | ), |
507 | |
508 | TP_fast_assign( |
509 | __assign_str(foo, foo); |
510 | __entry->bar = bar; |
511 | ), |
512 | |
513 | TP_printk("foo %s %d" , __get_str(foo), __entry->bar) |
514 | ); |
515 | |
516 | /* |
517 | * Here's a better way for the previous samples (except, the first |
518 | * example had more fields and could not be used here). |
519 | */ |
520 | DEFINE_EVENT(foo_template, foo_with_template_simple, |
521 | TP_PROTO(const char *foo, int bar), |
522 | TP_ARGS(foo, bar)); |
523 | |
524 | DEFINE_EVENT_CONDITION(foo_template, foo_with_template_cond, |
525 | TP_PROTO(const char *foo, int bar), |
526 | TP_ARGS(foo, bar), |
527 | TP_CONDITION(!(bar % 8))); |
528 | |
529 | |
530 | DEFINE_EVENT_FN(foo_template, foo_with_template_fn, |
531 | TP_PROTO(const char *foo, int bar), |
532 | TP_ARGS(foo, bar), |
533 | foo_bar_reg, foo_bar_unreg); |
534 | |
535 | /* |
536 | * Anytime two events share basically the same values and have |
537 | * the same output, use the DECLARE_EVENT_CLASS() and DEFINE_EVENT() |
538 | * when ever possible. |
539 | */ |
540 | |
541 | /* |
542 | * If the event is similar to the DECLARE_EVENT_CLASS, but you need |
543 | * to have a different output, then use DEFINE_EVENT_PRINT() which |
544 | * lets you override the TP_printk() of the class. |
545 | */ |
546 | |
547 | DEFINE_EVENT_PRINT(foo_template, foo_with_template_print, |
548 | TP_PROTO(const char *foo, int bar), |
549 | TP_ARGS(foo, bar), |
550 | TP_printk("bar %s %d" , __get_str(foo), __entry->bar)); |
551 | |
552 | /* |
553 | * There are yet another __rel_loc dynamic data attribute. If you |
554 | * use __rel_dynamic_array() and __rel_string() etc. macros, you |
555 | * can use this attribute. There is no difference from the viewpoint |
556 | * of functionality with/without 'rel' but the encoding is a bit |
557 | * different. This is expected to be used with user-space event, |
558 | * there is no reason that the kernel event use this, but only for |
559 | * testing. |
560 | */ |
561 | |
562 | TRACE_EVENT(foo_rel_loc, |
563 | |
564 | TP_PROTO(const char *foo, int bar, unsigned long *mask, const cpumask_t *cpus), |
565 | |
566 | TP_ARGS(foo, bar, mask, cpus), |
567 | |
568 | TP_STRUCT__entry( |
569 | __rel_string( foo, foo ) |
570 | __field( int, bar ) |
571 | __rel_bitmask( bitmask, |
572 | BITS_PER_BYTE * sizeof(unsigned long) ) |
573 | __rel_cpumask( cpumask ) |
574 | ), |
575 | |
576 | TP_fast_assign( |
577 | __assign_rel_str(foo); |
578 | __entry->bar = bar; |
579 | __assign_rel_bitmask(bitmask, mask, |
580 | BITS_PER_BYTE * sizeof(unsigned long)); |
581 | __assign_rel_cpumask(cpumask, cpus); |
582 | ), |
583 | |
584 | TP_printk("foo_rel_loc %s, %d, %s, %s" , __get_rel_str(foo), __entry->bar, |
585 | __get_rel_bitmask(bitmask), |
586 | __get_rel_cpumask(cpumask)) |
587 | ); |
588 | #endif |
589 | |
590 | /***** NOTICE! The #if protection ends here. *****/ |
591 | |
592 | |
593 | /* |
594 | * There are several ways I could have done this. If I left out the |
595 | * TRACE_INCLUDE_PATH, then it would default to the kernel source |
596 | * include/trace/events directory. |
597 | * |
598 | * I could specify a path from the define_trace.h file back to this |
599 | * file. |
600 | * |
601 | * #define TRACE_INCLUDE_PATH ../../samples/trace_events |
602 | * |
603 | * But the safest and easiest way to simply make it use the directory |
604 | * that the file is in is to add in the Makefile: |
605 | * |
606 | * CFLAGS_trace-events-sample.o := -I$(src) |
607 | * |
608 | * This will make sure the current path is part of the include |
609 | * structure for our file so that define_trace.h can find it. |
610 | * |
611 | * I could have made only the top level directory the include: |
612 | * |
613 | * CFLAGS_trace-events-sample.o := -I$(PWD) |
614 | * |
615 | * And then let the path to this directory be the TRACE_INCLUDE_PATH: |
616 | * |
617 | * #define TRACE_INCLUDE_PATH samples/trace_events |
618 | * |
619 | * But then if something defines "samples" or "trace_events" as a macro |
620 | * then we could risk that being converted too, and give us an unexpected |
621 | * result. |
622 | */ |
623 | #undef TRACE_INCLUDE_PATH |
624 | #undef TRACE_INCLUDE_FILE |
625 | #define TRACE_INCLUDE_PATH . |
626 | /* |
627 | * TRACE_INCLUDE_FILE is not needed if the filename and TRACE_SYSTEM are equal |
628 | */ |
629 | #define TRACE_INCLUDE_FILE trace-events-sample |
630 | #include <trace/define_trace.h> |
631 | |