usr/src/uts/common/sys/kcpc.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_KCPC_H
  27 #define _SYS_KCPC_H
  28
  29 #include <sys/cpc_impl.h>
  30 #include <sys/ksynch.h>
  31 #include <sys/types.h>
  32
  33 #ifdef  __cplusplus
  34 extern "C" {
  35 #endif
  36
  37
  38 /*
  39  * Kernel clients need this file in order to know what a request is and how to
  40  * program one.
  41  */
  42
  43 typedef struct _kcpc_set kcpc_set_t;
  44
  45 #ifdef _KERNEL
  46
  47 /*
  48  * Forward declarations.
  49  */
  50 struct _kthread;
  51 struct cpu;
  52 typedef struct _kcpc_request kcpc_request_t;
  53 struct __pcbe_ops;
  54
  55 #define KCPC_SET_BOUND          0x0001          /* Used in ks_state */
  56
  57 struct _kcpc_set {
  58         int                     ks_flags;
  59         int                     ks_nreqs;       /* Number of reqs */
  60         kcpc_request_t          *ks_req;        /* Pointer to reqs */
  61         uint64_t                *ks_data;       /* Data store for this set */
  62         kcpc_ctx_t              *ks_ctx;        /* ctx this set belongs to */
  63         ushort_t                ks_state;       /* Set is bound or unbound */
  64         kmutex_t                ks_lock;        /* Protects ks_state */
  65         kcondvar_t              ks_condv;       /* Wait for bind to complete */
  66 };
  67
  68 struct _kcpc_request {
  69         void                    *kr_config;
  70         int                     kr_index;       /* indx of data for this req */
  71         int                     kr_picnum;      /* Number of phys pic */
  72         kcpc_pic_t              *kr_picp;       /* Ptr to PIC in context */
  73         uint64_t                *kr_data;       /* Ptr to virtual 64-bit pic */
  74         char                    kr_event[CPC_MAX_EVENT_LEN];
  75         uint64_t                kr_preset;
  76         uint_t                  kr_flags;
  77         uint_t                  kr_nattrs;
  78         kcpc_attr_t             *kr_attr;
  79         void                    *kr_ptr;        /* Ptr assigned by requester */
  80 };
  81
  82 typedef struct _kcpc_request_list {
  83         kcpc_request_t          *krl_list;      /* counter event requests */
  84         int                     krl_cnt;        /* how many requests */
  85         int                     krl_max;        /* max request entries */
  86 } kcpc_request_list_t;
  87
  88 /*
  89  * Type of update function to be called when reading counters on current CPU in
  90  * kcpc_read()
  91  */
  92 typedef int (*kcpc_update_func_t)(void *, uint64_t);
  93
  94 /*
  95  * Type of read function to be called when reading counters on current CPU
  96  * (ie. should be same type signature as kcpc_read())
  97  */
  98 typedef int (*kcpc_read_func_t)(kcpc_update_func_t);
  99
 100
 101 /*
 102  * Initialize the kcpc framework
 103  */
 104 extern int kcpc_init(void);
 105
 106 /*
 107  * Bind the set to the indicated thread.
 108  * Returns 0 on success, or an errno in case of error. If EINVAL is returned,
 109  * a specific error code will be returned in the subcode parameter.
 110  */
 111 extern int kcpc_bind_thread(kcpc_set_t *set, struct _kthread *t, int *subcode);
 112
 113 /*
 114  * Bind the set to the indicated CPU.
 115  * Same return convention as kcpc_bind_thread().
 116  */
 117 extern int kcpc_bind_cpu(kcpc_set_t *set, int cpuid, int *subcode);
 118
 119 /*
 120  * Request the system to sample the current state of the set into users buf.
 121  */
 122 extern int kcpc_sample(kcpc_set_t *set, uint64_t *buf, hrtime_t *hrtime,
 123     uint64_t *tick);
 124
 125 /*
 126  * Create CPC context containing specified list of requested counter events
 127  */
 128 extern int kcpc_cpu_ctx_create(struct cpu *cp, kcpc_request_list_t *req_list,
 129     int kmem_flags, kcpc_ctx_t ***ctx_ptr_array, size_t *ctx_ptr_array_sz);
 130
 131 /*
 132  * Returns whether specified counter event is supported
 133  */
 134 extern boolean_t kcpc_event_supported(char *event);
 135
 136 /*
 137  * Initialize list of CPC event requests
 138  */
 139 extern kcpc_request_list_t *kcpc_reqs_init(int nreqs, int kmem_flags);
 140
 141 /*
 142  * Add counter event request to given list of counter event requests
 143  */
 144 extern int kcpc_reqs_add(kcpc_request_list_t *req_list, char *event,
 145     uint64_t preset, uint_t flags, uint_t nattrs, kcpc_attr_t *attr, void *ptr,
 146     int kmem_flags);
 147
 148 /*
 149  * Reset list of CPC event requests so its space can be used for another set
 150  * of requests
 151  */
 152 extern int kcpc_reqs_reset(kcpc_request_list_t *req_list);
 153
 154 /*
 155  * Free given list of counter event requests
 156  */
 157 extern int kcpc_reqs_fini(kcpc_request_list_t *req_list);
 158
 159 /*
 160  * Read CPC data for given event on current CPU
 161  */
 162 extern int kcpc_read(kcpc_update_func_t);
 163
 164 /*
 165  * Program current CPU with given CPC context
 166  */
 167 extern void kcpc_program(kcpc_ctx_t *ctx, boolean_t for_thread,
 168     boolean_t cu_interpose);
 169
 170 /*
 171  * Unprogram CPC counters on current CPU
 172  */
 173 extern void kcpc_unprogram(kcpc_ctx_t *ctx, boolean_t cu_interpose);
 174
 175 /*
 176  * Unbind a request and release the associated resources.
 177  */
 178 extern int kcpc_unbind(kcpc_set_t *set);
 179
 180 /*
 181  * Preset the indicated request's counter and underlying PCBE config to the
 182  * given value.
 183  */
 184 extern int kcpc_preset(kcpc_set_t *set, int index, uint64_t preset);
 185
 186 /*
 187  * Unfreeze the set and get it counting again.
 188  */
 189 extern int kcpc_restart(kcpc_set_t *set);
 190
 191 extern int kcpc_enable(struct _kthread *t, int cmd, int enable);
 192
 193 /*
 194  * Mark a thread's CPC context, if it exists, INVALID.
 195  */
 196 extern void kcpc_invalidate(struct _kthread *t);
 197
 198 extern int kcpc_overflow_ast(void);
 199 extern uint_t kcpc_hw_overflow_intr(caddr_t, caddr_t);
 200 extern int kcpc_hw_cpu_hook(int cpuid, ulong_t *kcpc_cpumap);
 201 extern int kcpc_hw_lwp_hook(void);
 202 extern void kcpc_idle_save(struct cpu *cp);
 203 extern void kcpc_idle_restore(struct cpu *cp);
 204
 205 extern krwlock_t        kcpc_cpuctx_lock;  /* lock for 'kcpc_cpuctx' below */
 206 extern int              kcpc_cpuctx;       /* number of cpu-specific contexts */
 207
 208 extern void kcpc_free(kcpc_ctx_t *ctx, int isexec);
 209
 210 /*
 211  * 'dtrace_cpc_in_use' contains the number of currently active cpc provider
 212  * based enablings. See the block comment in uts/common/os/dtrace_subr.c for
 213  * details of its actual usage.
 214  */
 215 extern uint32_t         dtrace_cpc_in_use;
 216 extern void (*dtrace_cpc_fire)(uint64_t);
 217
 218 extern void kcpc_free_set(kcpc_set_t *set);
 219
 220 extern void *kcpc_next_config(void *token, void *current,
 221     uint64_t **data);
 222 extern void kcpc_invalidate_config(void *token);
 223 extern char *kcpc_list_attrs(void);
 224 extern char *kcpc_list_events(uint_t pic);
 225 extern void kcpc_free_configs(kcpc_set_t *set);
 226 extern uint_t kcpc_pcbe_capabilities(void);
 227 extern int kcpc_pcbe_loaded(void);
 228
 229 /*
 230  * Called by a PCBE to determine if nonprivileged access to counters should be
 231  * allowed. Returns non-zero if non-privileged access is allowed, 0 if not.
 232  */
 233 extern int kcpc_allow_nonpriv(void *token);
 234
 235 extern void kcpc_register_pcbe(struct __pcbe_ops *);
 236
 237 #endif /* _KERNEL */
 238
 239 #ifdef  __cplusplus
 240 }
 241 #endif
 242
 243 #endif /* _SYS_KCPC_H */