Commit | Line | Data |
---|---|---|
e1d8aa9f FW |
1 | /* |
2 | * Workqueue statistical tracer. | |
3 | * | |
4 | * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com> | |
5 | * | |
6 | */ | |
7 | ||
8 | ||
fb39125f | 9 | #include <trace/events/workqueue.h> |
e1d8aa9f | 10 | #include <linux/list.h> |
3690b5e6 | 11 | #include <linux/percpu.h> |
5a0e3ad6 | 12 | #include <linux/slab.h> |
a3578000 | 13 | #include <linux/kref.h> |
e1d8aa9f FW |
14 | #include "trace_stat.h" |
15 | #include "trace.h" | |
16 | ||
17 | ||
18 | /* A cpu workqueue thread */ | |
19 | struct cpu_workqueue_stats { | |
20 | struct list_head list; | |
a3578000 | 21 | struct kref kref; |
e1d8aa9f | 22 | int cpu; |
ef18012b | 23 | pid_t pid; |
e1d8aa9f | 24 | /* Can be inserted from interrupt or user context, need to be atomic */ |
ef18012b | 25 | atomic_t inserted; |
e1d8aa9f FW |
26 | /* |
27 | * Don't need to be atomic, works are serialized in a single workqueue thread | |
28 | * on a single CPU. | |
29 | */ | |
ef18012b | 30 | unsigned int executed; |
e1d8aa9f FW |
31 | }; |
32 | ||
33 | /* List of workqueue threads on one cpu */ | |
34 | struct workqueue_global_stats { | |
35 | struct list_head list; | |
36 | spinlock_t lock; | |
37 | }; | |
38 | ||
39 | /* Don't need a global lock because allocated before the workqueues, and | |
40 | * never freed. | |
41 | */ | |
3690b5e6 LJ |
42 | static DEFINE_PER_CPU(struct workqueue_global_stats, all_workqueue_stat); |
43 | #define workqueue_cpu_stat(cpu) (&per_cpu(all_workqueue_stat, cpu)) | |
e1d8aa9f | 44 | |
a3578000 LJ |
45 | static void cpu_workqueue_stat_free(struct kref *kref) |
46 | { | |
47 | kfree(container_of(kref, struct cpu_workqueue_stats, kref)); | |
48 | } | |
49 | ||
e1d8aa9f FW |
50 | /* Insertion of a work */ |
51 | static void | |
38516ab5 SR |
52 | probe_workqueue_insertion(void *ignore, |
53 | struct task_struct *wq_thread, | |
e1d8aa9f FW |
54 | struct work_struct *work) |
55 | { | |
56 | int cpu = cpumask_first(&wq_thread->cpus_allowed); | |
1fdfca9c | 57 | struct cpu_workqueue_stats *node; |
e1d8aa9f FW |
58 | unsigned long flags; |
59 | ||
3690b5e6 | 60 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
1fdfca9c | 61 | list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) { |
e1d8aa9f FW |
62 | if (node->pid == wq_thread->pid) { |
63 | atomic_inc(&node->inserted); | |
64 | goto found; | |
65 | } | |
66 | } | |
67 | pr_debug("trace_workqueue: entry not found\n"); | |
68 | found: | |
3690b5e6 | 69 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f FW |
70 | } |
71 | ||
72 | /* Execution of a work */ | |
73 | static void | |
38516ab5 SR |
74 | probe_workqueue_execution(void *ignore, |
75 | struct task_struct *wq_thread, | |
e1d8aa9f FW |
76 | struct work_struct *work) |
77 | { | |
78 | int cpu = cpumask_first(&wq_thread->cpus_allowed); | |
1fdfca9c | 79 | struct cpu_workqueue_stats *node; |
e1d8aa9f FW |
80 | unsigned long flags; |
81 | ||
3690b5e6 | 82 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
1fdfca9c | 83 | list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) { |
e1d8aa9f FW |
84 | if (node->pid == wq_thread->pid) { |
85 | node->executed++; | |
86 | goto found; | |
87 | } | |
88 | } | |
89 | pr_debug("trace_workqueue: entry not found\n"); | |
90 | found: | |
3690b5e6 | 91 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f FW |
92 | } |
93 | ||
94 | /* Creation of a cpu workqueue thread */ | |
38516ab5 SR |
95 | static void probe_workqueue_creation(void *ignore, |
96 | struct task_struct *wq_thread, int cpu) | |
e1d8aa9f FW |
97 | { |
98 | struct cpu_workqueue_stats *cws; | |
99 | unsigned long flags; | |
100 | ||
bbcd3063 | 101 | WARN_ON(cpu < 0); |
e1d8aa9f FW |
102 | |
103 | /* Workqueues are sometimes created in atomic context */ | |
104 | cws = kzalloc(sizeof(struct cpu_workqueue_stats), GFP_ATOMIC); | |
105 | if (!cws) { | |
106 | pr_warning("trace_workqueue: not enough memory\n"); | |
107 | return; | |
108 | } | |
e1d8aa9f | 109 | INIT_LIST_HEAD(&cws->list); |
a3578000 | 110 | kref_init(&cws->kref); |
e1d8aa9f | 111 | cws->cpu = cpu; |
e1d8aa9f FW |
112 | cws->pid = wq_thread->pid; |
113 | ||
3690b5e6 | 114 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
3690b5e6 LJ |
115 | list_add_tail(&cws->list, &workqueue_cpu_stat(cpu)->list); |
116 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); | |
e1d8aa9f FW |
117 | } |
118 | ||
119 | /* Destruction of a cpu workqueue thread */ | |
38516ab5 SR |
120 | static void |
121 | probe_workqueue_destruction(void *ignore, struct task_struct *wq_thread) | |
e1d8aa9f FW |
122 | { |
123 | /* Workqueue only execute on one cpu */ | |
124 | int cpu = cpumask_first(&wq_thread->cpus_allowed); | |
125 | struct cpu_workqueue_stats *node, *next; | |
126 | unsigned long flags; | |
127 | ||
3690b5e6 LJ |
128 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
129 | list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list, | |
e1d8aa9f FW |
130 | list) { |
131 | if (node->pid == wq_thread->pid) { | |
132 | list_del(&node->list); | |
a3578000 | 133 | kref_put(&node->kref, cpu_workqueue_stat_free); |
e1d8aa9f FW |
134 | goto found; |
135 | } | |
136 | } | |
137 | ||
138 | pr_debug("trace_workqueue: don't find workqueue to destroy\n"); | |
139 | found: | |
3690b5e6 | 140 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f FW |
141 | |
142 | } | |
143 | ||
144 | static struct cpu_workqueue_stats *workqueue_stat_start_cpu(int cpu) | |
145 | { | |
146 | unsigned long flags; | |
147 | struct cpu_workqueue_stats *ret = NULL; | |
148 | ||
149 | ||
3690b5e6 | 150 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f | 151 | |
a3578000 | 152 | if (!list_empty(&workqueue_cpu_stat(cpu)->list)) { |
3690b5e6 | 153 | ret = list_entry(workqueue_cpu_stat(cpu)->list.next, |
e1d8aa9f | 154 | struct cpu_workqueue_stats, list); |
a3578000 LJ |
155 | kref_get(&ret->kref); |
156 | } | |
e1d8aa9f | 157 | |
3690b5e6 | 158 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f FW |
159 | |
160 | return ret; | |
161 | } | |
162 | ||
42548008 | 163 | static void *workqueue_stat_start(struct tracer_stat *trace) |
e1d8aa9f FW |
164 | { |
165 | int cpu; | |
166 | void *ret = NULL; | |
167 | ||
168 | for_each_possible_cpu(cpu) { | |
169 | ret = workqueue_stat_start_cpu(cpu); | |
170 | if (ret) | |
171 | return ret; | |
172 | } | |
173 | return NULL; | |
174 | } | |
175 | ||
176 | static void *workqueue_stat_next(void *prev, int idx) | |
177 | { | |
178 | struct cpu_workqueue_stats *prev_cws = prev; | |
a3578000 | 179 | struct cpu_workqueue_stats *ret; |
e1d8aa9f FW |
180 | int cpu = prev_cws->cpu; |
181 | unsigned long flags; | |
e1d8aa9f | 182 | |
3690b5e6 LJ |
183 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
184 | if (list_is_last(&prev_cws->list, &workqueue_cpu_stat(cpu)->list)) { | |
185 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); | |
bbcd3063 KM |
186 | do { |
187 | cpu = cpumask_next(cpu, cpu_possible_mask); | |
188 | if (cpu >= nr_cpu_ids) | |
189 | return NULL; | |
190 | } while (!(ret = workqueue_stat_start_cpu(cpu))); | |
191 | return ret; | |
a3578000 LJ |
192 | } else { |
193 | ret = list_entry(prev_cws->list.next, | |
194 | struct cpu_workqueue_stats, list); | |
195 | kref_get(&ret->kref); | |
e1d8aa9f | 196 | } |
3690b5e6 | 197 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
e1d8aa9f | 198 | |
a3578000 | 199 | return ret; |
e1d8aa9f FW |
200 | } |
201 | ||
202 | static int workqueue_stat_show(struct seq_file *s, void *p) | |
203 | { | |
204 | struct cpu_workqueue_stats *cws = p; | |
889a6c36 KM |
205 | struct pid *pid; |
206 | struct task_struct *tsk; | |
207 | ||
208 | pid = find_get_pid(cws->pid); | |
209 | if (pid) { | |
210 | tsk = get_pid_task(pid, PIDTYPE_PID); | |
211 | if (tsk) { | |
212 | seq_printf(s, "%3d %6d %6u %s\n", cws->cpu, | |
213 | atomic_read(&cws->inserted), cws->executed, | |
214 | tsk->comm); | |
215 | put_task_struct(tsk); | |
216 | } | |
217 | put_pid(pid); | |
218 | } | |
e1d8aa9f | 219 | |
e1d8aa9f FW |
220 | return 0; |
221 | } | |
222 | ||
a3578000 LJ |
223 | static void workqueue_stat_release(void *stat) |
224 | { | |
225 | struct cpu_workqueue_stats *node = stat; | |
226 | ||
227 | kref_put(&node->kref, cpu_workqueue_stat_free); | |
228 | } | |
229 | ||
e1d8aa9f FW |
230 | static int workqueue_stat_headers(struct seq_file *s) |
231 | { | |
232 | seq_printf(s, "# CPU INSERTED EXECUTED NAME\n"); | |
2f63b840 | 233 | seq_printf(s, "# | | | |\n"); |
e1d8aa9f FW |
234 | return 0; |
235 | } | |
236 | ||
237 | struct tracer_stat workqueue_stats __read_mostly = { | |
238 | .name = "workqueues", | |
239 | .stat_start = workqueue_stat_start, | |
240 | .stat_next = workqueue_stat_next, | |
241 | .stat_show = workqueue_stat_show, | |
a3578000 | 242 | .stat_release = workqueue_stat_release, |
e1d8aa9f FW |
243 | .stat_headers = workqueue_stat_headers |
244 | }; | |
245 | ||
246 | ||
247 | int __init stat_workqueue_init(void) | |
248 | { | |
249 | if (register_stat_tracer(&workqueue_stats)) { | |
250 | pr_warning("Unable to register workqueue stat tracer\n"); | |
251 | return 1; | |
252 | } | |
253 | ||
254 | return 0; | |
255 | } | |
256 | fs_initcall(stat_workqueue_init); | |
257 | ||
258 | /* | |
259 | * Workqueues are created very early, just after pre-smp initcalls. | |
260 | * So we must register our tracepoints at this stage. | |
261 | */ | |
262 | int __init trace_workqueue_early_init(void) | |
263 | { | |
264 | int ret, cpu; | |
265 | ||
e0cf0cd4 JB |
266 | for_each_possible_cpu(cpu) { |
267 | spin_lock_init(&workqueue_cpu_stat(cpu)->lock); | |
268 | INIT_LIST_HEAD(&workqueue_cpu_stat(cpu)->list); | |
269 | } | |
270 | ||
38516ab5 | 271 | ret = register_trace_workqueue_insertion(probe_workqueue_insertion, NULL); |
e1d8aa9f FW |
272 | if (ret) |
273 | goto out; | |
274 | ||
38516ab5 | 275 | ret = register_trace_workqueue_execution(probe_workqueue_execution, NULL); |
e1d8aa9f FW |
276 | if (ret) |
277 | goto no_insertion; | |
278 | ||
38516ab5 | 279 | ret = register_trace_workqueue_creation(probe_workqueue_creation, NULL); |
e1d8aa9f FW |
280 | if (ret) |
281 | goto no_execution; | |
282 | ||
38516ab5 | 283 | ret = register_trace_workqueue_destruction(probe_workqueue_destruction, NULL); |
e1d8aa9f FW |
284 | if (ret) |
285 | goto no_creation; | |
286 | ||
e1d8aa9f FW |
287 | return 0; |
288 | ||
289 | no_creation: | |
38516ab5 | 290 | unregister_trace_workqueue_creation(probe_workqueue_creation, NULL); |
e1d8aa9f | 291 | no_execution: |
38516ab5 | 292 | unregister_trace_workqueue_execution(probe_workqueue_execution, NULL); |
e1d8aa9f | 293 | no_insertion: |
38516ab5 | 294 | unregister_trace_workqueue_insertion(probe_workqueue_insertion, NULL); |
e1d8aa9f FW |
295 | out: |
296 | pr_warning("trace_workqueue: unable to trace workqueues\n"); | |
297 | ||
298 | return 1; | |
299 | } | |
300 | early_initcall(trace_workqueue_early_init); |