Title of Invention

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 mudules into a running opetation system kernel. Systems and methods described herein have the following advantage; (1)they permit an application programmer to write, compile, execute, and termicate application code that is to be loaded into a kernal 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 enviromnent, and (3) they permit automatic cleanup of errors and freeing of program resources when the application termicates.

Full Text

FORM 2 THE PATENTS ACT, 1970 (39 of 1970) & THE PATENTS RULES, 2003 COMPLETE SPECIFICATION [See section 10, Rule 13] SYSTEMS AND METHODS FOR DYNAMICALLY LINKING APPLICATION SOFTWARE INTO A RUNNING OPERATING SYSTEM KERNEL; FINITE STATE MACHINE LABS, INC., INCORPORATED IN THE STATE OF NEW MEXICO, WHOSE ADDRESS IS 204 NEEL AVE., BLDG. B, SOCORRO, NEW MEXICO 87801, U.S.A. THE FOLLOWING SPECIFICATION PARTICULARLY DESCRIBES THE INVENTION AND THE MANNER IN WHICH IT IS TO BE PERFORMED. 1 SYSTEMS AND METHODS FOR DYNAMICALLY LINKING APPLICATION SOFTWARE INTO A RUNNING OPERATING SYSTEM KERNEL COPYRIGHT NOTICE A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever. COMPUTER PROGRAM LISTING APPENDIX A computer program listing appendix on a compact disc incorporating features of the present invention has been submitted with the earlier national application, U.S. Application S.N. 10/670,802, in which this patent application claims priority, and is incorporated herein by reference in its entirety. The files contained on the disc are: (1) user.c (size = 9406 bytes, creation date = 07/10/2003); (2) Makefile (size = 737 bytes, creation date = 07/10/2003); (3) rtl_crt0.c (size = 7151 bytes, creation date = 07/10/2003); (4) example.c (size = 972 bytes, creation date = 09/24/2003); (5) rtl_mainhelper.h (size = 3847 bytes, creation date = 07/10/2003); and (6) rtl_mainhelper.c (size = 5438 bytes, creation date = 07/10/2003). The contents of the above files are attached hereto (see "source code appendix"). The 2 computer program listing and the files contained on the compact discs are subject to copyright protection and any use thereof, other than as part of the reproduction of the patent document or the patent disclosure, is strictly prohibited. BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates, generally, to systems and methods for dynamically linking application software into a running operating system kernel and, more specifically, to systems, software, hardware, products, and processes for use by programmers in creating such application software, and dynamically loading it into and unloading it from a running operating system kernel. 2. Discussion of the Background There are many software applications in which it is desirable to link the software or one or more modules of the software into a running operating system kernel. For example, it is generally desirable to link device driver software into the operating system kernel because it enables the device driver software to access kernel data space. Many operating systems offer utilities for dynamically linking application software (a.k.a, "application code" or "application modules") into a running operating system kernel. Typically, these methods involve copying the application module code 3 and data into kernel memory and then resolving symbol table references. Conventionally, application modules that are to be linked into an operating system kernel include the following sections of code: (1) a section of operating system "kernel" code, (2) a section of code to handle initialization of the module, and (3) a section of code to handle module cleanup when the module is in the process of being removed. These application modules are considered, essentially, to be dynamically loadable parts of the operating system kernel. But operating system kernels provide a very complex and low level interface to these application software modules, complicating the process of developing such application software and requiring the programmer to directly address and write operating system kernel code, code to handle initialization/loading of the application software, and code to handle unloading/cleanup after termination. Furthermore, there is generally no defined and stable application programming interface within an operating system, and required data structures and interfaces change especially rapidly in operating systems, such as, for example, BSD and Linux, further complicating the programmer's development and implementation of the application software. Creating and loading/unloading the modules is often complex, time consuming, and requires constant monitoring and updating of the code to ensure reliable, error-free implementation. 4 What is desired, therefore, are systems and methods to overcome the above described and other disadvantages of the conventional system and methods for dynamically linking modules into a running operating system kernel. * SUMMARY OF THE INVENTION The present invention provides systems and methods for dynamically linking modules into a running operating system kernel. The systems and methods of the present invention overcome the above described and other disadvantages of the conventional systems and methods. For example, the systems and methods specified herein (1) 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 (i.e., not kernel loadable) application program, (2) allow a standard programming environment to be used to encapsulate application software in a familiar environment, and (3) permit automatic cleanup of errors and freeing of program resources when the application terminates. The present invention preserves the advantages of in-kernel programming by providing an application program access to the hardware address space seen by the kernel, as well as access to kernel data structures, internal kernel services and to privileged machine instructions. Advantageously, the present invention can be applied to a wide range of application 5 environments (what the application programmer sees) and kernel environments (the underlying programming environment). For example, we have implemented the method for the POSIX threads application environment and the RTLinux and RTCore BSD kernel environments. The RTLinux kernel environment is described in U.S. Patent No. 5,995,745, the contents of which are incorporated herein by reference. In one embodiment, the system of the present invention enables a programmer to dynamically link application code created by the programmer into a running operating system kernel , wherein the system includes the following components: (1) an environment library comprising one or more routines for insulating the application code from the operating system environment and for implementing a uniform execution environment; (2) a build system for constructing a loadable module from the application code and the environment library; (3) an execution library comprising one or more routines for encapsulating the loadable module within a standard executable program file, transparently loading the loadable module into the running operating system kernel, setting up input/output channels that may be required, passing arguments to the loadable module, and terminating and unloading the loadable module after receiving a termination signal; (4) an infrastructure library comprising one or more routines that may need to be executed prior to loading the loadable module into the running operating system kernel and/or after unloading the loadable module from the kernel (such 6 routines may include routines to allocate stable memory (memory that will need to be held after the module completes and is unloaded), routines to initialize a list of modules that will be managed, routines to free memory used by the module, and routines to close files and free semaphores and other resources used by the module); and (5) a build system for constructing the executable program from the loadable module and the execution library, wherein the executable program may be in several files or a single file. In another aspect, the present invention includes a computer readable medium, such as, for example, an optical or magnetic data storage device, having stored thereon the execution library, the environment library, the infrastructure library, and the build system. The above and other features and advantages of the present invention, as well as the structure and operation of preferred embodiments of the present invention, are described in detail below with reference to the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS The accompanying drawings, which are incorporated herein and form part of the specification, illustrate various embodiments of the present invention and, together with the description, further serve to explain the principles of the invention and to enable a person skilled in 7 the pertinent art to make and use the invention. In the drawings, like reference numbers indicate identical or functionally similar elements. Additionally, the left-most digit(s) of a reference number identifies the drawing in which the reference number first appears. FIG. 1 is a functional block diagram that illustrates the components of a system according to one embodiment of the invention. FIG. 2 is a diagram illustrating a first function of a build system component of the invention. FIG. 3 is a diagram illustrating a second function of a build system component of the invention. '" 1 FIG. 4 is a flow chart illustrating a process 400 that may be performed by build system component of the invention. FIG. 5 is a flow chart illustrating a process performed by the "main" routine of the execution library component of the invention. FIG. 6 illustrates example pseudo-code of an example loadable module. FIG. 7 illustrates a representative computer system for implementing the systems and methods of the present invention for dynamically linking application software into a running operating system kernel. 8 DETAILED DESCRIPTION OF THE PREFERRED EMBODMENT In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular systems, computers, devices, components, techniques, computer languages, storage techniques, software products and systems, operating systems, interfaces, hardware, etc. in order to provide a thorough understanding of the present invention. However, it will be apparent to one skilled in the art that the present invention may be practiced in other embodiments that depart from these specific details. Detailed descriptions of well-known systems, computers, devices, components, techniques, computer languages, storage techniques, software products and systems, operating systems, interfaces, and hardware are omitted so as not to obscure the description of the present invention. FIG. 1 is a functional block diagram that illustrates the components of a system 100, according to one embodiment of the invention, for dynamically linking application code 102 into a running operating system kernel 104. Application code 102 is code written by a user 101 of system 100. In one embodiment, the code is written as a standard WC" program and includes the "main" function. Example application code that can be used with system 100 is provided in the file "example.c", which is included in the above referenced computer program listing appendix. 9 As shown in FIG. 1, system 100 includes an infrastructure library 110, an environment library 112, an execution library 114, and a build system 116. As used herein, the term "library" means: "a set of one or more routines," and the term "routine" means: "a set of one or more program instructions that can be executed." Preferably, each library 112, 114, and 116 is stored in a separate file, but this need not be the case. The libraries could all be stored in one file, in multiple files, or in any other suitable storage architecture or arrangement. Build system 116 is configured to construct a "loadable module" 202 from application code 102 and environment library 112, as is illustrated in FIG. 2. As used herein the term "loadable module" means "object code produced from the application code and environment library." In one embodiment, the build system 116 includes one or more makefiles. As further illustrated in FIG. 3, build system 116 is configured to construct an executable program 302 from loadable module 202 and execution library 114. FIG. 4 is a flow chart illustrating a process 400 that may be performed by build system 116 to create loadable module 202 and executable program 302. Process 400 can be used when, for example, the C programming language is used in implementing the invention or with any other comparable programming language. Process 400 begins in step 402, where build system 116 compiles application code 102 into object code. Next (step 10 404), build system 116 links the object code with the environment library 112 object code to produce a linked object module. Next (step 406), build system 116 converts the linked object module into a C code array. This C code array is the "loadable module." Next (step 408), build system 116 compiles the C code array produced in step 406 to produce an object file. Next (step 410), system 116 links the object file produced in step 408 with execution library 112 object code to produce the executable program 302. In one embodiment, when user 101 executes program 302, a routine from the execution library 114 sets up an input channel and an output channel by connecting the standard output and standard input of the original process to the standard output and input of the process that will insert the module, and to the fifos that connect user space to kernel space. Setting up the input/output channels is optional if application code 102 does not use input/output channels. Also, when program 302 is executed a routine from execution library 114 inserts loadable module 202 into the operating system address space. Once loadable module 202 is inserted into the operating system address space, loadable module 202 begins to execute. If application code 102, which is included in loadable module 202, uses input/output channels, then a routine from execution library 114 waits for loadable module 202 to connect via kernel/user channels, which are implemented as RT-fifos in this embodiment, and then connects those kernel/user I I channels to the input/output channels mentioned above. . - , After loadable module 202 begins to execute, a routine from environment library 112 creates kernel/user channels, creates a thread to execute application code 102, and then waits for the thread to complete. Creating the kernel/user channels is optional. When the thread completes, a routine from environment library 112 frees resources and unloads loadable module 202. The routines from environment library 112 may need to call routines from infrastructure library 110 for carrying out their work. For example, environment library 112 may delegate some cleanup operations to infrastructure library 110 so that cleanup can take place after loadable module 202 has been unloaded. EXAMPLE CODE FOR IMPLEMENTING THE INVENTION The following examples of code are for the Linux, RTLinux, and/or RTCore BSD operating systems. However, the present invention is not limited to operating only within the Linux operating system. The present invention can, for example, work with other operating systems, including: Net BSD and Free BSD, Apple OS X, other UNIX type operating systems, WindRiver's VxWorks system, and Microsoft's XP and NT operating systems. Example code for implementing execution library 114 is provided in the file "user.c", which is included in the above referenced computer program listing appendix. This code is merely an example and should not be used to limit the invention. 12 The example code for implementing execution library 114 is written in the C language and includes a "main" routine. This main routine is the first routine that is executed after user 101 executes executable program 302. FIG. 5 is a flow chart illustrating the process 500 performed by the main routine. As shown in FIG. 5, the main routine collects the arguments to be passed to loadable module 202 (step 502). Next (step 504), the main routine sets up the input and output channels. Next (step 506), main routine creates a child process by executing the fork() routine. The child process immediately replaces its process image with the insmod process image. The child process does this by executing the execl() routine. Next (step 508), the main routine pipes loadable module 202 to the insmod process. This causes the insmod process to put loadable module 202 with arguments in kernel address space. When the application code within loadable module 202 begins running in kernel space, a routine within loadable module 202 will create kernel/user channels (e.g., RTCore "fifos") that move data between kernel and user space. The main routine waits until it can open these kernel/user channels (step 510) . Once it can open the channels it does and then uses the channels to transfer data back and forth so that data coming from loadable module 202 is sent to the standard output of executable program 302 and data coming into the standard input of executable program 302 is 13 transmitted via the kernel/user channel to loadable module 202 (step 512). ', Example code for implementing environment library 112 is provided in the file "rtl_crt0.c", which is included in the above referenced computer program listing appendix. This code is merely an example and should not be used to limit the invention. As discussed above, environment library 112 includes one or more routines for insulating application code 102 from the operating system environment and implementing a uniform execution environment. That is, instead of depending on a changeable and specialized operating system interface, the program can use standard WC" interfaces - or alternatively, any standard application programming interface. For example, in the current embodiment of the invention, instead of using a Linux kernel "sys_open" operation applied to some terminal device so that the program can output data, the program can simply use the standard "printf" routine. Instead of using some OS dependent routine for generating a thread, the program can use "pthread_create" - a POSIX standard function. As shown in the example code, environment library 112 includes an initialization routine called "init_module()" for performing the functions of insulating application code 102 from the operating system environment and implementing a uniform execution environment. The init_module routine is executed as soon as the module is loaded 14 into the kernel address space and is executed in the context of the process that invokes the insert/load operation. The init_module performs the following steps: (1) copies in arguments that have been passed to it by the execution library and that were passed to the execution library by the user or program that invoked the process, (2) creates the kernel/user channels that connect loadable module 202 to the executable program 302, (3) requests a block of memory from the operating system and stores a "task" structure that describes the application in the module to the infrastructure library, (4) puts the data describing application code 102 on a "task" list that is used by the infrastructure library to control all the modules that it manages, and (5) creates a Linux kernel thread to run a "startup_thread" routine, which is included in the infrastructure library 110 and which is describe below. As further shown, environment library 112 may also include a cleanup routine. The cleanup routine included in the example environment library is called "cleanup_module." The cleanup_module routine performs the following task: (1) removes from the task list the task (i.e., the data describing application code 102; (2) waits for the kernel thread to terminate; (3) closes the channels created by the init_module; (4) cleans up state by freeing memory, closing files, and releasing semaphores and possibly other resources; and (5) frees the block of memory that was used to store the task structure. 15 Example code for implementing infrastructure library 110 is provided in the files "mainhelper.c" and "mainhelper. h", which are included in the above referenced computer program listing appendix. This code is merely an example and should not be used to limit the invention. The example infrastructure library 110 includes the "startup_thread" routine. As discussed above, the init_module routine creates a Linux kernel thread to run the startup_thread routine. As is illustrated from the example code, the startup_thread routine does some operating system specific setup by detaching the kernel process from any terminals ("daemonize" in Linux), and filling in information in the task structure such as the identity of the current kernel thread, and then executes application code 102 by calling the "task" function. After executing application code 102, the startup_thread routine waits for application code 102 to terminate. When application code 102 terminates, the startup_thread routine sends the application code 102 return value down the output channel, signals completion, and exits. By signaling completion, the startup_thread routine causes the cleanup_module routine to execute. The example infrastructure module 110 further includes a routine called "rtl_main_wait." This routine implements the function to wait for the application kernel thread to complete. The function “rtl_main_wait" is called in the application after threads are started so that the "main" routine can 16 safely be suspended until the subsidiary threads are completed. Example code for implementing build system 116 is provided in the file "Makefile", which is included in the above referenced computer program listing appendix. This code is merely an example and should not be used to limit the invention. EXAMPLE APPLICATIONS OF THE INVENTION In general, all of the modules described below require the addition of application code to a running or booting operating system - the basic functionality provided by loadable kernel modules. Utilizing the present invention, the modules are all (1) simpler to develop and debug, (2) simpler to connect to other components to make a useful software system, and (3) more reliable. Since development time and software reusability (connection to existing software applications) dominate the costs of producing software, the invention provides a significant economic value. In addition, the present invention provides the programmer with a familiar, less complicated development environment, and does not require the programmer to handle complicated kernel-related initialization/loading and unloading/cleanup functions. The invention, thus, facilitates more reliable, error-free application code. (1) A real-time data acquisition module under RTLinux: 17 The present invention enables a loadable kernel data acquisition module to be developed and tested as if the module were a standard non-kernel module. To develop a real-time data acquisition system in RTLinux using the invention all one needs to do is write a program that runs under the UNIX operating system. The program should include a main program and a thread. The thread should be configured to sample data from the device from which data is to be acquired (e.g., a voltage sensor) at a fixed interval and then write the data to standard output. The program text in pseudo-code 600 is shown in FIG. 6. This program can be tested for logical correctness under any POSIX compliant standard UNIX. After testing for logical correctness, the program can be rebuilt using build system 116 to create an executable program that can be run under RTLinux or RTCore BSD, for example. The complexity of launching the thread into the real-time operating system, connecting the thread to data streams, and closing the module on termination is now all hidden to the application. The module can be tested on a UNIX command line with the command: % data_acquisition > test_file. (2) A device driver module: As noted herein, the invention provides a means of simplifying and automating module deployment and testing. Currently, the most common use for loadable kernel modules is for device drivers that are not statically linked into the 18 operating system. Drivers in loadable kernel module form allow an operating system to configure itself on boot - adding drivers for devices it detects -and allowing users and system administrators to update systems by, for example, upgrading a disk drive or a communications device and adding a new driver without re-booting a system and interrupting other functions. However, driver modules are often very dependent on specific releases of the operating system and are notorious for failing to cooperate with other components. Using the invention, a driver developer can insulate the driver from non-relevant operating system internal changes. More importantly, a system administrator can rely on the automatic cleanup provided by the invention to improve reliability and rely on the automatic setup of communication channels to improve reports. In a Linux system, without the invention, the method for testing a loadable kernel driver module might involve the following steps: (1) the administrator logs in as root to get the correct privileges; (2) the administrator uses the "insmod" utility to attempt to load the driver; and (3) if the insmod utility works, the system administrator uses a "dmesg" utility to print out internal operating system diagnostic messages and to see if he or she can find one relevant to the driver. Suppose that the driver cannot correctly start because, for example, a prior driver for the device has not been removed. At this point, the system administrator must use the "rmmod" tool to try to remove both the 19 new driver and the prior one, and then again tries to install the new driver. The driver writer must have correctly handled the complex case of responding to an "rmmod" request. With the invention, the method for testing the loadable kernel driver is much simpler. The method might include simply the step of running the executable program that loads the module into the kernel. If the module needs to be unloaded from the kernel, the administrator need only execute the kill command to kill the executable program. (3) An encryption module: This example illustrates the value of the automatic creation of input/output channels by the invention. Suppose that we have a generic operating system module that provides an encryption and security stamp facility and want to attach it to a database. The command line for initiating secure operation of the database in a system utilizing the invention might be: %(decrypt_input | my_database | encrypt_output)& so that the two security modules (i.e., wdecrypt_input" and "encrypt_output") are automatically loaded and connected to the inputs and outputs of database module, wmy_database". The entire system can be terminated and automatically unloaded with a single signal. (4) A security module: Loadable kernel modules are themselves potentially a security weakness of an operating 20 \ 1 system, since modules traditionally operate within the address space and with all privileges of the operating system itself. There is generally only a check on whether the user loading the module has sufficient privileges to load a module. However, the invention makes it convenient to add more sophisticated security checking either directly in the infrastructure libraries or in a root module that controls all module loads after loading. This module can validate certificates and even provide dynamic code check. (5) A fault tolerant module: The invention provides a means of dynamically adding a fault tolerance capability to a running operating system by adding a kernel data logger. For example, the script % checkpoint_kernel | netcat 10.0.0.244:45 runs a fault tolerance module named "checkpoint_kernel" and sends the module's output to a standard program (i.e., "netcat") that directs output to a named internet site and TCP port. Using prior methods, the programmer would have had to hand code creation of an output channel in the checkpoint_kernel module and then produce further code to redirect the data to a destination and to process the destination IP and port as parameters. FIG. 7 is an illustration of a representative computer system for implementing the systems and methods of the present invention for dynamically linking application software into a running operating system kernel. With reference to 21 FIG. 7, the method of the present invention may be advantageously implemented using one or more computer programs executing on a computer system 702 having a processor or central processing unit 704, such as, for example, a workstation, server, or embedded-single-board computer using, for example, an Intel-based CPU, such a Centrino, running one of the operating systems previously described, having a memory 706, such as, for example, a hard drive, RAM, ROM, a compact disc, magneto-optical storage device, and/or fixed or removable media, having a one or more user interface devices 708, such as, for example, computer terminals, personal computers, laptop computers, and/or handheld devices, with an input means, such as, for example, a keyboard 710, mouse, pointing device, and/or microphone. The computer program is stored in memory 11 along with other parameters and data necessary to implement the method of the present invention. In addition, the computer system 702 may include an analog-to-digital converter, sensors, and various input-output devices, and may be coupled to a computer network, which may also be communicatively coupled to the Internet and/or other computer network to facilitate data transfer and operator control. The systems, processes, and components set forth in the present description may be implemented using one or more general purpose computers, microprocessors, or the like programmed according to the teachings of the present specification, as will 22 be appreciated by those skilled in the relevant art(s). Appropriate software coding can readily be prepared by skilled programmers based on the teachings of the present disclosure, as will be apparent to those skilled in the relevant art(s). The present invention thus also includes a computer-based product which may be hosted on a storage medium and include instructions that can be used to program a computer to perform a process in accordance with the present invention. The storage medium can include, but is not limited to, any type of disk including a floppy disk, optical disk, CDROM, magneto-optical disk, ROMs, RAMs, EPROMs, EEPROMs, flash memory, magnetic or optical cards, or any type of media suitable for storing electronic instructions, either locally or remotely. While the processes described herein have been illustrated as a series or sequence of steps, the steps need not necessarily be performed in the order described, unless indicated otherwise. The foregoing has described the principles, embodiments, and modes of operation of the present invention. However, the invention should not be construed as being limited to the particular embodiments described above, as they should be regarded as being illustrative and not as restrictive. It should be appreciated that variations may be made in those embodiments by those skilled in the art without departing from the scope of the present invention. Obviously, numerous modifications and variations of the present 23 I invention are possible in light of the above teachings. It is therefore to be understood that the invention may be practiced otherwise than as specifically described herein. Thus, the breadth and scope of the present invention should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents. 24 Source Code Appendix: The following is an example of a loadable kernel module. /* Copyright (C) Finite State Machine Labs Inc., 1995-2003. All rights reserved. */ #include #include #include pthread_t thread; void *thread-code(void *t) { struct timespec next; clock_gettime( CLOCK_REALTIME, &next ); while ( 1 ) { timespec-add-ns( &Next, 1000*1000 ); clock-nanosleep( CLOCK_REALTIME, TIMER_ABSTIME, &next, NULL); printf("inside thread\n"); } return NULL; } int main(void) { int ret; ret = pthread_create( &thread, NULL, thread_code, (void *)0 ); if (ret) { printf("Error on create\n"); return -1; } /* wait for the thread to exit or an asynchronous signal to stop us */ rtl_main_wait() ; ret = pthread_cancel( thread ); if (ret) { printf("Error on cancel\n"); return -2; } ret = pthread-join( thread, NULL ); if (ret) { printf("Error on join\n"); return -31; } 25 return 0; } 2.6 # # MAKEFILE - RTLINUX_COPYRIGHT # include ../rtl.mk CFLAGS := ${SYSCFLAGS} ifeq ($(CONFIG_UCLINUX),) all: rtl_crt0.o array user.o user-nostdout.o copy else all: array copy endif ifeq ($(CONFIG_RTL_BSD),y) USER_EXTRA += user-elf.o endif copy: mkdir -p ../libs -cp -f rtl_crt0.o user-nostdout.o user.o array ../libs user.o: user.c $(USER_EXTRA) $(CC) $(INCLUDE) -c user.c -o temp.o $(LD) -r -o user.o temp.o $(USER_EXTRA) , @rm -f temp.o user_nostdout.o: user.c $(USER_EXTRA) $(CC) $(INCLUDE) -DRTL_NO_STDOUT=l -c user.c -o temp.o $(LD) -r -o user_nostdout.o temp.o $(USER_EXTRA) @rm -f temp.o array: array.c $(HOSTCC) -o array array.c clean: rm -f *.o *.rtl array include ../Rules.make 27 /* * RTLINUX_COPYRIGHT */ #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_RTL_NETBSD # include #endif #ifdef CONFIG_RTL_LINUX int stdout-_fifo = -1; /* per-task info for RTLinux to keep track of applications */ extern struct per-_task-_info *info; extern int main(int argc, char **); int argc; char * argv[RTL_MAIN_MAXARGS] ; MODULE_PARM(argv, "1-" MODULE_STRING (RTL_MAIN_MAXARGS) " S " ) ; MODULE_PARM(argc,"i"); int init_module(void) { struct per_task_info *inf; /* setup our task info */ if ( !(inf = (struct per_task_info *)kmalloc( sizeof(struct per_task_info), GFP_KERNEL)) ) return -1; inf->modu1e = & this_modu1e; inf->mainfunc = main; /* 28 * If we're loaded by the user with insmod instead of * by the user program with the module built into it * then argc/argv may not be set right. Setup some * safe defaults if so. -- Cort */ if ( large ) { argc = 1; argv[0] = "this-_program"; } inf->argc = argc; inf->argv = argv; init-_completion( &inf->mainwait ); init-_completion( &inf->waitexit ); /* create the stdout FIFO */ { int ret; char fnam[16]; inf->stdout-_pid = current->pid; sprintf(fnam, "/dev/stdout.%d", inf->stdout-pid); if ( (ret = rtl-_mkfifo(fnam, 0666)) ) { printk("mkfifo() of %s failed\n", fnam) ; rtl-perror("mkfifo()"); } /* open the file for read only */ if ( (stdout_fifo = rtl-_open(fnam, RTL_0_WRONLY|RTL-0_NONBLOCK)) printk("open() of %s failed\n", fnam) ; rtl-_perror("open()"); } inf->stdout_fifo = stdout_fifo; } /* add this to the list */ spin-lock( &per-task-lock ); inf->next = info; info = inf; spin-unlock( &per-task-lock ) ; 23 if ( kernel-thread(startup_thread, (void *)inf, CLONE_FS | CLONE_FILES | CLONE_SIGNAL | SIGCHLD ) return -1; else return 0; } void c1eanup_modu1e(void) { struct per_task_info *inf, *free = NULL; /* remove entry this from the list */ spin-lock(&per-task-lock) ; if (info && (info->module == & this-module)) { free = info; info = info->next; } else { inf = info; while (inf) { if (inf->next->module == &-- this-module) { free = inf->next->next; inf = inf->next; break; } } } spin-unlock(&per-task-lock); if (!free) { rtl-printf("Did not find task on list!\n"); return; } /* wakeup the GPOS task */ complete(&free->mainwait); /* wait for the GPOS task to exit */ wait-_for-completion(&free->waitexit); /* remove the stdout FIFO */ { char fnam[16]; int ret; rtl-close(stdout_fifo); 3o sprintf(fnam, "/dev/stdout.%d", free->stdout-pid); if ( (ret = rtl-unlink(fnam)) rtL-perror("unlink() ") ; } } /* cleanup any state this module left */ rtl-cleanup-module(free); /* free the structure now that it's done */ kfree(free); } #endif /* CONFIG_RTL_LINUX */ #ifdef CONFIG_RTL_NETBSD int rtl-main-split-args(const char *cmdline, char **args); void rtl-main-free-args(char **args); /* Module management functions */ int rtl-main-init_module(struct per_task_info *inf) { const unsigned int buf-size = 256; struct rtl-module *module = inf->module; struct proc *pptr = curproc->p-pptr; char *cmdline; int ret; cmdline = malloc(buf-size, M_TEMP, M_WAITOK | M_ZERO); if (cmdline == NULL) return -ENOMEM; /* modload, is called via a shell script */ inf->stdout-pid = pptr->p-pid; /* split up the arguments */ inf->argv[0] = NULL; inf->argc = rtl-main-split-args(inf- >–– rtl-main-args, inf->argv); if (inf->argc 31 goto out; } if (inf->argc ==0) { /* no arguments, setup sane defaults */ snprintf(inf->argv[0], RTL_MAIN_ARGLEN, "% s", module->name); inf->argc = 1; } /* initialize completion idents */ init-completion(&inf->mainwait); init-completion(&inf->waitexit); /* create the stdout FIFO */ sprintf(cmdline, "/dev/stdout.%d", inf->stdout-pid); /* * attribute this one to the core system, otherwise our * refcount will be high, ditto for open */ if ((ret = rtl_mkfifo(cmdline, 0666, NULL))) { rtl-_printf ("mkfifo() of %s failed\n", cmdline); rtl-perror("mkfifo()"); } /* open the file for write only */ inf->stdout_fifo = rtl-open(cmdline, RTL_0_WRONLY|RTL_0_NONBLOCK, NULL); if (inf->stdout_fifo Rtl-printf ("open() of %s failed\n", cmdline) ; Rtl-perror("open()"); } /* Add this task to the head of the global list */ simple-lock(&per-task-lock); SLIST_INSERT_HEAD(&rtl-task-list, inf, list); simple-unlock(&per-task-lock); /* * finally, fire up our kernel thread, upon successful exit. 32. * inf->tsk has our task struct and we have a kernel thread * called module->name. */ ret = kthread-createl(startup_thread, inf, &inf->tsk, "%s", module->name); out: free(cmdline, M_TEMP); return ret; } int rtl-main-cleanup_module(struct per_task_info *inf) { char buf[32]; int ret; simple-lock(&per-task-lock); SLIST_REMOVE(&rtl-task-list, inf, per_task_info, list); simple-_unlock(&per-task-lock) ; /* wakeup the GPOS task */ complete(&inf->mainwait); /* wait for GPOS task completion */ wait-for-completion(&inf->waitexit); /* * remove our stdout fifo, we don't have to lock anymore because * we're not in the rtl-task-list lock anymore */ rtl-close(inf->stdout_fifo); sprintf(buf, "/dev/stdout.%d",inf->stdout-pid); if ((ret = rtl-unlink(buf)) rtl-printf("unlink() of %s failed\n", buf); rtl-perror("unlink()"); simple-unlock(&per-task-lock); return ret; } /* cleanup any state the module left behind */ 33 I rtl_cleanup_module(inf); rtl-main-free-args(inf->argv); return 0; } /* * rtl-main-split-args - split arguments in @cmdline into an argv array * ©cmdline: the argument list * @args: the array to store the returned arguments, the function * will only allocate the string array. */ int rtl-main-split-args(const char *cmdline, char **args) { const int m-flags = M_WAITOK | M_ZERO; int i, j, idx; char *buf; buf = malloc(RTL_MAIN_MAXARGS * RTL_MAIN_ARGLEN, M_TEMP, m-flags); if (!buf) return -ENOMEM; for (i = 0; i args[i] = buf + (i * RTL_MAIN_ARGLEN); i = 0, j = 0, idx = 0; while (cmdline[i] && (idx { if (j >= RTL_MAIN_ARGLEN) break; args[idx][j] = cmdline[i]; if (isspace(cmdline[i])) { args[idx][j] = '\0■; idx++; j = 0; } else j++; i++; } return idx; } 34 void rtl_main_free_args(char **args) { free(args[0], M_TEMP); } . #endif /* CONFIG_RTL_NETBSD */ 35 /*. * RTLINUX_COPYRIGHT */ #include #include #include #include #include #include #include #include #ifdef CONFIG_RTL_NETBSD #include #include struct simplelock per-task-lock = SIMPLELOCK_INITIALIZER; struct rtl-task-list_s rtl-task-list = SLIST_HEAD_INITIALIZER(rtl-task-list); #endif /* CONFIG_RTL_NETBSD */ #ifdef CONFIG_RTL_LINUX /* per-task info for RTLinux to keep track of applications */ spinlock-t per-task-_lock = SPIN_LOCK_UNLOCKED; struct per_task_info *info = NULL; #endif /* CONFIG_RTL_LINUX */ kthread_ret_t startup_thread(void *arg) { struct per_task_info *inf = (struct per_task_info *)arg; int ret, temp = -1; #ifdef CONFIG_RTL_LINUX /* detach this thread from the user/tty */ daemonize(); /* * update some per-process information, inf >tsk is already * set to curproc on NetBSD */ inf->tsk = current; #endif /* CONFIG_RTL_LINUX */ 36 inf->thread = inf->module; /* call the task main routine */ ret = inf->mainfunc(inf->argc, inf->argv); /* we have the return value, send it to the user-program */ rtl-write(inf->stdout_fifo, &temp, sizeof(temp)); rtl-write(inf->stdout_fifo, &ret, sizeof(ret)); /* wake up the cleanup_module() routine if it's waiting on us */ complete(&inf->waitexit) ; /* * We always return success here. That way, the module * loading always appears successful for the user-program * unless there was an actual load problem (unresolved references, * bad file and so on). * * When there is an error from main() or any other operation * inside the application then we return the error value above * through the stdout FIFO. * -- Cort */ #ifdef CONFIG_RTL_LINUX return 0; #endif #ifdef CONFIG_RTL_NETBSD kthread-exit(0); #endif } void rtl_main_wait(struct rtl_module *module) { struct per_task_info *inf = NULL; #ifdef CONFIG_RTL_LINUX /* remove entry this from the list */ spin-lock(&per-task-lock); inf = info; 37 while (inf) { if (inf->module == module) break; inf = inf->next; } spin-unlock(&per-task-lock); #endif /* CONFIG_RTL_LINUX */ #ifdef CONFIG_RTL_NETBSD simple-lock(&per-task-lock); SLIST_FOREACH(inf, &rtl-task-list, list) { if (inf->module == module) break; } simple-unlock(&per-task-lock); #endif /* CONFIG_RTL_NETBSD */ if (!inf) { rtl_printf("%s:%d !inf\n", FILE , LINE ) ; return; } /* wait for an rmmod event */ wait-for-completion(&inf->mainwait); } #ifdef CONFIG_RTL_NETBSD /* sleep until completion wakeup, the ->done is so that if a thread * completes before the waiter the waiter can proceed */ void wait-for-completion{struct completion *ident) { simple-lock(&ident->lock); while (ident->done ==0) { ltsleep(ident, curproc->p-priority | PCATCH, FUNCTION , 0, &ident->lock); } simple-unlock(&ident->lock); } void complete(struct completion *ident) { simple-lock(&ident->lock) ; ident->done++; 3S simple-unlock(&ident->lock); wakeup(ident); } #endif /* * Cleanup after a rtlinux module that has exited */ void rtl_cleanup_module(struct per_task_info *inf) { int i; #if 0 rtl-_pthread_t t; /* cancel/join all threads for this module */ repeat: rtl-spin-lock( &sched-data(i)->rtl-tasks-lock >; for ( i = 0; i rtl_tasks; while( t != NULL ) { if ( t->creator == & this-module ) { rtl_printf("Canceling thread %08x\n", t); rtl-spin-unlock( &sched-data(i)->rtl-tasks-lock ); if ( rtl-pthread_cancel( t ) ) rtl_printf("cancel failed\n"); if ( rtl-pthread_join( t, NULL ) ) rtl_printf("join failed\n"); goto repeat; } t = t->next; } rtl-spin-_unlock( &sched-data(i)->rtl-tasks-lock ); } #endif /* kill any FDs that this task opened */ for ( i = 0 ; i incr-_fd_usage(i); if ( (rtl-fds[i].f-op) && (rtl-fds[i].creator == inf->module) ) rtl-close( i ); 33 decr-fd-usage(i) ; } /* unregister any devices that this task managed */ for ( i = 0 / i incr-dev-usage(i) ; if ( (rtl-inodes[i].valid) && (rtl-inodes[i].creator == inf->thread) ) { /* find all FDs that have this file open */ for ( j = 0 ; j incr-fd-usage(j); if ( (rtl-fds[j].f-op) && (rtl-fds[j].devs-index == i) ) rtl-close( j ); decr-fd-usage(j) ; } if (i >= CONFIG_RTL_MAX_LEGACY_DEV) { /* need to unlink unconditionally */ if (rtl-inodesfi].has-gpos-file) { rtl-gpos-unlink(rtl-inodes[i].name); rtl-inodes[i].has-gpos-file = 0; } /* The user may have pushed usage to any amount. Reset and handle now. */ rtl_xchg(&rtl_inodes[i].use_count,1); /* The GPOS user may still be out there. Let them go - they'll clean up. Otherwise, do it here, (the deer will drop usage 1 to 0. */ if (!rtl-gpos-devices[i].active) { 40 decr_dev_usage(i); rtl_gpos_unregister_dev(rtl_inodes[i].name); rtl-unregister-dev(rtl_inodes[i].name); } } } else { decr_dev_usage(i); } } } 41 /* * RTLINUX_COPYRIGHT */ #ifndef RTL_MAINHELPER idefine RTL_MAINHELPER #include #ifndef CONFIG_UCLINUX /* max # of arguments that can be passed into a main() * program via argc/argv */ #define RTL_MAIN_MAXARGS 5 #define RTL_MAIN_ARGLEN 64 #ifdef KERNEL #ifdef CONFIG_RTL_LINUX extern spinlock-t per-task-lock; struct per_task_info { struct rtl_module *module; struct rtl_module *thread; struct per_task_info *next; struct task-struct *tsk; int (*mainfunc)(int, char **); struct completion mainwait, waitexit; int argc; char **argv; int stdout_fifo, stdout_pid; }; typedef int kthread_ret_t; #endif /* CONFIG_RTL_LINUX */ #ifdef CONFIG_RTL_NETBSD # include struct completion { struct simplelock lock; unsigned int done; }; /* Used to protect rtl-task-list traversal/insertion/removal */ extern struct simplelock per-task-lock; struct per_task_info { struct rtl_module *module; struct rtl_module *thread; SLIST_ENTRY(per_task_info) list; struct proc *tsk; int (*mainfunc) (int, char **) ; struct completion mainwait, waitexit; int argc; char *argv[RTL_MAIN_MAXARGSJ; char * rtl-main-args; int stdout_fifo, stdout_pid; }; typedef void kthread_ret_t; SLIST_HEAD(rtl-task-list_s, per_task_info); extern struct rtl-task-list_s rtl-task-list; extern void complete(struct completion *); extern void wait-for-completion(struct completion *); #define init_completion(x) do { simple_lock_init(&(x)->lock); (x)->done = 0; \ } while (0) /*************************************************** *** * * We only include the following in 'main' applications * **************************************************** **/ #ifdef KMOD #undef RTL_MODULE #undef RTLINUX_MODULE /* * Note the declaration of main,' there are too many users of int main(void) * and this only results in a warning, however really they should not be using A3 * that kind of a declaration for their main function. The correct definition * being int main(int, char **) and parameter passing might have undefined side * effects on some systems -Zwane */ #define RTLINUX_MODULE(modname) MOD_MISC(#modname) static char -rtl-main-args[RTL_MAIN_MAXARGS*RTL_MAIN_ARGLEN] attribute ((section(".rtl-main-args"))); static struct rtl_module this-_module = {.usecount = 0, .name = #modname}; extern int rtl-main-init-module(struct per_task_info *); extern int rtl-main-cleanup-module (struct per_task_info *); static int main();static struct per_task_info inf = { .mainfunc = main, .module = & this-_module, . rtl-main-args = rtl-main-args }; static int modname##_module_handle(struct lkm_table *lkmtp, int cmd) (int err = 0; \ switch (cmd) {\ case LKM_E_LOAD:\ if (lkmexists(lkmtp))\ return -EEXIST;\ err = rtl-main-init_module(& inf);break;\ case LKM_E_UNLOAD:\ if ( this-module-usecount > 0) { return -EBUSY; \ } err = rtl-main-cleanup_module(& inf);break;\ default:err = -EINVAL;4A i break;}\ return err;\ }\ int modname##-lkmentry(struct lkm_table *lkmtp, int cmd, int ver)\ (DISPATCH(lkmtp,cmd,ver,modname##_module_handle, modname##_module_handle, lkm-nofunc)\ } #define RTL_MODULE(modname) RTLINUX_MODULE(modname) /* This is defined during build to evaluate to RTL_MODULE(module) */ KMOD /* The real main entry point */ #define main static main #define stdout_fifo ( inf-stdout-fifo) #endif /* KMOD */ #endif /* CONFIG_RTL_NETBSD */ extern void rtl_cleanup_module(struct per_task_info *); extern kthread_ret_t startup_thread(void *); #endif /* KERNEL */ #endif /* CONFIG_UCLINUX */ #endif /* RTL_MAINHELPER */ 45 y /* * RTLINUX COPYRIGHT #include #include #include #include #include #include #include #include #include #include #include #include #include #include char filename[255]; char *paths[] = { ■/opt/rtldk-2.0/bin/", "/opt/rtldk-1.2/bin/", "/sbin/", ,,/binn, " /usr/bin/", NULL }; char *program = NULL; void setup-signals(void); void do-printf-read(void); /* stdout FD from the module */ int f ; /* return value from the module */ int retval = 0, have-retval = 0; #ifdef CONFIG_RTL_NETBSD int loading-rtcore = 0; #endif int platform-exec(char *cmd, char *module-argc, char *args) { #if defined(CONFIG_RTL_LINUX) return execl(cmd, cmd, filename, "-o", program, module-argc, args, NULL); #elif defined(CONFIG_RTL_NETBSD) return execl(cmd, cmd, filename, NULL); #endif } 46 void prepare-arguments(int argc, char **argv, char * argc, char * argv) { int i; argv[0] = 0; #if defined(CONFIG_RTL_LINUX) /* setup args for the module itself */ sprintf( argc, "argc=%d", argc); sprintf( argv, "argv=\"%s\"", argv[0]); for ( i = 1; i sprintf( argv, "%s,\"%s\"", argv, argv[i]); #elif defined(CONFIG_RTL_NETBSD) /* we take the arguments as-is under BSD */ sprintf( argv, "%s ", program); /* argv[0] */ for (i = 1; i streat( argv, argv[i]); streat( argv, " "); } #endif } void handler(int signal) { char command[256]; int i ; struct stat buf; /* find the right path */ for ( i = 0 ; paths[i] != 0; i++ ) { sprintf(command, "%srmmod", paths[i]); if ( !stat( command, &buf ) ) break; } /* error if we could not find rmmod */ if { !paths[i] ) { fprintf(stderr, "Could not find rmmod\n") exit(-1); } sprintf(command, "%s %s", command, program); i = system(command); if ( i != 0 ) { 47 fprintf(stderr,"%s: received signal but removal of module failed.\n", program); fprintf(stderr,"There may be other programs running that require this module.\n"); setup-signals(); return; } #ifndef RTL_NO_STDOUT /* if we don't have the retval set, get one */ while ( !have-retval ) { do-printf-read(); } #endif /* RTL_NO_STDOUT */ close(f); exit(retval); } void setup-signals(void) { struct sigaction act; /* setup to catch any signals that this process receives */ act.sa-handler = handler; act.sa-flags = SA_RESETHAND; sigaction(SIGINT, &act, NULL); sigaction(SIGQUIT, &act, NULL); sigaction(SIGTERM, &act, NULL); } char cmd[256], args[256], module_argc[16]; #ifndef RTL_NO_STDOUT void do-printf-read(void) { /* for reading stdout data from the module */ char *fmt = NULL, *string = NULL; int fmtlen = 0; int argtype, argsize; int i; /* read the size of the fmt string */ if ( read(f, &i, sizeof(i)) fprintf(stderr, "%s: read of string length failed\n", program); ^8 ■j- perror (" read () ") ; exit(-1); } /* * special case for when the main() routine in the kernel exits on * its own */ if ( i == -1 ) { /* read the return value */ ) { retval\n" if ( read(f, &retval, sizeof(retval)) fprintf(stderr, "%s: read of program); perror("read()"); exit(-1); } } have-retval = 1; return; /* read the size of the arg */ if ( read(f, &argsize, sizeof(argsize)) { fprintf(stderr, "%s: read of arg length failed\n", program); perror("read()"); exit(-1); } /* get the arg type */ if ( (read(f, &argtype, sizeof(argtype))) fprintf(stderr, "%s: read of arg type failed\n", program); perror("read()"); exit(-1); } /* if the string is too large, get more memory */ if ( i+1 > fmtlen ) { if ( fmt ) free(fmt); fmtlen = i+1; 43 if ( (fmt = (char *)malloc(fmtlen)) { fprintf(stderr, "Cannot allocate memory for larger format string\n"); perror("malloc()") ; } } /* read the format string */ if ( (read{f, fmt, i)) fprintf(stderr, "%s: read of fmt string failed\n", program); perror(n read() ") ; exit(-l); } fmt[i] = 0; /* if there is no arg, just print the string and continue */ if ( argsize == 0 ) { printf(fmt); fflush(stdout); return; } /* read the argument */ switch( (char)argtype ) { int d; char * s; unsigned long 1; double dl; case 'f' : if ( (read(f, &dl, argsize)) perror("read() ") ; exit(-l); } printf(fmt, dl) ; fflush(stdout); break; case 'p': if ( (read(f, &1, argsize)) perror("read()"); exit(-1); } 50 printf(fmt, 1); fflush(stdout); break; case 'd1: case 'i ' : case 'o': case ' u': case 'x': case 'X': if ( (read(f, &d, argsize)) perror("read() ") ; exit(-1); } printf(fmt, d); fflush(stdout); break; case 'c': if ( (read(f, &d, argsize)) perror("read()"); exit(-1); } printf(fmt, (char)d); fflush(stdout); break; case 's': /* get space for the string */ if ( (string = (char *)malloc(argsize+1)) fprintf(stderr, "Cannot allocate memory for string arg\n"); perror("malloc()"); } if ( (read(f, string, argsize)). ) { fprintf(stderr, "%s: read of 's' type failed\n", program); perror("read()"); exit(-1); } string[argsize] = 0; printf( fmt, string ); fflush(stdout); 51 free( string ); break; } } #endif /* RTL_NO_STDOUT */ int main(int argc, char **argv) { extern char module-data[]; extern unsigned long module size; int sysret, child, status, i; struct stat buf; fd-set readfds, writefds, exceptfds; mode-t old_umask; char *tmp-dir; /* * strip off the extension, Linux doesn't care but * BSD modload(8) uses it to determine the module * entry point */ program = (char *)basename(argv[0]); strtok(program, "."); setup_signals(); # ifdef CONFIG_RTL_NETBSD /* check whether we're loading rtcore */ if (!strncmp(program, "rtcore",6)) { loading_rtcore = 1; program = "rtl"; } #endif tmp-dir = (char *)getenv("TMP"); sprintf(filename, "%s/%s.o", tmp-dir ? : "/tmp", program); if ( argc > RTL_MAIN_MAXARGS+1 ) { fprintf(stderr,"Cannot pass more than %d arguments\n", RTL_MAIN_MAXARGS); return -1; } old_umask = umask(0600) ; 52 r if ((f = open(filename, 0_CREAT | 0_WRONLY | OJTRUNC)) perror("open()"); return -1; } umask(old_umask); prepare-arguments(argc, argv, module_argc, args); #ifdef CONFIG_RTL_NETBSD copy_module_args ( module_data, args) ; #endif /* write the module data to the file */ if ( write (f, module-data, module-size) ! = module-size ) { perror("write()") ; close(f); unlink(filename) ; return -1; } cl'ose (f) ; /* find the right path */ for ( i = 0 ; paths[i] != 0; i++ ) { sprintf(cmd, "%sinsmod", paths[i]); if ( !stat( cmd, &buf ) ) break; } /*■ error if we could not find insmod */ if ( !paths[i] ) { fprintf(stderr, "Could not find insmod\n"); unlink(filename); return -1; } /* We do a fork and exec here so we get the PID of the insmod process * so we are able to open the proper /dev/stdout.* file. Also, we * need to be careful since system/setuid and certain versions of bash * do not cooporate well. — Cort */ 53 if ( (child = fork() > 0 ) { /* parent */ } else { /* child */ /* exec the insmod */ platform_exec(cmd, module_argc, args); /* we got here, things aren't looking good perror("execl"); exit(1); } /* wait for the module load to be done, remove the file */ wait(&status); unlink(filename); if (WEXITSTATUS(status) == 0) { #ifndef RTL_NO_STDOUT /* Try to open the stdout. We don't check for errors since * some modules (rtcore, ckit and so on) will not produce a stdout * FIFO — Cort */ sprintf(cmd, "/dev/stdout.%d", child); if ( (f = open(cmd, 0_RD0NLY)) perror("open()"); } ■/* setup select arguments */ ■if ( f >= 0 ) { FD_ZERO(&readfds); FD_ZER0(&writefds); FD_2ERO(&exceptfds); FD_SET(f, &readfds); } #else f = -1; #endif /* RTL_NO_STDOUT */ while( 1 ) { #ifndef RTL_NO_STDOUT if ( f >= 0 ) { 54 1 select( f+1, &readfds, &writefds, &exceptfds, NULL ); /* loop through here, printing when necessary */ do-printf-read() ; /* if the last read gave us a retval, we're done */ if ( have-retval ) handler(0); } else #endif /* RTL_N0_STD0UT */ sleep(300); } } else { /* the 'insmod' failed for some reason */ fprintf(stderr,"%s: Problem loading module\n", program); exit(-1); } handler(0) ; return 0; } 55 r WE CLAIM 1. A computer system configured to operate to provide for dynamically linking application source code created by a programmer into a running operating system kernel, comprising: an input device for enabling the programmer to input application source code; a memory for storing data representing said application source code; and a processor, communicatively associated with said input device and said memory, configured to operate to: (a) run the operating system kernel; (b) construct a loadable module from the application source code; and (c) create an executable program, wherein the processor, based on the executable program, is further configured to operate to: (d) set up input/output channels; (e) insert the loadable module into address space of the running operating system kernel; (f) once the loadable module is inserted into the address space, to execute the loadable module; and (g) wait for the loadable module to connect via kernel/user channels and then connect those kernel/user channels to the input/output channels. 2. The computer system of claim 1, wherein the application source code is an ordinary application program. 3. The computer system of claim 1, wherein constructing the loadable module from the application source code consists essentially of executing a predefined makefile. 4. The computer system of claim 1, wherein the processor is further configured to operate to provide a makefile to the user, wherein the user constructs the loadable module by executing the makefile after the user has input the application source code. 5. The computer system of claim 1, wherein the processor is further configured to operate to: (a) provide the user with a library comprising object code; and (b) construct the loadable module from the application source code by compiling the application source code into object code; linking the object code with object code from the library to produce a linked object module; and converting the linked object module into a C code array. 6. The computer system of claim 5, wherein the processor is further configured to operate to construct the loadable module from the application source code by compiling the C code array to produce an object file. 7. The computer system of claim 6, wherein the processor is further configured to operate to: (a) provide the user with a second library comprising object code; and (b) create the executable program by linking the object file with object code from the second library. 8. The computer system of claim 5, wherein the library includes one or more routines to create kernel/user channels. 9. The computer system of claim 5, wherein the library includes one or more routines to create a thread to execute the executable program. 10. The computer system of claim 9, wherein the library includes one or more routines for freeing resources and unloading the loadable module when the thread completes. 11. The computer system of claim 5, wherein the library includes one or more routines for (a) copying in arguments; (b) creating communication channels that connect the loadable module to the executable program; (c) requesting a block of memory from the operating system and storing a structure therein that describes the application code; and (d) putting data describing the application code on a task list. 12. The computer system of claim 11, wherein the environment library further includes one or more routines for (a) removing said data describing the application code from the task list; (b) closing said communication channels that connect the loadable module to the executable program; and (c) freeing the block of memory that was requested from the operating system. 13. The computer system of claim 1, wherein the executable program is configured to set up input/output channels. 14. The computer system of claim 1, wherein the executable program is configured to execute a utility for installing the loadable module into the running operating system kernel. 15. The computer system of claim 14, wherein the utility for installing the loadable module into the running operating system kernel is the insmod program. 16. The computer system of claim 14, wherein the processor is further configured to operate to insert the loadable module into an operating system address space by creating a child process, wherein the child process replaces its image with the insmod process image. 17. The computer system of claim 16, wherein the processor is further configured to operate to insert the loadable module into an operating system address space by piping the loadable module to the insmod process. 18. In a computer system including an input device enabling the input of data, a memory for storing data, and a processor, communicatively associated with the input device and the memory, configured to run an operating system, a method for dynamically linking application source code created by a user into a running operating system kernel, said method comprising the steps of: constructing a loadable module from the application source code created by the user and storing said loadable module in the memory; creating an executable program, wherein the executable program is configured to transparently load the loadable module into the running operating system kernel, and storing said executable program in the memory; configuring the processor to execute the executable program, thereby loading the loadable module into the running operating system kernel; and further configuring the processor to send a termination signal to the executable program, thereby unloading the loadable module from the running operating system kernel. 19. The method of claim 18, wherein the application source code is an ordinary application program. 20. The method of claim 18, wherein the step of constructing the loadable module from the application source code consists essentially of executing a pre-defined makefile. 21. The method of claim 18, further comprising the step of providing a makefile to the user, wherein the user performs the step of constructing the loadable module by executing the makefile after the user has created the application source code. 22. The method of claim 18, further comprising the step of providing the user with a library comprising object code, wherein the step of constructing the loadable module from the application source code comprises the steps of compiling the application source code into object code; linking the object code with object code from the library to produce a linked object module; and converting the linked object module into a C code array. 23. The method of claim 22, wherein the step of constructing the loadable module further comprises the step of compiling the C code array to produce an object file. 24. The method of claim 23, further comprising the step of providing the user with a second library comprising object code, wherein the step of creating the executable program comprises the steps of linking the object file with object code from the second library. 25. The method of claim 22, wherein the library includes one or more routines to create kernel/user channels. 26. The method of claim 22, wherein the library includes one or more routines to create a thread to execute the executable program. 27. The method of claim 26, wherein the library includes one or more routines for freeing resources and unloading the loadable module when the thread completes. 28. The method of claim 22, wherein the library includes one or more routines for (a) copying in arguments; (b) creating communication channels that connect the loadable module to the executable program; (c) requesting a block of memory from the operating system and storing a structure therein that describes the application source code; and (d) putting data describing the application code on a task list. 29. The method of claim 28, wherein the environment library further includes one or more routines for (a) removing said data describing the application source code from the task list; (b) closing said communication channels that connect the loadable module to the executable program; and (c) freeing the block of memory that was requested from the operating system. 30. The method of claim 18, wherein the executable program is configured to set up input/output channels. 31. The method of claim 18, wherein the executable program is configured to execute a utility for installing the loadable module into the running operating system kernel. 32. The method of claim 31, wherein the utility for installing the loadable module into the running operating system kernel is the insmod program. 33. The method of claim 31, wherein the step of inserting the loadable module into an operating system address space includes the step of creating a child process, wherein the child process replaces its image with the insmod process image. 34. The method of claim 33, wherein the step of inserting the loadable module into an operating system address space further includes the step of piping the loadable module to the insmod process. Dated this 7th day of April, 2006. FOR FINITE STATE MACHINE LABS, INC. By their Agent (GIRISH VIJAYANAND SHETH) KRISHNA & SAURASTRI i I ; 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.

Documents:

402-mumnp-2006-abstract(10-6-2008).pdf

402-mumnp-2006-abstract(14-6-2008).doc

402-mumnp-2006-abstract-1.jpg

402-mumnp-2006-abstract.pdf

402-mumnp-2006-cancelled page(10-6-2008).pdf

402-mumnp-2006-claim(granted)-(10-6-2008).pdf

402-mumnp-2006-claim(granted)-(14-6-2008).doc

402-mumnp-2006-claims.pdf

402-mumnp-2006-correspondance-po.pdf

402-mumnp-2006-correspondance-received.pdf

402-mumnp-2006-correspondence(11-6-2008).pdf

402-mumnp-2006-correspondence(ipo)-(9-7-2008).pdf

402-mumnp-2006-description (complete).pdf

402-mumnp-2006-drawing(10-6-2008).pdf

402-mumnp-2006-form 1(7-4-2006).pdf

402-mumnp-2006-form 13(7-4-2006).pdf

402-mumnp-2006-form 18(27-7-2006).pdf

402-mumnp-2006-form 2(granted)-(10-6-2008).pdf

402-mumnp-2006-form 2(granted)-(14-6-2008).doc

402-mumnp-2006-form 3(11-6-2008).pdf

402-mumnp-2006-form 3(7-4-2006).pdf

402-mumnp-2006-form 5(7-4-2006).pdf

402-mumnp-2006-form 6(25-3-2008).pdf

402-mumnp-2006-form-1.pdf

402-mumnp-2006-form-13.pdf

402-mumnp-2006-form-2.doc

402-mumnp-2006-form-2.pdf

402-mumnp-2006-form-3.pdf

402-mumnp-2006-form-5.pdf

402-mumnp-2006-form-pct-isa-210(10-6-2008).pdf

402-mumnp-2006-power of attorney(29-6-2006).pdf

abstract1.jpg