Mechanism for associating resource pools with operating system partitions

• US 20040226017A1
• Filed: 01/29/2004
• Published: 11/11/2004
• Est. Priority Date: 05/09/2003
• Status: Abandoned Application

• Current Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Dorofeev, Andrei V., Leonard, Ozgur C., Tucker, Andrew G.
• Application Number:
  US10/768,303
• Publication Number:
  US 20040226017A1
• Time in Patent Office: Days
• US Class Current: 718/104
• CPC Class Codes: G06F 21/53 by executing in a restricted environment, e.g. sandbox or secure virtual machine
• CPC Class Codes: G06F 21/6209 to a single file or object, e.g. in a secure envelope, encrypted and accessed using a key, or with access control rules appended to the object itself
• CPC Class Codes: G06F 2221/2149 Restricted operating environment
• CPC Class Codes: G06F 9/468 Specific access rights for resources, e.g. using capability register

Abstract

A global operating system environment provided by an operating system kernel may have one or more non-global partitions. These non-global partitions serve to isolate processes running within each non-global partition from other non-global partitions within the global operating system environment. A non-global partition may have associated with it a resource pool (e.g. processors, memory, etc.). The resource pool sets forth the resources that are available to the non-global partition. Processes running within the non-global partition are limited to utilizing only the resources in the resource pool. By associating a resource pool with a non-global partition in this manner, it is possible to easily and conveniently set limits on what is available to a non-global partition.

Claims

1. A machine-implemented method, comprising:

establishing, within a global operating system environment provided by an operating system, a particular non-global partition which serves to isolate processes running within the particular non-global partition from other non-global partitions within the global operating system environment;

associating the particular non-global partition with a first resource pool comprising one or more resources; and

ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the first resource pool.

2. The method of claim 1, wherein the first resource pool comprises one or more processors.

3. The method of claim 2, wherein ensuring comprises:

assigning work from processes running within the particular non-global partition to only the one or more processors in the first resource pool.

4. The method of claim 1, wherein the first resource pool comprises an indication of a maximum amount of memory that can be consumed.

5. The method of claim 4, wherein ensuring comprises:

receiving, from a particular process running within the particular non-global partition, a memory allocation request;

determining whether granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded; and

in response to a determination that granting the memory allocation request would not cause the maximum amount of memory that can be consumed to be exceeded, granting the memory allocation request.

6. The method of claim 5, wherein ensuring further comprises:

in response to a determination that granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded, deallocating sufficient memory from one or more other processes to enable the memory allocation request to be granted without causing the maximum amount of memory that can be consumed to be exceeded; and

granting the memory allocation request.

7. The method of claim 1, wherein the operating system is executed on a computer system, and wherein the resources in the first resource pool are just a subset of a total set of resources available on the computer system.

8. The method of claim 1, wherein ensuring comprises:

associating each process running within the particular non-global partition with the first resource pool.

9. The method of claim 8, further comprising:

receiving an indication that the particular non-global partition is to be associated with a second resource pool instead of the first resource pool, wherein the second resource pool is different from the first resource pool, and wherein the second resource pool comprises one or more resources;

associating the particular non-global partition with the second resource pool instead of the first resource pool; and

ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool.

10. The method of claim 9, wherein ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool comprises:

associating each process running within the particular non-global partition with the second resource pool instead of the first resource pool.

11. The method of claim 1, wherein the operating system executes on a computer system, and wherein the method further comprises:

receiving, from a particular process running within the particular non-global partition, a request for information pertaining to all resources; and

providing, to the particular process, information pertaining only to the one or more resources in the first resource pool, even though the computer system comprises other resources.

12. A machine-readable medium, comprising:

instructions for causing one or more processors to establish, within a global operating system environment provided by an operating system, a particular non-global partition which serves to isolate processes running within the particular non-global partition from other non-global partitions within the global operating system environment;

instructions for causing one or more processors to associate the particular non-global partition with a first resource pool comprising one or more resources; and

instructions for causing one or more processors to ensure that processes running within the particular non-global partition are allowed to utilize only the resources in the first resource pool.

13. The machine-readable medium of claim 12, wherein the first resource pool comprises one or more processors.

14. The machine-readable medium of claim 13, wherein the instructions for causing one or more processors to ensure comprises:

instructions for causing one or more processors to assign work from processes running within the particular non-global partition to only the one or more processors in the first resource pool.

15. The machine-readable medium of claim 12, wherein the first resource pool comprises an indication of a maximum amount of memory that can be consumed.

16. The machine-readable medium of claim 15, wherein the instructions for causing one or more processors to ensure comprises:

instructions for causing one or more processors to receive, from a particular process running within the particular non-global partition, a memory allocation request;

instructions for causing one or more processors to determine whether granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded; and

instructions for causing one or more processors to grant, in response to a determination that granting the memory allocation request would not cause the maximum amount of memory that can be consumed to be exceeded, the memory allocation request.

17. The machine-readable medium of claim 16, wherein the instructions for causing one or more processors to ensure further comprises:

instructions for causing one or more processors to deallocate, in response to a determination that granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded, sufficient memory from one or more other processes to enable the memory allocation request to be granted without causing the maximum amount of memory that can be consumed to be exceeded; and

instructions for causing one or more processors to grant the memory allocation request.

18. The machine-readable medium of claim 12, wherein the operating system is executed on a computer system, and wherein the resources in the first resource pool are just a subset of a total set of resources available on the computer system.

19. The machine-readable medium of claim 12, wherein the instructions for causing one or more processors to ensure comprises:

instructions for causing one or more processors to associate each process running within the particular non-global partition with the first resource pool.

20. The machine-readable medium of claim 19, further comprising:

instructions for causing one or more processors to receive an indication that the particular non-global partition is to be associated with a second resource pool instead of the first resource pool, wherein the second resource pool is different from the first resource pool, and wherein the second resource pool comprises one or more resources;

instructions for causing one or more processors to associate the particular non-global partition with the second resource pool instead of the first resource pool; and

instructions for causing one or more processors to ensure that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool.

21. The machine-readable medium of claim 20, wherein the instructions for causing one or more processors to ensure that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool comprises:

instructions for causing one or more processors to associate each process running within the particular non-global partition with the second resource pool instead of the first resource pool.

22. The machine-readable medium of claim 12, wherein the operating system executes on a computer system, and wherein the machine-readable medium further comprises:

instructions for causing one or more processors to receive, from a particular process running within the particular non-global partition, a request for information pertaining to all resources; and

instructions for causing one or more processors to provide, to the particular process, information pertaining only to the one or more resources in the first resource pool, even though the computer system comprises other resources.

23. An apparatus, comprising:

a mechanism for establishing, within a global operating system environment provided by an operating system, a particular non-global partition which serves to isolate processes running within the particular non-global partition from other non-global partitions within the global operating system environment;

a mechanism for associating the particular non-global partition with a first resource pool comprising one or more resources; and

a mechanism for ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the first resource pool.

24. The apparatus of claim 23, wherein the first resource pool comprises one or more processors.

25. The apparatus of claim 24, wherein the mechanism for ensuring comprises:

a mechanism for assigning work from processes running within the particular non-global partition to only the one or more processors in the first resource pool.

26. The apparatus of claim 23, wherein the first resource pool comprises an indication of a maximum amount of memory that can be consumed.

27. The apparatus of claim 26, wherein the mechanism for ensuring comprises:

a mechanism for receiving, from a particular process running within the particular non-global partition, a memory allocation request;

a mechanism for determining whether granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded; and

a mechanism for granting, in response to a determination that granting the memory allocation request would not cause the maximum amount of memory that can be consumed to be exceeded, the memory allocation request.

28. The apparatus of claim 27, wherein the mechanism for ensuring further comprises:

a mechanism for deallocating, in response to a determination that granting the memory allocation request would cause the maximum amount of memory that can be consumed to be exceeded, sufficient memory from one or more other processes to enable the memory allocation request to be granted without causing the maximum amount of memory that can be consumed to be exceeded; and

a mechanism for granting the memory allocation request.

29. The apparatus of claim 23, wherein the operating system is executed on a computer system, and wherein the resources in the first resource pool are just a subset of a total set of resources available on the computer system.

30. The apparatus of claim 23, wherein the mechanism for ensuring comprises:

a mechanism for associating each process running within the particular non-global partition with the first resource pool.

31. The apparatus of claim 30, further comprising:

a mechanism for receiving an indication that the particular non-global partition is to be associated with a second resource pool instead of the first resource pool, wherein the second resource pool is different from the first resource pool, and wherein the second resource pool comprises one or more resources;

a mechanism for associating the particular non-global partition with the second resource pool instead of the first resource pool; and

a mechanism for ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool.

32. The apparatus of claim 31, wherein the mechanism for ensuring that processes running within the particular non-global partition are allowed to utilize only the resources in the second resource pool comprises:

a mechanism for associating each process running within the particular non-global partition with the second resource pool instead of the first resource pool.

33. The apparatus of claim 23, wherein the operating system executes on a computer system, and wherein the apparatus further comprises:

a mechanism for receiving, from a particular process running within the particular non-global partition, a request for information pertaining to all resources; and

a mechanism for providing, to the particular process, information pertaining only to the one or more resources in the first resource pool, even though the computer system comprises other resources.