1 // SPDX-License-Identifier: GPL-2.0-only <<
2 #include <linux/module.h> 1 #include <linux/module.h>
3 #include <linux/kthread.h> 2 #include <linux/kthread.h>
4 3
5 /* 4 /*
6 * Any file that uses trace points, must inclu 5 * Any file that uses trace points, must include the header.
7 * But only one file, must include the header 6 * But only one file, must include the header by defining
8 * CREATE_TRACE_POINTS first. This will make 7 * CREATE_TRACE_POINTS first. This will make the C code that
9 * creates the handles for the trace points. 8 * creates the handles for the trace points.
10 */ 9 */
11 #define CREATE_TRACE_POINTS 10 #define CREATE_TRACE_POINTS
12 #include "trace-events-sample.h" 11 #include "trace-events-sample.h"
13 12
14 static const char *random_strings[] = { 13 static const char *random_strings[] = {
15 "Mother Goose", 14 "Mother Goose",
16 "Snoopy", 15 "Snoopy",
17 "Gandalf", 16 "Gandalf",
18 "Frodo", 17 "Frodo",
19 "One ring to rule them all" 18 "One ring to rule them all"
20 }; 19 };
21 20
22 static void do_simple_thread_func(int cnt, con !! 21 static void simple_thread_func(int cnt)
23 { 22 {
24 unsigned long bitmask[1] = {0xdeadbeef <<
25 va_list va; <<
26 int array[6]; 23 int array[6];
27 int len = cnt % 5; 24 int len = cnt % 5;
28 int i; 25 int i;
29 26
30 set_current_state(TASK_INTERRUPTIBLE); 27 set_current_state(TASK_INTERRUPTIBLE);
31 schedule_timeout(HZ); 28 schedule_timeout(HZ);
32 29
33 for (i = 0; i < len; i++) 30 for (i = 0; i < len; i++)
34 array[i] = i + 1; 31 array[i] = i + 1;
35 array[i] = 0; 32 array[i] = 0;
36 33
37 va_start(va, fmt); <<
38 <<
39 /* Silly tracepoints */ 34 /* Silly tracepoints */
40 trace_foo_bar("hello", cnt, array, ran 35 trace_foo_bar("hello", cnt, array, random_strings[len],
41 current->cpus_ptr, fmt, !! 36 tsk_cpus_allowed(current));
42 <<
43 va_end(va); <<
44 37
45 trace_foo_with_template_simple("HELLO" 38 trace_foo_with_template_simple("HELLO", cnt);
46 39
47 trace_foo_bar_with_cond("Some times pr 40 trace_foo_bar_with_cond("Some times print", cnt);
48 41
49 trace_foo_with_template_cond("prints o 42 trace_foo_with_template_cond("prints other times", cnt);
50 43
51 trace_foo_with_template_print("I have 44 trace_foo_with_template_print("I have to be different", cnt);
52 <<
53 trace_foo_rel_loc("Hello __rel_loc", c <<
54 } <<
55 <<
56 static void simple_thread_func(int cnt) <<
57 { <<
58 do_simple_thread_func(cnt, "iter=%d", <<
59 } 45 }
60 46
61 static int simple_thread(void *arg) 47 static int simple_thread(void *arg)
62 { 48 {
63 int cnt = 0; 49 int cnt = 0;
64 50
65 while (!kthread_should_stop()) 51 while (!kthread_should_stop())
66 simple_thread_func(cnt++); 52 simple_thread_func(cnt++);
67 53
68 return 0; 54 return 0;
69 } 55 }
70 56
71 static struct task_struct *simple_tsk; 57 static struct task_struct *simple_tsk;
72 static struct task_struct *simple_tsk_fn; 58 static struct task_struct *simple_tsk_fn;
73 59
74 static void simple_thread_func_fn(int cnt) 60 static void simple_thread_func_fn(int cnt)
75 { 61 {
76 set_current_state(TASK_INTERRUPTIBLE); 62 set_current_state(TASK_INTERRUPTIBLE);
77 schedule_timeout(HZ); 63 schedule_timeout(HZ);
78 64
79 /* More silly tracepoints */ 65 /* More silly tracepoints */
80 trace_foo_bar_with_fn("Look at me", cn 66 trace_foo_bar_with_fn("Look at me", cnt);
81 trace_foo_with_template_fn("Look at me 67 trace_foo_with_template_fn("Look at me too", cnt);
82 } 68 }
83 69
84 static int simple_thread_fn(void *arg) 70 static int simple_thread_fn(void *arg)
85 { 71 {
86 int cnt = 0; 72 int cnt = 0;
87 73
88 while (!kthread_should_stop()) 74 while (!kthread_should_stop())
89 simple_thread_func_fn(cnt++); 75 simple_thread_func_fn(cnt++);
90 76
91 return 0; 77 return 0;
92 } 78 }
93 79
94 static DEFINE_MUTEX(thread_mutex); 80 static DEFINE_MUTEX(thread_mutex);
95 static int simple_thread_cnt; <<
96 81
97 int foo_bar_reg(void) 82 int foo_bar_reg(void)
98 { 83 {
99 mutex_lock(&thread_mutex); <<
100 if (simple_thread_cnt++) <<
101 goto out; <<
102 <<
103 pr_info("Starting thread for foo_bar_f 84 pr_info("Starting thread for foo_bar_fn\n");
104 /* 85 /*
105 * We shouldn't be able to start a tra 86 * We shouldn't be able to start a trace when the module is
106 * unloading (there's other locks to p 87 * unloading (there's other locks to prevent that). But
107 * for consistency sake, we still take 88 * for consistency sake, we still take the thread_mutex.
108 */ 89 */
>> 90 mutex_lock(&thread_mutex);
109 simple_tsk_fn = kthread_run(simple_thr 91 simple_tsk_fn = kthread_run(simple_thread_fn, NULL, "event-sample-fn");
110 out: <<
111 mutex_unlock(&thread_mutex); 92 mutex_unlock(&thread_mutex);
112 return 0; 93 return 0;
113 } 94 }
114 95
115 void foo_bar_unreg(void) 96 void foo_bar_unreg(void)
116 { 97 {
117 mutex_lock(&thread_mutex); <<
118 if (--simple_thread_cnt) <<
119 goto out; <<
120 <<
121 pr_info("Killing thread for foo_bar_fn 98 pr_info("Killing thread for foo_bar_fn\n");
>> 99 /* protect against module unloading */
>> 100 mutex_lock(&thread_mutex);
122 if (simple_tsk_fn) 101 if (simple_tsk_fn)
123 kthread_stop(simple_tsk_fn); 102 kthread_stop(simple_tsk_fn);
124 simple_tsk_fn = NULL; 103 simple_tsk_fn = NULL;
125 out: <<
126 mutex_unlock(&thread_mutex); 104 mutex_unlock(&thread_mutex);
127 } 105 }
128 106
129 static int __init trace_event_init(void) 107 static int __init trace_event_init(void)
130 { 108 {
131 simple_tsk = kthread_run(simple_thread 109 simple_tsk = kthread_run(simple_thread, NULL, "event-sample");
132 if (IS_ERR(simple_tsk)) 110 if (IS_ERR(simple_tsk))
133 return -1; 111 return -1;
134 112
135 return 0; 113 return 0;
136 } 114 }
137 115
138 static void __exit trace_event_exit(void) 116 static void __exit trace_event_exit(void)
139 { 117 {
140 kthread_stop(simple_tsk); 118 kthread_stop(simple_tsk);
141 mutex_lock(&thread_mutex); 119 mutex_lock(&thread_mutex);
142 if (simple_tsk_fn) 120 if (simple_tsk_fn)
143 kthread_stop(simple_tsk_fn); 121 kthread_stop(simple_tsk_fn);
144 simple_tsk_fn = NULL; 122 simple_tsk_fn = NULL;
145 mutex_unlock(&thread_mutex); 123 mutex_unlock(&thread_mutex);
146 } 124 }
147 125
148 module_init(trace_event_init); 126 module_init(trace_event_init);
149 module_exit(trace_event_exit); 127 module_exit(trace_event_exit);
150 128
151 MODULE_AUTHOR("Steven Rostedt"); 129 MODULE_AUTHOR("Steven Rostedt");
152 MODULE_DESCRIPTION("trace-events-sample"); 130 MODULE_DESCRIPTION("trace-events-sample");
153 MODULE_LICENSE("GPL"); 131 MODULE_LICENSE("GPL");
154 132
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.