The kernel is non-preemptive, so as long as a process is executing in the kernel, no other process can execute in the kernel. If another process, even with higher priority, becomes runnable while a process is executing kernel code, it will have to wait until the active process leaves the kernel or sleeps. Processes protect themselves against the interrupt context, primarily the bottom half of device drivers, by masking interrupts. It's not always easy to solve the question of which interrupts need to be masked in which context, and one of the interesting observations at this meeting was that as time goes on, the interrupt masks are getting blacker. This is not good for performance.
Processes sleep on a specific address.
In many cases, the address in itself has no meaning, and it's probably easier to think of it as a number. When a process sleeps, it is put on a sleep queue. We currently haven't implemented a solution for this. The other issue is with masking interrupts. This is also quite a problem for SMP machines, since it requires masking the interrupts on all processors, again requiring an expensive synchronization.