bsd/sys/monotonic.h

   1 /*
   2  * Copyright (c) 2017-2019 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #ifndef SYS_MONOTONIC_H
  30 #define SYS_MONOTONIC_H
  31
  32 #include <stdbool.h>
  33 #include <stdint.h>
  34 #include <sys/cdefs.h>
  35
  36 __BEGIN_DECLS
  37
  38 struct mt_cpu_inscyc {
  39         uint64_t mtci_instructions;
  40         uint64_t mtci_cycles;
  41 };
  42
  43 __END_DECLS
  44
  45 #if !MACH_KERNEL_PRIVATE
  46
  47 #include <sys/ioccom.h>
  48
  49 __BEGIN_DECLS
  50
  51 /*
  52  * XXX These declarations are subject to change at any time.
  53  */
  54
  55 #define MT_IOC(x) _IO('m', (x))
  56 #define MT_IOC_RESET MT_IOC(0)
  57 #define MT_IOC_ADD MT_IOC(1)
  58 #define MT_IOC_ENABLE MT_IOC(2)
  59 #define MT_IOC_COUNTS MT_IOC(3)
  60 #define MT_IOC_GET_INFO MT_IOC(4)
  61
  62 __END_DECLS
  63
  64 #endif /* !MACH_KERNEL_PRIVATE */
  65
  66 __BEGIN_DECLS
  67
  68 struct monotonic_config {
  69         uint64_t event;
  70         uint64_t allowed_ctr_mask;
  71         uint64_t cpu_mask;
  72 };
  73
  74 union monotonic_ctl_add {
  75         struct {
  76                 struct monotonic_config config;
  77         } in;
  78
  79         struct {
  80                 uint32_t ctr;
  81         } out;
  82 };
  83
  84 union monotonic_ctl_enable {
  85         struct {
  86                 bool enable;
  87         } in;
  88 };
  89
  90
  91 union monotonic_ctl_counts {
  92         struct {
  93                 uint64_t ctr_mask;
  94         } in;
  95
  96         struct {
  97                 uint64_t counts[1];
  98         } out;
  99 };
 100
 101
 102 union monotonic_ctl_info {
 103         struct {
 104                 unsigned int nmonitors;
 105                 unsigned int ncounters;
 106         } out;
 107 };
 108
 109 __END_DECLS
 110
 111 #if XNU_KERNEL_PRIVATE
 112
 113 #if MONOTONIC
 114
 115 #include <kern/monotonic.h>
 116 #include <machine/monotonic.h>
 117 #include <sys/kdebug.h>
 118 #include <kern/locks.h>
 119
 120 __BEGIN_DECLS
 121
 122 #ifdef MT_CORE_INSTRS
 123 #define COUNTS_INSTRS __counts[MT_CORE_INSTRS]
 124 #else /* defined(MT_CORE_INSTRS) */
 125 #define COUNTS_INSTRS 0
 126 #endif /* !defined(MT_CORE_INSTRS) */
 127
 128 /*
 129  * MT_KDBG_TMP* macros are meant for temporary (i.e. not checked-in)
 130  * performance investigations.
 131  */
 132
 133 /*
 134  * Record the current CPU counters.
 135  *
 136  * Preemption must be disabled.
 137  */
 138 #define MT_KDBG_TMPCPU_EVT(CODE) \
 139         KDBG_EVENTID(DBG_MONOTONIC, DBG_MT_TMPCPU, CODE)
 140
 141 #define MT_KDBG_TMPCPU_(CODE, FUNC) \
 142         do { \
 143                 if (kdebug_enable && \
 144                                 kdebug_debugid_enabled(MT_KDBG_TMPCPU_EVT(CODE))) { \
 145                         uint64_t __counts[MT_CORE_NFIXED]; \
 146                         mt_fixed_counts(__counts); \
 147                         KDBG(MT_KDBG_TMPCPU_EVT(CODE) | (FUNC), COUNTS_INSTRS, \
 148                                         __counts[MT_CORE_CYCLES]); \
 149                 } \
 150         } while (0)
 151
 152 #define MT_KDBG_TMPCPU(CODE) MT_KDBG_TMPCPU_(CODE, DBG_FUNC_NONE)
 153 #define MT_KDBG_TMPCPU_START(CODE) MT_KDBG_TMPCPU_(CODE, DBG_FUNC_START)
 154 #define MT_KDBG_TMPCPU_END(CODE) MT_KDBG_TMPCPU_(CODE, DBG_FUNC_END)
 155
 156 /*
 157  * Record the current thread counters.
 158  *
 159  * Interrupts must be disabled.
 160  */
 161 #define MT_KDBG_TMPTH_EVT(CODE) \
 162         KDBG_EVENTID(DBG_MONOTONIC, DBG_MT_TMPTH, CODE)
 163
 164 #define MT_KDBG_TMPTH_(CODE, FUNC) \
 165         do { \
 166                 if (kdebug_enable && \
 167                                 kdebug_debugid_enabled(MT_KDBG_TMPTH_EVT(CODE))) { \
 168                         uint64_t __counts[MT_CORE_NFIXED]; \
 169                         mt_cur_thread_fixed_counts(__counts); \
 170                         KDBG(MT_KDBG_TMPTH_EVT(CODE) | (FUNC), COUNTS_INSTRS, \
 171                                         __counts[MT_CORE_CYCLES]); \
 172                 } \
 173         } while (0)
 174
 175 #define MT_KDBG_TMPTH(CODE) MT_KDBG_TMPTH_(CODE, DBG_FUNC_NONE)
 176 #define MT_KDBG_TMPTH_START(CODE) MT_KDBG_TMPTH_(CODE, DBG_FUNC_START)
 177 #define MT_KDBG_TMPTH_END(CODE) MT_KDBG_TMPTH_(CODE, DBG_FUNC_END)
 178
 179 extern lck_grp_t * mt_lock_grp;
 180
 181 int mt_dev_init(void);
 182
 183 struct mt_device {
 184         const char *mtd_name;
 185         int(*const mtd_init)(struct mt_device *dev);
 186         int(*const mtd_add)(struct monotonic_config *config, uint32_t *ctr_out);
 187         void(*const mtd_reset)(void);
 188         void(*const mtd_enable)(bool enable);
 189         int(*const mtd_read)(uint64_t ctr_mask, uint64_t *counts_out);
 190         decl_lck_mtx_data(, mtd_lock);
 191
 192         uint8_t mtd_nmonitors;
 193         uint8_t mtd_ncounters;
 194         bool mtd_inuse;
 195 };
 196 typedef struct mt_device *mt_device_t;
 197
 198 extern struct mt_device mt_devices[];
 199
 200 __END_DECLS
 201
 202 #endif /* MONOTONIC */
 203
 204 #endif /* XNU_KERNEL_PRIVATE */
 205
 206 #endif /* !defined(SYS_MONOTONIC_H) */