# Patent

## Title
Mechanism for implementing file access control across a network using labeled containers

## Abstract

A mechanism is disclosed for enabling labeled containers on different host machines to share file system portions. Before a process in a first container on a first host machine is allowed to access a file in a file system contained within a second container on a second host machine, a check is performed to determine whether a first sensitivity label associated with the first container is either identical to or dominates a second sensitivity label associated with the second container. If either is true, access to the file is granted. If the first sensitivity label is neither identical to nor dominates the second sensitivity label, access to the file is denied. By controlling access in this way, it is ensured that only containers with identical or higher sensitivity labels will be allowed to access the file. This in turn allows files to be shared by multiple containers without compromising security.

## Background
PRIORITY CLAIM
This application is a continuation-in-part of U.S. Ser. No. 11/361,437, entitled MECHANISM FOR IMPLEMENTING FILE ACCESS CONTROL USING LABELED CONTAINERS, filed on Feb. 23, 2006, by Glenn T. Faden, the contents of which are incorporated in their entirety herein by reference.


BACKGROUND
In many computer implementations, it is desirable to limit access to files based upon accessibility level. This is especially true in a government context. For example, in a government security implementation, it is quite desirable, and most likely required, for top secret files to be accessible only by users and processes having the proper clearance level (e.g. top secret clearance or above). It may also be desirable for users and processes having high clearance levels to be able to access files at lower levels (e.g. users and processes with top secret clearance can access need-to-know and public files). In order to implement such controls, some mechanism needs to be put in place to check the clearance levels of the users, processes, and files, and to determine whether certain accesses should be allowed. One such mechanism may be an operating system.
Currently, in order to implement such file access control, sensitivity labels need to be associated and stored with each file. When an access of a file is requested by a user or process, the sensitivity label of the file is checked against the sensitivity level of the user or process, and based upon that check, a decision is made as to whether to allow or deny the requested access.
This approach has at least one significant drawback, which is that it requires a customized file system in order to work. Most standard file systems do not allow sensitivity labels to be associated and stored with each file. Thus, only a customized file system that allows sensitivity labels to be stored with each file can be used with this approach. This aspect of the approach significantly limits its applicability. Because of at least this drawback, this approach does not provide wholly satisfactory results. Consequently, an improved mechanism for enforcing file access control is needed.
SUMMARY
In accordance with one embodiment of the present invention, there is provided a mechanism for implementing file access control which does not require a sensitivity label to be associated and stored with each file. Rather, file access control is achieved through the use of labeled containers.
In one embodiment, one or more containers may be established within a global operating system environment. Each container, which for example may be an operating system partition (also referred to herein as a non-global zone), represents a separate virtual operating environment. Each container has its own file system. Each container also acts as a process isolation mechanism for isolating processes executing within that container from processes executing in other containers. Given these two aspects of a container, the processes executing within a container can access only the files and directories that are part of the file system for that container. The processes in a container are generally unaware of the file systems of other containers.
In addition to having its own file system, each container also has its own unique sensitivity label. In one embodiment, each sensitivity label comprises a portion that specifies a sensitivity level, and a portion that specifies a category. The sensitivity level specifies where, in a sensitivity hierarchy, a particular container falls. For example, one container may have a sensitivity level that corresponds to “top secret” while another container may have a sensitivity level that corresponds to “need-to-know”, which is lower than “top secret”. The category portion specifies the matter to which the container pertains. For example, the category portion may specify a country (e.g. Iraq, Egypt, etc.), a particular matter (e.g. Iran Contra), etc. Together, the sensitivity level portion and the category portion form an overall unique sensitivity label for each container (e.g. “top secret Iraq”, “need-to-know Egypt”, etc.). These sensitivity labels may be used to determine whether one container dominates another.
Given the container characteristics set forth above, file access control may be implemented as follows. Suppose that a first container is being established in a global operating system environment. When the first container is created, it is assigned a first sensitivity label. A first file system is also associated with the first container. As part of the container establishment process, a determination is made as to whether there are any other containers in the global operating system environment that are dominated by the first container. The first container dominates another container if the first sensitivity label of the first container dominates the sensitivity label of the other container. In one embodiment, the first sensitivity label dominates the other sensitivity label if: (1) the first sensitivity label has a higher sensitivity level than the other sensitivity label; and (2) both sensitivity labels have the same category portion. For example, “top secret Iraq” dominates “need-to-know Iraq” but it does not dominate “need-to-know Egypt” because, even though it has a higher sensitivity level, it has a different category.
For the sake of example, it will be assumed that a second container already exists in the global operating system environment, and that the second container has a second sensitivity label and a second file system associated therewith. It will further be assumed that the second sensitivity label is dominated by the first sensitivity label of the first container. In such a case, it is determined that the second container is dominated by the first container. In response to this determination, a particular portion of the second file system of the second container is incorporated into the first file system of the first container (this particular portion may be a portion of the second file system that has been designated as being exportable to higher level containers). This incorporation may be done, for example, by mounting the particular portion of the second file system onto a particular mount point in the first file system. By doing so, the particular portion of the second file system is made accessible to the processes executing within the first container. In effect, file access control is enforced because the files and directories of the second file system (which have a lower sensitivity level) are made accessible to the processes of the first container (which have a higher sensitivity level).
In one embodiment, as a further part of the container establishment process, a further determination is made as to whether there are any other containers in the global operating system environment that dominate the first container. For the sake of example, it will be assumed that a third container already exists in the global operating system environment, and that the third container has a third sensitivity label and a third file system associated therewith. It will be further assumed that the third sensitivity label dominates the first sensitivity label of the first container. In such a case, it is determined that the third container dominates the first container. In response to this determination, a certain portion of the first file system of the first container is incorporated into the third file system of the third container (this certain portion may be a portion of the first file system that has been designated as being exportable to higher level containers). Again, this incorporation may be done, for example, by mounting the certain portion of the first file system onto a particular mount point in the third file system. By doing so, the certain portion of the first file system is made accessible to the processes executing within the third container. In effect, file access control is enforced because the files and directories of the first file system (which have a lower sensitivity level) are made accessible to the processes of the third container (which have a higher sensitivity level).
Notice that implementing file access control in the above manner does not require a sensitivity label to be stored with each file. Rather, the sensitivity label is associated with a container, and is applied to all of the directories and files in the file system of that container. Thus, this file access control approach does not require a customized file system that allows a sensitivity label to be stored with each file but rather can be implemented with most standard types of file systems. Also, notice that the sensitivity labels are not checked every time a file is accessed but rather only at the time that a container is established. Because of this, system overhead is significantly reduced. Thus, with this approach, it is possible to implement file access control simply and efficiently.
The above embodiment addresses the situation where file system portions are controllably shared by multiple containers on the same host machine. To enable file system portions to be controllably shared by containers on different host machines, a slightly different methodology is implemented.
To illustrate, suppose that a first host machine: (1) has a first kernel executing thereon; (2) has a first container established thereon, wherein the first container has a first sensitivity label associated therewith; and (3) has a first process executing within the first container. Suppose further that a second host machine: (1) is coupled to the first host machine via a network; (2) has a second kernel executing thereon; (3) has a second container established thereon, wherein the second container has a second sensitivity label associated therewith; and (4) has a file system that is contained within the second container. Given this arrangement, the sharing of file system portions may be controllably carried out as follows, in accordance with one embodiment of the present invention.
Initially, when the second container is established on the second host machine, the second kernel registers a particular portion of the file system as being sharable. Doing so renders the particular portion potentially accessible to containers on other host machines. Now, suppose that the first process in the first container on the first host machine sends a request to the first kernel to access a file in the particular portion of the file system contained within the second container on the second host machine. When the first kernel receives this request from the first process, it determines that the first process is executing within the first container. The first kernel also determines that the first container has the first sensitivity label associated therewith. With this information, the first kernel constructs a network packet that contains the request to access the file in the particular portion of the file system. The kernel includes in this network packet the first sensitivity label. After the packet is constructed, the first kernel sends the packet from the first host machine to the second host machine via the network.
The second kernel on the second host machine receives the packet. The second kernel determines from the request contained within the packet that the file being requested resides within the particular portion of the file system, which is contained within the second container on the second host machine. The second kernel also determines that the second container has the second sensitivity label associated therewith. Further, the second kernel extracts the first sensitivity label from the packet, and determines whether the first sensitivity label is either identical to or dominates the second sensitivity label. If the first sensitivity label is identical to the second sensitivity label, then the second kernel grants read/write access to the requested file in the particular portion of the file system contained within the second container. If the first sensitivity label is not identical to but dominates the second sensitivity label, then the second kernel grants read only access to the file. If the first sensitivity label is neither identical to nor dominates the second sensitivity label, then the second kernel denies access to the file. In this manner, the second kernel ensures that access to the file is granted to only those containers that have the same or higher sensitivity labels.
By carrying out the above methodology, it is possible for labeled containers on different host machines to controllably share file system portions across a network.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows a functional block diagram of a system in which one embodiment of the present invention may be implemented.
FIGS. 2A-2C show some sample file system of some sample zones to illustrate how file access control may be implemented in accordance with one embodiment of the present invention.
FIG. 3 shows, in tree form, an overall file system comprising a branch that represents a file system of a zone.
FIG. 4 shows, in tree form, an overall file system comprising two branches representing the file systems of two separate zones.
FIG. 5 is a block diagram of a general purpose computer system in which one embodiment of the present invention may be implemented.
FIG. 6 is a functional block diagram of a system in which file access control may be implemented across a network, in accordance with one embodiment of the present invention.



DETAILED DESCRIPTION OF EMBODIMENT(S)
System Overview
With reference to FIG. 1, there is shown a functional block diagram of a system in which one embodiment of the present invention may be implemented. In the system of FIG. 1, an operating system (OS) environment 100 is derived by executing an OS in a general-purpose computer system, such as computer system 500 illustrated in FIG. 5. For illustrative purposes, it will be assumed that the OS is Solaris manufactured by Sun Microsystems, Inc. of Santa Clara, Calif. However, it should be noted that the concepts taught herein may be applied to any OS, including but not limited to Unix, Linux, Windows, MacOS, etc.
As shown in FIG. 1, OS environment 100 may comprise one or more zones (also referred to herein as operating system partitions), including a global zone 130 and zero or more non-global zones 140 (also referred to as containers). The global zone 130 is the general OS environment that is created when the OS is booted and executed, and serves as the default zone in which processes may be executed if no non-global zones 140 are created. In the global zone 130, administrators and/or processes having the proper rights and privileges can perform generally any task and access any device/resource that is available on the computer system on which the OS is run. Thus, in the global zone 130, an administrator can administer the entire computer system. In one embodiment, it is in the global zone 130 that an administrator executes processes to configure and to manage the non-global zones 140.
The non-global zones or containers 140 represent separate and distinct partitions of the OS environment 100. Each non-global zone 140 provides a separate virtual operating environment. One of the purposes of the non-global zones 140 is to provide isolation. In one embodiment, a non-global zone 140 can be used to isolate a number of entities, including but not limited to processes 170, one or more file systems 180, and zero or more logical network interfaces 182. Because of this isolation, processes 170 executing in one non-global zone 140 cannot access or affect processes in any other zone. Similarly, processes 170 in a non-global zone 140 generally cannot access or affect the file system 180 of another zone, nor can they access or affect the network interface 182 of another zone. As a result, the processes 170 in a non-global zone 140 are limited to accessing and affecting the processes and entities in that zone. Isolated in this manner, each non-global zone 140 behaves like a virtual standalone computer.
Having non-global zones 140 that are isolated from each other may be desirable in many implementations. For example, if a single computer system running a single instance of an OS is to be used to host applications and file systems having different security levels, it may be desirable to isolate the data and processes so that sensitive information does not leak from one file system to another. Partitioning an OS environment 100 into non-global zones 140 and hosting the different applications and file systems in separate non-global zones 140 is one possible way of achieving this isolation.
In one embodiment, each non-global zone 140 may be administered separately. More specifically, it is possible to assign a zone administrator to a particular non-global zone 140 and grant that zone administrator rights and privileges to manage various aspects of that non-global zone 140. With such rights and privileges, the zone administrator can perform any number of administrative tasks that affect the processes and other entities within that non-global zone 140. However, the zone administrator cannot change or affect anything in any other non-global zone 140 or the global zone 130. In one embodiment, to prevent a non-global zone 140 from affecting other zones, the entities in a non-global zone 140 are generally not allowed to access or control any of the physical devices of the computer system.
In contrast to a non-global zone administrator, a global zone administrator with proper rights and privileges may administer all aspects of the OS environment 100 and the computer system as a whole. Thus, a global zone administrator may, for example, access and control physical devices, allocate and control system resources, establish operational parameters, etc. A global zone administrator may also access and control processes and entities within a non-global zone 140.
In one embodiment, enforcement of the zone boundaries is carried out by the kernel 150 of the OS. More specifically, it is the kernel 150 that ensures that processes 170 in one non-global zone 140 are not able to access or affect processes 170, file systems 180, and network interfaces 182 of another zone (non-global or global). In addition to enforcing the zone boundaries, kernel 150 also provides a number of other services. These services include but certainly are not limited to mapping the network interfaces 182 of the non-global zones 140 to the physical network devices 120 of the computer system, mapping the file systems 180 of the non-global zones 140 to an overall file system and a physical storage 1 10 of the computer system, and enabling file access to be implemented across a network. The operation of the kernel 150 will be discussed in greater detail in a later section.
Sensitivity Labels
As noted previously, one of the purposes of the non-global zones 140 is to provide isolation to prevent the processes in one non-global zone from accessing the file system of another non-global zone. While such isolation is generally desirable, there may be implementations in which it is desirable to allow the processes in one non-global zone to access at least a portion of the file system of another non-global zone. For example, suppose that a non-global zone hosts a set of top secret processes and files while another non-global zone hosts a set of public processes and files. In such a case, it may be desirable to allow the top secret processes of the first zone to access at least a portion of the public files of the second zone. In one embodiment, to facilitate this cross-zone file access, each non-global zone 140 is assigned a unique sensitivity label.
In one embodiment, a sensitivity label comprises two portions: (1) a sensitivity level portion; and (2) a category portion. The sensitivity level portion specifies a sensitivity level for the non-global zone 140. This sensitivity level is one of the levels in a sensitivity hierarchy, and specifies where in that hierarchy the non-global zone belongs. For example, if the sensitivity hierarchy includes the levels of “top secret”, “secret”, “need-to-know”, and “public”, where “top secret” is the highest, then if a non-global zone 140 has a sensitivity level of “secret”, it is known that that non-global zone 140 is higher than “need-to-know” and “public” but lower than “top secret”. The sensitivity level portion of a sensitivity label may be common among a plurality of non-global zones 140. Thus, for example, more than one non-global zone 140 may have a sensitivity level of “secret”.
The category portion of the sensitivity label may be used to specify some particular aspect of a non-global zone 140. For example, the category portion may specify a country (e.g. Iraq, Egypt, etc.) or some particular matter (e.g. Iran Contra) to which the information in the non-global zone 140 pertains. Like the sensitivity level portion, the category portion of a sensitivity label may be common among a plurality of non-global zones 140. Thus, for example, more than one non-global zone 140 may have a category of “Iraq”.
While neither the sensitivity level portion nor the category portion in and of itself contains unique information, together, they form a unique sensitivity label for each non-global zone 140. Thus, for example, one non-global zone may have a sensitivity label of “top secret Iraq”, while another may have a sensitivity label of “need-to-know Iraq”, while another may have a sensitivity label of “need-to-know Egypt”. In one embodiment, no two non-global zones 140 within the same global zone 130 on the same host machine have the same sensitivity label (note: it is possible for non-global zones on different host machines to have the same sensitivity label; for example, a non-global zone on machine 1 may have the sensitivity label of “top secret Iraq” while a non-global zone on machine 2 may have the same sensitivity label). In the above discussion, the sensitivity levels and categories are expressed in terms of words to best facilitate understanding; however, it should be noted that these portions may be expressed in any form (e.g. numbers, combination of numbers and text, etc.) that serve the same purposes.
Given the sensitivity labels for two non-global zones 140, it is possible to determine whether one non-global zone 140 dominates the other. Specifically, a first non-global zone dominates a second non-global zone if the sensitivity label of the first non-global zone (referred to as the first sensitivity label) dominates the sensitivity label of the second non-global zone (referred to as the second sensitivity label). In one embodiment, the first sensitivity label dominates the second sensitivity label if: (1) the first sensitivity label has a higher sensitivity level than the second sensitivity label; and (2) both the first and second sensitivity labels have the same category portion. Given these criteria, if the first sensitivity label is “top secret Iraq” and the second sensitivity label is “need-to-know Iraq”, then the first sensitivity label dominates the second sensitivity label because the first sensitivity label has a higher sensitivity level (“top secret” is higher than “need-to-know”) and both labels have the same category (“Iraq”). On the other hand, if the first sensitivity label is “top secret Iraq” and the second sensitivity label is “need-to-know Egypt”, then there is no dominance because, even though the first sensitivity label has a higher sensitivity level, it has a different category (“Iraq” instead of “Egypt”). In such a case, the labels are said to be disjoint.
It should be noted that the above dominance criteria is just one of many ways for determining whether one sensitivity label dominates another. Other criteria may be used. For example, if so desired, the category portion of a sensitivity label may be ignored so that as long as a first sensitivity label has a higher sensitivity level than a second sensitivity label, the first sensitivity label is deemed to dominate the second sensitivity label. This and other ways of determining dominance may be used. All such criteria for determining dominance are within the scope of the present invention.
The significance of the dominance determination is that it determines whether the processes in a first non-global zone may be allowed to access at least a portion of the file system of a second non-global zone. Specifically, if the first non-global zone dominates the second non-global zone, then the processes in the first non-global zone may be allowed to access at least a portion of the file system of the second non-global zone. In one embodiment, to enable the processes in the first non-global zone to access the portion of the file system of the second non-global zone, the portion of the file system of the second non-global zone is incorporated into the file system of the first non-global zone. By doing so, the portion of the file system of the second non-global zone is made accessible to the processes in the first non-global zone without violating the isolation aspect of the non-global zones. Since the portion of the file system of the second non-global zone is now part of the file system of the first non-global zone, when the processes in the first non-global zone access the portion of the file system of the second non-global zone, they are really just accessing a portion of the file system of their own non-global zone; thus, the isolation aspect of the first non-global zone is preserved.
The above discussion provides just a brief overview of how the sensitivity labels may be used to enable cross-zone file access. A particular manner in which this may be achieved will be described in greater detail in a later section.
File System for a Non-Global Zone
As noted above, each non-global zone 140 has its own associated file system 180. This file system 180 is used by the processes 170 running within the associated zone 140, and generally cannot be accessed by processes 170 running within any other non-global zone 140 (although it can be accessed by a process running within the global zone 130 if that process has the appropriate privileges). To illustrate how a separate file system may be maintained for each non-global zone 140, reference will be made to FIGS. 3 and 4.
FIG. 3 shows, in tree format, a portion of an overall file system maintained by the kernel 150 for the global zone 130. This overall file system comprises a /directory 302, which acts as the root for the entire file system. Under this root directory 302 are all of the directories, subdirectories, files, and mounts of the overall file system.
As shown in FIG. 3, under the/directory 302 is a path to a root directory 322 of a file system 180 for a particular non-global zone 140. In the example shown, the path is /Zones/ZoneA Root (as seen from the global zone 130), and the non-global zone is zone A 140(a) (FIG. 1). This root 322 acts as the root of the file system 180(a) for zone A 140(a), and everything underneath this root 322 is part of that file system 180(a). Because root 322 is the root of the file system 180(a) for zone A 140(a), processes 170(a) within zone A 140(a) cannot traverse up the file system hierarchy beyond root 322 (the kernel 150 enforces this). Thus, processes 170(a) cannot see or access any of the directories above root 322, or any of the subdirectories that can be reached from those directories. To processes 170(a), it is as if the other portions of the overall file system did not exist.
FIG. 4 shows the same overall file system, except that another file system for another non-global zone 140 has been added. In the example shown, the other non-global zone is zone B 140(b) (FIG. 1), and the path to the root 422 of the file system 180(b) for zone B 140(b) is /Zones/ZoneB Root. Root 422 acts as the root of the file system 180(b) for zone B 140(b), and everything underneath it is part of that file system 180(b). Because root 422 is the root of the file system 180(b) for zone B 140(b), processes 170(b) within zone B 140(b) cannot traverse up the file system hierarchy beyond root 422. Thus, processes 170(b) cannot see or access any of the directories above root 422, or any of the subdirectories that can be reached from those directories. To processes 170(b), it is as if the other portions of the overall file system did not exist. By organizing the file systems in this manner, it is possible to maintain, within an overall file system maintained for the global zone 130, a separate file system 180 for each non-global zone 140. It should be noted that this is just one way of maintaining a separate file system for each non-global zone. Other methods may be used, and all such methods are within the scope of the present invention.
The root of a non-global zone's file system may have any number of directories, subdirectories, and files underneath it. Using root 322 as an example, these directories may include some directories, such as ETC 332, which contain files specific to a zone 140(a) (for example, program files that are to be executed within the zone 140(a)), and some directories, such as USR 324, which contain operating system files that are used by the zone 140(a). The directories may also include an Export directory 328, which contains directories and files that can be exported to the file systems of other non-global zones with higher sensitivity levels. The significance of the Export directory 328 will be discussed in greater detail in a later section. These and other directories and files may be included under the root 322, or a subdirectory thereof.
The root of a non-global zone's file system may also have one or more mounts underneath it. Put another way, one or more mount points may exist under the root (or a subdirectory thereof), on which entities may be mounted. The mount points may be used to mount loop back file systems (LOFS), network file systems (NFS), or other types of file systems. Basically, any number of mount points, on which any type of file system may be mounted, may exist under the root of a non-global zone's file system.
Non-Global Zone States
In one embodiment, a non-global zone 140 may take on one of four states: (1) Configured; (2) Installed; (3) Ready; and (4) Running. When a non-global zone 140 is in the Configured state, it means that an administrator in the global zone 130 has invoked an operating system utility (in one embodiment, zonecfg(1 m)) to specify all of the configuration parameters of a non-global zone 140, and has saved that configuration in persistent physical storage 110. In configuring a non-global zone 140, an administrator may specify a number of different parameters. These parameters may include, but are not limited to, a zone name, a zone path to the root directory of the zone's file system 180, a sensitivity label, specification of zero or more mount points and entities to be mounted when the zone is readied, specification of zero or more network interfaces, specification of devices to be configured when the zone is created, etc.
Once a zone is in the Configured state, a global administrator may invoke another operating system utility (in one embodiment, zoneadm(1 m)) to put the zone into the Installed state. When invoked, the operating system utility interacts with the kernel 150 to install all of the necessary files and directories into the zone's root directory, or a subdirectory thereof.
To put an Installed zone into the Ready state, a global administrator invokes an operating system utility (in one embodiment, zoneadm(1 m) again), which causes a ZoneADMD process 162 to be started (there is a ZoneADMD process associated with each non-global zone). In one embodiment, ZoneADMD 162 runs within the global zone 130 and is responsible for managing its associated non-global zone 140. After ZoneADMD 162 is started, it interacts with the kernel 150 to establish the non-global zone 140. In establishing a non-global zone 140, a number of operations are performed. These operations include creating the non-global zone 140 (in one embodiment, this involves assigning a zone ID to the non-global zone 140, associating a sensitivity label with the zone, creating a zone data structure which will be used by the kernel 150 to enforce and manage zone boundaries and file access, establishing the path to the root directory of the zone as the root of the zone's file system 180, etc.). These operations may also include starting a zsched process 164 (zsched is a kernel process; however, it runs within the non-global zone 140, and is used to track kernel resources associated with the non-global zone 140), plumbing network interfaces 182, configuring devices, etc. In one embodiment, it is during this establishment process that sensitivity labels are checked, and portions of file systems of non-global zones are incorporated into the file systems of other non-global zones. This will be described in greater detail in a later section. These and other operations put the non-global zone 140 into the Ready state to prepare it for normal operation.
Putting a non-global zone 140 into the Ready state gives rise to a virtual platform on which one or more processes may be executed. This virtual platform provides the infrastructure necessary for enabling one or more processes to be executed within the non-global zone 140 in isolation from processes in other non-global zones 140. The virtual platform also makes it possible to isolate other entities such as file system 180 and network interfaces 182 within the non-global zone 140, so that the zone behaves like a virtual standalone computer.
After a non-global zone 140 is in the Ready state, it can be transitioned into the Running state by executing one or more user processes in the zone. In one embodiment, this is done by having ZoneADMD 162 start an init process 172 in its associated zone. Once started, the init process 172 looks in the file system 180 of the non-global zone 140 to determine what applications to run. The init process 172 then executes those applications to give rise to one or more other processes 174. In this manner, an application environment is initiated on the virtual platform of the non-global zone 140. In this application environment, all processes 170 are confined to the non-global zone 140; thus, they cannot access or affect processes, file systems, or network interfaces in other zones. The application environment exists so long as one or more user processes are executing within the non-global zone 140.
After a non-global zone 140 is in the Running state, its associated ZoneADMD 162 can be used to manage it. ZoneADMD 162 can be used to initiate and control a number of zone administrative tasks. These tasks may include, for example, halting and rebooting the non-global zone 140. When a non-global zone 140 is halted, it is brought from the Running state down to the Installed state. In effect, both the application environment and the virtual platform are terminated. When a non-global zone 140 is rebooted, it is brought from the Running state down to the Installed state, and then transitioned from the Installed state through the Ready state to the Running state. In effect, both the application environment and the virtual platform are terminated and restarted. These and many other tasks may be initiated and controlled by ZoneADMD 162 to manage a non-global zone 140 on an ongoing basis during regular operation.
Establishment of File Access Control
As noted previously, it is during the establishment of a non-global zone 140 that sensitivity labels are checked and certain portions of file systems of non-global zones are incorporated into the file systems of other non-global zones. To illustrate how this is done in accordance with one embodiment of the present invention, reference will be made to an example.
FIG. 2A shows a global zone 130 in which there are three non-global zones 140(1), 140(2), 140(3) (hereinafter, the non-global zones will be referred to as zones for the sake of brevity). Zones 140(2) and 140(3) are already established (i.e. they are in either the ready or running state). Zone 140(1) is about to be established (i.e. it is in the installed state). Zone 140(2) has a sensitivity label which is “public Iraq”, zone 140(3) has an sensitivity label which is “top secret Iraq”, and zone 140(1), which is about to be established, will have a sensitivity label which is “secret Iraq”. Since they are already established, zones 140(2) and 140(3) have established file systems 180(2) and 180(3), respectively (for the sake of simplicity, only a portion of these file systems is shown in FIG. 2A). They also have currently executing ZoneADMD's 162(2) and 162(3) for managing them. Given this existing environment, the establishment of zone 140(1) will now be described.
Initially, zone 140(1) is in the Installed state. In this state, the zone 140(1) will have had all of the necessary files and directories already installed under its root directory. Thus, its file system 180(1) is already established. For the sake of example, it will be assumed that the file system 180(1) has a root 202 called Zone1 Root, and that there is a Zone directory 206 and an Export directory 204 stemming from the root 202. The file system 180(1) may also have other directories, subdirectories, and files that are not shown in FIG. 2A. In one embodiment, the Export directory 204 contains all of the directories, subdirectories, and files that can be made accessible to processes of other zones with higher sensitivity levels. This naming convention is followed by all of the zones. Thus, the Export directory 214 in the file system 180(2) of zone 140(2) also contains all of the directories, subdirectories, and files that can be made accessible to processes of other zones with higher sensitivity levels.
To transition zone 140(1) from the Installed state into the Ready state, a global administrator invokes an operating system utility (in one embodiment, zoneadm(1 m)), which causes a ZoneADMD process 162(1) to be started. This ZoneADMD 162(1) runs within the global zone 130 and is responsible for establishing and managing zone 140(1). After ZoneADMD 162(1) is started, it interacts with the kernel 150 to establish zone 140(1). To do so, ZoneADMD 162(1) initially creates the zone 140(1). In one embodiment, this involves accessing the configuration information for the zone 140(1) (which was provided by the administrator when putting the zone into the Configured state). It further involves assigning an ID to the zone 140(1), assigning the sensitivity label specified in the configuration information to the zone 140(1), creating a zone data structure that will be used by the kernel 150 to enforce and manage zone boundaries and file access, establishing the path to the root directory 202 of the zone as the root of the file system 180, etc. In addition to creating the zone 140(1), the ZoneADMD 162(1) also performs other tasks, such as starting a zsched process (not shown) (zsched is a kernel process; however, it runs within the zone 140(1), and is used to track kernel resources associated with the zone 140(1)), plumbing one or more network interfaces, configuring devices, etc. These operations put the zone 140(1) into the Ready state.
In one embodiment, as part of the establishment process, ZoneADMD 162(1) also checks the sensitivity labels of other zones. Specifically, ZoneADMD 162(1) queries the kernel 150 for the sensitivity labels of all of the other zones in the system. Since ZoneADMD 162(1) executes in the global zone 130 and not in one of the zones 140, it is allowed to obtain information pertaining to all of the zones in the system. After ZoneADMD 162(1) has the sensitivity labels of all of the zones in the system, it checks each sensitivity label to determine whether there are any zones that are dominated by zone 140(1). In the current example, zone 140(1) has a sensitivity label of “secret Iraq” while zone 140(2) has a sensitivity label of “public Iraq”. Since “secret” is higher than “public” in the sensitivity hierarchy, and since both labels specify “Iraq”, the sensitivity label of zone 140(1) dominates the sensitivity label of zone 140(2). Given this situation, it may be desirable to give the processes in zone 140(1) (which have a higher sensitivity level) access to at least a portion of the file system of zone 140(2) (which has a lower sensitivity level).
In response to this determination, ZoneADMD 162(1) checks the file system 180(2) of zone 140(2) to determine whether there is any portion of the file system 180(2) that is exportable to other zones. In one embodiment, ZoneADMD 162(1) checks for an Export directory, which the file system 180(2) of zone 140(2) has. Upon finding the Export directory 214, ZoneADMD 162(1) incorporates that directory 214 into the file system 180(1) of zone 140(1). In one embodiment, to do so, ZoneADMD 162(1) creates a Zone2 directory under the Zone directory 206 of file system 180(1), and mounts the Export directory 214 onto the Zone2 directory (thereby using Zone2 as a mount point). The result is shown in FIG. 2B, wherein the file system 180(1) of zone 140(1) has been updated to include a Zone2 directory 208 upon which the Export directory 214 has been mounted. In one embodiment, this mount is a LOFS mount. An advantage of a LOFS type of mount is that it does not require the contents of the Export directory 214 of file system 180(2) to be copied into the file system 180(1) of zone 140(1). Rather, the LOFS mount acts as a reference to the Export directory 214 of file system 180(2) so that when a process in zone 140(1) accesses the Export directory 214 in file system 180(1), it is redirected to the Export directory 214 of file system 180(2). In this way, there is no need to replicate or synchronize multiple copies of the Export directory 214. In one embodiment, to prevent the downgrade of information, ZoneADMD 162(1) makes the Zone2 mount point 208 a read-only mount. This prevents the processes in zone 140(1) from writing any information (which may be “secret” information) into the Export directory 214, which in turn, precludes the processes in zone 140(2) from being able to access any “secret” information that might otherwise have been written into the Export directory 214.
By incorporating the Export directory 214 of the file system 180(2) of zone 140(2) into the file system 180(1) of zone 140(1) in the above manner, information in the file system 180(2) of zone 140(2) is now made accessible to the processes of zone 140(1). In effect, file access control is enforced because the files and directories of the Export directory 214 in zone 140(2) (which have a lower sensitivity level) are now made accessible to the processes of the zone 140(1) (which have a higher sensitivity level). This file access control is achieved without violating the isolation aspect of zone 140(1). Since the Export directory 214 of the file system 180(2) of zone 140(2) is now part of the file system 180(1) of zone 140(1), when the processes in zone 140(1) access the Export directory 214, they are really just accessing a portion of the file system 180(1) of their own zone 140(1); thus, the isolation aspect of zone 140(1) is preserved.
In one embodiment, in addition to checking for zones that are dominated by zone 140(1), ZoneADMD 162(1) also checks for zones that dominate zone 140(1). Specifically, ZoneADMD 162(1) checks each sensitivity label to determine whether there are any zones that have sensitivity labels that dominate the sensitivity label of zone 140(1). In the current example, zone 140(3) has a sensitivity label of “top secret Iraq” while zone 140(1) has a sensitivity label of “secret Iraq”. Since “top secret” is higher than “osecret” in the sensitivity hierarchy, and since both labels specify “Iraq”, the sensitivity label of zone 140(3) dominates the sensitivity label of zone 140(1). Given this situation, it may be desirable to give the processes in zone 140(3) (which have a higher sensitivity level) access to at least a portion of the file system of zone 140(1) (which has a lower sensitivity level).
In response to this determination, ZoneADMD 162(1) checks the file system 180(1) of zone 140(1) to determine whether there is any portion of the file system 180(1) that is exportable to other zones. In one embodiment, ZoneADMD 162(1) checks for an Export directory, which the file system 180(1) of zone 140(1) has. Upon finding the Export directory 204, ZoneADMD 162(1) incorporates that directory 204 into the file system 180(3) of zone 140(3). In one embodiment, to do so, ZoneADMD 162(1) creates a Zone1 directory under the Zone directory 224 of file system 180(3), and mounts the Export directory 204 onto the Zone1 directory (thereby using Zone1 as a mount point). The result is shown in FIG. 2C, wherein the file system 180(3) of zone 140(3) has been updated to include a Zone1 directory 230 upon which the Export directory 204 has been mounted. In one embodiment, this mount is a LOFS mount, which acts as a reference to the Export directory 204 of file system 180(1) so that when a process in zone 140(3) accesses the Export directory 204 in file system 180(3), it is redirected to the Export directory 204 of file system 180(1). In one embodiment, to prevent the downgrade of information, ZoneADMD 162(1) makes the Zone1 mount point 230 a read-only mount. This prevents the processes in zone 140(3) from writing any information (which may be “top secret” information) into the Export directory 204, which in turn, precludes the processes in zone 140(1) from being able to access any “top secret” information that might otherwise have been written into the Export directory 204.
By incorporating the Export directory 204 of the file system 180(1) of zone 140(1) into the file system 180(3) of zone 140(3) in the above manner, information in the file system 180(1) of zone 140(1) is made accessible to the processes of zone 140(3). In effect, file access control is enforced because the files and directories of the Export directory 204 in zone 140(1) (which have a lower sensitivity level) are now made accessible to the processes of zone 140(3) (which have a higher sensitivity level). This file access control is achieved without violating the isolation aspect of zone 140(3). Since the Export directory 204 of the file system 180(1) of zone 140(1) is now part of the file system 180(3 of zone 140(3), when the processes in zone 140(3) access the Export directory 204, they are reallyjust accessing a portion of the file system 180(3) of their own zone 140(3); thus, the isolation aspect of zone 140(3) is preserved.
Notice that implementing file access control in the above manner does not require a sensitivity label to be stored with each file. Rather, the sensitivity label is associated with a zone, and applied to all of the directories and files in the file system of that zone. Thus, this file access control approach does not require a customized file system that allows a sensitivity label to be stored with each file but rather can be implemented with most standard types of file systems. Also, notice that the sensitivity labels need not be checked every time a file is accessed but rather only at the time that a zone is established. Because of this, system overhead is significantly reduced. Thus, with this approach, it is possible to implement file access control simply and efficiently.
Enforcement of Zone Boundaries
As noted previously, in one embodiment, it is the kernel 150 that enforces the zone boundaries. In this regard, the kernel 150 ensures that the processes within a zone 140 are not allowed to access or affect anything outside of the zone. This includes ensuring that the processes within a zone 140 are allowed to access only the files and directories that are within the file system of that zone. In one embodiment, the kernel 150 does this by associating the zone ID (assigned at the time of zone creation) with each process executing within a zone 140.
Specifically, whenever a process is started within a zone 140, the kernel 150 ascertains the ID of the zone, and associates that ID with the process. When a process requests access to a file or a directory, the kernel 150 determines the zone ID associated with that process. The kernel 150 then accesses the data structure associated with that zone 140, and determines the path to the root of the file system for that zone 140. The kernel 150 then determines whether the requested file or directory has a path that is under the root of the file system for that zone 140. If it is, then access to the file or directory may be granted (if other conditions, such as having the proper privileges, are met). Otherwise, access is denied. By doing so, the kernel 150 ensures that a process is allowed to access only the files and directories that are part of the file system of the zone in which the process is executing.
File Access Control Across a Network
In the above embodiment, file access control is implemented to enable file system portions to be shared by multiple zones on the same host machine. As shown in FIGS. 2A-2C, all of the non-global zones 140(1), 140(2), 140(3) reside within a single global zone 130, and all of the zones 130, 140(1), 140(2), 140(3) reside on the same host machine (e.g. computer system 500). In some implementations, it may be desirable to extend this file access control and file sharing capability to operate across a network so that a first process in a first zone on a first host machine is able to controllably access a file in a second zone on a second host machine across a network. To enable such access, a slightly different methodology is provided. To illustrate this methodology in accordance with one embodiment of the present invention, reference will be made to an example.
Suppose that a networked system has the arrangement shown in FIG. 6, wherein the system 600 comprises a first host machine 602(1), a second host machine 602(2), and a network 604 for coupling the host machines. For the sake of simplicity, only two host machines are shown in system 600. However, it should be noted that the system 600 may comprise any desired number of host machines.
The first host machine 602(1) has a first kernel 650(1) executing thereon. The first host machine 602(1) also has a global zone 630(1) established thereon, and a first non-global zone (hereinafter, container) 640(1) established within the global zone 630(1). For the sake of simplicity, only one container 640(1) is shown within the global zone 630(1); however, it should be noted that the global zone 630(1) may comprise any desired number of containers. As shown, the container 640(1) has a sensitivity label 1 associated therewith. The container 640(1) also has two processes executing therein: process 674 and the automount daemon process 670. For the sake of simplicity, only two processes are shown within container 640(1). If so desired, more or fewer processes may be executing therein. In one embodiment, the container 640(1) also has a file system associated therewith. For the sake of simplicity, this file system is not shown in FIG. 6.
The second host machine 602(2) has a second kernel 650(2) executing thereon. The second host machine 602(2) also has a global zone 630(2) established thereon, and a second container 640(2) established within the global zone 630(4). For the sake of simplicity, only one container 640(2) is shown within the global zone 630(2); however, it should be noted that the global zone 630(2) may comprise any desired number of containers. As shown, the container 640(2) has a sensitivity label 2 associated therewith. The container 640(1) also has a file system 680 associated therewith. This file system 680 has a portion 690 that is designated as being sharable with other containers. The sharable or shared portion 690 may comprise one or more directories and one or more files. The container 640(2) may also have one or more processes executing therein. For the sake of simplicity, no such processes are shown. In addition to the components already mentioned, the global zone 630(2) may also have a ZoneADMD process 662 executing therein, which interacts with the kernel 650(2) to establish and manage the container 640(2).
In one embodiment, to enable file access control and file sharing to be carried out across the network 604, some setup is performed on both host machines 602. In one embodiment, on the server side (the side or host machine 602(2) on which the shared file system portion 690 resides), the setup is performed by the ZoneADMD 662 and the second kernel 650(2). Specifically, when the ZoneADMD 662 establishes the container 640(2), it consults a configuration data structure and determines whether there are any directories or files within the file system 680 that are to be shared with other containers. This configuration data structure may be provided by a system administrator. If the ZoneADMD 662 determines that there is a portion 690 of the file system 680 that is to be shared, then it registers that portion 690 (which may comprise one or more directories and one or more files) with the second kernel 650(2) as being sharable. In response, the second kernel 650(2) creates a sharing data structure to store information pertaining to the one or more directories of the file system 680 that are being shared. In one embodiment, the second kernel 650(2) maintains a separate sharing data structure for each container on the second host machine 602(2) that is sharing a portion of its file system.
On the client side (the side or host machine 602(1) that is accessing the shared portion 690 of the file system 680), the setup, in one embodiment, is performed by the automount daemon process 670 and the first kernel 650(1). When the automount daemon process 670 executes, it consults a set of configuration information. This configuration information may be provided by a system administrator, or it may be obtained by the automount daemon 670 from a list server. Basically, the configuration information sets forth the directory or directories within the file system (not shown) of container 640(1) that are “special”. These directories may include one or more NFS (network file system) mount points that correspond to one or more shared directories 690 of the file system 680 associated with container 640(2). Once these special directories are determined, the automount daemon 670 registers the special directories with the first kernel 650(1). The effect of this registration is that whenever one of these directories is accessed, the first kernel 650(1) will notify the automount dearnon 670. The automount daemon 670 will then determine what should be done. For example, if one of the special directories is an NFS mount point that corresponds to one of the shared directories 690 of file system 680, and if a file in that directory is being accessed, then the automount daemon 670 will know to send a file access request to the second host machine 602(2). With the above setup operations having been performed, the system is now prepared to implement file access control and file sharing across the network 604.
Suppose now that process 674 tries to access a file that is in one of the special directories that the automount daemon 670 has registered with the first kernel 650(1). Suppose further that this special directory is an NFS mount point that corresponds to one of the shared directories 690 of the files system 680 associated with the second container 640(2) on the second host machine 602(2). When this access is detected, the first kernel 650(1) determines that the access is to one of the special directories that the automount daemon 670 has registered. Thus, the first kernel 650(1) notifies the automount daemon 670 of the access. In response, the automount daemon 670 determines that the access is to a file that is under an NFS mount point. It further determines that the NFS mount point points to the second host machine 602(2); thus, the automount daemon 670 constructs a file access request to access the file from the appropriate shared directory 690 of the file system 680 associated with the second container 640(2). The automount daemon 670 sends this file access request to the first kernel 650(1) to have the first kernel 650(1) send the file access request across the network 604 to the second host machine 602(2).
Upon receiving this file access request from the automount daemon 670, the first kernel 650(1) determines that the automount daemon 670 is executing within the first container 640(1). In one embodiment, this determination is made based upon the process credentials of the automount daemon 670, which include the process ID of the automount daemon 670 and the container ID of container 640(1). The first kernel 650(1) also determines that the first container 640(1) has sensitivity label 1 associated therewith. With this information, the first kernel 650(1) constructs a network packet to contain the file access request. Included in this packet is the sensitivity label 1 associated with container 640(1). After the packet is constructed, the first kernel 650(1) sends the packet across the network 640 to the second host machine 602(2).
The second kernel 650(2) on the second host machine 602(2) receives the packet. From the file access request contained within the packet, the second kernel 650(2) determines the path to the desired file. From this path, the second kernel 650(2) determines that the file resides within the file system 680 associated with container 640(2). With container 640(2) thus determined, the second kernel 650(2) accesses the sharing data structure that was previously created and associated with container 640(2). Based on the information in the sharing data structure and the path to the desired file, the second kernel 650(2) determines whether the file resides within one of the directories 690 that has been registered as being sharable. If not, the second kernel 650(2) will deny access to the file. If so, the second kernel 650(2) will proceed further to determine whether access to the file should be granted. For the sake of example, it will be assumed that the file resides within one of the sharable directories 690.
To determine whether access to the requested file should be granted, the second kernel 650(2) extracts the sensitivity label 1 from the packet (recall that the first kernel 650(1) included this sensitivity label in the packet). This sensitivity label specifies the sensitivity level of the container 640(1) from which the file access request originated. The second kernel 650(2) also determines that container 640(2) has the sensitivity label 2 associated therewith. This sensitivity label specifies the sensitivity level of the container 640(2) with which the requested file and file system 680 are associated. Based on these two sensitivity labels, the second kernel 650(2) determines whether access to the requested file should be granted.
To make this determination, the second kernel 650(2) compares the two sensitivity labels. If sensitivity label 1 is identical to sensitivity label 2 (recall that it is possible for containers on different host machines to have identical sensitivity labels), then read/write access is granted to the requested file. If sensitivity label 1 is not identical to sensitivity label 2 but dominates sensitivity label 2, then read only access is granted to the requested file. This dominance determination may be made in the manner described previously. By granting read only access, it is ensured that the process in container 640(1) will not be able to write any information (which has a higher sensitivity level) into the file system 680 of container 640(2). This in turn precludes the processes in container zone 640(2) from being able to access any higher sensitivity level information that might otherwise have been written into the file system 680. If sensitivity label 1 neither is identical to nor dominates sensitivity label 2, then access to the requested file is denied. By controlling access in this manner, the second kernel 650(2) ensures that only processes and containers with sufficient sensitivity levels will be allowed to access the file.
Depending upon the access granted and the file access operation requested, the second kernel 650(2) will perform different operations. If, for example, the access granted is read/write access and the requested operation is a write into the requested file, then the second kernel 650(2) will update the requested file as requested in the file access request. If, on the other hand, the access granted is read/write or read only access and the requested operation is a read, then the second kernel 650(2) will access the requested file, package the data in the requested file into one or more network packets, and send the one or more packets back to the first host machine 602(1) via the network 640.
On the receiving end, the first kernel 650(1) receives the one or more packets and forwards the information contained in the packets to the automount daemon 670. In turn, the automount daemon 670 forwards the information to the process 674 that originally tried to access the requested file. The process 674 is thus able to access the requested file without ever knowing that the file resided on another host machine.
In the above example, the first kernel 650(1) is described as implementing the “client” side functionality and the second kernel 650(2) is described as implementing the “server” side functionality. It should be noted that the first kernel 650(1) may also implement the “server” side functionality as described above in connection with the second kernel 650(2), and the second kernel 650(2) may also implement the “client” side functionality as described above in connection with the first kernel 650(1). This and other modifications/enhancements are within the scope of the present invention.
Hardware Overview
In one embodiment, the ZoneADMD's 162, 662, the automount daemon 670, and the OS, which includes kernels 150, 650, may take the form of sets of instructions that are executed by one or more processors. If they take the form of sets of instructions, FIG. 5 shows a block diagram of a computer system 500 upon which these sets of instructions may be executed. Computer system 500 includes a bus 502 for facilitating information exchange, and one or more processors 504 coupled with bus 502 for processing information. Computer system 500 also includes a main memory 506, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 502 for storing information and instructions to be executed by processor 504. Main memory 506 also may be used for storing temporary variables or other intermediate information during execution of instructions by processor 504. Computer system 500 may further include a read only memory (ROM) 508 or other static storage device coupled to bus 502 for storing static information and instructions for processor 504. A storage device 510, such as a magnetic disk or optical disk, is provided and coupled to bus 502 for storing information and instructions.
Computer system 500 may be coupled via bus 502 to a display 512 for displaying information to a computer user. An input device 514, including alphanumeric and other keys, is coupled to bus 502 for communicating information and command selections to processor 504. Another type of user input device is cursor control 516, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 504 and for controlling cursor movement on display 512. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.
In computer system 500, bus 502 may be any mechanism and/or medium that enables information, signals, data, etc., to be exchanged between the various components. For example, bus 502 may be a set of conductors that carries electrical signals. Bus 502 may also be a wireless medium (e.g. air) that carries wireless signals between one or more of the components. Bus 502 may further be a network connection that connects one or more of the components. Any mechanism and/or medium that enables information, signals, data, etc., to be exchanged between the various components may be used as bus 502.
Bus 502 may also be a combination of these mechanisms/media. For example, processor 504 may communicate with storage device 510 wirelessly. In such a case, the bus 502, from the standpoint of processor 504 and storage device 510, would be a wireless medium, such as air. Further, processor 504 may communicate with ROM 508 capacitively. Further, processor 504 may communicate with main memory 506 via a network connection. In this case, the bus 502 would be the network connection. Further, processor 504 may communicate with display 512 via a set of conductors. In this instance, the bus 502 would be the set of conductors. Thus, depending upon how the various components communicate with each other, bus 502 may take on different forms. Bus 502, as shown in FIG. 5, functionally represents all of the mechanisms and/or media that enable information, signals, data, etc., to be exchanged between the various components.
The invention is related to the use of computer system 500 for implementing the techniques described herein. According to one embodiment of the invention, those techniques are performed by computer system 500 in response to processor 504 executing one or more sequences of one or more instructions contained in main memory 506. Such instructions may be read into main memory 506 from another machine-readable medium, such as storage device 510. Execution of the sequences of instructions contained in main memory 506 causes processor 504 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software.
The term “machine-readable medium” as used herein refers to any medium that participates in providing data that causes a machine to operation in a specific fashion. In an embodiment implemented using computer system 500, various machine-readable media are involved, for example, in providing instructions to processor 504 for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 510. Volatile media includes dynamic memory, such as main memory 506. Transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 502. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.
Common forms of machine-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD-ROM, DVD, or any other optical storage medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read.
Various forms of machine-readable media may be involved in carrying one or more sequences of one or more instructions to processor 504 for execution. For example, the instructions may initially be carried on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 500 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 502. Bus 502 carries the data to main memory 506, from which processor 504 retrieves and executes the instructions. The instructions received by main memory 506 may optionally be stored on storage device 510 either before or after execution by processor 504.
Computer system 500 also includes a communication interface 518 coupled to bus 502. Communication interface 518 provides a two-way data communication coupling to a network link 520 that is connected to a local network 522. For example, communication interface 518 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 518 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 518 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
Network link 520 typically provides data communication through one or more networks to other data devices. For example, network link 520 may provide a connection through local network 522 to a host computer 524 or to data equipment operated by an Internet Service Provider (ISP) 526. ISP 526 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 528. Local network 522 and Internet 528 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 520 and through communication interface 518, which carry the digital data to and from computer system 500, are exemplary forms of carrier waves transporting the information.
Computer system 500 can send messages and receive data, including program code, through the network(s), network link 520 and communication interface 518. In the Internet example, a server 530 might transmit a requested code for an application program through Internet 528, ISP 526, local network 522 and communication interface 518.
The received code may be executed by processor 504 as it is received, and/or stored in storage device 510, or other non-volatile storage for later execution. In this manner, computer system 500 may obtain application code in the form of a carrier wave.
At this point, it should be noted that although the invention has been described with reference to a specific embodiment, it should not be construed to be so limited. Various modifications may be made by those of ordinary skill in the art with the benefit of this disclosure without departing from the spirit of the invention. Thus, the invention should not be limited by the specific embodiments used to illustrate it but only by the scope of the issued claims and the equivalents thereof.

## Claims

1. A machine implemented method, comprising:
registering a particular portion of a first file system of a first container as being sharable, wherein the particular portion of the first file system comprises a file, wherein the first container comprises a first isolated execution environment in a global operating system environment;
mounting the particular portion of the first file system to a second file system of a second container, wherein the second container comprises a second isolated execution environment in the global operating system environment;
receiving a network packet containing a request to access the file from the second container;
determining that the file resides within the particular potion of the first file system, and wherein the first container serves to prevent processes executing within the first container from accessing files in the global operating system environment that are located external to the first container, wherein the global operating system environment and the first isolated execution environment are executed on a computer system;
determining, after determining that the file resides within the particular portion of the first file system, that the particular portion of the first file system is sharable;
in response to determining that the particular portion of the first file system is shareable, determining that the first container has a first sensitivity label associated therewith;
extracting a packet sensitivity label from the network packet;
determining whether the packet sensitivity label dominates the first sensitivity label; and
in response to determining that the packet sensitivity label dominates the first sensitivity label, granting access to the file using the first container;
wherein no sensitivity label is associated with the file, and wherein access to the file is determined without requiring any sensitivity label to be associated with the file.

2. The method of claim 1, wherein the access granted to the file is read only access.

3. The method of claim 1, further comprising:
determining whether the packet sensitivity label is identical to the first sensitivity label; and
in response to determining that the packet sensitivity label is identical to the first sensitivity label, granting read/write access to the file.

4. The method of claim 1, wherein the packet sensitivity label comprises a sensitivity level portion which specifies a requestor sensitivity level, wherein the first sensitivity label comprises a sensitivity level which specifies a sensitivity level for the first container, and wherein determining whether the packet sensitivity label dominates the first sensitivity label comprises:
determining whether the requestor sensitivity level is higher than the sensitivity level of the first container.

5. The method of claim 1, wherein the packet sensitivity label comprises a sensitivity level portion, which specifies a requestor sensitivity level, and a category portion, wherein the first sensitivity label comprises a sensitivity level, which specifies a sensitivity level for the first container, and a category portion, and wherein determining whether the packet sensitivity label dominates the first sensitivity label comprises:
determining whether the requestor sensitivity level is higher than the sensitivity level of the first container; and
determining whether the category portion of the packet sensitivity label is identical to the category portion of the first sensitivity label.

6. The method of claim 1, further comprising:
establishing the first container within the global operating system environment in such a manner that the first file system and the first sensitivity label are associated with the first container.

7. The method of claim 6, wherein the first container is an operating system partition.

8. A non-transitory machine readable storage medium, comprising:
instructions for causing one or more processors to register a particular portion of a first file system of a first container as being sharable, wherein the particular portion of the first file system comprises a file, wherein the first container comprises a first isolated execution environment in a global operating system environment;
instructions for causing the one or more processors to mount the particular portion of the first file system to a second file system of a second container, wherein the second container comprises a second isolated execution environment in the global operating system environment;
instructions for causing the one or more processors to receive a network packet containing a request to access the file from the second container;
instructions for causing the one or more processors to determine that the file resides within the particular potion of the first file system, and wherein the first container serves to prevent processes executing within the first container from accessing files in the global operating system environment that are located external to the first container, wherein the global operating system environment and the first isolated execution environment are executed on a computer system;
instructions for causing the one or more processors to determine, after determining that the file resides within the particular portion of the first file system, that the particular portion of the first file system is sharable;
instructions for causing the one or more processors to, in response to determining that the particular portion of the first file system is shareable, determine that the first container has a first sensitivity label associated therewith;
instructions for causing the one or more processors to extract a packet sensitivity label from the network packet;
instructions for causing the one or more processors to determine whether the packet sensitivity label dominates the first sensitivity label; and
instructions for causing the one or more processors to grant, in response to a determining that the packet sensitivity label dominates the first sensitivity label, access to the file using the first container;
wherein no sensitivity label is associated with the file, and wherein access to the file is determined without requiring any sensitivity label to be associated with the file.

9. The non-transitory machine readable storage medium of claim 8, wherein the access granted to the file is read only access.

10. The non-transitory machine readable medium of claim 8, further comprising:
instructions for causing one or more processors to determine whether the packet sensitivity label is identical to the first sensitivity label; and
instructions for causing one or more processors to grant, in response to determining that the packet sensitivity label is identical to the first sensitivity label, read/write access to the file.

11. The non-transitory machine readable storage medium of claim 8, wherein the packet sensitivity label comprises a sensitivity level portion which specifies a requestor sensitivity level, wherein the first sensitivity label comprises a sensitivity level which specifies a sensitivity level for the first container, and wherein the instructions for causing one or more processors to determine whether the packet sensitivity label dominates the first sensitivity label comprises:
instructions for causing one or more processors to determine whether the requestor sensitivity level is higher than the sensitivity level of the first container.

12. The non-transitory machine readable storage medium of claim 8, wherein the packet sensitivity label comprises a sensitivity level portion, which specifies a requester sensitivity level, and a category portion, wherein the first sensitivity label comprises a sensitivity level, which specifies a sensitivity level for the first container, and a category portion, and wherein the instructions for causing one or more processors to determine whether the packet sensitivity label dominates the first sensitivity label comprises:
instructions for causing one or more processors to determine whether the requestor sensitivity level is higher than the sensitivity level of the first container; and
instructions for causing one or more processors to determine whether the category portion of the packet sensitivity label is identical to the category portion of the first sensitivity label.

13. The non-transitory machine readable storage medium of claim 8, further comprising:
instructions for causing one or more processors to establish the first container within the global operating system environment in such a manner that the first file system and the first sensitivity label are associated with the first container.

14. The non-transitory machine readable storage medium of claim 13, wherein the first container is an operating system partition.

15. A computer system, comprising:
a memory; and
a processor, operatively connected to the memory and having functionality to execute instructions for:
registering a particular portion of a first file system of a first container as being sharable, wherein the particular portion of the first file system comprises a file, wherein the first container comprises a first isolated execution environment in a global operating system environment;
mounting the particular portion of the first file system to a second file system of a second container, wherein the second container comprises a second isolated execution environment in the global operating system environment;
receiving a network packet containing a request to access the file from the second container;
determining that the file resides within the particular potion of the first file system, and wherein the first container serves to prevent processes executing within the first container from accessing files in the global operating system environment that are located external to the first container, wherein the global operating system environment and the first isolated execution environment are executed on a computer system;
determining, after determining that the file resides within the particular portion of the first file system, that the particular portion of the first file system is sharable;
in response to determining that the particular portion of the first file system is shareable, determining that the first container has a first sensitivity label associated therewith;
extracting a packet sensitivity label from the network packet;
determining whether the packet sensitivity label dominates the first sensitivity label; and
in response to determining that the packet sensitivity label dominates the first sensitivity label, granting access to the file using the first container;
wherein no sensitivity label is associated with the file, and wherein access to the file is determined without requiring any sensitivity label to be associated with the file.

16. The computer system of claim 15, wherein the access granted to the file is read only access.

17. The computer system of claim 15, the instructions further for:
determining whether the packet sensitivity label is identical to the first sensitivity label; and
in response to determining that the packet sensitivity label is identical to the first sensitivity label, granting read/write access to the file.

18. The computer system of claim 15, wherein the packet sensitivity label comprises a sensitivity level portion which specifies a requestor sensitivity level, wherein the first sensitivity label comprises a sensitivity level which specifies a sensitivity level for the first container, and wherein determining whether the packet sensitivity label dominates the first sensitivity label comprises:
determining whether the requestor sensitivity level is higher than the sensitivity level of the first container.

19. The computer system of claim 15, wherein the packet sensitivity label comprises a sensitivity level portion, which specifies a requestor sensitivity level, and a category portion, wherein the first sensitivity label comprises a sensitivity level, which specifies a sensitivity level for the first container, and a category portion, and wherein determining whether the packet sensitivity label dominates the first sensitivity label comprises:
determining whether the requestor sensitivity level is higher than the sensitivity level of the first container; and
determining whether the category portion of the packet sensitivity label is identical to the category portion of the first sensitivity label.

20. The computer system of claim 15, the instructions further for:
establishing the first container within the global operating system environment in such a manner that the first file system and the first sensitivity label are associated with the first container.

21. The computer system of claim 20, wherein the first container is an operating system partition.