Subversion Repositories planix.SVN

#include "u.h"

#include "../port/lib.h"

#include "mem.h"

#include "dat.h"

#include "fns.h"

#include "io.h"

#include "ureg.h"

#include "../port/error.h"

enum {

	Maxtimerloops = 20*1000,

};

struct Timers

{

	Lock;

	Timer	*head;

};

static Timers timers[MAXMACH];

static int timersinited;

ulong intrcount[MAXMACH];

ulong fcallcount[MAXMACH];

static vlong

tadd(Timers *tt, Timer *nt)

{

	Timer *t, **last;

	/* Called with tt locked */

	assert(nt->tt == nil);

	switch(nt->tmode){

	default:

		panic("timer");

		break;

	case Trelative:

		if(nt->tns <= 0)

			nt->tns = 1;

		nt->twhen = fastticks(nil) + ns2fastticks(nt->tns);

		break;

	case Tperiodic:

		assert(nt->tns >= 100000);	/* At least 100 µs period */

		if(nt->twhen == 0){

			/* look for another timer at same frequency for combining */

			for(t = tt->head; t; t = t->tnext){

				if(t->tmode == Tperiodic && t->tns == nt->tns)

					break;

			}

			if (t)

				nt->twhen = t->twhen;

			else

				nt->twhen = fastticks(nil);

		}

		nt->twhen += ns2fastticks(nt->tns);

		break;

	}

	for(last = &tt->head; t = *last; last = &t->tnext){

		if(t->twhen > nt->twhen)

			break;

	}

	nt->tnext = *last;

	*last = nt;

	nt->tt = tt;

	if(last == &tt->head)

		return nt->twhen;

	return 0;

}

static uvlong

tdel(Timer *dt)

{

	Timer *t, **last;

	Timers *tt;

	tt = dt->tt;

	if (tt == nil)

		return 0;

	for(last = &tt->head; t = *last; last = &t->tnext){

		if(t == dt){

			assert(dt->tt);

			dt->tt = nil;

			*last = t->tnext;

			break;

		}

	}

	if(last == &tt->head && tt->head)

		return tt->head->twhen;

	return 0;

}

/* add or modify a timer */

void

timeradd(Timer *nt)

{

	Timers *tt;

	vlong when;

	/* Must lock Timer struct before Timers struct */

	ilock(nt);

	if(tt = nt->tt){

		ilock(tt);

		tdel(nt);

		iunlock(tt);

	}

	tt = &timers[m->machno];

	ilock(tt);

	when = tadd(tt, nt);

	if(when)

		timerset(when);

	iunlock(tt);

	iunlock(nt);

}

void

timerdel(Timer *dt)

{

	Timers *tt;

	uvlong when;

	ilock(dt);

	if(tt = dt->tt){

		ilock(tt);

		when = tdel(dt);

		if(when && tt == &timers[m->machno])

			timerset(tt->head->twhen);

		iunlock(tt);

	}

	iunlock(dt);

}

void

hzclock(Ureg *ur)

{

	m->ticks++;

	if(m->proc)

		m->proc->pc = ur->pc;

	if(m->flushmmu){

		if(up)

			flushmmu();

		m->flushmmu = 0;

	}

	accounttime();

	kmapinval();

	if(kproftimer != nil)

		kproftimer(ur->pc);

	if((active.machs&(1<<m->machno)) == 0)

		return;

	if(active.exiting) {

		print("someone's exiting\n");

		exit(0);

	}

	checkalarms();

	if(up && up->state == Running)

		hzsched();	/* in proc.c */

}

void

timerintr(Ureg *u, Tval)

{

	Timer *t;

	Timers *tt;

	uvlong when, now;

	int count, callhzclock;

	intrcount[m->machno]++;

	callhzclock = 0;

	tt = &timers[m->machno];

	now = fastticks(nil);

	if(now == 0)

		panic("timerintr: zero fastticks()");

	ilock(tt);

	count = Maxtimerloops;

	while((t = tt->head) != nil){

		/*

		 * No need to ilock t here: any manipulation of t

		 * requires tdel(t) and this must be done with a

		 * lock to tt held.  We have tt, so the tdel will

		 * wait until we're done

		 */

		when = t->twhen;

		if(when > now){

			timerset(when);

			iunlock(tt);

			if(callhzclock)

				hzclock(u);

			return;

		}

		tt->head = t->tnext;

		assert(t->tt == tt);

		t->tt = nil;

		fcallcount[m->machno]++;

		iunlock(tt);

		if(t->tf)

			(*t->tf)(u, t);

		else

			callhzclock++;

		ilock(tt);

		if(t->tmode == Tperiodic)

			tadd(tt, t);

		if (--count <= 0) {

			count = Maxtimerloops;

			iprint("timerintr: probably stuck in while loop; "

				"scrutinise clock.c or use faster cycle "

				"counter\n");

		}

	}

	iunlock(tt);

}

void

timersinit(void)

{

	Timer *t;

	/*

	 * T->tf == nil means the HZ clock for this processor.

	 */

	timersinited = 1;

	todinit();

	t = malloc(sizeof(*t));

	if(t == nil)

		error(Enomem);

	t->tmode = Tperiodic;

	t->tt = nil;

	t->tns = 1000000000/HZ;

	t->tf = nil;

	timeradd(t);

}

Timer*

addclock0link(void (*f)(void), int ms)

{

	Timer *nt;

	uvlong when;

	if(!timersinited)

		panic("addclock0link: timersinit not called yet");

	/* Synchronize to hztimer if ms is 0 */

	nt = malloc(sizeof(Timer));

	if(nt == nil)

		error(Enomem);

	if(ms == 0)

		ms = 1000/HZ;

	nt->tns = (vlong)ms*1000000LL;

	nt->tmode = Tperiodic;

	nt->tt = nil;

	nt->tf = (void (*)(Ureg*, Timer*))f;

	ilock(&timers[0]);

	when = tadd(&timers[0], nt);

	if(when)

		timerset(when);

	iunlock(&timers[0]);

	return nt;

}

/*

 *  This tk2ms avoids overflows that the macro version is prone to.

 *  It is a LOT slower so shouldn't be used if you're just converting

 *  a delta.

 */

ulong

tk2ms(ulong ticks)

{

	uvlong t, hz;

	t = ticks;

	hz = HZ;

	t *= 1000L;

	t = t/hz;

	ticks = t;

	return ticks;

}

ulong

ms2tk(ulong ms)

{

	/* avoid overflows at the cost of precision */

	if(ms >= 1000000000/HZ)

		return (ms/1000)*HZ;

	return (ms*HZ+500)/1000;

}