US 7,143,024 B1Grant
Associating identifiers with virtual processes
Issue Date:2006-11-28
•25 Claims
•4 Drawing Sheets
Abstract
Multiple virtual processes are each associated with a unique virtual process identifier. For each virtual process, a separate initialization process is started, from which all other processes included in the virtual process originate. The initialization process is associated with the appropriate virtual process identifier. System calls that create new processes are intercepted, and created processes are associated with the virtual process identifier of the appropriate initialization process. Multiple virtual processes are provided on a single, physical computer system.
Metadata
Assignee
- Ensim Corporation
Inventors
- Pawan Goyal
- Snorri Gylfason
- Xun Wilson Huang
- Srinivasan Keshav
- Rosen Sharma
Application Information
Application Number:US 09/611,877
Filing Date:2000-07-07
Priority Date:2000-07-07
Art Unit:2121
Classifications
IPC:
G06F13/24G06F9/46G06F9/44G06F13/10G06F13/12
Patent Drawings (4 sheets)
Description
BACKGROUND
[0001] 1. Field of Invention
[0002] The present invention relates generally to virtual computer processes, and specifically to associating an identifier with each of a plurality of processes comprising a virtual process.
[0003] 2. Background of Invention
[0004] With the popularity and success of the Internet, server technologies are of great commercial importance today. Typically, an individual server application executes on a single physical host computer, servicing client requests. However, providing a unique physical host for each server application is expensive and inefficient. Hosting services are often provided commercially by an Internet Service Provider (ISP). Typically, an ISP has to provide a separate physical host computer on which to execute a server application for every customer that purchases hosting services. Often, a customer purchasing hosting services from an ISP will neither require nor be amenable to paying for use of an entire host computer. Generally, only a fraction of the processing power, storage, and other resources of a host computer will be required to meet the needs of an individual customer.
[0005] It is desirable for an ISP to be able to provide multiple server applications on a single physical host computer. However, in order to be commercially viable, every server application would have to be isolated from every other server application running on the same physical host. Obviously, it would be unacceptable to customers of an ISP to purchase hosting services, only to have another server application program (perhaps belonging to a competitor) be able to access the customer's data and client requests. Thus, each server application program would have to be isolated, receiving requests from only its own clients, transmitting data to only its own clients, and being prevented from accessing data associated with other server applications. Furthermore, it would be necessary to allocate varying specific levels of system resources to different server applications, depending upon the needs of and amounts paid by the various customers of the ISP. In effect, each server application would need to comprise a virtual private server, simulating a server application executing on a dedicated physical host computer.
[0006] Such functionality has been heretofore impossible because a virtual private server, rather than comprising a single, discrete process, must be made up of a plurality of seemingly unrelated processes, each performing various elements of the sum total of the functionality required by the customer. Because each virtual private server must comprise a plurality of processes, it has been impossible for an ISP to isolate the processes associated with one virtual private server from those processes associated with other virtual private servers. What is needed is a method whereby the individual ones of pluralities of separate processes comprising multiple, virtual private servers can each be associated with their respective virtual private server.
SUMMARY OF INVENTION
[0007] The present invention facilitates the association of multiple processes with their respective virtual private servers. In order to run multiple virtual processes on a single, physical computer system, each virtual private server is started by executing a separate, system initialization process. Each system initialization process is associated with a virtual private server identifier, for example by storing the identification number of the process and the virtual private server identifier in a data structure in computer memory. Each virtual private server identifier may be associated with a particular customer to identify the virtual private server belonging to the customer.
[0008] System calls that create processes are intercepted, and a system call wrapper associates created processes with the virtual private server identifier with which the process that made the system call is associated. Thus, all processes originating from each system initialization process will be associated with the virtual private server identifier associated with the corresponding system initialization process. Because all processes that are part of a virtual private server will be created by the associated system initialization process or by its progeny, all processes comprising a virtual private server will be associated with the corresponding virtual private server identifier. This allows all processes that are a part of each customer's virtual private server to be identified and segregated from the processes of other customers, even though these processes are executing on the same physical server.
[0009] It will be readily apparent to one skilled in the art that the present invention can be utilized to associate a plurality of processes comprising any type of virtual process with a corresponding virtual process identifier. Of course, all such utilizations are within the scope of the present invention. Although in one embodiment, the virtual process is in the form of a virtual private server, the present invention is by no means limited to this embodiment.
[0010] The features and advantages described in this summary and the following detailed description are not all-inclusive, and particularly, many additional features and advantages will be apparent to one of ordinary skill in the art in view of the drawings, specification, and claims hereof. Moreover, it should be noted that the language used in the specification has been principally selected for readability and instructional purposes, and may not have been selected to delineate or circumscribe the inventive subject matter, resort to the claims being necessary to determine such inventive subject matter.
BRIEF DESCRIPTION OF THE DRAWINGS
[0011] FIG. 1 is a block diagram providing a high level overview of a system for associating identifiers with virtual processes, according to one embodiment of the present invention.
[0012] FIG. 2 is a block diagram illustrating a system utilizing a virtual process manager program, according to one embodiment of the present invention.
[0013] FIG. 3 is a block diagram illustrating a system utilizing a modified loader program, according to another embodiment of the present invention.
[0014] The figures depict embodiments of the present invention for purposes of illustration only. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles of the invention described herein.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
I. System Overview
[0015] FIG. 1 illustrates a high level overview of a system 100 for associating identifiers with virtual processes according to one embodiment of the present invention. A computer memory 101 includes user address space 103 and operating system address space 105. Multiple initialization processes 107 execute in user address space 103. Although FIG. 1 illustrates only two initialization processes 107 executing in user address space 103, it is to be understood that within a given computer memory 101, more than two initialization processes 107 can execute simultaneously.
[0016] Also executing in user address space are descendent processes 108, originating from the initialization processes 107. A descendent process 108 is a child process of an initialization process 107, or a child process thereof, extended to any number of generations of subsequent child processes. Although FIG. 1 illustrates only two descendent processes 108 for each initialization process 107, it is to be understood that within a given computer memory 101, fewer or more than two descendent processes 108 per initialization process 107 can execute simultaneously.
[0017] Preferably, a data structure for storing associations 129 between executing processes (initialization processes 107 or descendent processes 108) and virtual processes is inserted into the operating system 117. In one embodiment, the data structure is a mapping table 127, but in other embodiments other data structures are utilized, for example a linked list. In one embodiment, the mapping table 127 (or other data structure) is dynamically loaded into the operating system kernel 109, while the kernel 109 is active. In another embodiment, the mapping table 127 is stored in user address space 103. The maintenance and use of the mapping table 127 is discussed in detail below.
[0018] It is to be understood that a virtual process is not an actual process that executes in computer memory 101. Instead, the term “virtual process” describes a collection of associated functionality. For example, a virtual private server application is not actually a discrete process, but instead comprises a plurality of actual processes that together provide the desired functionality, thereby simulating the existence of a single server application executing on a dedicated physical host. Each actual process that performs some of the functionality of the virtual private server is a part of the virtual process. In FIG. 1 for example, initialization process 1 and descendent processes 1 and 2 (the processes descended from initialization process 1) comprise one virtual process, whereas initialization process 2 and descendent processes 3 and 4 comprise another.
[0019] In order to associate a specific identifier with each actual process that is a part of a virtual process, a separate system initialization process 107 is started for each virtual process. Normally, each process executing on a multitasking operating system is descended from a single system initialization process 107 that is started when the operating system 117 is booted. However, the present invention uses techniques described in detail below to start a separate system initialization process 107 for each virtual process. When each system initialization process 107 is started, an association 129 between the system initialization process 107 and the virtual process is stored in the mapping table 127. All additional processes that are descended from a given initialization process are thus identified with the virtual process associated with that initialization process.
[0020] In one embodiment, rather than starting a separate system initialization process 107 for each virtual process, a custom initialization process is started. In this embodiment, all processes that are a part of a specific virtual process are descended from the associated custom initialization process, and are associated with the virtual process with which the custom initialization process is associated. The exact functionality included in the custom initialization process is a design choice that can be made by a system administrator.
[0021] System calls 115 that generate child processes (for example, the UNIX® fork and clone functions) are intercepted so that the child processes can be associated with the virtual process with which the parent process is associated. A system call wrapper 111 is utilized in order to intercept system calls 115. In one embodiment, the system call wrapper 111 is dynamically loaded into the operating system kernel 109, while the kernel 109 is active. In another embodiment, the system call wrapper is loaded in user address space 103. The system call wrapper 111 is preferably in the form of object code, the functional features of which are described in detail below.
[0022] Pointers 114 to system calls 115 are located in an operating system call vector table 113. It is to be understood that the term “system call vector table” as used herein denotes an area in operating system address space 105 in which there are stored the addresses of system calls. In the UNIX® operating system, this part of the operating system is called the “system call vector table,” and that term is used in this specification. Other operating systems employ different terminology to denote the same system component. A system call vector table by any other name is still within the scope of the present invention.
[0023] A copy 116 is made of a pointer 114 to each system call 115 to be intercepted. These copies 116 of pointers 114 are preferably stored in operating system address space 105, but in an alternative embodiment are stored in user address space 103. Once the copies 116 have been made and saved, the pointers 114 in the system call vector table 113 to the system calls 115 to be intercepted are replaced with pointers 118 to the system call wrapper 111, such that when a system call 115 to be intercepted is made, the system call wrapper 111 executes instead. In one embodiment, this copying, storing, and replacing of pointers is performed by the system call wrapper 111. In other embodiments, copying, storing, and replacing of pointers is performed by a pointer management module executing in either operating system address space 105 or user address space 103 as desired. The pointer management module can either be a stand alone program, or a component of a larger application program as desired.
[0024] Executing alternative code when a system call 115 is made comprises intercepting the system call 115. The steps of inserting a system call wrapper 111 into the operating system 117, making a copy 116 of an operating system pointer 114 to a system call 115, and replacing the operating system pointer 114 with a pointer 118 to the system call wrapper 111 facilitate interception of a system call 115. When a system call 115 to be intercepted is made, the operating system 117 uses the pointer 118 in the system call vector table 113 to the system call wrapper 111 to execute the system call wrapper 111.
[0025] It is to be understood that only system calls 115 that create child processes need be intercepted, and thus only pointers 114 to system calls 115 to be intercepted are replaced with pointers 118 to the system call wrapper 111. Pointers 114 to system calls 115 which are not to be intercepted are not replaced. Thus, when a non-intercepted system call 115 is made, the system call 115 executes, not the system call wrapper 111.
[0026] The various initialization processes 107 and descendent processes 108 execute in user address space 103 under control of the operating system 117, and make system calls 115. When a process makes a system call 115 that creates a child process, the system call wrapper 111 reads the mapping table 127, and determines whether the process that made the system call (the parent of the child process being created) is associated with a virtual process. If so, the system call wrapper 111 uses the saved copy of the pointer 116 to execute the system call 115, allowing the creation of the child process. The system call wrapper 111 updates the mapping table 127, storing an association 129 between the newly created child process and the virtual process with which the process that made the system call is associated. Thus, all descendent processes 108 are associated with the virtual process with which their parent process is associated.
II. Starting Initialization Processes by a Manager Program
[0027] FIG. 2 illustrates one embodiment of a system 200 for associating identifiers with virtual processes. In the embodiment illustrated by FIG. 2 , the initialization processes 107 are started by a virtual process manager program 201 executing in user address space 103.
[0028] The virtual process manager program 201 modifies the operating system 117 of the computer to include the mapping table 127. Preferably, the manager program 201 loads the mapping table 127 into the kernel 109 of the operating system 117 while the kernel is active.
[0029] For each virtual process, the manager program 201 starts an initialization process 107 from which all other processes that are part of the virtual process will originate as descendent processes 108. Each time the manager program 201 starts an initialization process 107 for a virtual process, the manager program 201 stores, in the mapping table 127, an association 129 between the initialization process 107 and the appropriate virtual process. Subsequently, all additional processes that are part of the virtual process will be originated from the initialization process, and thus associated with the appropriate virtual process.
[0030] For example, suppose that the manager program 201 starts a first virtual private server. To do so, the manager process 107 starts an initialization process 107 for the virtual private server, storing an association 129 between the initialization process 107, and a virtual process identifier for the virtual private server. Additional processes that are part of the virtual private server originate from the initialization process 107, and are associated with the virtual process identifier of the virtual private server. The manager process 201 can proceed to start a second virtual private server by starting a separate initialization process 107, and associating the second initialization process 107 with a separate virtual process identifier for the second virtual private server. Consequently, all of the processes associated with the second virtual private server will be associated with the appropriate virtual process identifier. In this manner, multiple virtual processes on the same physical computer are each associated with unique identifiers.
III. Starting Initialization Processes by a Loader Program
[0031] FIG. 3 illustrates another embodiment of a system 300 for associating identifiers with virtual processes. In the embodiment illustrated by FIG. 3 , initialization processes 107 are not started by a manager program 201, but instead are loaded by a modified loader program 301.
[0032] A loader program is an operating system utility that is used to execute computer programs that are stored on static media. Typically, a loader program loads an executable image from static media into user address space 103 of computer memory 101, and then initiates execution of the loaded image by transferring execution to the first instruction thereof.
[0033] Like a standard loader program, the modified loader 301 loads executable images (in this case, initialization processes 107) from static media into user address space 103. Additionally, the modified loader program 301 stores, in the mapping table 127, an association 129 between the initialization process 107 being loaded and the appropriate virtual process. Thus, for each virtual process, an initialization process 107 is loaded by the modified loader program, and an association between the initialization process 107 and the virtual process is stored in the mapping table 127. Subsequently, additional processes that are part of the virtual process originate from the associated initialization process 107, and are thus associated with the virtual process as described above.
[0034] In another embodiment, the modified loader program 301 loads all processes that are part of each virtual process. In that embodiment, whenever the modified loader program 301 loads a process, the modified loader program 301 also stores, in the mapping table, an association 129 between the loaded process and the appropriate virtual process.
[0035] As will be understood by those familiar with the art, the invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. Likewise, the particular naming of the modules, features, attributes or any other aspect is not mandatory or significant, and the mechanisms that implement the invention or its features may have different names or formats. Accordingly, the disclosure of the present invention is intended to be illustrative, but not limiting, of the scope of the invention, which is set forth in the following claims.
Claims
What is claimed is:
1. A method in a computer operating system for associating an identifier with a plurality of processes, the method comprising:
starting a first process;
associating the first process with the identifier;
creating, from the first process, a second process;
associating the second process with the identifier;
associating a third process with the identifier, wherein the third process is not a descendant of the first process;
creating, from the third process, a fourth process; and
associating the fourth process with the identifier.
2. The method of claim 1 wherein the plurality of processes together provide the functionality of a dedicated server application program.
3. The method of claim 1 wherein the first process comprises a system initialization process.
4. The method of claim 1 wherein associating the first process with the identifier comprises storing an entry in a data structure, the entry comprising the identifier and a process identification number of the first process.
5. The method of claim 1 further comprising intercepting a system call, made by the first process, that creates a process.
6. The method of claim 5 wherein intercepting the system call comprises replacing a first pointer, which points to object code of the system call, with a second pointer, which points to different object code, such that making the system call causes the different object code to execute.
7. The method of claim 6 further comprising inserting the different object code into the operating system.
8. The method of claim 7 wherein inserting the different object code into the operating system comprises loading a module into a running operating system kernel, the module comprising the different object code.
9. The method of claim 1 further comprising:
loading, by a modified loader program, the first process into computer memory;
starting, by the modified loader program, the first process; and
storing, by the modified loader program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of the first process.
10. The method of claim 1 further comprising:
starting, by a virtual process manager program, the first process; and
storing, by the manager program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of the first process.
11. A computer-readable medium storing a computer program product for using a computer operating system to associate an identifier with a plurality of processes, the computer program product comprising:
program code for starting a first process;
program code for associating the first process with the identifier;
program code for creating, from the first process, a second process;
program code for associating the second process with the identifier;
program code for associating a third process with the identifier, wherein the third process is not a descendant of the first process;
program code for creating, from the third process, a fourth process; and
program code for associating the fourth process with the identifier.
12. The computer-readable medium of claim 11 wherein the computer program product further comprises program code for storing an entry in a data structure, the entry comprising the identifier and a process identification number of the first process.
13. The computer-readable medium of claim 11 wherein the computer program product further comprises:
program code for intercepting a system call that creates a process; and
program code for associating the process being created with the identifier of a process that made the system call.
14. The computer-readable medium of claim 11 wherein the computer program product further comprises:
program code comprising instructions to associate the process being created with the identifier of the process that made the system call; and
program code for replacing a pointer to the system call with a pointer to the instructions to associate, such that making the system call causes the instructions to associate to execute.
15. The computer-readable medium of claim 14 wherein the computer program product further comprises program code for storing the instructions to associate in the operating system by loading a module into a running operating system kernel, the module comprising the instructions to associate.
16. The computer-readable medium of claim 11 wherein the computer program product further comprises:
program code for starting the first process; and
program code for storing an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of the first process.
17. The computer-readable medium of claim 16 wherein the computer program product further comprises program code for loading the first process into computer memory.
18. A computer operating system for associating an identifier with a plurality of processes, the computer operating system comprising:
an initiation module, for starting a first process and a third process, wherein the third process is not a descendant of the first process;
a creation module, coupled to the initiation module, for creating, from the first process, a second process, and for creating, from the third process, a fourth process; and
an association module, coupled to the creation module, for associating the first process with the identifier, and for associating the second process with the identifier, and for associating the third process with the identifer, and for associating the fourth process with the identifier.
19. The system of claim 18 further comprising a storage module, coupled to the association module, for storing an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of the first process.
20. The system of claim 18 further comprising an interception module, coupled to the association module, for intercepting a system call that creates a process; and wherein the association module is further for associating the process being created with the identifier of a process that made the system call.
21. The system of claim 20 further comprising a storage module, coupled to the interception module, for storing object code comprising instructions to associate the process being created with the identifier of the process that made the system call; and wherein the interception module is further for replacing a pointer to the system call with a pointer to the stored object code, such that making the system call causes the object code to execute.
22. The system of claim 21 further comprising an insertion module, coupled to the storage module, for inserting the instructions to associate in the operating system by loading a module into a running operating system kernel.
23. A method in a computer operating system for associating an identifier with a plurality of processes, the method comprising:
executing a system initialization process;
associating the system initialization process with the identifier;
associating a second process, created from the system initialization process, with the identifier;
associating a third process with the identifier, wherein the third process is not a descendant of the system initialization process;
creating, from the third process, a fourth process; and
associating the fourth process with the identifier.
24. A method in a computer operating system for associating an identifier with a plurality of processes, the method comprising:
loading, by a modified loader program, a first process into computer memory; and
storing, by the modified loader program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of the loaded process;
storing, by the modified loader program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of a second process, wherein the second process was created from the first process;
storing, by the modified loader program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of a third process, wherein the third process is not a descendant of the first process;
storing, by the modified loader program, an entry in a data structure in computer memory, the entry comprising the identifier and a process identification number of a fourth process, wherein the fourth process was created from the third process.
25. A method in a computer operating system for associating an identifier with a plurality of processes, the method comprising:
associating a first process with the identifier;
associating a second process with the identifier, wherein the second process is not a descendant of the first process;
creating, from the second process, a third process; and
associating the third process with the identifier.
Patent Citations (154)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US3377624(A) | 1968-04-01 | Nelson et al. | Applicant |
| US4177510(A) | 1979-12-01 | Appell et al. | Applicant |
| US5189667(A) | 1993-02-01 | Esaki et al. | Applicant |
| US5212793(A) | 1993-05-01 | Donica et al. | Applicant |
| US5226160(A) | 1993-07-01 | Waldron et al. | Applicant |
| US5249290(A) | 1993-09-01 | Heizer | Applicant |
| US5263147(A) | 1993-11-01 | Francisco et al. | Applicant |
| US5325530(A) | 1994-06-01 | Mohrmann | Applicant |
| US5437032(A) | 1995-07-01 | Wolf et al. | Applicant |
| US5528753(A) | 1996-06-01 | Fortin | Applicant |
| US5566334(A) | 1996-10-01 | Loader | Examiner |
| US5572680(A) | 1996-11-01 | Ikeda et al. | Examiner |
| US5584023(A) | 1996-12-01 | Hsu | Applicant |
| US5603020(A) | 1997-02-01 | Hashimoto et al. | Applicant |
| US5615400(A) | 1997-03-01 | Cowsar et al. | Examiner |
| US5623492(A) | 1997-04-01 | Teraslinna | Applicant |
| US5636371(A) | 1997-06-01 | Yu | Applicant |
| US5640595(A) | 1997-06-01 | Baugher et al. | Applicant |
| US5692047(A) | 1997-11-01 | McManis | Applicant |
| US5706097(A) | 1998-01-01 | Schelling et al. | Applicant |
| US5706453(A) | 1998-01-01 | Cheng et al. | Applicant |
| US5708774(A) | 1998-01-01 | Boden | Applicant |
| US5719854(A) | 1998-02-01 | Choudhury et al. | Applicant |
| US5727147(A) | 1998-03-01 | van Hoff | Examiner |
| US5727203(A) | 1998-03-01 | Hapner et al. | Examiner |
| US5748614(A) | 1998-05-01 | Wallmeier | Applicant |
| US5752003(A) | 1998-05-01 | Hart | Applicant |
| US5761477(A) | 1998-06-01 | Wahbe et al. | Applicant |
| US5764889(A) | 1998-06-01 | Ault et al. | Applicant |
| US5781550(A) | 1998-07-01 | Templin et al. | Applicant |
| US5799173(A) | 1998-08-01 | Gossler et al. | Applicant |
| US5809527(A) | 1998-09-01 | Cooper et al. | Applicant |
| US5828893(A) | 1998-10-01 | Weid et al. | Applicant |
| US5838686(A) | 1998-11-01 | Ozkan | Applicant |
| US5838916(A) | 1998-11-01 | Domenikos et al. | Applicant |
| US5842002(A) | 1998-11-01 | Schnurer et al. | Applicant |
| US5845129(A) | 1998-12-01 | Wendorf et al. | Applicant |
| US5850399(A) | 1998-12-01 | Ganmukhi et al. | Applicant |
| US5860004(A) | 1999-01-01 | Fowlow et al. | Applicant |
| US5864683(A) | 1999-01-01 | Boebert et al. | Examiner |
| US5889956(A) | 1999-03-01 | Hauser et al. | Applicant |
| US5889996(A) | 1999-03-01 | Adams | Examiner |
| US5892968(A) | 1999-04-01 | Iwasaki et al. | Applicant |
| US5905730(A) | 1999-05-01 | Yang et al. | Applicant |
| US5905859(A) | 1999-05-01 | Holloway et al. | Applicant |
| US5913024(A) | 1999-06-01 | Green et al. | Applicant |
| US5915085(A) | 1999-06-01 | Koved | Applicant |
| US5915095(A) | 1999-06-01 | Miskowiec | Applicant |
| US5918018(A) | 1999-06-01 | Gooderum et al. | Applicant |
| US5920699(A) | 1999-07-01 | Bare | Applicant |
| US5933603(A) | 1999-08-01 | Vahalia et al. | Applicant |
| US5937159(A) | 1999-08-01 | Meyers et al. | Applicant |
| US5956481(A) | 1999-09-01 | Walsh et al. | Applicant |
| US5961582(A) | 1999-10-01 | Gaines | Applicant |
| US5978373(A) | 1999-11-01 | Hoff et al. | Applicant |
| US5982748(A) | 1999-11-01 | Yin et al. | Applicant |
| US5987242(A) | 1999-11-01 | Bentley et al. | Examiner |
| US5987524(A) | 1999-11-01 | Yoshida et al. | Applicant |
| US5987608(A) | 1999-11-01 | Roskind | Examiner |
| US5991812(A) | 1999-11-01 | Srinivasan | Applicant |
| US5999963(A) | 1999-12-01 | Bruno et al. | Applicant |
| US6016318(A) | 2000-01-01 | Tomoike | Applicant |
| US6018527(A) | 2000-01-01 | Yin et al. | Applicant |
| US6023721(A) | 2000-02-01 | Cummings | Applicant |
| US6038608(A) | 2000-03-01 | Katsumanta | Applicant |
| US6038609(A) | 2000-03-01 | Geulen | Applicant |
| US6047325(A) | 2000-04-01 | Jain et al. | Applicant |
| US6055617(A) | 2000-04-01 | Kingsbury | Applicant |
| US6055637(A) | 2000-04-01 | Hudson et al. | Applicant |
| US6061349(A) | 2000-05-01 | Coile et al. | Examiner |
| US6065118(A) | 2000-05-01 | Bull et al. | Applicant |
| US6075791(A) | 2000-06-01 | Chiussi et al. | Applicant |
| US6075938(A) | 2000-06-01 | Bugnion et al. | Applicant |
| US6078929(A) | 2000-06-01 | Rao | Applicant |
| US6078957(A) | 2000-06-01 | Adelman et al. | Applicant |
| US6086623(A) | 2000-07-01 | Broome et al. | Applicant |
| US6092178(A) | 2000-07-01 | Jindal et al. | Applicant |
| US6094674(A) | 2000-07-01 | Hattori et al. | Applicant |
| US6101543(A) | 2000-08-01 | Alden et al. | Applicant |
| US6108701(A) | 2000-08-01 | Davis et al. | Applicant |
| US6108759(A) | 2000-08-01 | Orcutt et al. | Applicant |
| US6122673(A) | 2000-09-01 | Basak et al. | Applicant |
| US6154776(A) | 2000-11-01 | Martin | Applicant |
| US6154778(A) | 2000-11-01 | Koistinen et al. | Applicant |
| US6161139(A) | 2000-12-01 | Win et al. | Applicant |
| US6167520(A) | 2000-12-01 | Touboul | Applicant |
| US6172981(B1) | 2001-01-01 | Cox et al. | Applicant |
| US6189046(B1) | 2001-02-01 | Moore et al. | Examiner |
| US6192389(B1) | 2001-02-01 | Ault et al. | Examiner |
| US6192512(B1) | 2001-02-01 | Chess | Applicant |
| US6230203(B1) | 2001-05-01 | Koperda et al. | Applicant |
| US6240463(B1) | 2001-05-01 | Benmohamed et al. | Applicant |
| US6247057(B1) | 2001-06-01 | Barrera | Applicant |
| US6247068(B1) | 2001-06-01 | Kyle | Applicant |
| US6259699(B1) | 2001-07-01 | Opalka et al. | Applicant |
| US6266678(B1) | 2001-07-01 | McDevitt et al. | Applicant |
| US6269404(B1) | 2001-07-01 | Hart et al. | Applicant |
| US6279039(B1) | 2001-08-01 | Bhat et al. | Applicant |
| US6279040(B1) | 2001-08-01 | Ma et al. | Applicant |
| US6282581(B1) | 2001-08-01 | Moore et al. | Applicant |
| US6282703(B1) | 2001-08-01 | Meth et al. | Examiner |
| US6286047(B1) | 2001-09-01 | Ramanathan et al. | Applicant |
| US6298479(B1) | 2001-10-01 | Chessin et al. | Applicant |
| US6314558(B1) | 2001-11-01 | Angel et al. | Applicant |
| US6327622(B1) | 2001-12-01 | Jindal et al. | Applicant |
| US6336138(B1) | 2002-01-01 | Caswell et al. | Applicant |
| US6351775(B1) | 2002-02-01 | Yu | Applicant |
| US6353616(B1) | 2002-03-01 | Elwalid et al. | Applicant |
| US6363053(B1) | 2002-03-01 | Schuster et al. | Applicant |
| US6366958(B1) | 2002-04-01 | Ainsworth et al. | Applicant |
| US6370583(B1) | 2002-04-01 | Fishler et al. | Applicant |
| US6374292(B1) | 2002-04-01 | Srivastava et al. | Applicant |
| US6381228(B1) | 2002-04-01 | Prieto, Jr. et al. | Applicant |
| US6385638(B1) | 2002-05-01 | Baker-Harvey | Applicant |
| US6385722(B1) | 2002-05-01 | Connelly et al. | Examiner |
| US6389448(B1) | 2002-05-01 | Primak et al. | Applicant |
| US6393484(B1) | 2002-05-01 | Massarani | Applicant |
| US6425003(B1) | 2002-07-01 | Herzog et al. | Applicant |
| US6430622(B1) | 2002-08-01 | Aiken, Jr. et al. | Applicant |
| US6434631(B1) | 2002-08-01 | Bruno et al. | Applicant |
| US6434742(B1) | 2002-08-01 | Koepele, Jr. | Applicant |
| US6438134(B1) | 2002-08-01 | Chow et al. | Applicant |
| US6442164(B1) | 2002-08-01 | Wu | Applicant |
| US6449652(B1) | 2002-09-01 | Blumenau et al. | Applicant |
| US6457008(B1) | 2002-09-01 | Rhee et al. | Applicant |
| US6463459(B1) | 2002-10-01 | Orr et al. | Applicant |
| US6470398(B1) | 2002-10-01 | Zargham et al. | Applicant |
| US6484173(B1) | 2002-11-01 | O'Hare et al. | Applicant |
| US6487578(B1) | 2002-11-01 | Ranganathan | Applicant |
| US6487663(B1) | 2002-11-01 | Jaisimha et al. | Applicant |
| US6490670(B1) | 2002-12-01 | Collins et al. | Applicant |
| US6496847(B1) | 2002-12-01 | Bugnion et al. | Applicant |
| US6499137(B1) | 2002-12-01 | Hunt | Applicant |
| US6529950(B1) | 2003-03-01 | Lumelsky et al. | Applicant |
| US6529985(B1) | 2003-03-01 | Deianov et al. | Examiner |
| US6542167(B1) | 2003-04-01 | Darlet et al. | Applicant |
| US6553413(B1) | 2003-04-01 | Leighton et al. | Applicant |
| US6578055(B1) | 2003-06-01 | Hutchison et al. | Applicant |
| US6578068(B1) | 2003-06-01 | Bowman-Amuah | Applicant |
| US6580721(B1) | 2003-06-01 | Beshai | Applicant |
| US6590588(B1) | 2003-07-01 | Lincke et al. | Applicant |
| US6622159(B1) | 2003-09-01 | Chao et al. | Applicant |
| US6647422(B1) | 2003-11-01 | Wesinger et al. | Applicant |
| US6658571(B1) | 2003-12-01 | O'Brien et al. | Applicant |
| US6691312(B1) | 2004-02-01 | Sen et al. | Applicant |
| US6725456(B1) | 2004-04-01 | Bruno et al. | Applicant |
| US6760775(B1) | 2004-07-01 | Anerousis et al. | Applicant |
| US6785728(B1) | 2004-08-01 | Schneider et al. | Applicant |
| US6820117(B1) | 2004-11-01 | Johnson | Applicant |
| US6859835(B1) | 2005-02-01 | Hipp | Applicant |
| US6912590(B1) | 2005-06-01 | Lundback et al. | Applicant |
| US2003/0061338(A1) | 2003-03-01 | Stelliga | Applicant |
| JP64-002145 | 1989-01-01 | Applicant | |
| WO99/39261 | 1999-08-01 | Applicant |
Non-Patent Literature (57)
- Debasis Mitra et al. Hierarchical Virtual Partitioning- Algorithms for Virtual Private Networking, Bell Labs Technical Journal, Spring, 1997, http://cm.bell-labs.com/cm/ms/who/mitra/papers/globe.ps.Examiner
- Goyal, P. et al., “Start-time Fair Queuing: A Scheduling Algorithm for Integrated Services Packet Switching Networks,” Proceedings of ACM SIGCOMM '96, San Francisco, CA, Aug. 1996, 14 pages.Applicant
- Jánosi, T., “Notes on ‘A Hierarchical CPU Scheduler for Multimedia Operating Systems’ by Pawan Goyal, Xingang Guo and Harrick Vin,” [online], [retrieved on May 8, 2000]. Retrieved from the internet: <URL: http://cs.cornell.edu/Info/Courses/Spring-97/CS614/goy.html>.Applicant
- Goyal, P., “Packet Scheduling Algorithms for Integrated Services Networks,” PhD Dissertation, University of Texas, Austin, TX, Aug. 1997.Applicant
- Pending United States patent application entitled “Providing Quality of Service Guarantees to Virtual Hosts,” U.S. Appl. No. 09/452,286, filed Nov. 30, 1999.Applicant
- Pending United States patent application entitled “Selective Interception of System Calls,” U.S. Appl. No. 09/499,098, filed Feb. 4, 2000.Applicant
- Pending United States patent application entitled “Dynamic Scheduling of Task Streams in a Multiple-Resource System to Ensure Task Stream Quality of Service,” U.S. Appl. No. 09/498,450, filed Feb. 4, 2000.Applicant
- Pending United States patent application entitled “Disambiguating File Descriptors,” U.S. Appl. No. 09/500,212, filed Feb. 8, 2000.Applicant
- Pending United States patent application entitled “Restricting Communication Between Network Devices on a Common Network,” U.S. Appl. No. 09/502,155, filed Feb. 11, 2000.Applicant
- Pending United States patent application entitled “Restricting Communication of Selected Processes to a Set of Specific Network Addresses,” U.S. Appl. No. 09/503,975, filed Feb. 14, 2000.Applicant
- Pending United States patent application entitled “Enabling a Service Provider to Provide Intranet Services,” U.S. Appl. No. 09/526,980, filed Mar. 15, 2000.Applicant
- Pending United States patent application entitled “Dynamically Modifying the Resources of a Virtual Server,” U.S. Appl. No. 09/569,371, filed May 11, 2000.Applicant
- Pending United States patent application entitled “Regulating File Access Rates According to File Type,” U.S. Appl. No. 09/572,672, filed May 16, 2000.Applicant
- Pending United States patent application entitled “Modifying Internal Components of a Running Operating System,” U.S. Appl. No. 09/576,393, filed May 22, 2000.Applicant
- Boehm, B., “Managing Software Productivity and Reuse,” IEEE Computer, vol. 32, No. 9, Sep. 1999, 3 pages.Applicant
- Corbato, F. J. et al. “An Experimental Timesharing System,” Proceedings of the American Federation Of Information Processing Societies Spring Joint Computer Conference, San Francisco, CA, May 1-3, 1962, pp. 335-344.Applicant
- Deutsch, P. and Grant, C.A., “A Flexible Measurement Tool for Software Systems,” Information Processing 71 (Proc. of the IFIP Congress), 1971, pp. 320-326.Applicant
- Edjlali, G., et al., “History-based Access Control for Mobile Code,” Fifth ACM Conference on Computer and Communication Security, Nov. 3-5, 1998, 19 pages.Applicant
- Erlingsson, U. and Schneider, F. B., “SASI Enforcement of Security Policies: A Retrospective,” Proc. New Security Paradigms Workshop, Apr. 2, 1999, pp. 1-17.Applicant
- Erlingsson, U. and Schnieder, F. B., IRM Enforcement of Java Stack Inspection, [online], Feb. 19, 2000, [retrieved on Apr. 2, 2002]. Retrieved from the Internet: <URL: http://cs-tr.cs.cornell.edu/Dienst/UI2.0/Show Page/ncstrl.cornell/TR2000-1786>.Applicant
- Evans, D. and Twyman, A., “Flexible Policy-Directed Code Safety,” Proc. of 1999 IEEE Symposium on Security and Privacy, Oakland, CA, May 9-12, 1999, pp. 1-14.Applicant
- Fraser, T. et al., “Hardening COTS Software with Generic Software Wrappers,” Proc. of 1999 IEEE Symposium on Security and Privacy, 1999, 15 pages.Applicant
- Goldberg, I. et al., “A Secure Environment For Untrusted Helper Applications (Confining the Wily Hacker),” Proc. of the Sixth USENIX UNIX Security Symposium, San Jose, CA, Jul. 1996, 14 pages.Applicant
- Goldberg, R. P., “Survey of Virtual Machine Research,” IEEE Computer, Jun. 1974, pp. 34-45.Applicant
- Pandey, R. and Hashii, B., “Providing Fine-Grained Access Control For Mobile Programs Through Binary Editing,” Technical Report TR98 08, University of California, Davis, CA, 1998, pp. 1-22.Applicant
- Ritchie, D. M., “The Evolution of the Unix Time-Sharing System,” AT&T Bell Laboratories Technical Journal 63, No. 6, Part 2, Oct. 1984, (originally presented 1979), 11 pages.Applicant
- Saltzer, J., H. and Schroeder, M. D., The Protection of Information in Computer Systems, [online], 1973, [retrieved on Apr. 2, 2002]. Retrieved from the Internet: <URL: http://www.cs.virginia.edu˜evans/cs551/saltzer/>.Applicant
- Wahbe, R., et al., “Efficient Software-Based Fault Isolation,” Proc. of the Symposium on Operating System Principles, 1993, 14 pages.Applicant
- Goyal, Pawan et al., Generalized Guaranteed Rate Scheduling Algorithms: A Framework, IEEE/ACM Transactions, vol. 5, Issue: 4, Aug. 1997; pp. 561-571.Applicant
- Symbol Table, [online] copyright 1997, 1998, [Retrieved on Apr. 4, 2003] Retrieved from the internet < URL: http://216.239.33.100/search?q=cache:eASXk8qC—-AC:www.caldera.com/developers/gabi/1998-04-29/ch4.2...], pp. 1-5.Applicant
- Plummer, D. C., An Ethernet Address Resolution Protocol—or—Converting Network Protocol Addresses to 48.bit Ethernet Address for Transmission on Ethernet Hardware, Nov. 1982, [online], [retrieved on Jan. 17, 2000]. Retrieved from the Internet: <URL: http://www.msg.net/kadow/answers/extras/rfc/rfc826.txt>.Applicant
- Huang, X. W. et al., “The ENTRAPID Protocol Development Environment,” Proceedings of IEEE Infocom'99, Mar. 1999, nine pages.Applicant
- Duffield, N.G., et al., “A Flexible Model for Resource Management in Virtual Private Networks,” Computer Communication Review Conference, Computer Communication, ACM SIGCOMM '99 Conference, Cambridge, MA, Aug. 30, 1999-Sep. 3, 1999. pp. 95-108.Applicant
- Campbell, A. T. and Keshav, S., “Quality of Service in Distributed Systems,” Computer Communications 21, 1998, pp. 291-293.Applicant
- Bach, M. J., The Design of the Unix® Operating System, New Delhi, Prentice-Hall of India, 1989, pp. v-x, 19-37.Applicant
- McDougall, R., et al., Resource Management, Upper Saddle River, NJ, Prentice Hall, 1999, pp. iii-xix, 135-191.Applicant
- Rijsinghani, A., RFC 1624, May 1994, [online], [retrieved Feb. 2, 2000]. retrieved from the internet: <URL: http://www.faqs.org/rfcs/rfc1624.html>.Applicant
- Mallory, T and Kullberg, A., RFC 1141, Jan. 1990 [online], [retrieved Feb. 2, 2000]. retrieved from the Internet: <URL: http://www.faqs.org/rfcs/rfc1141.html>.Applicant
- Egevang, K. and Francis P., RFC 1631, May 1994 [online], [retrieved Feb. 2, 2000]. retrieved from the Internet: <URL: http://www.faqs.org/rfcs/rfc1631.html>.Applicant
- Keshav, S., An Engineering Approach to Computer Networking: ATM Networks, the Internet, and the Telephone Network, Reading, MA, Addison-Wesley, 1997, pp. vii-xi, 85-115, 209-355, 395-444.Applicant
- Stevens, R. W., UNIX Network Programming vol. 1 Networking APIs: Sockets and XTI, Upper Saddle River, NJ, Prentice Hall, 1998, pp. v-xiv, 29-53, 85-110, 727-760.Applicant
- Tanenbaum, A. S. and Woodhull, A. S., Operating Systems: Design and Implementation, Upper Saddle River, NJ, Prentice Hall, 1997, pp. vii-xiv, 1-46, 401-454.Applicant
- Rubini, A., LINUX Device Drivers, Sebastopol, CA, O'Reilly & Associates, Inc., 1998, pp. v-x, 13-40.Applicant
- Goyal, P., et al., “A Hierarchical CPU Scheduler for Multimedia Operating Systems,” Proceedings of the Second Symposium on Operating Systems Design and Implementations (OSDI'96), Seattle, WA, Oct. 1996, 15 pages.Applicant
- Laurie, B. and Laurie, P., Apache The Definitive Guide, Sebastopol, CA, O'Reilly & Associates, Inc., Feb. 1999, pp. v-viii, 43-74.Applicant
- Aho, A. V. and Ullman J. D., Principles of Complier Design, Reading, MA, 1977, pp. vii-x, 359-362, 519-522.Applicant
- Jonsson, J., “Exploring the Importance of Preprocessing Operations in Real-Time Multiprocessor Scheduling,” Proc. of the IEEE Real-Time Systems Symposium—Work-in-Progress session, San Francisco, CA, Dec. 4, 1997, pp. 31-34.Applicant
- Rusling, D. A., Processes, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node44.html>.Applicant
- Rusling, D. A., Linux Processes, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node45.html>.Applicant
- Rusling, D. A., Identifiers, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node46.html>.Applicant
- Rusling, D. A., Scheduling, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node47.html>.Applicant
- Rusling, D. A., Scheduling in Multiprocessor Systems, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node48.html>.Applicant
- Rusling, D. A., Files, [online], [retrieved on Dec. 7, 1999]. Retrieved from the Internet: <URL: http://www.cebaf.gov/˜saw/linux/tlk-html/node49.html>.Applicant
- Berkeley Software Distribution, “man page: setpgid”, Feb. 1, 1994, [Retrieved on Oct. 13, 2005], Retrieved from the Internet <URL: http://www.neosoft.com/neosoft/man/setpgid.2.html>.Applicant
- Berkeley Software Distribution, “man page: setsid”, Feb. 1, 1994, [Retrieved on Oct. 13, 2005], Retrieved from the Internet <URL: http://www.neosoft.com/neosoft/man/setsid.2.html>.Applicant
- Frost, J., “UNIX Signals and Process Groups”, Aug. 17, 1994, [Retrieved on Oct. 13, 2005], Retrieved from the Internet <URL: http://www.cs.ucsb.edu/˜almeroth/classes/W99.276/assignment1/signals.html>.Applicant
- Stevens, Richard W., “Advanced Programming in the UNIX® Environment”, 1993, pp. 237-246, 282-285, Addison Wesley Longman, Inc., USA.Applicant