~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_sched_wakeup.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * trace task wakeup timings
  3  *
  4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  5  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
  6  *
  7  * Based on code from the latency_tracer, that is:
  8  *
  9  *  Copyright (C) 2004-2006 Ingo Molnar
 10  *  Copyright (C) 2004 Nadia Yvette Chambers
 11  */
 12 #include <linux/module.h>
 13 #include <linux/kallsyms.h>
 14 #include <linux/uaccess.h>
 15 #include <linux/ftrace.h>
 16 #include <linux/sched/rt.h>
 17 #include <linux/sched/deadline.h>
 18 #include <trace/events/sched.h>
 19 #include "trace.h"
 20 
 21 static struct trace_array       *wakeup_trace;
 22 static int __read_mostly        tracer_enabled;
 23 
 24 static struct task_struct       *wakeup_task;
 25 static int                      wakeup_cpu;
 26 static int                      wakeup_current_cpu;
 27 static unsigned                 wakeup_prio = -1;
 28 static int                      wakeup_rt;
 29 static int                      wakeup_dl;
 30 static int                      tracing_dl = 0;
 31 
 32 static arch_spinlock_t wakeup_lock =
 33         (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 34 
 35 static void wakeup_reset(struct trace_array *tr);
 36 static void __wakeup_reset(struct trace_array *tr);
 37 static int wakeup_graph_entry(struct ftrace_graph_ent *trace);
 38 static void wakeup_graph_return(struct ftrace_graph_ret *trace);
 39 
 40 static int save_flags;
 41 static bool function_enabled;
 42 
 43 #define TRACE_DISPLAY_GRAPH     1
 44 
 45 static struct tracer_opt trace_opts[] = {
 46 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 47         /* display latency trace as call graph */
 48         { TRACER_OPT(display-graph, TRACE_DISPLAY_GRAPH) },
 49 #endif
 50         { } /* Empty entry */
 51 };
 52 
 53 static struct tracer_flags tracer_flags = {
 54         .val  = 0,
 55         .opts = trace_opts,
 56 };
 57 
 58 #define is_graph() (tracer_flags.val & TRACE_DISPLAY_GRAPH)
 59 
 60 #ifdef CONFIG_FUNCTION_TRACER
 61 
 62 /*
 63  * Prologue for the wakeup function tracers.
 64  *
 65  * Returns 1 if it is OK to continue, and preemption
 66  *            is disabled and data->disabled is incremented.
 67  *         0 if the trace is to be ignored, and preemption
 68  *            is not disabled and data->disabled is
 69  *            kept the same.
 70  *
 71  * Note, this function is also used outside this ifdef but
 72  *  inside the #ifdef of the function graph tracer below.
 73  *  This is OK, since the function graph tracer is
 74  *  dependent on the function tracer.
 75  */
 76 static int
 77 func_prolog_preempt_disable(struct trace_array *tr,
 78                             struct trace_array_cpu **data,
 79                             int *pc)
 80 {
 81         long disabled;
 82         int cpu;
 83 
 84         if (likely(!wakeup_task))
 85                 return 0;
 86 
 87         *pc = preempt_count();
 88         preempt_disable_notrace();
 89 
 90         cpu = raw_smp_processor_id();
 91         if (cpu != wakeup_current_cpu)
 92                 goto out_enable;
 93 
 94         *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
 95         disabled = atomic_inc_return(&(*data)->disabled);
 96         if (unlikely(disabled != 1))
 97                 goto out;
 98 
 99         return 1;
100 
101 out:
102         atomic_dec(&(*data)->disabled);
103 
104 out_enable:
105         preempt_enable_notrace();
106         return 0;
107 }
108 
109 /*
110  * wakeup uses its own tracer function to keep the overhead down:
111  */
112 static void
113 wakeup_tracer_call(unsigned long ip, unsigned long parent_ip,
114                    struct ftrace_ops *op, struct pt_regs *pt_regs)
115 {
116         struct trace_array *tr = wakeup_trace;
117         struct trace_array_cpu *data;
118         unsigned long flags;
119         int pc;
120 
121         if (!func_prolog_preempt_disable(tr, &data, &pc))
122                 return;
123 
124         local_irq_save(flags);
125         trace_function(tr, ip, parent_ip, flags, pc);
126         local_irq_restore(flags);
127 
128         atomic_dec(&data->disabled);
129         preempt_enable_notrace();
130 }
131 #endif /* CONFIG_FUNCTION_TRACER */
132 
133 static int register_wakeup_function(struct trace_array *tr, int graph, int set)
134 {
135         int ret;
136 
137         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
138         if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
139                 return 0;
140 
141         if (graph)
142                 ret = register_ftrace_graph(&wakeup_graph_return,
143                                             &wakeup_graph_entry);
144         else
145                 ret = register_ftrace_function(tr->ops);
146 
147         if (!ret)
148                 function_enabled = true;
149 
150         return ret;
151 }
152 
153 static void unregister_wakeup_function(struct trace_array *tr, int graph)
154 {
155         if (!function_enabled)
156                 return;
157 
158         if (graph)
159                 unregister_ftrace_graph();
160         else
161                 unregister_ftrace_function(tr->ops);
162 
163         function_enabled = false;
164 }
165 
166 static void wakeup_function_set(struct trace_array *tr, int set)
167 {
168         if (set)
169                 register_wakeup_function(tr, is_graph(), 1);
170         else
171                 unregister_wakeup_function(tr, is_graph());
172 }
173 
174 static int wakeup_flag_changed(struct trace_array *tr, u32 mask, int set)
175 {
176         struct tracer *tracer = tr->current_trace;
177 
178         if (mask & TRACE_ITER_FUNCTION)
179                 wakeup_function_set(tr, set);
180 
181         return trace_keep_overwrite(tracer, mask, set);
182 }
183 
184 static int start_func_tracer(struct trace_array *tr, int graph)
185 {
186         int ret;
187 
188         ret = register_wakeup_function(tr, graph, 0);
189 
190         if (!ret && tracing_is_enabled())
191                 tracer_enabled = 1;
192         else
193                 tracer_enabled = 0;
194 
195         return ret;
196 }
197 
198 static void stop_func_tracer(struct trace_array *tr, int graph)
199 {
200         tracer_enabled = 0;
201 
202         unregister_wakeup_function(tr, graph);
203 }
204 
205 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
206 static int
207 wakeup_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
208 {
209 
210         if (!(bit & TRACE_DISPLAY_GRAPH))
211                 return -EINVAL;
212 
213         if (!(is_graph() ^ set))
214                 return 0;
215 
216         stop_func_tracer(tr, !set);
217 
218         wakeup_reset(wakeup_trace);
219         tr->max_latency = 0;
220 
221         return start_func_tracer(tr, set);
222 }
223 
224 static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
225 {
226         struct trace_array *tr = wakeup_trace;
227         struct trace_array_cpu *data;
228         unsigned long flags;
229         int pc, ret = 0;
230 
231         if (!func_prolog_preempt_disable(tr, &data, &pc))
232                 return 0;
233 
234         local_save_flags(flags);
235         ret = __trace_graph_entry(tr, trace, flags, pc);
236         atomic_dec(&data->disabled);
237         preempt_enable_notrace();
238 
239         return ret;
240 }
241 
242 static void wakeup_graph_return(struct ftrace_graph_ret *trace)
243 {
244         struct trace_array *tr = wakeup_trace;
245         struct trace_array_cpu *data;
246         unsigned long flags;
247         int pc;
248 
249         if (!func_prolog_preempt_disable(tr, &data, &pc))
250                 return;
251 
252         local_save_flags(flags);
253         __trace_graph_return(tr, trace, flags, pc);
254         atomic_dec(&data->disabled);
255 
256         preempt_enable_notrace();
257         return;
258 }
259 
260 static void wakeup_trace_open(struct trace_iterator *iter)
261 {
262         if (is_graph())
263                 graph_trace_open(iter);
264 }
265 
266 static void wakeup_trace_close(struct trace_iterator *iter)
267 {
268         if (iter->private)
269                 graph_trace_close(iter);
270 }
271 
272 #define GRAPH_TRACER_FLAGS (TRACE_GRAPH_PRINT_PROC | \
273                             TRACE_GRAPH_PRINT_ABS_TIME | \
274                             TRACE_GRAPH_PRINT_DURATION)
275 
276 static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
277 {
278         /*
279          * In graph mode call the graph tracer output function,
280          * otherwise go with the TRACE_FN event handler
281          */
282         if (is_graph())
283                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
284 
285         return TRACE_TYPE_UNHANDLED;
286 }
287 
288 static void wakeup_print_header(struct seq_file *s)
289 {
290         if (is_graph())
291                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
292         else
293                 trace_default_header(s);
294 }
295 
296 static void
297 __trace_function(struct trace_array *tr,
298                  unsigned long ip, unsigned long parent_ip,
299                  unsigned long flags, int pc)
300 {
301         if (is_graph())
302                 trace_graph_function(tr, ip, parent_ip, flags, pc);
303         else
304                 trace_function(tr, ip, parent_ip, flags, pc);
305 }
306 #else
307 #define __trace_function trace_function
308 
309 static int
310 wakeup_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
311 {
312         return -EINVAL;
313 }
314 
315 static int wakeup_graph_entry(struct ftrace_graph_ent *trace)
316 {
317         return -1;
318 }
319 
320 static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
321 {
322         return TRACE_TYPE_UNHANDLED;
323 }
324 
325 static void wakeup_graph_return(struct ftrace_graph_ret *trace) { }
326 static void wakeup_trace_open(struct trace_iterator *iter) { }
327 static void wakeup_trace_close(struct trace_iterator *iter) { }
328 
329 #ifdef CONFIG_FUNCTION_TRACER
330 static void wakeup_print_header(struct seq_file *s)
331 {
332         trace_default_header(s);
333 }
334 #else
335 static void wakeup_print_header(struct seq_file *s)
336 {
337         trace_latency_header(s);
338 }
339 #endif /* CONFIG_FUNCTION_TRACER */
340 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
341 
342 /*
343  * Should this new latency be reported/recorded?
344  */
345 static int report_latency(struct trace_array *tr, cycle_t delta)
346 {
347         if (tracing_thresh) {
348                 if (delta < tracing_thresh)
349                         return 0;
350         } else {
351                 if (delta <= tr->max_latency)
352                         return 0;
353         }
354         return 1;
355 }
356 
357 static void
358 probe_wakeup_migrate_task(void *ignore, struct task_struct *task, int cpu)
359 {
360         if (task != wakeup_task)
361                 return;
362 
363         wakeup_current_cpu = cpu;
364 }
365 
366 static void
367 tracing_sched_switch_trace(struct trace_array *tr,
368                            struct task_struct *prev,
369                            struct task_struct *next,
370                            unsigned long flags, int pc)
371 {
372         struct trace_event_call *call = &event_context_switch;
373         struct ring_buffer *buffer = tr->trace_buffer.buffer;
374         struct ring_buffer_event *event;
375         struct ctx_switch_entry *entry;
376 
377         event = trace_buffer_lock_reserve(buffer, TRACE_CTX,
378                                           sizeof(*entry), flags, pc);
379         if (!event)
380                 return;
381         entry   = ring_buffer_event_data(event);
382         entry->prev_pid                 = prev->pid;
383         entry->prev_prio                = prev->prio;
384         entry->prev_state               = prev->state;
385         entry->next_pid                 = next->pid;
386         entry->next_prio                = next->prio;
387         entry->next_state               = next->state;
388         entry->next_cpu = task_cpu(next);
389 
390         if (!call_filter_check_discard(call, entry, buffer, event))
391                 trace_buffer_unlock_commit(buffer, event, flags, pc);
392 }
393 
394 static void
395 tracing_sched_wakeup_trace(struct trace_array *tr,
396                            struct task_struct *wakee,
397                            struct task_struct *curr,
398                            unsigned long flags, int pc)
399 {
400         struct trace_event_call *call = &event_wakeup;
401         struct ring_buffer_event *event;
402         struct ctx_switch_entry *entry;
403         struct ring_buffer *buffer = tr->trace_buffer.buffer;
404 
405         event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
406                                           sizeof(*entry), flags, pc);
407         if (!event)
408                 return;
409         entry   = ring_buffer_event_data(event);
410         entry->prev_pid                 = curr->pid;
411         entry->prev_prio                = curr->prio;
412         entry->prev_state               = curr->state;
413         entry->next_pid                 = wakee->pid;
414         entry->next_prio                = wakee->prio;
415         entry->next_state               = wakee->state;
416         entry->next_cpu                 = task_cpu(wakee);
417 
418         if (!call_filter_check_discard(call, entry, buffer, event))
419                 trace_buffer_unlock_commit(buffer, event, flags, pc);
420 }
421 
422 static void notrace
423 probe_wakeup_sched_switch(void *ignore,
424                           struct task_struct *prev, struct task_struct *next)
425 {
426         struct trace_array_cpu *data;
427         cycle_t T0, T1, delta;
428         unsigned long flags;
429         long disabled;
430         int cpu;
431         int pc;
432 
433         tracing_record_cmdline(prev);
434 
435         if (unlikely(!tracer_enabled))
436                 return;
437 
438         /*
439          * When we start a new trace, we set wakeup_task to NULL
440          * and then set tracer_enabled = 1. We want to make sure
441          * that another CPU does not see the tracer_enabled = 1
442          * and the wakeup_task with an older task, that might
443          * actually be the same as next.
444          */
445         smp_rmb();
446 
447         if (next != wakeup_task)
448                 return;
449 
450         pc = preempt_count();
451 
452         /* disable local data, not wakeup_cpu data */
453         cpu = raw_smp_processor_id();
454         disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
455         if (likely(disabled != 1))
456                 goto out;
457 
458         local_irq_save(flags);
459         arch_spin_lock(&wakeup_lock);
460 
461         /* We could race with grabbing wakeup_lock */
462         if (unlikely(!tracer_enabled || next != wakeup_task))
463                 goto out_unlock;
464 
465         /* The task we are waiting for is waking up */
466         data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
467 
468         __trace_function(wakeup_trace, CALLER_ADDR0, CALLER_ADDR1, flags, pc);
469         tracing_sched_switch_trace(wakeup_trace, prev, next, flags, pc);
470 
471         T0 = data->preempt_timestamp;
472         T1 = ftrace_now(cpu);
473         delta = T1-T0;
474 
475         if (!report_latency(wakeup_trace, delta))
476                 goto out_unlock;
477 
478         if (likely(!is_tracing_stopped())) {
479                 wakeup_trace->max_latency = delta;
480                 update_max_tr(wakeup_trace, wakeup_task, wakeup_cpu);
481         }
482 
483 out_unlock:
484         __wakeup_reset(wakeup_trace);
485         arch_spin_unlock(&wakeup_lock);
486         local_irq_restore(flags);
487 out:
488         atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
489 }
490 
491 static void __wakeup_reset(struct trace_array *tr)
492 {
493         wakeup_cpu = -1;
494         wakeup_prio = -1;
495         tracing_dl = 0;
496 
497         if (wakeup_task)
498                 put_task_struct(wakeup_task);
499 
500         wakeup_task = NULL;
501 }
502 
503 static void wakeup_reset(struct trace_array *tr)
504 {
505         unsigned long flags;
506 
507         tracing_reset_online_cpus(&tr->trace_buffer);
508 
509         local_irq_save(flags);
510         arch_spin_lock(&wakeup_lock);
511         __wakeup_reset(tr);
512         arch_spin_unlock(&wakeup_lock);
513         local_irq_restore(flags);
514 }
515 
516 static void
517 probe_wakeup(void *ignore, struct task_struct *p)
518 {
519         struct trace_array_cpu *data;
520         int cpu = smp_processor_id();
521         unsigned long flags;
522         long disabled;
523         int pc;
524 
525         if (likely(!tracer_enabled))
526                 return;
527 
528         tracing_record_cmdline(p);
529         tracing_record_cmdline(current);
530 
531         /*
532          * Semantic is like this:
533          *  - wakeup tracer handles all tasks in the system, independently
534          *    from their scheduling class;
535          *  - wakeup_rt tracer handles tasks belonging to sched_dl and
536          *    sched_rt class;
537          *  - wakeup_dl handles tasks belonging to sched_dl class only.
538          */
539         if (tracing_dl || (wakeup_dl && !dl_task(p)) ||
540             (wakeup_rt && !dl_task(p) && !rt_task(p)) ||
541             (!dl_task(p) && (p->prio >= wakeup_prio || p->prio >= current->prio)))
542                 return;
543 
544         pc = preempt_count();
545         disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
546         if (unlikely(disabled != 1))
547                 goto out;
548 
549         /* interrupts should be off from try_to_wake_up */
550         arch_spin_lock(&wakeup_lock);
551 
552         /* check for races. */
553         if (!tracer_enabled || tracing_dl ||
554             (!dl_task(p) && p->prio >= wakeup_prio))
555                 goto out_locked;
556 
557         /* reset the trace */
558         __wakeup_reset(wakeup_trace);
559 
560         wakeup_cpu = task_cpu(p);
561         wakeup_current_cpu = wakeup_cpu;
562         wakeup_prio = p->prio;
563 
564         /*
565          * Once you start tracing a -deadline task, don't bother tracing
566          * another task until the first one wakes up.
567          */
568         if (dl_task(p))
569                 tracing_dl = 1;
570         else
571                 tracing_dl = 0;
572 
573         wakeup_task = p;
574         get_task_struct(wakeup_task);
575 
576         local_save_flags(flags);
577 
578         data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
579         data->preempt_timestamp = ftrace_now(cpu);
580         tracing_sched_wakeup_trace(wakeup_trace, p, current, flags, pc);
581 
582         /*
583          * We must be careful in using CALLER_ADDR2. But since wake_up
584          * is not called by an assembly function  (where as schedule is)
585          * it should be safe to use it here.
586          */
587         __trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
588 
589 out_locked:
590         arch_spin_unlock(&wakeup_lock);
591 out:
592         atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
593 }
594 
595 static void start_wakeup_tracer(struct trace_array *tr)
596 {
597         int ret;
598 
599         ret = register_trace_sched_wakeup(probe_wakeup, NULL);
600         if (ret) {
601                 pr_info("wakeup trace: Couldn't activate tracepoint"
602                         " probe to kernel_sched_wakeup\n");
603                 return;
604         }
605 
606         ret = register_trace_sched_wakeup_new(probe_wakeup, NULL);
607         if (ret) {
608                 pr_info("wakeup trace: Couldn't activate tracepoint"
609                         " probe to kernel_sched_wakeup_new\n");
610                 goto fail_deprobe;
611         }
612 
613         ret = register_trace_sched_switch(probe_wakeup_sched_switch, NULL);
614         if (ret) {
615                 pr_info("sched trace: Couldn't activate tracepoint"
616                         " probe to kernel_sched_switch\n");
617                 goto fail_deprobe_wake_new;
618         }
619 
620         ret = register_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
621         if (ret) {
622                 pr_info("wakeup trace: Couldn't activate tracepoint"
623                         " probe to kernel_sched_migrate_task\n");
624                 return;
625         }
626 
627         wakeup_reset(tr);
628 
629         /*
630          * Don't let the tracer_enabled = 1 show up before
631          * the wakeup_task is reset. This may be overkill since
632          * wakeup_reset does a spin_unlock after setting the
633          * wakeup_task to NULL, but I want to be safe.
634          * This is a slow path anyway.
635          */
636         smp_wmb();
637 
638         if (start_func_tracer(tr, is_graph()))
639                 printk(KERN_ERR "failed to start wakeup tracer\n");
640 
641         return;
642 fail_deprobe_wake_new:
643         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
644 fail_deprobe:
645         unregister_trace_sched_wakeup(probe_wakeup, NULL);
646 }
647 
648 static void stop_wakeup_tracer(struct trace_array *tr)
649 {
650         tracer_enabled = 0;
651         stop_func_tracer(tr, is_graph());
652         unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
653         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
654         unregister_trace_sched_wakeup(probe_wakeup, NULL);
655         unregister_trace_sched_migrate_task(probe_wakeup_migrate_task, NULL);
656 }
657 
658 static bool wakeup_busy;
659 
660 static int __wakeup_tracer_init(struct trace_array *tr)
661 {
662         save_flags = trace_flags;
663 
664         /* non overwrite screws up the latency tracers */
665         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
666         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, 1);
667 
668         tr->max_latency = 0;
669         wakeup_trace = tr;
670         ftrace_init_array_ops(tr, wakeup_tracer_call);
671         start_wakeup_tracer(tr);
672 
673         wakeup_busy = true;
674         return 0;
675 }
676 
677 static int wakeup_tracer_init(struct trace_array *tr)
678 {
679         if (wakeup_busy)
680                 return -EBUSY;
681 
682         wakeup_dl = 0;
683         wakeup_rt = 0;
684         return __wakeup_tracer_init(tr);
685 }
686 
687 static int wakeup_rt_tracer_init(struct trace_array *tr)
688 {
689         if (wakeup_busy)
690                 return -EBUSY;
691 
692         wakeup_dl = 0;
693         wakeup_rt = 1;
694         return __wakeup_tracer_init(tr);
695 }
696 
697 static int wakeup_dl_tracer_init(struct trace_array *tr)
698 {
699         if (wakeup_busy)
700                 return -EBUSY;
701 
702         wakeup_dl = 1;
703         wakeup_rt = 0;
704         return __wakeup_tracer_init(tr);
705 }
706 
707 static void wakeup_tracer_reset(struct trace_array *tr)
708 {
709         int lat_flag = save_flags & TRACE_ITER_LATENCY_FMT;
710         int overwrite_flag = save_flags & TRACE_ITER_OVERWRITE;
711 
712         stop_wakeup_tracer(tr);
713         /* make sure we put back any tasks we are tracing */
714         wakeup_reset(tr);
715 
716         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
717         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
718         ftrace_reset_array_ops(tr);
719         wakeup_busy = false;
720 }
721 
722 static void wakeup_tracer_start(struct trace_array *tr)
723 {
724         wakeup_reset(tr);
725         tracer_enabled = 1;
726 }
727 
728 static void wakeup_tracer_stop(struct trace_array *tr)
729 {
730         tracer_enabled = 0;
731 }
732 
733 static struct tracer wakeup_tracer __read_mostly =
734 {
735         .name           = "wakeup",
736         .init           = wakeup_tracer_init,
737         .reset          = wakeup_tracer_reset,
738         .start          = wakeup_tracer_start,
739         .stop           = wakeup_tracer_stop,
740         .print_max      = true,
741         .print_header   = wakeup_print_header,
742         .print_line     = wakeup_print_line,
743         .flags          = &tracer_flags,
744         .set_flag       = wakeup_set_flag,
745         .flag_changed   = wakeup_flag_changed,
746 #ifdef CONFIG_FTRACE_SELFTEST
747         .selftest    = trace_selftest_startup_wakeup,
748 #endif
749         .open           = wakeup_trace_open,
750         .close          = wakeup_trace_close,
751         .allow_instances = true,
752         .use_max_tr     = true,
753 };
754 
755 static struct tracer wakeup_rt_tracer __read_mostly =
756 {
757         .name           = "wakeup_rt",
758         .init           = wakeup_rt_tracer_init,
759         .reset          = wakeup_tracer_reset,
760         .start          = wakeup_tracer_start,
761         .stop           = wakeup_tracer_stop,
762         .print_max      = true,
763         .print_header   = wakeup_print_header,
764         .print_line     = wakeup_print_line,
765         .flags          = &tracer_flags,
766         .set_flag       = wakeup_set_flag,
767         .flag_changed   = wakeup_flag_changed,
768 #ifdef CONFIG_FTRACE_SELFTEST
769         .selftest    = trace_selftest_startup_wakeup,
770 #endif
771         .open           = wakeup_trace_open,
772         .close          = wakeup_trace_close,
773         .allow_instances = true,
774         .use_max_tr     = true,
775 };
776 
777 static struct tracer wakeup_dl_tracer __read_mostly =
778 {
779         .name           = "wakeup_dl",
780         .init           = wakeup_dl_tracer_init,
781         .reset          = wakeup_tracer_reset,
782         .start          = wakeup_tracer_start,
783         .stop           = wakeup_tracer_stop,
784         .print_max      = true,
785         .print_header   = wakeup_print_header,
786         .print_line     = wakeup_print_line,
787         .flags          = &tracer_flags,
788         .set_flag       = wakeup_set_flag,
789         .flag_changed   = wakeup_flag_changed,
790 #ifdef CONFIG_FTRACE_SELFTEST
791         .selftest    = trace_selftest_startup_wakeup,
792 #endif
793         .open           = wakeup_trace_open,
794         .close          = wakeup_trace_close,
795         .use_max_tr     = true,
796 };
797 
798 __init static int init_wakeup_tracer(void)
799 {
800         int ret;
801 
802         ret = register_tracer(&wakeup_tracer);
803         if (ret)
804                 return ret;
805 
806         ret = register_tracer(&wakeup_rt_tracer);
807         if (ret)
808                 return ret;
809 
810         ret = register_tracer(&wakeup_dl_tracer);
811         if (ret)
812                 return ret;
813 
814         return 0;
815 }
816 core_initcall(init_wakeup_tracer);
817 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp