xnu-3789.21.4.tar.gz

[apple/xnu.git] / osfmk / kperf / action.c

diff --git a/osfmk/kperf/action.c b/osfmk/kperf/action.c
index 3f1b5e2b0cfa1c4d803261259635130dc594f52c..34098fa93319721c43553cb539b54d1cb3bcdbd3 100644 (file)
--- a/osfmk/kperf/action.c
+++ b/osfmk/kperf/action.c
@@ -33,137 +33,222 @@
 
 #include <mach/mach_types.h>
 #include <machine/machine_routines.h>
 
 #include <mach/mach_types.h>
 #include <machine/machine_routines.h>

-// #include <libkern/libkern.h>

 #include <kern/kalloc.h>
 #include <kern/debug.h> /* panic */
 #include <kern/thread.h>
 #include <sys/errno.h>
 #include <kern/kalloc.h>
 #include <kern/debug.h> /* panic */
 #include <kern/thread.h>
 #include <sys/errno.h>

+#include <sys/vm.h>

 
 

-#include <chud/chud_xnu.h>
-#include <kperf/kperf.h>
-
+#include <kperf/action.h>
+#include <kperf/ast.h>

 #include <kperf/buffer.h>
 #include <kperf/buffer.h>

-#include <kperf/timetrigger.h>
-#include <kperf/threadinfo.h>

 #include <kperf/callstack.h>
 #include <kperf/callstack.h>

-#include <kperf/sample.h>
-#include <kperf/filter.h>
-#include <kperf/action.h>

 #include <kperf/context.h>
 #include <kperf/context.h>

-#include <kperf/ast.h>
-
-#define ACTION_MAX 32
+#include <kperf/kdebug_trigger.h>
+#include <kperf/kperf.h>
+#include <kperf/kperf_kpc.h>
+#include <kperf/kperf_timer.h>
+#include <kperf/pet.h>
+#include <kperf/sample.h>
+#include <kperf/thread_samplers.h>

 
 

-/* XXX: callback handler from chudxnu */
-/* FIXME: hook this up to something */
-//void (*kperf_thread_ast_handler)(thread_t);
+#define ACTION_MAX (32)

 
 /* the list of different actions to take */
 struct action
 {
 
 /* the list of different actions to take */
 struct action
 {

-       unsigned sample;
+       uint32_t sample;
+       uint32_t ucallstack_depth;
+       uint32_t kcallstack_depth;
+       uint32_t userdata;
+       int pid_filter;

 };
 
 /* the list of actions */
 static unsigned actionc = 0;
 static struct action *actionv = NULL;
 
 };
 
 /* the list of actions */
 static unsigned actionc = 0;
 static struct action *actionv = NULL;
 

+/* should emit tracepoint on context switch */
+int kperf_kdebug_cswitch = 0;

 
 

-/* Do the real work! */
-/* this can be called in any context ... right? */

 static kern_return_t
 static kern_return_t

-kperf_sample_internal( struct kperf_sample *sbuf,
-              struct kperf_context *context,
-              unsigned sample_what, boolean_t pend_user )
+kperf_sample_internal(struct kperf_sample *sbuf,
+                      struct kperf_context *context,
+                      unsigned sample_what, unsigned sample_flags,
+                      unsigned actionid, uint32_t ucallstack_depth)

 {
 {

-       boolean_t enabled;
-       int did_ucallstack = 0, did_tinfo_extra = 0;
+       int pended_ucallstack = 0;
+       int pended_th_dispatch = 0;

 
        /* not much point continuing here, but what to do ? return
         * Shutdown? cut a tracepoint and continue?
         */
 
        /* not much point continuing here, but what to do ? return
         * Shutdown? cut a tracepoint and continue?
         */

-       if( sample_what == 0 )
+       if (sample_what == 0) {

                return SAMPLE_CONTINUE;
                return SAMPLE_CONTINUE;

+       }
+
+       /* callstacks should be explicitly ignored */
+       if (sample_flags & SAMPLE_FLAG_EMPTY_CALLSTACK) {
+               sample_what &= ~(SAMPLER_KSTACK | SAMPLER_USTACK);
+       }

 
 

-       int is_kernel = (context->cur_pid == 0);
+       context->cur_thread->kperf_pet_gen = kperf_pet_gen;
+       boolean_t is_kernel = (context->cur_pid == 0);

 
 

-       /*  an event occurred. Sample everything and dump it in a
-        *  buffer.
+       if (actionid && actionid <= actionc) {
+               sbuf->kcallstack.nframes = actionv[actionid - 1].kcallstack_depth;
+       } else {
+               sbuf->kcallstack.nframes = MAX_CALLSTACK_FRAMES;
+       }
+
+       if (ucallstack_depth) {
+               sbuf->ucallstack.nframes = ucallstack_depth;
+       } else {
+               sbuf->ucallstack.nframes = MAX_CALLSTACK_FRAMES;
+       }
+
+       sbuf->kcallstack.flags = CALLSTACK_VALID;
+       sbuf->ucallstack.flags = CALLSTACK_VALID;
+
+       /* an event occurred. Sample everything and dump it in a
+        * buffer.

         */
 
        /* collect data from samplers */
         */
 
        /* collect data from samplers */

-       if( sample_what & SAMPLER_TINFO ) {
-               kperf_threadinfo_sample( &sbuf->threadinfo, context );
-               
-               /* XXX FIXME This drops events when the thread is idle.
-                * This should be configurable. */
-               if (sbuf->threadinfo.runmode & 0x40)
-                       return SAMPLE_CONTINUE;
+       if (sample_what & SAMPLER_TH_INFO) {
+               kperf_thread_info_sample(&sbuf->th_info, context);
+
+               /* See if we should drop idle thread samples */
+               if (!(sample_flags & SAMPLE_FLAG_IDLE_THREADS)) {
+                       if (sbuf->th_info.kpthi_runmode & 0x40) {
+                               return SAMPLE_CONTINUE;
+                       }
+               }

        }
 
        }
 

-       if( sample_what & SAMPLER_KSTACK )
-               kperf_kcallstack_sample( &sbuf->kcallstack, context );
+       if (sample_what & SAMPLER_TH_SNAPSHOT) {
+               kperf_thread_snapshot_sample(&(sbuf->th_snapshot), context);
+       }
+       if (sample_what & SAMPLER_TH_SCHEDULING) {
+               kperf_thread_scheduling_sample(&(sbuf->th_scheduling), context);
+       }
+       if (sample_what & SAMPLER_KSTACK) {
+               if (sample_flags & SAMPLE_FLAG_CONTINUATION) {
+                       kperf_continuation_sample(&(sbuf->kcallstack), context);
+               /* outside of interrupt context, backtrace the current thread */
+               } else if (sample_flags & SAMPLE_FLAG_NON_INTERRUPT) {
+                       kperf_backtrace_sample(&(sbuf->kcallstack), context);
+               } else {
+                       kperf_kcallstack_sample(&(sbuf->kcallstack), context);
+               }
+       }
+       if (sample_what & SAMPLER_TK_SNAPSHOT) {
+               kperf_task_snapshot_sample(&(sbuf->tk_snapshot), context);
+       }

 
        /* sensitive ones */
 
        /* sensitive ones */

-       if ( !is_kernel ) {
-               if( pend_user )
-               {
-                       if( sample_what & SAMPLER_USTACK )
-                               did_ucallstack = kperf_ucallstack_pend( context );
-
-                       if( sample_what & SAMPLER_TINFOEX )
-                               did_tinfo_extra = kperf_threadinfo_extra_pend( context );
+       if (!is_kernel) {
+               if (sample_what & SAMPLER_MEMINFO) {
+                       kperf_meminfo_sample(&(sbuf->meminfo), context);

                }
                }

-               else
-               {
-                       if( sample_what & SAMPLER_USTACK )
-                               kperf_ucallstack_sample( &sbuf->ucallstack, context );
-
-                       if( sample_what & SAMPLER_TINFOEX )
-                               kperf_threadinfo_extra_sample( &sbuf->tinfo_ex,
-                                                              context );
+
+               if (sample_flags & SAMPLE_FLAG_PEND_USER) {
+                       if (sample_what & SAMPLER_USTACK) {
+                               pended_ucallstack = kperf_ucallstack_pend(context, sbuf->ucallstack.nframes);
+                       }
+
+                       if (sample_what & SAMPLER_TH_DISPATCH) {
+                               pended_th_dispatch = kperf_thread_dispatch_pend(context);
+                       }
+               } else {
+                       if (sample_what & SAMPLER_USTACK) {
+                               kperf_ucallstack_sample(&(sbuf->ucallstack), context);
+                       }
+
+                       if (sample_what & SAMPLER_TH_DISPATCH) {
+                               kperf_thread_dispatch_sample(&(sbuf->th_dispatch), context);
+                       }

                }
        }
 
                }
        }
 

+       if (sample_what & SAMPLER_PMC_THREAD) {
+               kperf_kpc_thread_sample(&(sbuf->kpcdata), sample_what);
+       } else if (sample_what & SAMPLER_PMC_CPU) {
+               kperf_kpc_cpu_sample(&(sbuf->kpcdata), sample_what);
+       }
+
+       /* lookup the user tag, if any */
+       uint32_t userdata;
+       if (actionid && (actionid <= actionc)) {
+               userdata = actionv[actionid - 1].userdata;
+       } else {
+               userdata = actionid;
+       }
+
+       /* avoid logging if this sample only pended samples */
+       if (sample_flags & SAMPLE_FLAG_PEND_USER &&
+           !(sample_what & ~(SAMPLER_USTACK | SAMPLER_TH_DISPATCH)))
+       {
+               return SAMPLE_CONTINUE;
+       }
+

        /* stash the data into the buffer
         * interrupts off to ensure we don't get split
         */
        /* stash the data into the buffer
         * interrupts off to ensure we don't get split
         */

-       enabled = ml_set_interrupts_enabled(FALSE);
-
-       if ( pend_user )
-               BUF_DATA1( PERF_GEN_EVENT | DBG_FUNC_START, sample_what );
-
-       /* dump threadinfo */
-       if( sample_what & SAMPLER_TINFO )
-               kperf_threadinfo_log( &sbuf->threadinfo );
+       boolean_t enabled = ml_set_interrupts_enabled(FALSE);

 
 

-       /* dump kcallstack */
-       if( sample_what & SAMPLER_KSTACK )
-               kperf_kcallstack_log( &sbuf->kcallstack );
+       BUF_DATA(PERF_GEN_EVENT | DBG_FUNC_START, sample_what,
+                actionid, userdata, sample_flags);

 
 

+       if (sample_what & SAMPLER_TH_INFO) {
+               kperf_thread_info_log(&sbuf->th_info);
+       }
+       if (sample_what & SAMPLER_TH_SCHEDULING) {
+               kperf_thread_scheduling_log(&(sbuf->th_scheduling));
+       }
+       if (sample_what & SAMPLER_TH_SNAPSHOT) {
+               kperf_thread_snapshot_log(&(sbuf->th_snapshot));
+       }
+       if (sample_what & SAMPLER_KSTACK) {
+               kperf_kcallstack_log(&sbuf->kcallstack);
+       }
+       if (sample_what & SAMPLER_TK_SNAPSHOT) {
+               kperf_task_snapshot_log(&(sbuf->tk_snapshot));
+       }

 
        /* dump user stuff */
 
        /* dump user stuff */

-       if ( !is_kernel ) {
-               if ( pend_user )
-               {
-                       if ( did_ucallstack )
-                               BUF_INFO1( PERF_CS_UPEND, 0 );
-
-                       if ( did_tinfo_extra )
-                               BUF_INFO1( PERF_TI_XPEND, 0 );
+       if (!is_kernel) {
+               /* dump meminfo */
+               if (sample_what & SAMPLER_MEMINFO) {
+                       kperf_meminfo_log(&(sbuf->meminfo));

                }
                }

-               else
-               {
-                       if( sample_what & SAMPLER_USTACK )
-                               kperf_ucallstack_log( &sbuf->ucallstack );

 
 

-                       if( sample_what & SAMPLER_TINFOEX )
-                               kperf_threadinfo_extra_log( &sbuf->tinfo_ex );
+               if (sample_flags & SAMPLE_FLAG_PEND_USER) {
+                       if (pended_ucallstack) {
+                               BUF_INFO(PERF_CS_UPEND);
+                       }
+
+                       if (pended_th_dispatch) {
+                               BUF_INFO(PERF_TI_DISPPEND);
+                       }
+               } else {
+                       if (sample_what & SAMPLER_USTACK) {
+                               kperf_ucallstack_log(&(sbuf->ucallstack));
+                       }
+
+                       if (sample_what & SAMPLER_TH_DISPATCH) {
+                               kperf_thread_dispatch_log(&(sbuf->th_dispatch));
+                       }

                }
        }
 
                }
        }
 

-       if ( pend_user )
-               BUF_DATA1( PERF_GEN_EVENT | DBG_FUNC_END, sample_what );
+       if (sample_what & SAMPLER_PMC_THREAD) {
+               kperf_kpc_thread_log(&(sbuf->kpcdata));
+       } else if (sample_what & SAMPLER_PMC_CPU) {
+               kperf_kpc_cpu_log(&(sbuf->kpcdata));
+       }
+
+       BUF_DATA(PERF_GEN_EVENT | DBG_FUNC_END, sample_what);

 
        /* intrs back on */
        ml_set_interrupts_enabled(enabled);
 
        /* intrs back on */
        ml_set_interrupts_enabled(enabled);


@@ -173,142 +258,279 @@ kperf_sample_internal( struct kperf_sample *sbuf,
 
 /* Translate actionid into sample bits and take a sample */
 kern_return_t
 
 /* Translate actionid into sample bits and take a sample */
 kern_return_t

-kperf_sample( struct kperf_sample *sbuf,
-             struct kperf_context *context,
-              unsigned actionid, boolean_t pend_user )
+kperf_sample(struct kperf_sample *sbuf,
+             struct kperf_context *context,
+             unsigned actionid, unsigned sample_flags)

 {
 {

-       unsigned sample_what = 0;
-
-       /* check samppling is on, or panic */
-       if( kperf_sampling_status() == KPERF_SAMPLING_OFF )
-               panic("trigger fired while sampling off");
-       else if( kperf_sampling_status() == KPERF_SAMPLING_SHUTDOWN )
-               return SAMPLE_SHUTDOWN;
-

        /* work out what to sample, if anything */
        /* work out what to sample, if anything */

-       if( actionid >= actionc )
+       if ((actionid > actionc) || (actionid == 0)) {

                return SAMPLE_SHUTDOWN;
                return SAMPLE_SHUTDOWN;

+       }
+
+       /* check the pid filter against the context's current pid.
+        * filter pid == -1 means any pid
+        */
+       int pid_filter = actionv[actionid - 1].pid_filter;
+       if ((pid_filter != -1) && (pid_filter != context->cur_pid)) {
+               return SAMPLE_CONTINUE;
+       }

 
 

-       sample_what = actionv[actionid].sample;
+       /* the samplers to run */
+       unsigned int sample_what = actionv[actionid - 1].sample;

 
 

-       return kperf_sample_internal( sbuf, context, sample_what, pend_user );
+       /* do the actual sample operation */
+       return kperf_sample_internal(sbuf, context, sample_what,
+                                    sample_flags, actionid,
+                                    actionv[actionid - 1].ucallstack_depth);

 }
 
 }
 

-/* ast callback on a thread */

 void
 void

-kperf_thread_ast_handler( thread_t thread )
+kperf_kdebug_handler(uint32_t debugid, uintptr_t *starting_fp)

 {
 {

-       int r;
-       uint32_t t_chud;
-       unsigned sample_what = 0;
-       /* we know we're on a thread, so let's do stuff */
-       task_t task = NULL;
-
-       /* Don't sample if we are shutting down or off */
-       if( kperf_sampling_status() != KPERF_SAMPLING_ON )
+       uint32_t sample_flags = SAMPLE_FLAG_PEND_USER;
+       struct kperf_context ctx;
+       struct kperf_sample *sample = NULL;
+       kern_return_t kr = KERN_SUCCESS;
+       int s;
+
+       if (!kperf_kdebug_should_trigger(debugid)) {

                return;
                return;

+       }

 
 

-       BUF_INFO1(PERF_AST_HNDLR | DBG_FUNC_START, thread);
+       BUF_VERB(PERF_KDBG_HNDLR | DBG_FUNC_START, debugid);

 
 

-       /* FIXME: probably want a faster allocator here... :P */
-       struct kperf_sample *sbuf = kalloc( sizeof(*sbuf) );
-       if( sbuf == NULL )
-       {
-               /* FIXME: error code */
-               BUF_INFO1( PERF_AST_ERROR, 0 );
-               goto error;
+       ctx.cur_thread = current_thread();
+       ctx.cur_pid = task_pid(get_threadtask(ctx.cur_thread));
+       ctx.trigger_type = TRIGGER_TYPE_KDEBUG;
+       ctx.trigger_id = 0;
+
+       s = ml_set_interrupts_enabled(0);
+
+       sample = kperf_intr_sample_buffer();
+
+       if (!ml_at_interrupt_context()) {
+               sample_flags |= SAMPLE_FLAG_NON_INTERRUPT;
+               ctx.starting_fp = starting_fp;
+       }
+
+       kr = kperf_sample(sample, &ctx, kperf_kdebug_get_action(), sample_flags);
+
+       ml_set_interrupts_enabled(s);
+       BUF_VERB(PERF_KDBG_HNDLR | DBG_FUNC_END, kr);
+}
+
+/*
+ * This function allocates >2.3KB of the stack.  Prevent the compiler from
+ * inlining this function into ast_taken and ensure the stack memory is only
+ * allocated for the kperf AST.
+ */
+__attribute__((noinline))
+void
+kperf_thread_ast_handler(thread_t thread)
+{
+       BUF_INFO(PERF_AST_HNDLR | DBG_FUNC_START, thread, kperf_get_thread_flags(thread));
+
+       /* ~2KB of the stack for the sample since this is called from AST */
+       struct kperf_sample sbuf;
+       memset(&sbuf, 0, sizeof(struct kperf_sample));
+
+       task_t task = get_threadtask(thread);
+
+       if (task_did_exec(task) || task_is_exec_copy(task)) {
+               BUF_INFO(PERF_AST_HNDLR | DBG_FUNC_END, SAMPLE_CONTINUE);
+               return;

        }
 
        /* make a context, take a sample */
        struct kperf_context ctx;
        ctx.cur_thread = thread;
        }
 
        /* make a context, take a sample */
        struct kperf_context ctx;
        ctx.cur_thread = thread;

-       ctx.cur_pid = -1;
-
-       task = chudxnu_task_for_thread(thread);
-       if(task)
-               ctx.cur_pid = chudxnu_pid_for_task(task);
-
-       /* decode the chud bits so we know what to sample */
-       t_chud = kperf_get_thread_bits(thread);
-       
-       if (t_chud & T_AST_NAME)
-               sample_what |= SAMPLER_TINFOEX;
-       
-       if (t_chud & T_AST_CALLSTACK)
-               sample_what |= SAMPLER_USTACK;
+       ctx.cur_pid = task_pid(task);
+
+       /* decode the flags to determine what to sample */
+       unsigned int sample_what = 0;
+       uint32_t flags = kperf_get_thread_flags(thread);

 
 

-       /* do the sample, just of the user stuff */
-       r = kperf_sample_internal( sbuf, &ctx, sample_what, FALSE );
+       if (flags & T_KPERF_AST_DISPATCH) {
+               sample_what |= SAMPLER_TH_DISPATCH;
+       }
+       if (flags & T_KPERF_AST_CALLSTACK) {
+               sample_what |= SAMPLER_USTACK;
+               sample_what |= SAMPLER_TH_INFO;
+       }

 
 

-       /* free it again */
-       kfree( sbuf, sizeof(*sbuf) );
+       uint32_t ucallstack_depth = T_KPERF_GET_CALLSTACK_DEPTH(flags);

 
 

-error:
-       BUF_INFO1(PERF_AST_HNDLR | DBG_FUNC_END, r);
+       int r = kperf_sample_internal(&sbuf, &ctx, sample_what, 0, 0, ucallstack_depth);

 
 

+       BUF_INFO(PERF_AST_HNDLR | DBG_FUNC_END, r);

 }
 
 /* register AST bits */
 int
 }
 
 /* register AST bits */
 int

-kperf_ast_pend( thread_t cur_thread, uint32_t check_bits,
-               uint32_t set_bits )
+kperf_ast_pend(thread_t thread, uint32_t set_flags)

 {
 {

-       /* pend on the thread */
-       uint32_t t_chud, set_done = 0;
- 

        /* can only pend on the current thread */
        /* can only pend on the current thread */

-       if( cur_thread != chudxnu_current_thread() )
+       if (thread != current_thread()) {

                panic("pending to non-current thread");
                panic("pending to non-current thread");

+       }

 
        /* get our current bits */
 
        /* get our current bits */

-       t_chud = kperf_get_thread_bits(cur_thread);
+       uint32_t flags = kperf_get_thread_flags(thread);

 
        /* see if it's already been done or pended */
 
        /* see if it's already been done or pended */

-       if( !(t_chud & check_bits ) )
-       {
+       if (!(flags & set_flags)) {

                /* set the bit on the thread */
                /* set the bit on the thread */

-               t_chud |= set_bits;
-               kperf_set_thread_bits(cur_thread, t_chud);
+               flags |= set_flags;
+               kperf_set_thread_flags(thread, flags);

 
                /* set the actual AST */
 
                /* set the actual AST */

-               kperf_set_thread_ast( cur_thread );
+               act_set_kperf(thread);
+               return 1;
+       }

 
 

-               set_done = 1;
+       return 0;
+}
+
+void
+kperf_ast_set_callstack_depth(thread_t thread, uint32_t depth)
+{
+       uint32_t ast_flags = kperf_get_thread_flags(thread);
+       uint32_t existing_callstack_depth = T_KPERF_GET_CALLSTACK_DEPTH(ast_flags);
+
+       if (existing_callstack_depth != depth) {
+               ast_flags &= ~T_KPERF_SET_CALLSTACK_DEPTH(depth);
+               ast_flags |= T_KPERF_SET_CALLSTACK_DEPTH(depth);
+
+               kperf_set_thread_flags(thread, ast_flags);

        }
        }

+}

 
 

-       return set_done;
+int
+kperf_kdbg_cswitch_get(void)
+{
+       return kperf_kdebug_cswitch;
+}
+
+int
+kperf_kdbg_cswitch_set(int newval)
+{
+       kperf_kdebug_cswitch = newval;
+       kperf_on_cpu_update();

 
 

-//     BUF_INFO3( dbg_code, (uintptr_t)cur_thread, t_chud, set_done );
+       return 0;

 }
 
 }
 

-unsigned
+/*
+ * Action configuration
+ */
+unsigned int

 kperf_action_get_count(void)
 {
        return actionc;
 }
 
 int
 kperf_action_get_count(void)
 {
        return actionc;
 }
 
 int

-kperf_action_set_samplers( unsigned actionid, uint32_t samplers )
+kperf_action_set_samplers(unsigned actionid, uint32_t samplers)
+{
+       if ((actionid > actionc) || (actionid == 0)) {
+               return EINVAL;
+       }
+
+       /* disallow both CPU and thread counters to be sampled in the same
+        * action */
+       if ((samplers & SAMPLER_PMC_THREAD) && (samplers & SAMPLER_PMC_CPU)) {
+               return EINVAL;
+       }
+
+       actionv[actionid - 1].sample = samplers;
+
+       return 0;
+}
+
+int
+kperf_action_get_samplers(unsigned actionid, uint32_t *samplers_out)
+{
+       if ((actionid > actionc)) {
+               return EINVAL;
+       }
+
+       if (actionid == 0) {
+               *samplers_out = 0; /* "NULL" action */
+       } else {
+               *samplers_out = actionv[actionid - 1].sample;
+       }
+
+       return 0;
+}
+
+int
+kperf_action_set_userdata(unsigned actionid, uint32_t userdata)
+{
+       if ((actionid > actionc) || (actionid == 0)) {
+               return EINVAL;
+       }
+
+       actionv[actionid - 1].userdata = userdata;
+
+       return 0;
+}
+
+int
+kperf_action_get_userdata(unsigned actionid, uint32_t *userdata_out)

 {
 {

-       if( actionid >= actionc )
+       if ((actionid > actionc)) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       actionv[actionid].sample = samplers;
+       if (actionid == 0) {
+               *userdata_out = 0; /* "NULL" action */
+       } else {
+               *userdata_out = actionv[actionid - 1].userdata;
+       }

 
        return 0;
 }
 
 int
 
        return 0;
 }
 
 int

-kperf_action_get_samplers( unsigned actionid, uint32_t *samplers_out )
+kperf_action_set_filter(unsigned actionid, int pid)

 {
 {

-       if( actionid >= actionc )
+       if ((actionid > actionc) || (actionid == 0)) {

                return EINVAL;
                return EINVAL;

+       }

 
 

-       *samplers_out = actionv[actionid].sample;
+       actionv[actionid - 1].pid_filter = pid;

 
        return 0;
 }
 
 
        return 0;
 }
 

+int
+kperf_action_get_filter(unsigned actionid, int *pid_out)
+{
+       if ((actionid > actionc)) {
+               return EINVAL;
+       }
+
+       if (actionid == 0) {
+               *pid_out = -1; /* "NULL" action */
+       } else {
+               *pid_out = actionv[actionid - 1].pid_filter;
+       }
+
+       return 0;
+}
+
+void
+kperf_action_reset(void)
+{
+       for (unsigned int i = 0; i < actionc; i++) {
+               kperf_action_set_samplers(i + 1, 0);
+               kperf_action_set_userdata(i + 1, 0);
+               kperf_action_set_filter(i + 1, -1);
+               kperf_action_set_ucallstack_depth(i + 1, MAX_CALLSTACK_FRAMES);
+               kperf_action_set_kcallstack_depth(i + 1, MAX_CALLSTACK_FRAMES);
+       }
+}
+

 int
 kperf_action_set_count(unsigned count)
 {
 int
 kperf_action_set_count(unsigned count)
 {


@@ -316,49 +538,125 @@ kperf_action_set_count(unsigned count)
        unsigned old_count;
 
        /* easy no-op */
        unsigned old_count;
 
        /* easy no-op */

-       if( count == actionc )
+       if (count == actionc) {

                return 0;
                return 0;

+       }

 
        /* TODO: allow shrinking? */
 
        /* TODO: allow shrinking? */

-       if( count < actionc )
+       if (count < actionc) {

                return EINVAL;
                return EINVAL;

+       }

 
        /* cap it for good measure */
 
        /* cap it for good measure */

-       if( count > ACTION_MAX )
+       if (count > ACTION_MAX) {

                return EINVAL;
                return EINVAL;

+       }

 
        /* creating the action arror for the first time. create a few
         * more things, too.
         */
 
        /* creating the action arror for the first time. create a few
         * more things, too.
         */

-               if( actionc == 0 )
-       {
+       if (actionc == 0) {

                int r;
                int r;

-               r = kperf_init();
-
-               if( r != 0 )
+               if ((r = kperf_init())) {

                        return r;
                        return r;

+               }

        }
 
        /* create a new array */
        }
 
        /* create a new array */

-       new_actionv = kalloc( count * sizeof(*new_actionv) );
-       if( new_actionv == NULL )
+       new_actionv = kalloc_tag(count * sizeof(*new_actionv), VM_KERN_MEMORY_DIAG);
+       if (new_actionv == NULL) {

                return ENOMEM;
                return ENOMEM;

+       }

 
        old_actionv = actionv;
        old_count = actionc;
 
 
        old_actionv = actionv;
        old_count = actionc;
 

-       if( old_actionv != NULL )
-               bcopy( actionv, new_actionv, actionc * sizeof(*actionv) );
+       if (old_actionv != NULL) {
+               memcpy(new_actionv, actionv, actionc * sizeof(*actionv));
+       }
+
+       memset(&(new_actionv[actionc]), 0, (count - old_count) * sizeof(*actionv));

 
 

-       bzero( &new_actionv[actionc], (count - old_count) * sizeof(*actionv) );
+       for (unsigned int i = old_count; i < count; i++) {
+               new_actionv[i].pid_filter = -1;
+               new_actionv[i].ucallstack_depth = MAX_CALLSTACK_FRAMES;
+               new_actionv[i].kcallstack_depth = MAX_CALLSTACK_FRAMES;
+       }

 
        actionv = new_actionv;
        actionc = count;
 
 
        actionv = new_actionv;
        actionc = count;
 

-       if( old_actionv != NULL )
-               kfree( old_actionv, old_count * sizeof(*actionv) );
+       if (old_actionv != NULL) {
+               kfree(old_actionv, old_count * sizeof(*actionv));
+       }
+
+       return 0;
+}
+
+int
+kperf_action_set_ucallstack_depth(unsigned action_id, uint32_t depth)
+{
+       if ((action_id > actionc) || (action_id == 0)) {
+               return EINVAL;
+       }
+
+       if (depth > MAX_CALLSTACK_FRAMES) {
+               return EINVAL;
+       }
+
+       actionv[action_id - 1].ucallstack_depth = depth;
+
+       return 0;
+}
+
+int
+kperf_action_set_kcallstack_depth(unsigned action_id, uint32_t depth)
+{
+       if ((action_id > actionc) || (action_id == 0)) {
+               return EINVAL;
+       }
+
+       if (depth > MAX_CALLSTACK_FRAMES) {
+               return EINVAL;
+       }
+
+       actionv[action_id - 1].kcallstack_depth = depth;
+
+       return 0;
+}
+
+int
+kperf_action_get_ucallstack_depth(unsigned action_id, uint32_t * depth_out)
+{
+       if ((action_id > actionc)) {
+               return EINVAL;
+       }
+
+       assert(depth_out);

 
 

-       printf( "kperf: done the alloc\n" );
+       if (action_id == 0) {
+               *depth_out = MAX_CALLSTACK_FRAMES;
+       } else {
+               *depth_out = actionv[action_id - 1].ucallstack_depth;
+       }
+
+       return 0;
+}
+
+int
+kperf_action_get_kcallstack_depth(unsigned action_id, uint32_t * depth_out)
+{
+       if ((action_id > actionc)) {
+               return EINVAL;
+       }
+
+       assert(depth_out);
+
+       if (action_id == 0) {
+               *depth_out = MAX_CALLSTACK_FRAMES;
+       } else {
+               *depth_out = actionv[action_id - 1].kcallstack_depth;
+       }

 
        return 0;
 }
 
        return 0;
 }