Field of the Inven(cid:415)on 
`
`TheFIELD OF THE INVENTION 
`
`This inven(cid:415)on relates to computer so(cid:332)warea compu(cid:415)ng system, and more specifically to so(cid:332)warean 
`architecture that affects and extends services  exported through applica(cid:415)on libraries. 
`
`Background of the Inven(cid:415)on 
`
`BACKGROUND OF THE INVENTION 
`
`Computer systems are designed in such a way that so(cid:332)ware applica(cid:415)on programs share common  
`resources. It is tradi(cid:415)onally the task of thean opera(cid:415)ng system to provide mechanisms to safely and 
`effec(cid:415)vely control access to shared resources. In some instances the centralized control of elements, 
`cri(cid:415)cal to so(cid:332)ware applica(cid:415)ons, herea(cid:332)er called cri(cid:415)cal system elements (CSEs) creates a limita(cid:415)on 
`caused by conflicts for shared resources. 
`
`In some cases the centralized control of elements cri(cid:415)cal to so(cid:332)ware applica(cid:415)ons creates a limita(cid:415)on 
`caused by conflicts for shared resources. TwoFor example, two so(cid:332)ware applica(cid:415)ons that require the 
`same file, yet each requirerequires a different version of the file will conflict. In the same manner two 
`applica(cid:415)ons that require independent access to specific network services will conflict. TheA common 
`solu(cid:415)on to these situa(cid:415)ons is to place so(cid:332)ware applica(cid:415)ons that may poten(cid:415)ally conflict on separate 
`compute pla(cid:414)orms. The current state of the art, defines two architectural approaches to the migra(cid:415)on of 
`cri(cid:415)cal system elements from an opera(cid:415)ng system into an applica(cid:415)on context. 
`
`Current state of the art defines two architectural approaches to the migra(cid:415)on of system elements from 
`an opera(cid:415)ng system into an applica(cid:415)on context. In one architectural approach, a single server opera(cid:415)ng 
`system places cri(cid:415)cal system elements in the same process. Despite the flexibility offered, the system 
`elements con(cid:415)nue to represent a centralized control point.  
`
`In the other architectural approach, a mul(cid:415)ple server opera(cid:415)ng system places cri(cid:415)cal system elements in 
`separate processes. While offering even greater op(cid:415)ons this architecture has suffered performance and 
`opera(cid:415)onal differences. 
`
`Summary of the Inven(cid:415)on 
`
`An important dis(cid:415)nc(cid:415)on between this inven(cid:415)on and prior art systems and architectures is the ability to 
`allow a CSE to execute in the same context as an applica(cid:415)on. This then allows, among other things, an 
`ability to deploy mul(cid:415)ple instances of a CSE. In contrast, exis(cid:415)ng systems and architectures, regardless of 
`where a service is defined to exist, that is, in kernel mode, in user mode as a single process or in user 
`mode as mul(cid:415)ple processes, all support the concept of a single shared service. 
`
`SUMMARY OF THE INVENTION 
`
`In accordance with a first broad aspect, the of this inven(cid:415)on provides, a compu(cid:415)ng architecturesystem is 
`provided that has an opera(cid:415)ng system kernel having opera(cid:415)ng system cri(cid:415)cal system elements (OSCSEs) 
`and adapted to run in kernel mode; and a shared library adapted to store replicas of at least some of the 
`cri(cid:415)cal system elements, for use by the so(cid:332)ware applica(cid:415)ons in user mode execu(cid:415)ng in the context of 
`the applica(cid:415)on. The cri(cid:415)cal system elements are run in a context of a so(cid:332)ware applica(cid:415)on. 
`
`1 
`
`Google Exhibit 1095
`Google v. VirtaMove
`
`

`

`The term replica used herein is meant to denote a CSE having similar a(cid:425)ributes to, but not necessarily 
`and preferably not an exact copy of a CSE in the opera(cid:415)ng system (OS); notwithstanding, a CSE for use in 
`user mode, may in a less preferred embodiment be a copy of a CSE in the OS. 
`
`In accordance with the inven(cid:415)on, a compu(cid:415)ng system for execu(cid:415)ng a plurality of so(cid:332)ware applica(cid:415)ons is 
`provided, comprising: 
`
`an opera(cid:415)ng system having an opera(cid:415)ng system kernel having OS cri(cid:415)cal system elements (OSCSEs) for 
`running in kernel mode; and, 
`
`a shared library having cri(cid:415)cal system elements (SLCSEs) stored therein for use by the so(cid:332)ware 
`applica(cid:415)ons in user mode wherein some of the CSEs stored in the shared library are accessible to a 
`plurality of the so(cid:332)ware applica(cid:415)ons and form a part of at least some of the so(cid:332)ware applica(cid:415)ons by 
`being linked thereto, and wherein an instance of a CSE provided to an applica(cid:415)on from the shared library 
`is run in a context of said so(cid:332)ware applica(cid:415)on without being shared with other so(cid:332)ware applica(cid:415)ons 
`and where some other applica(cid:415)ons running under the opera(cid:415)ng system can, have use of a unique 
`instance of a corresponding cri(cid:415)cal system element for performing essen(cid:415)ally the same func(cid:415)on. 
`
`In accordance with the inven(cid:415)on, there is provided, a compu(cid:415)ng system for execu(cid:415)ng a plurality of 
`so(cid:332)ware applica(cid:415)ons comprising an opera(cid:415)ng system having an opera(cid:415)ng system kernel having OS 
`cri(cid:415)cal system elements (OSCSEs) for running in kernel mode; and, 
`
`1. a shared library having cri(cid:415)cal system elements (SLCSEs) stored therein for use by the so(cid:332)ware 
`applica(cid:415)ons in user mode as a service dis(cid:415)nct from that supplied in the OS kernel. 
`
`2. wherein some of the SLCSEs stored in the shared library are accessible to a plurality of the so(cid:332)ware 
`applica(cid:415)ons and form a part of at least some of the so(cid:332)ware applica(cid:415)ons, and wherein a unique 
`instance of a CSE provided to an applica(cid:415)on from the shared library is run in a context of said so(cid:332)ware 
`applica(cid:415)on and where some other applica(cid:415)ons running under the opera(cid:415)ng system each have use of a 
`unique instance of a corresponding cri(cid:415)cal system element for performing essen(cid:415)ally the same func(cid:415)on. 
`
`In some embodiments, the compu(cid:415)ng architecturesystem has applica(cid:415)on libraries accessible by the 
`so(cid:332)ware applica(cid:415)ons and augmented by the shared library. 
`
`In some embodiments, the cri(cid:415)cal system elements are le(cid:332) in the opera(cid:415)ng system kernel. 
`
`In some embodiments, the cri(cid:415)cal system elements use system calls to access services in theApplica(cid:415)on 
`libraries are libraries of files required by an applica(cid:415)on in order to run. In accordance with this inven(cid:415)on, 
`SLCSEs are placed in shared libraries, thereby becoming applica(cid:415)on libraries, loaded when the 
`applica(cid:415)on is loaded. A shared library or dynamic linked library (DLL) refers to an approach, wherein the 
`term applica(cid:415)on library infers a dependency on a set of these libraries used by an applica(cid:415)on. 
`
`Typically, the cri(cid:415)cal system elements are not removed from opera(cid:415)ng system kernel. 
`
`In some embodiments, the opera(cid:415)ng system kernel has a kernel module adapted to serve as an interface 
`between a service in the context of an applica(cid:415)on program and a device driver. 
`
`In some embodiments, the cri(cid:415)cal system elements in the context of an applica(cid:415)on program use system 
`calls to access services in the kernel module. 
`
` 
`
`2 
`
`

`

`In some embodiments, the kernel module is adapted to provide a no(cid:415)fica(cid:415)on of an interrup(cid:415)on to a 
`service in the context of an applica(cid:415)on program. 
`
`In some embodiments, the opera(cid:415)ng system kernel is adapted to provide interrupt handling capabili(cid:415)es 
`to user mode CSEs. 
`
`In some embodiments, the interrupt handling capabili(cid:415)es are ini(cid:415)alized through a system call. 
`
`In some embodiments, the kernel module comprises a handler which is installed for a specific device 
`interrupt. 
`
`In some embodiments, the handler is called when an interrupt request is generated by a hardware 
`device.  
`
`In some embodiments, the handler no(cid:415)fies the service in the context of an applica(cid:415)on through the use 
`of an up call mechanism. 
`
`In some embodiments, func(cid:415)on overlays are used to intercept so(cid:332)ware applica(cid:415)on accesses to 
`opera(cid:415)ng system services. 
`
`intercept so(cid:332)ware applica(cid:415)on accesses to opera(cid:415)ng system 
`
`services. 
`
`In some embodiments, the opera(cid:415)ng system kernel is enabled when the so(cid:332)ware applica(cid:415)on is loaded 
`into memory.  
`
`In some embodiments, the cri(cid:415)cal system elements stored in the shared library are linked to the 
`so(cid:332)ware applica(cid:415)ons as the so(cid:332)ware applica(cid:415)ons are loaded. 
`
`In some embodiments, in a na(cid:415)ve form the cri(cid:415)cal system elements rely on kernel services supplied by 
`the opera(cid:415)ng system kernel for device access, interrupt delivery, and virtual memory mapping. 
`
`In some embodiments, the kernel services are replicated in user mode and contained in the shared 
`library with the cri(cid:415)cal system elements. In the preferred embodiment the kernel itself is not copied. 
`CSEs are not taken from the kernel and copied to user mode. An instance of a service that is also 
`provided in the kernel is created to be implemented in user mode. By way of example, the kernel may 
`provide a TCP/IP service and in accordance with this inven(cid:415)on, a TCP/IP service is provided in user mode 
`as an SLCSE. The TCP/IP service in the kernel remains fully intact. The CSE is not shared as such. Each 
`applica(cid:415)on that will use a CSE will link to a library containing the CSE independent of any other 
`applica(cid:415)on. The intent is to provide an applica(cid:415)on with a unique instance of a CSE. 
`
`In accordance with this inven(cid:415)on, the code shared is by all applica(cid:415)ons on the same compute pla(cid:414)orm. 
`However, this shared code does not imply that the CSE itself is shared. This sharing of code is common 
`prac(cid:415)ce. All applica(cid:415)ons currently share code for common services, such services include opera(cid:415)ons 
`such as such as open a file, write to the file, read from the file, etc. Each applica(cid:415)on has its own unique 
`data space. This indivisible data space ensures that CSEs are unique to an applica(cid:415)on or more commonly 
`to a set of applica(cid:415)ons associated with a container, for example. Despite the fact that all applica(cid:415)ons 
`may physically execute the same set of instruc(cid:415)ons in the same physical memory space, that is, shared 
`
` 
`
`3 
`
`

`

`code space, the instruc(cid:415)ons cause them to use separate data areas. In this manner CSEs are not shared 
`among applica(cid:415)ons even though the code is shared. 
`
`In some embodiments, the kernel services used by CSEs comprise memory alloca(cid:415)on, synchroniza(cid:415)on 
`and device access. 
`
`In some embodiments, the kernel services that are pla(cid:414)orm specific are not replicated, or provided as 
`SLCSEs. 
`
`In some embodiments, the kernel services which are pla(cid:414)orm specific are called by a cri(cid:415)cal system 
`element running in user mode. 
`
` In some embodiments, a user process running under the compu(cid:415)ng architecturesystem has a respec(cid:415)ve 
`one of the so(cid:332)ware applica(cid:415)ons, the applica(cid:415)on libraries, the shared library and the cri(cid:415)cal system 
`elements all of which are opera(cid:415)ng in user mode. 
`
`In some embodiments, the so(cid:332)ware applica(cid:415)ons are provided with respec(cid:415)ve versions of the cri(cid:415)cal 
`system elements. 
`
` In some embodiments, the system elements which are applica(cid:415)on specific reside in user mode, while 
`the system elements which are pla(cid:414)orm specific reside in the opera(cid:415)ng system kernel. 
`
` In some embodiments, a control code is placed in kernel mode. 
`
`In some embodiments, the kernel module is adapted to enable data exchange between the cri(cid:415)cal 
`servicesystem elements in user mode and a device driver in kernel mode. 
`
`In some embodiments, the data exchange uses mapping of virtual memory such that data is transferred 
`both from the cri(cid:415)cal servicesystem elements in user mode to the device driver in kernel mode and from 
`the device driver in kernel mode to the cri(cid:415)cal servicesystem elements in user mode. 
`
`In some embodiments, the kernel module is adapted to export services for device interface.  
`
`In some embodiments, the export services comprise ini(cid:415)aliza(cid:415)on to establish a channel between a 
`cri(cid:415)cal system element of the cri(cid:415)cal system elements in user mode and a device. 
`
`In some embodiments, the export services comprise transfer of data from a cri(cid:415)cal system element of 
`the cri(cid:415)cal system elements in user mode to a device managed by the opera(cid:415)ng system kernel. 
`
`In some embodiments, the export services include transfer of data from a device to a cri(cid:415)cal system 
`element of the cri(cid:415)cal system elements in user mode. 
`
`According to a second broad aspect, the inven(cid:415)on provides an opera(cid:415)ng system comprising the above 
`compu(cid:415)ng architecturesystem. 
`
`According to a third broad aspect, the inven(cid:415)on provides a compu(cid:415)ng pla(cid:414)orm comprising the above 
`opera(cid:415)ng system and compu(cid:415)ng hardware capable of running under the opera(cid:415)ng system. 
`
`According to a fourth broad aspect, the inven(cid:415)on provides a shared library accessible to so(cid:332)ware 
`applica(cid:415)ons in a user mode, the shared library being adapted to store system elements which are 
`
` 
`
`4 
`
`

`

`replicas of systems elements of an opera(cid:415)ng system kernel and which are cri(cid:415)cal to the so(cid:332)ware 
`applica(cid:415)ons. 
`
`According to a fi(cid:332)h broad aspect, the inven(cid:415)on provides an opera(cid:415)ng system kernel having 
`systemssystem elements and adapted to run in a kernel mode and to replicate, for storing in a shared 
`library which is accessible by so(cid:332)ware applica(cid:415)ons in user mode, system elements of the system 
`elements which are cri(cid:415)cal to the so(cid:332)ware applica(cid:415)ons. 
`
`According to a sixth broad aspect, the inven(cid:415)on provides an ar(cid:415)cle of manufacture comprising a 
`computer usable medium having computer readable program code means embodied therein for a 
`compu(cid:415)ng architecture. The computer readable code means in said ar(cid:415)cle of manufacture has computer 
`readable code means for running an opera(cid:415)ng system kernel having cri(cid:415)cal system elements in kernel 
`mode; and computer readable code means for storing in a shared library replicas of at least some of the 
`cri(cid:415)cal system elements, for use by so(cid:332)ware applica(cid:415)ons in user mode. The cri(cid:415)cal system elements are 
`run in a context of a so(cid:332)ware applica(cid:415)on. 
`
`The cri(cid:415)cal system elements are run in a context of a so(cid:332)ware applica(cid:415)on. Accordingly, elements cri(cid:415)cal 
`to a so(cid:332)ware applica(cid:415)on are migrated from centralized control in an opera(cid:415)ng system into the same 
`context as the applica(cid:415)on. 
`
` Advantageously, the inven(cid:415)on allows specific opera(cid:415)ng system services to efficiently operate in the 
`same context as a so(cid:332)ware applica(cid:415)on. 
`
`Cri(cid:415)calIn accordance with this inven(cid:415)on, cri(cid:415)cal system elements normally embodied in an opera(cid:415)ng 
`system are exported to so(cid:332)ware applica(cid:415)ons through shared libraries. The shared library services 
`provided in an opera(cid:415)ng system are used to expose these addi(cid:415)onal system elements. 
`
`Brief Descrip(cid:415)on of the Drawings 
`
`BRIEF DESCRIPTION OF THE DRAWINGS 
`
`Preferred embodiments of the inven(cid:415)on will now be described with reference to the a(cid:425)ached drawings 
`in which: 
`
`FigureFIG. 1 is an architectural view of the tradi(cid:415)onal monolithic prior art opera(cid:415)ng system; 
`
`FigureFIG. 2 a is an architectural view of a mul(cid:415)‐server opera(cid:415)ng system in which some cri(cid:415)cal system 
`elements are removed from the opera(cid:415)ng system kernel and are placed in mul(cid:415)ple dis(cid:415)nct processes or 
`servers; 
`
`FigureFIG. 2 b is illustra(cid:415)ve of a known system architecture where cri(cid:415)cal system elements execute in 
`user mode and execute in dis(cid:415)nct context from applica(cid:415)ons in a single applica(cid:415)on process context; 
`
`FIG. 3 is an architectural view of an embodiment of the inven(cid:415)on; 
`
`FigureFIG. 4 is a func(cid:415)onal view showing how cri(cid:415)cal system elements exist in the same context as an 
`applica(cid:415)on; 
`
`FigureFIG. 5 is a block diagram showing a kernel module provided by an embodiment of the inven(cid:415)on; 
`and, 
`
` 
`
`5 
`
`

`

`FigureFIG. 6 shows how interrupt handling occurs in an embodiment of the inven(cid:415)on. 
`
`Detailed Descrip(cid:415)on of the Preferred Embodiments 
`
`DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
`
`Embodiments of the inven(cid:415)on enable the replica(cid:415)on of cri(cid:415)cal system elements normally found in an 
`opera(cid:415)ng system kernel. These replicated CSEs are then able to run in the context of a so(cid:332)ware 
`applica(cid:415)on. Cri(cid:415)cal system elements are replicated through the use of shared libraries. Replica(cid:415)on 
`implies that system elements are not replaced from an opera(cid:415)ng system, rather they become separate 
`extensions accessed throughA CSE is replicated by way of a kernel service being repeated in user space. 
`This replicated CSE may differ slightly from its counterpart in the OS. Replica(cid:415)on is achieved placing CSEs 
`similar to those in the OS in shared libraries which provides a means of a(cid:425)aching or linking a CSE service 
`to an applica(cid:415)on having access to the shared library. Therefore, a service in the kernel is substan(cid:415)ally 
`replicated in user mode through the use of shared libraries. 
`
`The term replica(cid:415)on implies that system elements become separate extensions accessed through shared 
`libraries as opposed to being replaced from an opera(cid:415)ng system. Hence, CSEs are generally not copies of 
`a por(cid:415)on of the OS; they are an added addi(cid:415)onal service in the form of a CSE. Shared libraries are used 
`as a mechanism where by an applica(cid:415)on can u(cid:415)lize a CSE that is part of a library. By way of example; a 
`Linux based pla(cid:414)orm provides a TCP/IP stack in the Linux kernel. This inven(cid:415)on provides a TCP/IP stack in 
`the form of a CSE that is a different implementa(cid:415)on of a TCP/IP stack, from Berkeley So(cid:332)ware 
`Distribu(cid:415)on (BSD) by way of example. Applica(cid:415)ons on a Linux pla(cid:414)orm may use a BSD TPC/IP stack in the 
`form of a CSE. The mechanism for a(cid:425)aching the BSD TCP/IP stack to an applica(cid:415)on is in the form of a 
`shared library. Shared libraries as opposed to being copies from the OS to another space are a dis(cid:415)nct 
`implementa(cid:415)on of the service (i.e. TCP/IP) packaged in the form of a shared library capable of execu(cid:415)ng 
`in user mode linked to an applica(cid:415)on. 
`
`In a broad sense, the TCP/IP services in the CSE are the same as those provided in the Linux kernel. The 
`reason two of these service may be required is to allow an applica(cid:415)on to u(cid:415)lize network services 
`provided by a TCP/IP stack, that have unique configura(cid:415)on or se(cid:427)ngs for the applica(cid:415)on. Or the se(cid:427)ng 
`used by one applica(cid:415)on may conflict with the se(cid:427)ngs needed by another applica(cid:415)on. If, by way of 
`example, a first applica(cid:415)on requires that specific network packets using a range of port numbers be 
`passed to itself, it would need to configure route informa(cid:415)on to allow the TCP/IP stack to process these 
`packets accordingly. On the same pla(cid:414)orm a second applica(cid:415)on is then exposed to either undesirable 
`performance issues or security risks by allowing network packets with a broad port number range to be 
`processed by the TCP/IP stack. In another scenario the configura(cid:415)on/se(cid:427)ngs established to support one 
`applica(cid:415)on may have an adverse effect on the system as a whole. 
`
`By way of introduc(cid:415)on, a number of terms will now be defined. 
`
`Cri(cid:415)cal System Element (CSE): Any service or part of a service, “normally” supplied by an opera(cid:415)ng 
`system, that is cri(cid:415)cal to the opera(cid:415)on of a so(cid:332)ware applica(cid:415)on. 
`
`A CSE is a dynamic object providing some func(cid:415)on that is execu(cid:415)ng instruc(cid:415)ons used by applica(cid:415)ons. 
`
`BY WAY OF EXAMPLE CSEs INCLUDE: 
`
`Network services including TCP/IP, Bluetooth, ATM; or message passing protocols 
`
` 
`
`6 
`
`

`

`File System services that offer extensions to those supplied by the OS 
`
`1. Access files that reside in different loca(cid:415)ons as though they were all in a single locality 
`
`2. Access files in a compressed, encrypted or packaged image as though they were in a local directory in 
`a standard format 
`
`Implementa(cid:415)on of file system op(cid:415)miza(cid:415)ons for specific applica(cid:415)on behavior 
`
`Implementa(cid:415)on of network op(cid:415)miza(cid:415)ons for specific applica(cid:415)on services such as: 
`
`1. Kernel bypass where hardware supported protocol processing is provided 
`
`2. Modified protocol processing for custom hardware services 
`
`Compute pla(cid:414)orm: The combina(cid:415)on of computer hardware and a single instance of an opera(cid:415)ng system. 
`
`User mode: The context in which applica(cid:415)ons execute. 
`
`Kernel mode: The context in which the kernel por(cid:415)on of an opera(cid:415)ng system executes. In conven(cid:415)onal 
`systems, there is a physical separa(cid:415)on enforced by hardware between user mode and kernel mode.  
`Applica(cid:415)on code cannot run in kernel mode. 
`
`Applica(cid:415)on Programming Interface (API): An API refers to the opera(cid:415)ng system and programming 
`language specific func(cid:415)ons used by applica(cid:415)ons. These are typically supplied in libraries which 
`applica(cid:415)ons link with either when the applica(cid:415)on is created or when the applica(cid:415)on is loaded by the 
`opera(cid:415)ng system. The interfaces are described by header files provided with an opera(cid:415)ng system 
`distribu(cid:415)on. In prac(cid:415)ce, system APIs are used by applica(cid:415)ons to access opera(cid:415)ng system services. 
`
`Applica(cid:415)on library: A collec(cid:415)on of func(cid:415)ons in an archive format that is combined with an applica(cid:415)on to 
`export system elements. 
`
`Shared library: An applica(cid:415)on library whose code space is shared among all user mode applica(cid:415)ons. The 
`code space is different than that occupied by the kernel and its associated files. The shared library files 
`are placed in an address space that is accessible to mul(cid:415)ple applica(cid:415)ons. 
`
`Sta(cid:415)c library: An applica(cid:415)on library whose code space is contained in a single applica(cid:415)on. 
`
`Kernel module: A set of func(cid:415)ons that reside and execute in kernel mode as extensions to the opera(cid:415)ng 
`system kernel. It is common in most systems to include kernel modules which provide extensions to the 
`exis(cid:415)ng opera(cid:415)ng system kernel. 
`
`Up call mechanism: A means by which a service in kernel mode callsexecutes a func(cid:415)on in a user mode 
`applica(cid:415)on context. It is common to provide an up call mechanism within an opera(cid:415)ng system kernel. 
`
`FigureFIG. 1 shows a conven(cid:415)onal architecture where cri(cid:415)cal system elements execute in kernel mode. 
`Cri(cid:415)cal system elements are contained in the opera(cid:415)ng system kernel. Applica(cid:415)ons access system 
`elements through applica(cid:415)on libraries. 
`
`In order for an applica(cid:415)on of FigureFIG. 1 to make use of a cri(cid:415)cal system element 17 in the kernel 16, 
`the applica(cid:415)on 12 a or 12 b makes a call to the applica(cid:415)on libraries 14. It is imprac(cid:415)cal to write 
`applica(cid:415)ons, which handle CPU specific/opera(cid:415)ng specific issues directly. As such, what is commonly 
`
` 
`
`7 
`
`

`

`done is to provide an applica(cid:415)on library in shared code space, which mul(cid:415)ple applica(cid:415)ons can access. 
`This provides a pla(cid:414)orm independent interface where applica(cid:415)ons can access cri(cid:415)cal system elements. 
`When the applica(cid:415)on 12 a, 12 b makes a call to a cri(cid:415)cal system element 17 through the applica(cid:415)on 
`library 14, a system call may be used to transi(cid:415)on from user mode to kernel mode. The applica(cid:415)on stops 
`running as the hardware enters kernel mode.18 enters kernel mode. The processor makes the transi(cid:415)on 
`to a protected/privileged mode of execu(cid:415)on called kernel mode. Code supplied by the OS in the form of 
`a kernel begins execu(cid:415)on when the transi(cid:415)on is made. The applica(cid:415)on code is not used when execu(cid:415)ng 
`in kernel mode. The opera(cid:415)ng system kernel then provides the required func(cid:415)onality. It is noted that 
`each oval 12 a, 12 b in FigureFIG. 1 represents a different context. There are two applica(cid:415)on contexts in 
`the illustrated example and the opera(cid:415)ng system context is not shown as an oval but also has its own 
`context. There are many examples of this architecture in the prior art including SUN Solaris™, IBM AIX™, 
`HP‐UX™ and Linux™. 
`
`FigureFIG. 2 a shows a system architecture where cri(cid:415)cal system elements 27 a, 27 b execute in user 
`mode but in a dis(cid:415)nct context from applica(cid:415)ons. Some cri(cid:415)cal system elements are removed from the 
`opera(cid:415)ng system kernel. They reside in mul(cid:415)ple dis(cid:415)nct processes or servers as discussed in United 
`States Provisional Patent Applica(cid:415)on en(cid:415)tled "Drag & Drop Applica(cid:415)on Management" which is 
`incorporated herein by reference. . An example of the architecture described in FIG. 2 a is the GNU Hurd 
`opera(cid:415)ng system. 
`
`The servers that export cri(cid:415)cal system elements execute in a context dis(cid:415)nct from the opera(cid:415)ng system 
`kernel and applica(cid:415)ons. These servers operate at a peer level with respect to other applica(cid:415)ons. 
`Applica(cid:415)ons access system elements through applica(cid:415)on libraries. The libraries in this case communicate 
`with mul(cid:415)ple servers in order to access cri(cid:415)cal system elements. Thus, in the illustrated example, there 
`are two applica(cid:415)on contexts and two cri(cid:415)cal system element contexts. When an applica(cid:415)on needs to 
`makerequires the use of a cri(cid:415)cal system element, which is being run in user mode, a rather convoluted 
`sequence of events must take place. Typically the applica(cid:415)on first makes a pla(cid:414)orm independent call to 
`the applica(cid:415)on library. The applica(cid:415)on library in turn makes a call to the opera(cid:415)ng system kernel. The 
`opera(cid:415)ng system kernel then schedules the server with the cri(cid:415)cal system element in a different user 
`mode context. A(cid:332)er the server completes the opera(cid:415)on, a switch back to kernel mode is made which 
`then responds back to the applica(cid:415)on through the applica(cid:415)on library. Due to this architecture, such 
`implementa(cid:415)ons may result in poor performance. Ideally, an applica(cid:415)on, which runs on the system of 
`FigureFIG. 1, should be able to run on the system of FigureFIG. 2 a as well. However, in prac(cid:415)ce it is 
`difficult to maintain the same characteris(cid:415)cs and performance using such an architecture. 
`
`FIG. 2 b is illustra(cid:415)ve of a known system architecture where cri(cid:415)cal system elements execute in user 
`mode. The inven(cid:415)on is contrasted with both of these architectures in that cri(cid:415)cal system elements also 
`execute in a dis(cid:415)nct context from applica(cid:415)ons. Some cri(cid:415)cal system elements are removed from the 
`opera(cid:415)ng system kernel. The essen(cid:415)al difference between the architecture described in FIG. 2 a and FIG. 
`2 b is the use of a single process context to contain all user mode cri(cid:415)cal system elements. An example of 
`the architecture described in FIG. 2 b is Apple's MAC OS X™. 
`
`This inven(cid:415)on is contrasted with all three of the prior art examples. Cri(cid:415)cal system elements as defined 
`in the inven(cid:415)on are not isolated in the opera(cid:415)ng system kernel inas is the case of a monolithic 
`architecture (Figureshown in FIG. 1),; also they are not removed from the context of an applica(cid:415)on, as is 
`
` 
`
`8 
`
`

`

`the case with a mul(cid:415)‐server architecture (Figure 2).depicted in FIG. 2 a. Rather, they are replicated, and 
`embodied in the context of an applica(cid:415)on. 
`
`FigureFIG. 3 shows an architectural view of the overall opera(cid:415)on of thethis inven(cid:415)on. Mul(cid:415)ple user 
`processes execute above a single instance of an opera(cid:415)ng system.  
`
`So(cid:332)ware applica(cid:415)ons 32 a, 32 b, u(cid:415)lize shared libraries 34 as is done in United StatesU.S. Provisional 
`Patent Applica(cid:415)on Ser. No. 60/512,103 en(cid:415)tled "“SOFTWARE SYSTEM FOR CONTAINERIZATION OF 
`APPLICATION SETS"” which is incorporated herein by reference. The standard libraries are augmented by 
`an extension, which contains cri(cid:415)cal system elements., that reside in extended shared libraries 35. 
`Extended services are similar to those that appear in the context of the opera(cid:415)ng system kernel 36. 
`
`FigureFIG. 4 showsillustrates the func(cid:415)onality of an applica(cid:415)on process as it exists above thean 
`opera(cid:415)ng system kernel all of which isthat was described in FIG. 3. Applica(cid:415)ons exist and run in user 
`mode while the opera(cid:415)ng system kernel 46 itself runs in kernel mode. The userUser mode func(cid:415)onality 
`includes the user applica(cid:415)ons 42, the standard applica(cid:415)on libraries, and a new extended shared library 
`provided by an  44, and one or more cri(cid:415)cal system elements, 45 & 47. FIG. 4 shows one embodiment of 
`the inven(cid:415)on. The  where the CSE func(cid:415)onality is contained in two shared libraries. An extended library, 
`45, provides control opera(cid:415)ons while the CSE shared library, 47, provides an implementa(cid:415)on of a cri(cid:415)cal 
`system element. 
`
`The CSE library includes replicas or substan(cid:415)al func(cid:415)onal equivalents or replacements of kernel 
`func(cid:415)ons. The term replica, shall encompass any of these meanings, and although not a preferred 
`embodiment, may even be a copy of a CSE that is part of the OS. These func(cid:415)ons can be directly called 
`by the applica(cid:415)ons 42 and as such can be run in the same context as the applica(cid:415)ons 42. In preferred 
`embodiments, the kernel func(cid:415)ons which are included in the extended shared library and cri(cid:415)cal system 
`element library 45,47 are also included in the opera(cid:415)ng system kernel.  46. 
`
`Furthermore, there might be different versions of a given cri(cid:415)cal system element forming part of the 
`extended shared library47 with different applica(cid:415)ons accessing these different versions within their 
`respec(cid:415)ve context. 
`
`In preferred embodiments, the pla(cid:414)orm specific aspects of the cri(cid:415)cal system element are le(cid:332) in the  
`opera(cid:415)ng system kernel, for example certain system calls.. Then the cri(cid:415)cal system elements which are 
`includedrunning in the extended shared libraryuser mode may s(cid:415)ll make use of the opera(cid:415)ng system 
`kernel to implement these pla(cid:414)orm specific func(cid:415)ons.  
`
`FigureFIG. 5 represents the func(cid:415)on of the kernel module (58, described in more detail below).. A cri(cid:415)cal 
`system element in the context of an applica(cid:415)on program uses system calls to access services in the 
`kernel module. The kernel module serves as an interface between a service in