Date: Sat, 23 Sep 2000 00:34:22 -0700 (PDT) From: John Baldwin <jhb@FreeBSD.org> To: smp@FreeBSD.org, cp@bsdi.com, alpha@FreeBSD.org Subject: Status update Message-ID: <XFMail.000923003422.jhb@FreeBSD.org>
next in thread | raw e-mail | index | archive | help
Ok, the alpha seems to be rather stable now without the need for obscene hacks to the mutex code to dink with mtx_saveipl. To summarize, here are the changes thus far: - software interrupts (SWI's) are now MI except for a few constants. Currently we still only have 8 SWI's on the x86 due to old compatability nonsense. We should be able to bump this to 32 like it is on the alpha very easily if it proves beneficial. Also software interrutps are completely divorced from the x86 hardware interrupt code. The softinterrupt thread is also now a simple kthread instead of an ithread. - interrupt threads on the alpha for device I/O interrupts. Note that two bus chipsets (dwlpx and mcpcia) still need a couple of low-level functions to handle enable/disable of interrupt sources. - spl()'s are stubbed out on the alpha. Actually, they are now stubbed out in MI code (kern_intr.c specifically). As a side effect of the IPL code becoming mostly MI now, there is a <sys/ipl.h> that includes <machine/ipl.h> and should be used instead. The individal machine/ipl.h are now quite short and simple. - The interrupt state of the sched_lock is now saved in a process's PCB during cpu_switch(). This way, code before and after a call to either mi_switch() or cpu_switch() is guaranteed to be run at the same interrupt state. Without this I was having problems on the alpha where the idle loop was running at ALPHA_PSL_IPL_SOFT (1) and as a result init's child process was never ran, among other things. This last change is something I'd like some feedback on. I've checked the BSD/OS x86 code, and it onyl saves the recursion count of the sched_lock in the pcb. However, after the problems with the alpha and some discussion with Peter Wemm on IRC, I decided that we should be doing this. However, I'm not completely certain, and any thoughts that anyone has would be appreciated. There are also a few more weirdism's on the alpha. In a few places in sys/kern, we call spl0() instead of splx(). I've added some debugging code to do a printf() if we aren't actually at IPL_0 (what spl0 used to do) after the mtx_exit(). It does trigger in several cases during /etc/rc at least, but the machine seems to be running stable regardless (I'll be running a buildworld -j 8 tonight to stress test it). My question is: is it ok for the code to run with some interrupts disabled or do we need to replace the calls to spl0() with enable_intr()? I'll be updating my patchset at http://www.FreeBSD.org/~jhb/patches/alpha.ithreads.patch shortly. If you have time, please test this stuff out so we can get it committed. Thanks. -- John Baldwin <jhb@FreeBSD.org> -- http://www.FreeBSD.org/~jhb/ "Power Users Use the Power to Serve!" - http://www.FreeBSD.org/ To Unsubscribe: send mail to majordomo@FreeBSD.org with "unsubscribe freebsd-alpha" in the body of the message
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?XFMail.000923003422.jhb>