include/linux/tegra_profiler.h

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