misc: tegra-profiler: use power-of-2 sized buffer
[linux-3.10.git] / include / linux / tegra_profiler.h
1 /*
2  * include/linux/tegra_profiler.h
3  *
4  * Copyright (c) 2013-2017, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  */
16
17 #ifndef __TEGRA_PROFILER_H
18 #define __TEGRA_PROFILER_H
19
20 #include <linux/ioctl.h>
21
22 #define QUADD_SAMPLES_VERSION   37
23 #define QUADD_IO_VERSION        21
24
25 #define QUADD_IO_VERSION_DYNAMIC_RB             5
26 #define QUADD_IO_VERSION_RB_MAX_FILL_COUNT      6
27 #define QUADD_IO_VERSION_MOD_STATE_STATUS_FIELD 7
28 #define QUADD_IO_VERSION_BT_KERNEL_CTX          8
29 #define QUADD_IO_VERSION_GET_MMAP               9
30 #define QUADD_IO_VERSION_BT_UNWIND_TABLES       10
31 #define QUADD_IO_VERSION_UNWIND_MIXED           11
32 #define QUADD_IO_VERSION_EXTABLES_MMAP          12
33 #define QUADD_IO_VERSION_ARCH_TIMER_OPT         13
34 #define QUADD_IO_VERSION_DATA_MMAP              14
35 #define QUADD_IO_VERSION_BT_LOWER_BOUND         15
36 #define QUADD_IO_VERSION_STACK_OFFSET           16
37 #define QUADD_IO_VERSION_SECTIONS_INFO          17
38 #define QUADD_IO_VERSION_UNW_METHODS_OPT        18
39 #define QUADD_IO_VERSION_PER_CPU_SETUP          19
40 #define QUADD_IO_VERSION_TRACE_ALL_TASKS        20
41 #define QUADD_IO_VERSION_CB_POWER_OF_2          21
42
43 #define QUADD_SAMPLE_VERSION_THUMB_MODE_FLAG    17
44 #define QUADD_SAMPLE_VERSION_GROUP_SAMPLES      18
45 #define QUADD_SAMPLE_VERSION_THREAD_STATE_FLD   19
46 #define QUADD_SAMPLE_VERSION_BT_UNWIND_TABLES   22
47 #define QUADD_SAMPLE_VERSION_SUPPORT_IP64       23
48 #define QUADD_SAMPLE_VERSION_SPECIAL_MMAP       24
49 #define QUADD_SAMPLE_VERSION_UNWIND_MIXED       25
50 #define QUADD_SAMPLE_VERSION_UNW_ENTRY_TYPE     26
51 #define QUADD_SAMPLE_VERSION_USE_ARCH_TIMER     27
52 #define QUADD_SAMPLE_VERSION_SCHED_SAMPLES      28
53 #define QUADD_SAMPLE_VERSION_HDR_UNW_METHOD     29
54 #define QUADD_SAMPLE_VERSION_HDR_ARCH_TIMER     30
55 #define QUADD_SAMPLE_VERSION_STACK_OFFSET       31
56 #define QUADD_SAMPLE_VERSION_SCHED_TASK_STATE   32
57 #define QUADD_SAMPLE_VERSION_URCS               33
58 #define QUADD_SAMPLE_VERSION_HOTPLUG            34
59 #define QUADD_SAMPLE_VERSION_PER_CPU_SETUP      35
60 #define QUADD_SAMPLE_VERSION_REPORT_TGID        36
61 #define QUADD_SAMPLE_VERSION_MMAP_TS            37
62
63 #define QUADD_MMAP_HEADER_VERSION               1
64
65 #define QUADD_MAX_COUNTERS      32
66 #define QUADD_MAX_PROCESS       64
67
68 #define QUADD_DEVICE_NAME       "quadd"
69 #define QUADD_AUTH_DEVICE_NAME  "quadd_auth"
70
71 #define QUADD_MOD_DEVICE_NAME           "quadd_mod"
72 #define QUADD_MOD_AUTH_DEVICE_NAME      "quadd_mod_auth"
73
74 #define QUADD_IOCTL     100
75
76 /*
77  * Setup params (profiling frequency, etc.)
78  */
79 #define IOCTL_SETUP _IOW(QUADD_IOCTL, 0, struct quadd_parameters)
80
81 /*
82  * Start profiling.
83  */
84 #define IOCTL_START _IO(QUADD_IOCTL, 1)
85
86 /*
87  * Stop profiling.
88  */
89 #define IOCTL_STOP _IO(QUADD_IOCTL, 2)
90
91 /*
92  * Getting capabilities
93  */
94 #define IOCTL_GET_CAP _IOR(QUADD_IOCTL, 3, struct quadd_comm_cap)
95
96 /*
97  * Getting state of module
98  */
99 #define IOCTL_GET_STATE _IOR(QUADD_IOCTL, 4, struct quadd_module_state)
100
101 /*
102  * Getting version of module
103  */
104 #define IOCTL_GET_VERSION _IOR(QUADD_IOCTL, 5, struct quadd_module_version)
105
106 /*
107  * Send exception-handling tables info
108  * This ioctl is obsolete
109  */
110 /*#define IOCTL_SET_EXTAB _IOW(QUADD_IOCTL, 6, struct quadd_extables)*/
111
112 /*
113  * Send ring buffer mmap info
114  */
115 #define IOCTL_SET_MMAP_RB _IOW(QUADD_IOCTL, 7, struct quadd_mmap_rb_info)
116
117 /*
118  * Send sections info
119  */
120 #define IOCTL_SET_SECTIONS_INFO _IOW(QUADD_IOCTL, 8, struct quadd_sections)
121
122 /*
123  * Per CPU PMU setup
124  */
125 #define IOCTL_SETUP_PMU_FOR_CPU _IOW(QUADD_IOCTL, 9,\
126                                      struct quadd_pmu_setup_for_cpu)
127
128 /*
129  * Per CPU capabilities
130  */
131 #define IOCTL_GET_CAP_FOR_CPU _IOWR(QUADD_IOCTL, 10,\
132                                     struct quadd_comm_cap_for_cpu)
133
134
135
136 #define QUADD_CPUMODE_TEGRA_POWER_CLUSTER_LP    (1 << 29)       /* LP CPU */
137 #define QUADD_CPUMODE_THUMB                     (1 << 30)       /* thumb mode */
138
139 enum quadd_events_id {
140         QUADD_EVENT_TYPE_CPU_CYCLES = 0,
141
142         QUADD_EVENT_TYPE_INSTRUCTIONS,
143         QUADD_EVENT_TYPE_BRANCH_INSTRUCTIONS,
144         QUADD_EVENT_TYPE_BRANCH_MISSES,
145         QUADD_EVENT_TYPE_BUS_CYCLES,
146
147         QUADD_EVENT_TYPE_L1_DCACHE_READ_MISSES,
148         QUADD_EVENT_TYPE_L1_DCACHE_WRITE_MISSES,
149         QUADD_EVENT_TYPE_L1_ICACHE_MISSES,
150
151         QUADD_EVENT_TYPE_L2_DCACHE_READ_MISSES,
152         QUADD_EVENT_TYPE_L2_DCACHE_WRITE_MISSES,
153         QUADD_EVENT_TYPE_L2_ICACHE_MISSES,
154
155         QUADD_EVENT_TYPE_MAX,
156 };
157
158 struct event_data {
159         int event_source;
160         int event_id;
161
162         u32 val;
163         u32 prev_val;
164 };
165
166 enum quadd_record_type {
167         QUADD_RECORD_TYPE_SAMPLE = 1,
168         QUADD_RECORD_TYPE_MMAP,
169         QUADD_RECORD_TYPE_MA,
170         QUADD_RECORD_TYPE_COMM,
171         QUADD_RECORD_TYPE_DEBUG,
172         QUADD_RECORD_TYPE_HEADER,
173         QUADD_RECORD_TYPE_POWER_RATE,
174         QUADD_RECORD_TYPE_ADDITIONAL_SAMPLE,
175         QUADD_RECORD_TYPE_SCHED,
176         QUADD_RECORD_TYPE_HOTPLUG,
177 };
178
179 enum quadd_event_source {
180         QUADD_EVENT_SOURCE_PMU = 1,
181         QUADD_EVENT_SOURCE_PL310,
182 };
183
184 enum quadd_cpu_mode {
185         QUADD_CPU_MODE_KERNEL = 1,
186         QUADD_CPU_MODE_USER,
187         QUADD_CPU_MODE_NONE,
188 };
189
190 #pragma pack(push, 1)
191
192 #define QUADD_SAMPLE_RES_URCS_ENABLED   (1 << 0)
193
194 #define QUADD_SAMPLE_URC_MASK           0xff
195
196 #define QUADD_SAMPLE_URC_SHIFT_FP       0
197 #define QUADD_SAMPLE_URC_SHIFT_UT       (1 * 8)
198 #define QUADD_SAMPLE_URC_SHIFT_DWARF    (2 * 8)
199
200 enum {
201         QUADD_URC_SUCCESS = 0,
202         QUADD_URC_FAILURE,
203         QUADD_URC_IDX_NOT_FOUND,
204         QUADD_URC_TBL_NOT_EXIST,
205         QUADD_URC_EACCESS,
206         QUADD_URC_TBL_IS_CORRUPT,
207         QUADD_URC_CANTUNWIND,
208         QUADD_URC_UNHANDLED_INSTRUCTION,
209         QUADD_URC_REFUSE_TO_UNWIND,
210         QUADD_URC_SP_INCORRECT,
211         QUADD_URC_SPARE_ENCODING,
212         QUADD_URC_UNSUPPORTED_PR,
213         QUADD_URC_PC_INCORRECT,
214         QUADD_URC_LEVEL_TOO_DEEP,
215         QUADD_URC_FP_INCORRECT,
216         QUADD_URC_NONE,
217         QUADD_URC_UNWIND_MISMATCH,
218         QUADD_URC_TBL_LINK_INCORRECT,
219         QUADD_URC_MAX,
220 };
221
222 #define QUADD_SED_IP64                  (1 << 0)
223
224 #define QUADD_SED_STACK_OFFSET_SHIFT    1
225 #define QUADD_SED_STACK_OFFSET_MASK     (0xffff << QUADD_SED_STACK_OFFSET_SHIFT)
226
227 enum {
228         QUADD_UNW_TYPE_FP = 0,
229         QUADD_UNW_TYPE_UT,
230         QUADD_UNW_TYPE_LR_FP,
231         QUADD_UNW_TYPE_LR_UT,
232         QUADD_UNW_TYPE_KCTX,
233         QUADD_UNW_TYPE_DWARF_EH,
234         QUADD_UNW_TYPE_DWARF_DF,
235 };
236
237 struct quadd_sample_data {
238         u64 ip;
239         u32 pid;
240         u32 tgid;
241         u64 time;
242
243         u16     cpu:6,
244                 user_mode:1,
245                 lp_mode:1,
246                 thumb_mode:1,
247                 state:1,
248                 in_interrupt:1,
249                 reserved:5;
250
251         u8 callchain_nr;
252         u32 events_flags;
253 };
254
255 #define QUADD_MMAP_ED_IS_FILE_EXISTS    (1 << 0)
256
257 struct quadd_mmap_data {
258         u32 pid;
259         u64 time;
260
261         u64 addr;
262         u64 len;
263
264         u8 user_mode:1;
265         u16 filename_length;
266 };
267
268 struct quadd_ma_data {
269         u32 pid;
270         u64 time;
271
272         u32 vm_size;
273         u32 rss_size;
274 };
275
276 struct quadd_power_rate_data {
277         u64 time;
278
279         u8 nr_cpus;
280
281         u32 gpu;
282         u32 emc;
283 };
284
285 struct quadd_hotplug_data {
286         u64 time;
287         u32 cpu;
288
289         u32 is_online:1,
290             reserved:31;
291 };
292
293 struct quadd_additional_sample {
294         u8 type;
295
296         u32 values[6];
297         u16 extra_length;
298 };
299
300 enum {
301         QUADD_SCHED_IDX_TASK_STATE = 0,
302         QUADD_SCHED_IDX_RESERVED,
303 };
304
305 struct quadd_sched_data {
306         u32 pid;
307         u32 tgid;
308         u64 time;
309
310         u32     cpu:6,
311                 lp_mode:1,
312                 sched_in:1,
313                 reserved:24;
314
315         u32 data[2];
316 };
317
318 enum {
319         QM_DEBUG_SAMPLE_TYPE_SCHED_IN = 1,
320         QM_DEBUG_SAMPLE_TYPE_SCHED_OUT,
321
322         QM_DEBUG_SAMPLE_TYPE_TIMER_HANDLE,
323         QM_DEBUG_SAMPLE_TYPE_TIMER_START,
324         QM_DEBUG_SAMPLE_TYPE_TIMER_CANCEL,
325         QM_DEBUG_SAMPLE_TYPE_TIMER_FORWARD,
326
327         QM_DEBUG_SAMPLE_TYPE_READ_COUNTER,
328
329         QM_DEBUG_SAMPLE_TYPE_SOURCE_START,
330         QM_DEBUG_SAMPLE_TYPE_SOURCE_STOP,
331 };
332
333 struct quadd_debug_data {
334         u8 type;
335
336         u32 pid;
337         u64 time;
338
339         u16     cpu:6,
340                 user_mode:1,
341                 lp_mode:1,
342                 thumb_mode:1,
343                 reserved:7;
344
345         u32 extra_value[2];
346         u16 extra_length;
347 };
348
349 #define QUADD_HEADER_MAGIC      0x1122
350
351 #define QUADD_HDR_BT_FP                 (1 << 0)
352 #define QUADD_HDR_BT_UT                 (1 << 1)
353 #define QUADD_HDR_BT_UT_CE              (1 << 2)
354 #define QUADD_HDR_USE_ARCH_TIMER        (1 << 3)
355 #define QUADD_HDR_STACK_OFFSET          (1 << 4)
356 #define QUADD_HDR_BT_DWARF              (1 << 5)
357 #define QUADD_HDR_HAS_CPUID             (1 << 6)
358
359 struct quadd_header_data {
360         u16 magic;
361         u16 version;
362
363         u32     backtrace:1,
364                 use_freq:1,
365                 system_wide:1,
366                 power_rate:1,
367                 debug_samples:1,
368                 get_mmap:1,
369                 reserved:26;    /* reserved fields for future extensions */
370
371         u32 freq;
372         u16 ma_freq;
373         u16 power_rate_freq;
374
375         u8 nr_events;
376         u16 extra_length;
377 };
378
379 struct quadd_record_data {
380         u8 record_type;
381         u16 extra_size;
382
383         /* sample: it should be the biggest size */
384         union {
385                 struct quadd_sample_data        sample;
386                 struct quadd_mmap_data          mmap;
387                 struct quadd_ma_data            ma;
388                 struct quadd_debug_data         debug;
389                 struct quadd_header_data        hdr;
390                 struct quadd_power_rate_data    power_rate;
391                 struct quadd_hotplug_data       hotplug;
392                 struct quadd_sched_data         sched;
393                 struct quadd_additional_sample  additional_sample;
394         };
395 } __aligned(4);
396
397 #pragma pack(4)
398
399 #define QUADD_MAX_PACKAGE_NAME  320
400
401 enum {
402         QUADD_PARAM_IDX_SIZE_OF_RB      = 0,
403         QUADD_PARAM_IDX_EXTRA           = 1,
404         QUADD_PARAM_IDX_BT_LOWER_BOUND  = 2,
405 };
406
407 #define QUADD_PARAM_EXTRA_GET_MMAP              (1 << 0)
408 #define QUADD_PARAM_EXTRA_BT_FP                 (1 << 1)
409 #define QUADD_PARAM_EXTRA_BT_UT                 (1 << 2)
410 #define QUADD_PARAM_EXTRA_BT_MIXED              (1 << 3)
411 #define QUADD_PARAM_EXTRA_USE_ARCH_TIMER        (1 << 4)
412 #define QUADD_PARAM_EXTRA_STACK_OFFSET          (1 << 5)
413 #define QUADD_PARAM_EXTRA_BT_UT_CE              (1 << 6)
414 #define QUADD_PARAM_EXTRA_BT_DWARF              (1 << 7)
415 #define QUADD_PARAM_EXTRA_PER_PMU_SETUP         (1 << 8)
416
417 struct quadd_parameters {
418         u32 freq;
419         u32 ma_freq;
420         u32 power_rate_freq;
421
422         u64     backtrace:1,
423                 use_freq:1,
424                 system_wide:1,
425                 debug_samples:1,
426                 trace_all_tasks:1;
427
428         u32 pids[QUADD_MAX_PROCESS];
429         u32 nr_pids;
430
431         u8 package_name[QUADD_MAX_PACKAGE_NAME];
432
433         u32 events[QUADD_MAX_COUNTERS];
434         u32 nr_events;
435
436         u32 reserved[16];       /* reserved fields for future extensions */
437 };
438
439 struct quadd_pmu_setup_for_cpu {
440         u32 cpuid;
441         u32 events[QUADD_MAX_COUNTERS];
442         u32 nr_events;
443
444         u32 reserved[16];
445 };
446
447 struct quadd_events_cap {
448         u32     cpu_cycles:1,
449                 instructions:1,
450                 branch_instructions:1,
451                 branch_misses:1,
452                 bus_cycles:1,
453
454                 l1_dcache_read_misses:1,
455                 l1_dcache_write_misses:1,
456                 l1_icache_misses:1,
457
458                 l2_dcache_read_misses:1,
459                 l2_dcache_write_misses:1,
460                 l2_icache_misses:1;
461 };
462
463 enum {
464         QUADD_COMM_CAP_IDX_EXTRA = 0,
465         QUADD_COMM_CAP_IDX_CPU_MASK = 1,
466 };
467
468 #define QUADD_COMM_CAP_EXTRA_BT_KERNEL_CTX      (1 << 0)
469 #define QUADD_COMM_CAP_EXTRA_GET_MMAP           (1 << 1)
470 #define QUADD_COMM_CAP_EXTRA_GROUP_SAMPLES      (1 << 2)
471 #define QUADD_COMM_CAP_EXTRA_BT_UNWIND_TABLES   (1 << 3)
472 #define QUADD_COMM_CAP_EXTRA_SUPPORT_AARCH64    (1 << 4)
473 #define QUADD_COMM_CAP_EXTRA_SPECIAL_ARCH_MMAP  (1 << 5)
474 #define QUADD_COMM_CAP_EXTRA_UNWIND_MIXED       (1 << 6)
475 #define QUADD_COMM_CAP_EXTRA_UNW_ENTRY_TYPE     (1 << 7)
476 #define QUADD_COMM_CAP_EXTRA_ARCH_TIMER         (1 << 8)
477 #define QUADD_COMM_CAP_EXTRA_RB_MMAP_OP         (1 << 9)
478 #define QUADD_COMM_CAP_EXTRA_CPU_MASK           (1 << 10)
479
480 struct quadd_comm_cap {
481         u32     pmu:1,
482                 power_rate:1,
483                 l2_cache:1,
484                 l2_multiple_events:1,
485                 tegra_lp_cluster:1,
486                 blocked_read:1;
487
488         struct quadd_events_cap events_cap; /* Deprecated. */
489
490         u32 reserved[16];       /* reserved fields for future extensions */
491 };
492
493 struct quadd_comm_cap_for_cpu {
494         u32     l2_cache:1,
495                 l2_multiple_events:1;
496         int cpuid;
497         struct quadd_events_cap events_cap;
498 };
499
500 enum {
501         QUADD_MOD_STATE_IDX_RB_MAX_FILL_COUNT = 0,
502         QUADD_MOD_STATE_IDX_STATUS,
503 };
504
505 #define QUADD_MOD_STATE_STATUS_IS_ACTIVE        (1 << 0)
506 #define QUADD_MOD_STATE_STATUS_IS_AUTH_OPEN     (1 << 1)
507
508 struct quadd_module_state {
509         u64 nr_all_samples;
510         u64 nr_skipped_samples;
511
512         u32 buffer_size;
513         u32 buffer_fill_size;
514
515         u32 reserved[16];       /* reserved fields for future extensions */
516 };
517
518 struct quadd_module_version {
519         u8 branch[32];
520         u8 version[16];
521
522         u32 samples_version;
523         u32 io_version;
524
525         u32 reserved[4];        /* reserved fields for future extensions */
526 };
527
528 enum {
529         QUADD_SEC_TYPE_EXTAB = 0,
530         QUADD_SEC_TYPE_EXIDX,
531
532         QUADD_SEC_TYPE_EH_FRAME,
533         QUADD_SEC_TYPE_EH_FRAME_HDR,
534
535         QUADD_SEC_TYPE_DEBUG_FRAME,
536         QUADD_SEC_TYPE_DEBUG_FRAME_HDR,
537
538         QUADD_SEC_TYPE_MAX,
539 };
540
541 struct quadd_sec_info {
542         u64 addr;
543         u64 length;
544
545         u64 mmap_offset;
546 };
547
548 struct quadd_sections {
549         u64 vm_start;
550         u64 vm_end;
551
552         struct quadd_sec_info sec[QUADD_SEC_TYPE_MAX];
553
554         u64 user_mmap_start;
555
556         u64 reserved[4];        /* reserved fields for future extensions */
557 };
558
559 struct quadd_mmap_rb_info {
560         u32 cpu_id;
561
562         u64 vm_start;
563         u64 vm_end;
564
565         u32 reserved[4];        /* reserved fields for future extensions */
566 };
567
568 #define QUADD_MMAP_HEADER_MAGIC         0x33445566
569
570 struct quadd_mmap_header {
571         u32 magic;
572         u32 version;
573
574         u32 cpu_id;
575         u32 samples_version;
576
577         u32 reserved[4];        /* reserved fields for future extensions */
578 } __aligned(8);
579
580 enum {
581         QUADD_RB_STATE_NONE = 0,
582         QUADD_RB_STATE_ACTIVE,
583         QUADD_RB_STATE_STOPPED,
584 };
585
586 struct quadd_ring_buffer_hdr {
587         u32 state;
588         u32 size;
589
590         u32 pos_read;
591         u32 pos_write;
592
593         u32 max_fill_count;
594         u32 skipped_samples;
595
596         u32 reserved[4];        /* reserved fields for future extensions */
597 } __aligned(8);
598
599 #pragma pack(pop)
600
601 #ifdef __KERNEL__
602
603 struct task_struct;
604 struct vm_area_struct;
605
606 #ifdef CONFIG_TEGRA_PROFILER
607 extern void __quadd_task_sched_in(struct task_struct *prev,
608                                   struct task_struct *task);
609 extern void __quadd_task_sched_out(struct task_struct *prev,
610                                    struct task_struct *next);
611
612 extern void __quadd_event_mmap(struct vm_area_struct *vma);
613
614 static inline void quadd_task_sched_in(struct task_struct *prev,
615                                        struct task_struct *task)
616 {
617         __quadd_task_sched_in(prev, task);
618 }
619
620 static inline void quadd_task_sched_out(struct task_struct *prev,
621                                         struct task_struct *next)
622 {
623         __quadd_task_sched_out(prev, next);
624 }
625
626 static inline void quadd_event_mmap(struct vm_area_struct *vma)
627 {
628         __quadd_event_mmap(vma);
629 }
630
631 #else   /* CONFIG_TEGRA_PROFILER */
632
633 static inline void quadd_task_sched_in(struct task_struct *prev,
634                                        struct task_struct *task)
635 {
636 }
637
638 static inline void quadd_task_sched_out(struct task_struct *prev,
639                                         struct task_struct *next)
640 {
641 }
642
643 static inline void quadd_event_mmap(struct vm_area_struct *vma)
644 {
645 }
646
647 #endif  /* CONFIG_TEGRA_PROFILER */
648
649 #endif  /* __KERNEL__ */
650
651 #endif  /* __TEGRA_PROFILER_H */