Reference to and comments upon relevant work by others on the same or similar problems [55].
The high cost of protection domain crossings, especially from user-level into the kernel, has been well documented [65, , , ]. Often, a mismatch between modern microprocessor architectures and the changing needs of newer operating systems is cited as the main reason. Hardware, as well as software solutions, have been proposed to alleviate the problem [22, , , , , , ]. While some of the achieved improvements are significant, there is still a cost associated with a protection domain crossing. If that cost is high enough to cover the overhead of safely executing untrusted code in the kernel, then kernel extensions have merit. Otherwise, up-calls to the user level are more appropriate.
The research proposed builds on work done in several areas. In Section 3.1 we investigate several existing methods to send a message to a remote node and let a user-specified handler execute on the remote node when the message arrives. Essentially, all suffer from too high overhead or inflexibility. In Section 3.2 we look at operating systems that allow user processes to extend the kernel by inserting code. All of the extension methods described in Section 2.2 are used in one form or another. The goal of this research is to compare them and find the one that is best suited for our applications.
In Section 3.3 we look at two examples where hardware is used to solve the problem of high overhead in the start-up and execution of remote handlers. Since code is inserted into the kernel at runtime, research in the area of dynamic code generation is also of interest to us. We briefly discuss it in Section 3.4. Finally, we explore several areas related to interpreters in Section 3.5.
Choices