Systems and Methods for Dynamically Linking Application Software into a Running Operating System Kernel

Abstract

The present invention provides systems and methods for dynamically linking modules into a running operating system kernel. Systems and methods described herein have the following advantages: (1) they permit an application programmer to write, compile, execute, and terminate application code that is to be loaded into a kernel as if the application code was an ordinary application program, (2) they allow a standard programming environment to be used to encapsulate application software in a familiar environment, and (3) they permit automatic cleanup of errors and freeing of program resources when the application terminates.

1 - 9 . (canceled) 
     
     
         10 . A non-transitory computer-readable storage medium including a set of instructions, the set of instructions capable of being executed by a processor, the set of instructions performing the steps of:
 executing an application program;   inserting, when the application program is being executed, a loadable module into an address space of an operating system executing the application program, wherein the loadable module is created from application code of the application program and an environment library;   executing the loadable module; and   unloading the loadable module from the address space when the execution of the loadable module is complete.   
     
     
         11 . The computer readable storage medium of  claim 10 , wherein the set of instructions further perform the steps of:
 connecting a standard output and a standard input of the operating system to a corresponding standard output and standard input of an execution library that performs the inserting of the loadable module; and   connecting the standard output and the standard input of the operating system to channels connecting user space to kernel space.   
     
     
         12 . The computer readable storage medium of  claim 10 , wherein the set of instructions to perform the inserting includes further instructions to perform the steps of:
 collecting arguments to be passed to the loadable module;   creating a child process in the operating system; and   replacing an image of the child process with an image of an insertion process, wherein the loadable module is piped to the insertion process causing the loadable module to be inserted into the address space of the operating system.   
     
     
         13 . The computer readable storage medium of  claim 10 , wherein the set of instructions further perform the step of:
 copying, when the loadable module is inserted into the address space of the operating system, arguments passed by an execution library, wherein the arguments were passed to the execution library by a user invoking the insertion.   
     
     
         14 . The computer readable storage medium of  claim 10 , wherein the set of instructions further perform the step of:
 creating, when the loadable module is inserted into the address space of the operating system, kernel/user channels that connect the loadable module to the application program.   
     
     
         15 . The computer readable storage medium of  claim 10 , wherein the set of instructions further perform the steps of:
 requesting, when the loadable module is inserted into the address space of the operating system, a block of memory from the operating system; and   storing a structure in the block of memory describing the application program in the loadable module for an infrastructure library.   
     
     
         16 . The computer readable storage medium of  claim 10 , wherein the set of instructions further perform the step of:
 placing, when the loadable module is inserted into the address space of the operating system, data describing the application code on a list that is used by an infrastructure library to control modules that the infrastructure library manages.   
     
     
         17 . The computer readable storage medium of  claim 16 , wherein the set of instructions to perform the unloading includes further instructions to perform the step of:
 removing from the list the data describing the application code.   
     
     
         18 . The computer readable storage medium of  claim 14 , wherein the set of instructions to perform the unloading includes further instructions to perform the step of:
 closing the kernel/user channels that connect the loadable module to the application program.   
     
     
         19 . The computer readable storage medium of claim  1 , wherein the set of instructions to perform the unloading includes further instructions to perform the steps of:
 freeing memory associated with the loadable module;   closing files associated with the loadable module; and   releasing semaphores associated with the loadable module.   
     
     
         20 . The computer readable storage medium of  claim 15 , wherein the set of instructions to perform the unloading includes further instructions to perform the step of:
 freeing the block of memory used to store the structure.   
     
     
         21 . A non-transitory computer-readable storage medium including a set of instructions, the set of instructions capable of being executed by a processor, the set of instructions implementing an execution library and performing the steps of:
 collecting arguments to be passed to a loadable module that is to be inserted into an address space of an operating system, wherein the loadable module is related to an application program;   creating a child process in the operating system;   replacing an image of the child process with an image of an insertion process; and   piping the loadable module to the insertion process, the insertion process inserting the loadable module and the arguments in the address space of the operating system.   
     
     
         22 . The computer readable storage medium of  claim 21 , wherein the set of instructions further perform the steps of:
 opening kernel/user channels that were created by the execution of the loadable module in the operating system, wherein data coming from the loadable module is sent to a standard output of the application program and data coming into a standard input of the application program is transmitted to the loadable module.   
     
     
         23 . The computer readable storage medium of  claim 22 , wherein the set of instructions further perform the steps of:
 connecting a standard output and a standard input of the operating system to a corresponding standard output and standard input of the execution library.   
     
     
         24 . A system implemented as a set of instructions stored on a non-transitory computer readable medium and executable by a processor, the system comprising:
 a build system creating a loadable module from application code and creating an executable program from the application code;   an execution library inserting, when the application program is being executed, the loadable module into an address space of an operating system executing the executable program and unloading the loadable module from the address space when the execution of the loadable module is complete.   
     
     
         25 . The system of  claim 24 , wherein the inserting the loadable module into the address space includes collecting arguments to be passed to the loadable module, creating a child process in the operating system, replacing an image of the child process with an image of an insertion process and piping the loadable module to the insertion process, the insertion process inserting the loadable module and the arguments in the address space of the operating system. 
     
     
         26 . The system of  claim 24 , further comprising:
 an environment library insulating the application code from the operating system.   
     
     
         27 . The system of  claim 26 , wherein the creating of the loadable module from the application code further includes the build system linking object code of the application code with object code of the environment library. 
     
     
         28 . The system of  claim 24 , wherein the creating of the executable program from the application code further includes the build system linking object code of the application code with object code of the execution library. 
     
     
         29 . The system of  claim 24 , further comprising:
 an infrastructure library including routines executed prior to the inserting of the loadable module into the address space of the operating system.