Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Workqueue statistical tracer. |
| 3 | * |
| 4 | * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com> |
| 5 | * |
| 6 | */ |
| 7 | |
| 8 | |
Zhaolei | fb39125f | 2009-04-17 15:15:51 +0800 | [diff] [blame] | 9 | #include <trace/events/workqueue.h> |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 10 | #include <linux/list.h> |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 11 | #include <linux/percpu.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 12 | #include <linux/slab.h> |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 13 | #include <linux/kref.h> |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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; |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 21 | struct kref kref; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 22 | int cpu; |
Steven Rostedt | ef18012 | 2009-03-10 14:10:56 -0400 | [diff] [blame] | 23 | pid_t pid; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 24 | /* Can be inserted from interrupt or user context, need to be atomic */ |
Steven Rostedt | ef18012 | 2009-03-10 14:10:56 -0400 | [diff] [blame] | 25 | atomic_t inserted; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 26 | /* |
| 27 | * Don't need to be atomic, works are serialized in a single workqueue thread |
| 28 | * on a single CPU. |
| 29 | */ |
Steven Rostedt | ef18012 | 2009-03-10 14:10:56 -0400 | [diff] [blame] | 30 | unsigned int executed; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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 | */ |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 42 | static DEFINE_PER_CPU(struct workqueue_global_stats, all_workqueue_stat); |
| 43 | #define workqueue_cpu_stat(cpu) (&per_cpu(all_workqueue_stat, cpu)) |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 44 | |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 45 | static void cpu_workqueue_stat_free(struct kref *kref) |
| 46 | { |
| 47 | kfree(container_of(kref, struct cpu_workqueue_stats, kref)); |
| 48 | } |
| 49 | |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 50 | /* Insertion of a work */ |
| 51 | static void |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 52 | probe_workqueue_insertion(void *ignore, |
| 53 | struct task_struct *wq_thread, |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 54 | struct work_struct *work) |
| 55 | { |
| 56 | int cpu = cpumask_first(&wq_thread->cpus_allowed); |
Zhaolei | 1fdfca9 | 2009-04-20 14:58:26 +0800 | [diff] [blame] | 57 | struct cpu_workqueue_stats *node; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 58 | unsigned long flags; |
| 59 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 60 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
Zhaolei | 1fdfca9 | 2009-04-20 14:58:26 +0800 | [diff] [blame] | 61 | list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) { |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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: |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 69 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | /* Execution of a work */ |
| 73 | static void |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 74 | probe_workqueue_execution(void *ignore, |
| 75 | struct task_struct *wq_thread, |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 76 | struct work_struct *work) |
| 77 | { |
| 78 | int cpu = cpumask_first(&wq_thread->cpus_allowed); |
Zhaolei | 1fdfca9 | 2009-04-20 14:58:26 +0800 | [diff] [blame] | 79 | struct cpu_workqueue_stats *node; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 80 | unsigned long flags; |
| 81 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 82 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
Zhaolei | 1fdfca9 | 2009-04-20 14:58:26 +0800 | [diff] [blame] | 83 | list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) { |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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: |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 91 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | /* Creation of a cpu workqueue thread */ |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 95 | static void probe_workqueue_creation(void *ignore, |
| 96 | struct task_struct *wq_thread, int cpu) |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 97 | { |
| 98 | struct cpu_workqueue_stats *cws; |
| 99 | unsigned long flags; |
| 100 | |
KOSAKI Motohiro | bbcd306 | 2009-03-10 10:49:53 +0900 | [diff] [blame] | 101 | WARN_ON(cpu < 0); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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 | } |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 109 | INIT_LIST_HEAD(&cws->list); |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 110 | kref_init(&cws->kref); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 111 | cws->cpu = cpu; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 112 | cws->pid = wq_thread->pid; |
| 113 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 114 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 115 | list_add_tail(&cws->list, &workqueue_cpu_stat(cpu)->list); |
| 116 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | /* Destruction of a cpu workqueue thread */ |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 120 | static void |
| 121 | probe_workqueue_destruction(void *ignore, struct task_struct *wq_thread) |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 128 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
| 129 | list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list, |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 130 | list) { |
| 131 | if (node->pid == wq_thread->pid) { |
| 132 | list_del(&node->list); |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 133 | kref_put(&node->kref, cpu_workqueue_stat_free); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 134 | goto found; |
| 135 | } |
| 136 | } |
| 137 | |
| 138 | pr_debug("trace_workqueue: don't find workqueue to destroy\n"); |
| 139 | found: |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 140 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 150 | spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 151 | |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 152 | if (!list_empty(&workqueue_cpu_stat(cpu)->list)) { |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 153 | ret = list_entry(workqueue_cpu_stat(cpu)->list.next, |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 154 | struct cpu_workqueue_stats, list); |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 155 | kref_get(&ret->kref); |
| 156 | } |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 157 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 158 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 159 | |
| 160 | return ret; |
| 161 | } |
| 162 | |
Steven Rostedt | 4254800 | 2009-03-24 13:38:36 -0400 | [diff] [blame] | 163 | static void *workqueue_stat_start(struct tracer_stat *trace) |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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; |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 179 | struct cpu_workqueue_stats *ret; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 180 | int cpu = prev_cws->cpu; |
| 181 | unsigned long flags; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 182 | |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 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); |
KOSAKI Motohiro | bbcd306 | 2009-03-10 10:49:53 +0900 | [diff] [blame] | 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; |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 192 | } else { |
| 193 | ret = list_entry(prev_cws->list.next, |
| 194 | struct cpu_workqueue_stats, list); |
| 195 | kref_get(&ret->kref); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 196 | } |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 197 | spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 198 | |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 199 | return ret; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | static int workqueue_stat_show(struct seq_file *s, void *p) |
| 203 | { |
| 204 | struct cpu_workqueue_stats *cws = p; |
KOSAKI Motohiro | 889a6c3 | 2009-03-13 09:03:04 +0900 | [diff] [blame] | 205 | struct pid *pid; |
| 206 | struct task_struct *tsk; |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 207 | |
KOSAKI Motohiro | 889a6c3 | 2009-03-13 09:03:04 +0900 | [diff] [blame] | 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 | } |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 219 | |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 220 | return 0; |
| 221 | } |
| 222 | |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 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 | |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 230 | static int workqueue_stat_headers(struct seq_file *s) |
| 231 | { |
| 232 | seq_printf(s, "# CPU INSERTED EXECUTED NAME\n"); |
Lai Jiangshan | 2f63b84 | 2009-03-25 16:59:18 +0800 | [diff] [blame] | 233 | seq_printf(s, "# | | | |\n"); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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, |
Lai Jiangshan | a357800 | 2009-07-06 16:10:23 +0800 | [diff] [blame] | 242 | .stat_release = workqueue_stat_release, |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 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 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 266 | ret = register_trace_workqueue_insertion(probe_workqueue_insertion, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 267 | if (ret) |
| 268 | goto out; |
| 269 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 270 | ret = register_trace_workqueue_execution(probe_workqueue_execution, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 271 | if (ret) |
| 272 | goto no_insertion; |
| 273 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 274 | ret = register_trace_workqueue_creation(probe_workqueue_creation, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 275 | if (ret) |
| 276 | goto no_execution; |
| 277 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 278 | ret = register_trace_workqueue_destruction(probe_workqueue_destruction, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 279 | if (ret) |
| 280 | goto no_creation; |
| 281 | |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 282 | for_each_possible_cpu(cpu) { |
Lai Jiangshan | 3690b5e | 2009-01-16 16:32:25 +0800 | [diff] [blame] | 283 | spin_lock_init(&workqueue_cpu_stat(cpu)->lock); |
| 284 | INIT_LIST_HEAD(&workqueue_cpu_stat(cpu)->list); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 285 | } |
| 286 | |
| 287 | return 0; |
| 288 | |
| 289 | no_creation: |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 290 | unregister_trace_workqueue_creation(probe_workqueue_creation, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 291 | no_execution: |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 292 | unregister_trace_workqueue_execution(probe_workqueue_execution, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 293 | no_insertion: |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 294 | unregister_trace_workqueue_insertion(probe_workqueue_insertion, NULL); |
Frederic Weisbecker | e1d8aa9 | 2009-01-12 23:15:46 +0100 | [diff] [blame] | 295 | out: |
| 296 | pr_warning("trace_workqueue: unable to trace workqueues\n"); |
| 297 | |
| 298 | return 1; |
| 299 | } |
| 300 | early_initcall(trace_workqueue_early_init); |