Computer resource management system

• US 6,134,601 A
• Filed: 06/17/1996
• Issued: 10/17/2000
• Est. Priority Date: 06/17/1996
• Status: Expired due to Term

• Current Assignee: McAfee, Inc. (McAfee, LLC)
• Original Assignee: Network Associates, Inc.
• Inventors: Daub, Jonathan A., Spilo, Michael L.
• Primary Examiner(s): Banankhah, Majid
• Assistant Examiner(s): COURTENAY III, ST JOHN
• Application Number:
  US08/664,508
• Time in Patent Office: 1,583 Days
• Field of Search: 395/680, 395/682, 711/170-173, 711/206-209, 709/300, 709/302, 709/328
• US Class Current: 719/328
• CPC Class Codes: G06F 12/1036 for multiple virtual address spaces, e.g. segmentation G06F12/1045 takes precedence
• CPC Class Codes: G06F 12/109 for multiple virtual address spaces, e.g. segmentation G06F12/1036 takes precedence
• CPC Class Codes: G06F 9/50 Allocation of resources, e.g. of the central processing unit [CPU]

Abstract

A system and method for managing scarce computer system memory resources has three aspects. A first aspect allows large data structures to be replaced by a pointer that causes an intentional fault to occur. The fault is trapped, and the invention interposes the required data. A second aspect associates data structures with both the task and the module that own the structure. The structure can be eliminated from memory when both the owning task and the owning module have terminated. A third aspect utilizes swapping techniques to maintain multiple local data areas for multiple tasks. In conjunction, the three aspects of the invention provide improved resource availability and substantially unimpaired system performance

Claims

1. A method for intercepting access by a program to 16 bit exportable functions associated with a function module, comprising the steps of:

obtaining the address of a module header for a function module, wherein the header includes pointers identifying entry points of the exportable functions in said function module and at least one segment table identifying contents of the function module;

adding to the segment table one or more segment entries corresponding to segments of an interceptor module containing an interceptor routine wherein each segment containing an interceptor routine is made nondiscardable; and

modifying the module header so that an attempt to determine the entry point of an exportable function in the function module returns a pointer to an entry point of the interceptor routine.

2. The method of claim 1, wherein the module header is stored in a segment of the function module, and the step of adding to the segment table comprises the steps of:

allocating the segment in the function module containing the module header to a size sufficient to contain the module header, the segment table, and at least one additional segment entry;

relocating the segment table to the allocated portion of the module header;

updating entry point pointers contained in the module header to identify the location of the relocated segment table;

adding to the segment table at least one additional segment entry corresponding to segments of the interceptor routine; and

updating a value in the module header containing the number of segments in the segment table.

3. The method of claim 1, further comprising the step of, for each exportable function to be intercepted, changing the pointer to the entry point of the exportable function in an export table of the module header to indicate the entry point of the interceptor routine contained in the added segment entries.

4. The method of claim 3, wherein each pointer to an entry point comprises:

a segment index value identifying a particular segment in the module and

a segment offset value indicating a location in the particular segment,

and wherein the step of changing the pointer comprises the step of setting the segment index value to a segment index value identifying one of the additional segment entries and setting the segment offset value to an offset of the interceptor routine in the identified additional segment entry.

5. A method of redirecting an API function call by a program to an alternative intercept function, comprising the steps of:

identifying a function module for the API function, the module having an entry table containing at least one pointer that indicates an entry point for the API function, the module further containing a plurality of segments and a segment table identifying each segment in the function module, each API function being located in one of the segments;

selecting a pointer from the entry table that indicates an entry point for the API function;

changing the selected pointer to indicate the entry point for the intercept function;

adding at least one additional entry to the segment table representing a segment containing the intercept function, wherein each additional entry added to the segment table is preloaded and set as nondiscardable.

6. The method of claim 5, further comprising processing a request to provide the program with an entry point for the API function, and returning a pointer to the entry point for the intercept function.

7. The method of claim 5, wherein the function module has a header, and the entry table and segment table are in the header.

8. The method of claim 5, wherein at least part of the intercept function is contained in an intercept module having a corresponding segment table and the adding step comprises copying at least one entry from the segment table in the intercept module to the segment table in the function module.

9. The method of claim 7, further comprising the step of increasing the size of the header to make room for the at least one additional entry in the segment table.