minix/kernel/system/debugging.c

173 lines
4.6 KiB
C
Raw Normal View History

2005-04-21 16:53:53 +02:00
/* The system call implemented in this file:
* m_type: SYS_DEBUG
*
* The parameters for this system call are:
*/
#include "../kernel.h"
#include "../system.h"
#include "../proc.h"
#include "../glo.h"
#include <limits.h>
#if ENABLE_LOCK_TIMING
static unsigned long starttimes[TIMING_CATEGORIES][2];
#define HIGHCOUNT 0
#define LOWCOUNT 1
void timer_start(int cat, char *name)
{
static int init = 0;
unsigned long h, l;
int i;
if(cat < 0 || cat >= TIMING_CATEGORIES) return;
for(i = 0; i < sizeof(timingdata[0].names) && *name; i++)
timingdata[cat].names[i] = *name++;
timingdata[0].names[sizeof(timingdata[0].names)-1] = '\0';
if(starttimes[cat][HIGHCOUNT]) { return; }
if(!init) {
int t, f;
init = 1;
for(t = 0; t < TIMING_CATEGORIES; t++) {
timingdata[t].lock_timings_range[0] = 0;
timingdata[t].resets = timingdata[t].misses =
timingdata[t].measurements = 0;
}
}
read_tsc(&starttimes[cat][HIGHCOUNT], &starttimes[cat][LOWCOUNT]);
return;
}
void timer_end(int cat)
{
unsigned long h, l, d = 0, binsize;
int bin;
read_tsc(&h, &l);
if(cat < 0 || cat >= TIMING_CATEGORIES) return;
if(!starttimes[cat][HIGHCOUNT]) {
timingdata[cat].misses++;
return;
}
if(starttimes[cat][HIGHCOUNT] == h) {
d = (l - starttimes[cat][1]);
} else if(starttimes[cat][HIGHCOUNT] == h-1 &&
starttimes[cat][LOWCOUNT] > l) {
d = ((ULONG_MAX - starttimes[cat][LOWCOUNT]) + l);
} else {
timingdata[cat].misses++;
return;
}
starttimes[cat][HIGHCOUNT] = 0;
if(!timingdata[cat].lock_timings_range[0] ||
d < timingdata[cat].lock_timings_range[0] ||
d > timingdata[cat].lock_timings_range[1]) {
int t;
if(!timingdata[cat].lock_timings_range[0] ||
d < timingdata[cat].lock_timings_range[0])
timingdata[cat].lock_timings_range[0] = d;
if(!timingdata[cat].lock_timings_range[1] ||
d > timingdata[cat].lock_timings_range[1])
timingdata[cat].lock_timings_range[1] = d;
for(t = 0; t < TIMING_POINTS; t++)
timingdata[cat].lock_timings[t] = 0;
timingdata[cat].binsize =
(timingdata[cat].lock_timings_range[1] -
timingdata[cat].lock_timings_range[0])/(TIMING_POINTS+1);
if(timingdata[cat].binsize < 1)
timingdata[cat].binsize = 1;
timingdata[cat].resets++;
}
bin = (d-timingdata[cat].lock_timings_range[0]) /
timingdata[cat].binsize;
if(bin < 0 || bin >= TIMING_POINTS) {
int t;
/* this indicates a bug, but isn't really serious */
for(t = 0; t < TIMING_POINTS; t++)
timingdata[cat].lock_timings[t] = 0;
timingdata[cat].misses++;
} else {
timingdata[cat].lock_timings[bin]++;
timingdata[cat].measurements++;
}
return;
}
#endif
2005-04-21 16:53:53 +02:00
#if ENABLE_K_DEBUGGING /* only include code if enabled */
#define PROCLIMIT 10000
PUBLIC void
check_runqueues(char *when)
{
int q, l = 0;
register struct proc *xp;
for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
xp->p_found = 0;
if(l++ > PROCLIMIT) { panic("check error", NO_NUM); }
}
for (q=0; q < NR_SCHED_QUEUES; q++) {
if(rdy_head[q] && !rdy_tail[q]) {
kprintf("head but no tail: %s", (karg_t) when);
panic("scheduling error", NO_NUM);
}
if(!rdy_head[q] && rdy_tail[q]) {
kprintf("tail but no head: %s", (karg_t) when);
panic("scheduling error", NO_NUM);
}
if(rdy_tail[q] && rdy_tail[q]->p_nextready != NIL_PROC) {
kprintf("tail and tail->next not null; %s", (karg_t) when);
panic("scheduling error", NO_NUM);
}
for(xp = rdy_head[q]; xp != NIL_PROC; xp = xp->p_nextready) {
if (!xp->p_ready) {
kprintf("scheduling error: unready on runq: %s\n", (karg_t) when);
panic("found unready process on run queue", NO_NUM);
}
if(xp->p_priority != q) {
kprintf("scheduling error: wrong priority: %s\n", (karg_t) when);
panic("wrong priority", NO_NUM);
}
if(xp->p_found) {
kprintf("scheduling error: double scheduling: %s\n", (karg_t) when);
panic("proc more than once on scheduling queue", NO_NUM);
}
xp->p_found = 1;
if(xp->p_nextready == NIL_PROC && rdy_tail[q] != xp) {
kprintf("scheduling error: last element not tail: %s\n", (karg_t) when);
panic("scheduling error", NO_NUM);
}
if(l++ > PROCLIMIT) panic("loop in schedule queue?", NO_NUM);
}
}
for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
if(isalivep(xp) && xp->p_ready && !xp->p_found) {
kprintf("scheduling error: ready not on queue: %s\n", (karg_t) when);
panic("ready proc not on scheduling queue", NO_NUM);
if(l++ > PROCLIMIT) { panic("loop in proc.t?", NO_NUM); }
}
}
}
2005-04-21 16:53:53 +02:00
/*==========================================================================*
* do_debug *
*==========================================================================*/
#endif /* ENABLE_K_DEBUGGING */