int kperf_kdebug_set_filter(user_addr_t user_filter, uint32_t user_size) { uint32_t n_debugids_provided = 0; int err = 0; if ((err = kperf_init())) { return err; } /* detect disabling the filter completely */ if (user_filter == USER_ADDR_NULL || user_size == 0) { bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter)); goto out; } n_debugids_provided = (uint32_t)KPERF_KDEBUG_N_DEBUGIDS(user_size); if ((err = kperf_kdebug_set_n_debugids(n_debugids_provided))) { goto out; } if ((err = copyin(user_filter, (char *)kperf_kdebug_filter, KPERF_KDEBUG_FILTER_SIZE(n_debugids_provided)))) { bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter)); goto out; } out: kperf_kdebug_update(); return err; }
int kperf_action_set_count(unsigned count) { struct action *new_actionv = NULL, *old_actionv = NULL; unsigned old_count; /* easy no-op */ if( count == actionc ) return 0; /* TODO: allow shrinking? */ if( count < actionc ) return EINVAL; /* cap it for good measure */ if( count > ACTION_MAX ) return EINVAL; /* creating the action arror for the first time. create a few * more things, too. */ if( actionc == 0 ) { int r; r = kperf_init(); if( r != 0 ) return r; } /* create a new array */ new_actionv = kalloc( count * sizeof(*new_actionv) ); if( new_actionv == NULL ) return ENOMEM; old_actionv = actionv; old_count = actionc; if( old_actionv != NULL ) bcopy( actionv, new_actionv, actionc * sizeof(*actionv) ); bzero( &new_actionv[actionc], (count - old_count) * sizeof(*actionv) ); actionv = new_actionv; actionc = count; if( old_actionv != NULL ) kfree( old_actionv, old_count * sizeof(*actionv) ); printf( "kperf: done the alloc\n" ); return 0; }
void kperf_kdebug_reset(void) { int err; if ((err = kperf_init())) { return; } kperf_kdebug_action = 0; bzero(kperf_kdebug_filter, sizeof(*kperf_kdebug_filter)); kperf_kdebug_update(); }
uint32_t kperf_kdebug_get_filter(struct kperf_kdebug_filter **filter) { int err; if ((err = kperf_init())) { return 0; } assert(filter != NULL); *filter = kperf_kdebug_filter; return kperf_kdebug_filter->n_debugids; }
static void kperf_kdebug_update(void) { int err; if ((err = kperf_init())) { return; } if (kperf_kdebug_action != 0 && kperf_kdebug_filter->n_debugids != 0) { kperf_kdebug_active = TRUE; } else { kperf_kdebug_active = FALSE; } }
int kperf_kdebug_set_n_debugids(uint32_t n_debugids_in) { int err; if ((err = kperf_init())) { return EINVAL; } if (n_debugids_in > KPERF_KDEBUG_DEBUGIDS_MAX) { return EINVAL; } kperf_kdebug_filter->n_debugids = n_debugids_in; return 0; }
extern int kperf_timer_set_count(unsigned int count) { struct kperf_timer *new_timerv = NULL, *old_timerv = NULL; unsigned int old_count; if (min_period_abstime == 0) { nanoseconds_to_absolutetime(MIN_PERIOD_NS, &min_period_abstime); nanoseconds_to_absolutetime(MIN_PERIOD_BG_NS, &min_period_bg_abstime); nanoseconds_to_absolutetime(MIN_PERIOD_PET_NS, &min_period_pet_abstime); nanoseconds_to_absolutetime(MIN_PERIOD_PET_BG_NS, &min_period_pet_bg_abstime); assert(min_period_abstime > 0); } if (count == kperf_timerc) { return 0; } if (count > TIMER_MAX) { return EINVAL; } /* TODO: allow shrinking? */ if (count < kperf_timerc) { return EINVAL; } /* * Make sure kperf is initialized when creating the array for the first * time. */ if (kperf_timerc == 0) { int r; /* main kperf */ if ((r = kperf_init())) { return r; } } /* * Shut down any running timers since we will be messing with the timer * call structures. */ kperf_timer_stop(); /* create a new array */ new_timerv = kalloc_tag(count * sizeof(struct kperf_timer), VM_KERN_MEMORY_DIAG); if (new_timerv == NULL) { return ENOMEM; } old_timerv = kperf_timerv; old_count = kperf_timerc; if (old_timerv != NULL) { bcopy(kperf_timerv, new_timerv, kperf_timerc * sizeof(struct kperf_timer)); } /* zero the new entries */ bzero(&(new_timerv[kperf_timerc]), (count - old_count) * sizeof(struct kperf_timer)); /* (re-)setup the timer call info for all entries */ for (unsigned int i = 0; i < count; i++) { timer_call_setup(&(new_timerv[i].tcall), kperf_timer_handler, &(new_timerv[i])); } kperf_timerv = new_timerv; kperf_timerc = count; if (old_timerv != NULL) { kfree(old_timerv, old_count * sizeof(struct kperf_timer)); } return 0; }
extern int kperf_timer_set_count(unsigned count) { struct time_trigger *new_timerv = NULL, *old_timerv = NULL; unsigned old_count, i; /* easy no-op */ if( count == timerc ) return 0; /* TODO: allow shrinking? */ if( count < timerc ) return EINVAL; /* cap it for good measure */ if( count > TIMER_MAX ) return EINVAL; /* creating the action arror for the first time. create a few * more things, too. */ if( timerc == 0 ) { int r; /* main kperf */ r = kperf_init(); if( r ) return r; /* get the PET thread going */ r = kperf_pet_init(); if( r ) return r; } /* first shut down any running timers since we will be messing * with the timer call structures */ if( kperf_timer_stop() ) return EBUSY; /* create a new array */ new_timerv = kalloc( count * sizeof(*new_timerv) ); if( new_timerv == NULL ) return ENOMEM; old_timerv = timerv; old_count = timerc; if( old_timerv != NULL ) bcopy( timerv, new_timerv, timerc * sizeof(*timerv) ); /* zero the new entries */ bzero( &new_timerv[timerc], (count - old_count) * sizeof(*new_timerv) ); /* (re-)setup the timer call info for all entries */ for( i = 0; i < count; i++ ) setup_timer_call( &new_timerv[i] ); timerv = new_timerv; timerc = count; if( old_timerv != NULL ) kfree( old_timerv, old_count * sizeof(*timerv) ); return 0; }