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

TOMOYO Linux Cross Reference
Linux/include/trace/events/power.h

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ 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.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 /* SPDX-License-Identifier: GPL-2.0 */
  2 #undef TRACE_SYSTEM
  3 #define TRACE_SYSTEM power
  4 
  5 #if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
  6 #define _TRACE_POWER_H
  7 
  8 #include <linux/cpufreq.h>
  9 #include <linux/ktime.h>
 10 #include <linux/pm_qos.h>
 11 #include <linux/tracepoint.h>
 12 #include <linux/trace_events.h>
 13 
 14 #define TPS(x)  tracepoint_string(x)
 15 
 16 DECLARE_EVENT_CLASS(cpu,
 17 
 18         TP_PROTO(unsigned int state, unsigned int cpu_id),
 19 
 20         TP_ARGS(state, cpu_id),
 21 
 22         TP_STRUCT__entry(
 23                 __field(        u32,            state           )
 24                 __field(        u32,            cpu_id          )
 25         ),
 26 
 27         TP_fast_assign(
 28                 __entry->state = state;
 29                 __entry->cpu_id = cpu_id;
 30         ),
 31 
 32         TP_printk("state=%lu cpu_id=%lu", (unsigned long)__entry->state,
 33                   (unsigned long)__entry->cpu_id)
 34 );
 35 
 36 DEFINE_EVENT(cpu, cpu_idle,
 37 
 38         TP_PROTO(unsigned int state, unsigned int cpu_id),
 39 
 40         TP_ARGS(state, cpu_id)
 41 );
 42 
 43 TRACE_EVENT(powernv_throttle,
 44 
 45         TP_PROTO(int chip_id, const char *reason, int pmax),
 46 
 47         TP_ARGS(chip_id, reason, pmax),
 48 
 49         TP_STRUCT__entry(
 50                 __field(int, chip_id)
 51                 __string(reason, reason)
 52                 __field(int, pmax)
 53         ),
 54 
 55         TP_fast_assign(
 56                 __entry->chip_id = chip_id;
 57                 __assign_str(reason, reason);
 58                 __entry->pmax = pmax;
 59         ),
 60 
 61         TP_printk("Chip %d Pmax %d %s", __entry->chip_id,
 62                   __entry->pmax, __get_str(reason))
 63 );
 64 
 65 TRACE_EVENT(pstate_sample,
 66 
 67         TP_PROTO(u32 core_busy,
 68                 u32 scaled_busy,
 69                 u32 from,
 70                 u32 to,
 71                 u64 mperf,
 72                 u64 aperf,
 73                 u64 tsc,
 74                 u32 freq,
 75                 u32 io_boost
 76                 ),
 77 
 78         TP_ARGS(core_busy,
 79                 scaled_busy,
 80                 from,
 81                 to,
 82                 mperf,
 83                 aperf,
 84                 tsc,
 85                 freq,
 86                 io_boost
 87                 ),
 88 
 89         TP_STRUCT__entry(
 90                 __field(u32, core_busy)
 91                 __field(u32, scaled_busy)
 92                 __field(u32, from)
 93                 __field(u32, to)
 94                 __field(u64, mperf)
 95                 __field(u64, aperf)
 96                 __field(u64, tsc)
 97                 __field(u32, freq)
 98                 __field(u32, io_boost)
 99                 ),
100 
101         TP_fast_assign(
102                 __entry->core_busy = core_busy;
103                 __entry->scaled_busy = scaled_busy;
104                 __entry->from = from;
105                 __entry->to = to;
106                 __entry->mperf = mperf;
107                 __entry->aperf = aperf;
108                 __entry->tsc = tsc;
109                 __entry->freq = freq;
110                 __entry->io_boost = io_boost;
111                 ),
112 
113         TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%lu io_boost=%lu",
114                 (unsigned long)__entry->core_busy,
115                 (unsigned long)__entry->scaled_busy,
116                 (unsigned long)__entry->from,
117                 (unsigned long)__entry->to,
118                 (unsigned long long)__entry->mperf,
119                 (unsigned long long)__entry->aperf,
120                 (unsigned long long)__entry->tsc,
121                 (unsigned long)__entry->freq,
122                 (unsigned long)__entry->io_boost
123                 )
124 
125 );
126 
127 /* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */
128 #ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING
129 #define _PWR_EVENT_AVOID_DOUBLE_DEFINING
130 
131 #define PWR_EVENT_EXIT -1
132 #endif
133 
134 #define pm_verb_symbolic(event) \
135         __print_symbolic(event, \
136                 { PM_EVENT_SUSPEND, "suspend" }, \
137                 { PM_EVENT_RESUME, "resume" }, \
138                 { PM_EVENT_FREEZE, "freeze" }, \
139                 { PM_EVENT_QUIESCE, "quiesce" }, \
140                 { PM_EVENT_HIBERNATE, "hibernate" }, \
141                 { PM_EVENT_THAW, "thaw" }, \
142                 { PM_EVENT_RESTORE, "restore" }, \
143                 { PM_EVENT_RECOVER, "recover" })
144 
145 DEFINE_EVENT(cpu, cpu_frequency,
146 
147         TP_PROTO(unsigned int frequency, unsigned int cpu_id),
148 
149         TP_ARGS(frequency, cpu_id)
150 );
151 
152 TRACE_EVENT(cpu_frequency_limits,
153 
154         TP_PROTO(struct cpufreq_policy *policy),
155 
156         TP_ARGS(policy),
157 
158         TP_STRUCT__entry(
159                 __field(u32, min_freq)
160                 __field(u32, max_freq)
161                 __field(u32, cpu_id)
162         ),
163 
164         TP_fast_assign(
165                 __entry->min_freq = policy->min;
166                 __entry->max_freq = policy->max;
167                 __entry->cpu_id = policy->cpu;
168         ),
169 
170         TP_printk("min=%lu max=%lu cpu_id=%lu",
171                   (unsigned long)__entry->min_freq,
172                   (unsigned long)__entry->max_freq,
173                   (unsigned long)__entry->cpu_id)
174 );
175 
176 TRACE_EVENT(device_pm_callback_start,
177 
178         TP_PROTO(struct device *dev, const char *pm_ops, int event),
179 
180         TP_ARGS(dev, pm_ops, event),
181 
182         TP_STRUCT__entry(
183                 __string(device, dev_name(dev))
184                 __string(driver, dev_driver_string(dev))
185                 __string(parent, dev->parent ? dev_name(dev->parent) : "none")
186                 __string(pm_ops, pm_ops ? pm_ops : "none ")
187                 __field(int, event)
188         ),
189 
190         TP_fast_assign(
191                 __assign_str(device, dev_name(dev));
192                 __assign_str(driver, dev_driver_string(dev));
193                 __assign_str(parent,
194                         dev->parent ? dev_name(dev->parent) : "none");
195                 __assign_str(pm_ops, pm_ops ? pm_ops : "none ");
196                 __entry->event = event;
197         ),
198 
199         TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
200                 __get_str(device), __get_str(parent), __get_str(pm_ops),
201                 pm_verb_symbolic(__entry->event))
202 );
203 
204 TRACE_EVENT(device_pm_callback_end,
205 
206         TP_PROTO(struct device *dev, int error),
207 
208         TP_ARGS(dev, error),
209 
210         TP_STRUCT__entry(
211                 __string(device, dev_name(dev))
212                 __string(driver, dev_driver_string(dev))
213                 __field(int, error)
214         ),
215 
216         TP_fast_assign(
217                 __assign_str(device, dev_name(dev));
218                 __assign_str(driver, dev_driver_string(dev));
219                 __entry->error = error;
220         ),
221 
222         TP_printk("%s %s, err=%d",
223                 __get_str(driver), __get_str(device), __entry->error)
224 );
225 
226 TRACE_EVENT(suspend_resume,
227 
228         TP_PROTO(const char *action, int val, bool start),
229 
230         TP_ARGS(action, val, start),
231 
232         TP_STRUCT__entry(
233                 __field(const char *, action)
234                 __field(int, val)
235                 __field(bool, start)
236         ),
237 
238         TP_fast_assign(
239                 __entry->action = action;
240                 __entry->val = val;
241                 __entry->start = start;
242         ),
243 
244         TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
245                 (__entry->start)?"begin":"end")
246 );
247 
248 DECLARE_EVENT_CLASS(wakeup_source,
249 
250         TP_PROTO(const char *name, unsigned int state),
251 
252         TP_ARGS(name, state),
253 
254         TP_STRUCT__entry(
255                 __string(       name,           name            )
256                 __field(        u64,            state           )
257         ),
258 
259         TP_fast_assign(
260                 __assign_str(name, name);
261                 __entry->state = state;
262         ),
263 
264         TP_printk("%s state=0x%lx", __get_str(name),
265                 (unsigned long)__entry->state)
266 );
267 
268 DEFINE_EVENT(wakeup_source, wakeup_source_activate,
269 
270         TP_PROTO(const char *name, unsigned int state),
271 
272         TP_ARGS(name, state)
273 );
274 
275 DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
276 
277         TP_PROTO(const char *name, unsigned int state),
278 
279         TP_ARGS(name, state)
280 );
281 
282 /*
283  * The clock events are used for clock enable/disable and for
284  *  clock rate change
285  */
286 DECLARE_EVENT_CLASS(clock,
287 
288         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
289 
290         TP_ARGS(name, state, cpu_id),
291 
292         TP_STRUCT__entry(
293                 __string(       name,           name            )
294                 __field(        u64,            state           )
295                 __field(        u64,            cpu_id          )
296         ),
297 
298         TP_fast_assign(
299                 __assign_str(name, name);
300                 __entry->state = state;
301                 __entry->cpu_id = cpu_id;
302         ),
303 
304         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
305                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
306 );
307 
308 DEFINE_EVENT(clock, clock_enable,
309 
310         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
311 
312         TP_ARGS(name, state, cpu_id)
313 );
314 
315 DEFINE_EVENT(clock, clock_disable,
316 
317         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
318 
319         TP_ARGS(name, state, cpu_id)
320 );
321 
322 DEFINE_EVENT(clock, clock_set_rate,
323 
324         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
325 
326         TP_ARGS(name, state, cpu_id)
327 );
328 
329 /*
330  * The power domain events are used for power domains transitions
331  */
332 DECLARE_EVENT_CLASS(power_domain,
333 
334         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
335 
336         TP_ARGS(name, state, cpu_id),
337 
338         TP_STRUCT__entry(
339                 __string(       name,           name            )
340                 __field(        u64,            state           )
341                 __field(        u64,            cpu_id          )
342         ),
343 
344         TP_fast_assign(
345                 __assign_str(name, name);
346                 __entry->state = state;
347                 __entry->cpu_id = cpu_id;
348 ),
349 
350         TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
351                 (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
352 );
353 
354 DEFINE_EVENT(power_domain, power_domain_target,
355 
356         TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
357 
358         TP_ARGS(name, state, cpu_id)
359 );
360 
361 /*
362  * The pm qos events are used for pm qos update
363  */
364 DECLARE_EVENT_CLASS(pm_qos_request,
365 
366         TP_PROTO(int pm_qos_class, s32 value),
367 
368         TP_ARGS(pm_qos_class, value),
369 
370         TP_STRUCT__entry(
371                 __field( int,                    pm_qos_class   )
372                 __field( s32,                    value          )
373         ),
374 
375         TP_fast_assign(
376                 __entry->pm_qos_class = pm_qos_class;
377                 __entry->value = value;
378         ),
379 
380         TP_printk("pm_qos_class=%s value=%d",
381                   __print_symbolic(__entry->pm_qos_class,
382                         { PM_QOS_CPU_DMA_LATENCY,       "CPU_DMA_LATENCY" },
383                         { PM_QOS_NETWORK_LATENCY,       "NETWORK_LATENCY" },
384                         { PM_QOS_NETWORK_THROUGHPUT,    "NETWORK_THROUGHPUT" }),
385                   __entry->value)
386 );
387 
388 DEFINE_EVENT(pm_qos_request, pm_qos_add_request,
389 
390         TP_PROTO(int pm_qos_class, s32 value),
391 
392         TP_ARGS(pm_qos_class, value)
393 );
394 
395 DEFINE_EVENT(pm_qos_request, pm_qos_update_request,
396 
397         TP_PROTO(int pm_qos_class, s32 value),
398 
399         TP_ARGS(pm_qos_class, value)
400 );
401 
402 DEFINE_EVENT(pm_qos_request, pm_qos_remove_request,
403 
404         TP_PROTO(int pm_qos_class, s32 value),
405 
406         TP_ARGS(pm_qos_class, value)
407 );
408 
409 TRACE_EVENT(pm_qos_update_request_timeout,
410 
411         TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us),
412 
413         TP_ARGS(pm_qos_class, value, timeout_us),
414 
415         TP_STRUCT__entry(
416                 __field( int,                    pm_qos_class   )
417                 __field( s32,                    value          )
418                 __field( unsigned long,          timeout_us     )
419         ),
420 
421         TP_fast_assign(
422                 __entry->pm_qos_class = pm_qos_class;
423                 __entry->value = value;
424                 __entry->timeout_us = timeout_us;
425         ),
426 
427         TP_printk("pm_qos_class=%s value=%d, timeout_us=%ld",
428                   __print_symbolic(__entry->pm_qos_class,
429                         { PM_QOS_CPU_DMA_LATENCY,       "CPU_DMA_LATENCY" },
430                         { PM_QOS_NETWORK_LATENCY,       "NETWORK_LATENCY" },
431                         { PM_QOS_NETWORK_THROUGHPUT,    "NETWORK_THROUGHPUT" }),
432                   __entry->value, __entry->timeout_us)
433 );
434 
435 DECLARE_EVENT_CLASS(pm_qos_update,
436 
437         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
438 
439         TP_ARGS(action, prev_value, curr_value),
440 
441         TP_STRUCT__entry(
442                 __field( enum pm_qos_req_action, action         )
443                 __field( int,                    prev_value     )
444                 __field( int,                    curr_value     )
445         ),
446 
447         TP_fast_assign(
448                 __entry->action = action;
449                 __entry->prev_value = prev_value;
450                 __entry->curr_value = curr_value;
451         ),
452 
453         TP_printk("action=%s prev_value=%d curr_value=%d",
454                   __print_symbolic(__entry->action,
455                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
456                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
457                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
458                   __entry->prev_value, __entry->curr_value)
459 );
460 
461 DEFINE_EVENT(pm_qos_update, pm_qos_update_target,
462 
463         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
464 
465         TP_ARGS(action, prev_value, curr_value)
466 );
467 
468 DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,
469 
470         TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
471 
472         TP_ARGS(action, prev_value, curr_value),
473 
474         TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
475                   __print_symbolic(__entry->action,
476                         { PM_QOS_ADD_REQ,       "ADD_REQ" },
477                         { PM_QOS_UPDATE_REQ,    "UPDATE_REQ" },
478                         { PM_QOS_REMOVE_REQ,    "REMOVE_REQ" }),
479                   __entry->prev_value, __entry->curr_value)
480 );
481 
482 DECLARE_EVENT_CLASS(dev_pm_qos_request,
483 
484         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
485                  s32 new_value),
486 
487         TP_ARGS(name, type, new_value),
488 
489         TP_STRUCT__entry(
490                 __string( name,                    name         )
491                 __field( enum dev_pm_qos_req_type, type         )
492                 __field( s32,                      new_value    )
493         ),
494 
495         TP_fast_assign(
496                 __assign_str(name, name);
497                 __entry->type = type;
498                 __entry->new_value = new_value;
499         ),
500 
501         TP_printk("device=%s type=%s new_value=%d",
502                   __get_str(name),
503                   __print_symbolic(__entry->type,
504                         { DEV_PM_QOS_RESUME_LATENCY, "DEV_PM_QOS_RESUME_LATENCY" },
505                         { DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
506                   __entry->new_value)
507 );
508 
509 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,
510 
511         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
512                  s32 new_value),
513 
514         TP_ARGS(name, type, new_value)
515 );
516 
517 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,
518 
519         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
520                  s32 new_value),
521 
522         TP_ARGS(name, type, new_value)
523 );
524 
525 DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
526 
527         TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
528                  s32 new_value),
529 
530         TP_ARGS(name, type, new_value)
531 );
532 #endif /* _TRACE_POWER_H */
533 
534 /* This part must be outside protection */
535 #include <trace/define_trace.h>
536 

~ [ 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