osfmk/kperf/kperf.c

   1 /*
   2  * Copyright (c) 2011 Apple Computer, 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 #include <kern/ipc_tt.h> /* port_name_to_task */
  29 #include <kern/thread.h>
  30 #include <kern/machine.h>
  31 #include <kern/kalloc.h>
  32 #include <mach/mach_types.h>
  33 #include <sys/errno.h>
  34 #include <sys/ktrace.h>
  35
  36 #include <kperf/action.h>
  37 #include <kperf/buffer.h>
  38 #include <kperf/kdebug_trigger.h>
  39 #include <kperf/kperf.h>
  40 #include <kperf/kperf_timer.h>
  41 #include <kperf/pet.h>
  42 #include <kperf/sample.h>
  43
  44 /* from libkern/libkern.h */
  45 extern uint64_t strtouq(const char *, char **, int);
  46
  47 lck_grp_t kperf_lck_grp;
  48
  49 /* IDs of threads on CPUs before starting the PET thread */
  50 uint64_t *kperf_tid_on_cpus = NULL;
  51
  52 /* one wired sample buffer per CPU */
  53 static struct kperf_sample *intr_samplev;
  54 static unsigned int intr_samplec = 0;
  55
  56 /* current sampling status */
  57 static unsigned sampling_status = KPERF_SAMPLING_OFF;
  58
  59 /* only init once */
  60 static boolean_t kperf_initted = FALSE;
  61
  62 /* whether or not to callback to kperf on context switch */
  63 boolean_t kperf_on_cpu_active = FALSE;
  64
  65 struct kperf_sample *
  66 kperf_intr_sample_buffer(void)
  67 {
  68         unsigned ncpu = cpu_number();
  69
  70         assert(ml_get_interrupts_enabled() == FALSE);
  71         assert(ncpu < intr_samplec);
  72
  73         return &(intr_samplev[ncpu]);
  74 }
  75
  76 /* setup interrupt sample buffers */
  77 int
  78 kperf_init(void)
  79 {
  80         static lck_grp_attr_t lck_grp_attr;
  81
  82         unsigned ncpus = 0;
  83         int err;
  84
  85         if (kperf_initted) {
  86                 return 0;
  87         }
  88
  89         lck_grp_attr_setdefault(&lck_grp_attr);
  90         lck_grp_init(&kperf_lck_grp, "kperf", &lck_grp_attr);
  91
  92         ncpus = machine_info.logical_cpu_max;
  93
  94         /* create buffers to remember which threads don't need to be sampled by PET */
  95         kperf_tid_on_cpus = kalloc_tag(ncpus * sizeof(*kperf_tid_on_cpus),
  96                                           VM_KERN_MEMORY_DIAG);
  97         if (kperf_tid_on_cpus == NULL) {
  98                 err = ENOMEM;
  99                 goto error;
 100         }
 101         bzero(kperf_tid_on_cpus, ncpus * sizeof(*kperf_tid_on_cpus));
 102
 103         /* create the interrupt buffers */
 104         intr_samplec = ncpus;
 105         intr_samplev = kalloc_tag(ncpus * sizeof(*intr_samplev),
 106                                   VM_KERN_MEMORY_DIAG);
 107         if (intr_samplev == NULL) {
 108                 err = ENOMEM;
 109                 goto error;
 110         }
 111         bzero(intr_samplev, ncpus * sizeof(*intr_samplev));
 112
 113         /* create kdebug trigger filter buffers */
 114         if ((err = kperf_kdebug_init())) {
 115                 goto error;
 116         }
 117
 118         kperf_initted = TRUE;
 119         return 0;
 120
 121 error:
 122         if (intr_samplev) {
 123                 kfree(intr_samplev, ncpus * sizeof(*intr_samplev));
 124                 intr_samplev = NULL;
 125                 intr_samplec = 0;
 126         }
 127
 128         if (kperf_tid_on_cpus) {
 129                 kfree(kperf_tid_on_cpus, ncpus * sizeof(*kperf_tid_on_cpus));
 130                 kperf_tid_on_cpus = NULL;
 131         }
 132
 133         return err;
 134 }
 135
 136 void
 137 kperf_reset(void)
 138 {
 139         /* turn off sampling first */
 140         (void)kperf_sampling_disable();
 141
 142         /* cleanup miscellaneous configuration first */
 143         (void)kperf_kdbg_cswitch_set(0);
 144         (void)kperf_set_lightweight_pet(0);
 145         kperf_kdebug_reset();
 146
 147         /* timers, which require actions, first */
 148         kperf_timer_reset();
 149         kperf_action_reset();
 150 }
 151
 152 void
 153 kperf_kernel_configure(const char *config)
 154 {
 155         int pairs = 0;
 156         char *end;
 157         bool pet = false;
 158
 159         assert(config != NULL);
 160
 161         ktrace_start_single_threaded();
 162
 163         ktrace_kernel_configure(KTRACE_KPERF);
 164
 165         if (config[0] == 'p') {
 166                 pet = true;
 167                 config++;
 168         }
 169
 170         do {
 171                 uint32_t action_samplers;
 172                 uint64_t timer_period;
 173
 174                 pairs += 1;
 175                 kperf_action_set_count(pairs);
 176                 kperf_timer_set_count(pairs);
 177
 178                 action_samplers = (uint32_t)strtouq(config, &end, 0);
 179                 if (config == end) {
 180                         kprintf("kperf: unable to parse '%s' as action sampler\n", config);
 181                         goto out;
 182                 }
 183                 config = end;
 184
 185                 kperf_action_set_samplers(pairs, action_samplers);
 186
 187                 if (config[0] == '\0') {
 188                         kprintf("kperf: missing timer period in config\n");
 189                         goto out;
 190                 }
 191                 config++;
 192
 193                 timer_period = strtouq(config, &end, 0);
 194                 if (config == end) {
 195                         kprintf("kperf: unable to parse '%s' as timer period\n", config);
 196                         goto out;
 197                 }
 198                 config = end;
 199
 200                 kperf_timer_set_period(pairs - 1, timer_period);
 201                 kperf_timer_set_action(pairs - 1, pairs);
 202
 203                 if (pet) {
 204                         kperf_timer_set_petid(pairs - 1);
 205                         kperf_set_lightweight_pet(1);
 206                         pet = false;
 207                 }
 208         } while (*(config++) == ',');
 209
 210         kperf_sampling_enable();
 211
 212 out:
 213         ktrace_end_single_threaded();
 214 }
 215
 216 void
 217 kperf_on_cpu_internal(thread_t thread, thread_continue_t continuation,
 218                       uintptr_t *starting_fp)
 219 {
 220         if (kperf_kdebug_cswitch) {
 221                 /* trace the new thread's PID for Instruments */
 222                 int pid = task_pid(get_threadtask(thread));
 223
 224                 BUF_DATA(PERF_TI_CSWITCH, thread_tid(thread), pid);
 225         }
 226         if (kperf_lightweight_pet_active) {
 227                 kperf_pet_on_cpu(thread, continuation, starting_fp);
 228         }
 229 }
 230
 231 void
 232 kperf_on_cpu_update(void)
 233 {
 234         kperf_on_cpu_active = kperf_kdebug_cswitch ||
 235                               kperf_lightweight_pet_active;
 236 }
 237
 238 /* random misc-ish functions */
 239 uint32_t
 240 kperf_get_thread_flags(thread_t thread)
 241 {
 242         return thread->kperf_flags;
 243 }
 244
 245 void
 246 kperf_set_thread_flags(thread_t thread, uint32_t flags)
 247 {
 248         thread->kperf_flags = flags;
 249 }
 250
 251 unsigned int
 252 kperf_sampling_status(void)
 253 {
 254         return sampling_status;
 255 }
 256
 257 int
 258 kperf_sampling_enable(void)
 259 {
 260         if (sampling_status == KPERF_SAMPLING_ON) {
 261                 return 0;
 262         }
 263
 264         if (sampling_status != KPERF_SAMPLING_OFF) {
 265                 panic("kperf: sampling was %d when asked to enable", sampling_status);
 266         }
 267
 268         /* make sure interrupt tables and actions are initted */
 269         if (!kperf_initted || (kperf_action_get_count() == 0)) {
 270                 return ECANCELED;
 271         }
 272
 273         /* mark as running */
 274         sampling_status = KPERF_SAMPLING_ON;
 275         kperf_lightweight_pet_active_update();
 276
 277         /* tell timers to enable */
 278         kperf_timer_go();
 279
 280         return 0;
 281 }
 282
 283 int
 284 kperf_sampling_disable(void)
 285 {
 286         if (sampling_status != KPERF_SAMPLING_ON) {
 287                 return 0;
 288         }
 289
 290         /* mark a shutting down */
 291         sampling_status = KPERF_SAMPLING_SHUTDOWN;
 292
 293         /* tell timers to disable */
 294         kperf_timer_stop();
 295
 296         /* mark as off */
 297         sampling_status = KPERF_SAMPLING_OFF;
 298         kperf_lightweight_pet_active_update();
 299
 300         return 0;
 301 }
 302
 303 boolean_t
 304 kperf_thread_get_dirty(thread_t thread)
 305 {
 306         return (thread->c_switch != thread->kperf_c_switch);
 307 }
 308
 309 void
 310 kperf_thread_set_dirty(thread_t thread, boolean_t dirty)
 311 {
 312         if (dirty) {
 313                 thread->kperf_c_switch = thread->c_switch - 1;
 314         } else {
 315                 thread->kperf_c_switch = thread->c_switch;
 316         }
 317 }
 318
 319 int
 320 kperf_port_to_pid(mach_port_name_t portname)
 321 {
 322         task_t task;
 323         int pid;
 324
 325         if (!MACH_PORT_VALID(portname)) {
 326                 return -1;
 327         }
 328
 329         task = port_name_to_task(portname);
 330
 331         if (task == TASK_NULL) {
 332                 return -1;
 333         }
 334
 335         pid = task_pid(task);
 336
 337         task_deallocate_internal(task);
 338
 339         return pid;
 340 }