Patent Application
20110107339
Computer functionality is achieved through processes. A process is a program in execution including several components in memory, such as program code, data, and a process stack for holding temporary data (subroutine parameters, return addresses, temporary variables, etc). The process includes an address space in memory (i.e. process memory) which contains these components.
Processes need to consume or expose functionality in order to produce output. Often, functionality is provided by a third party as a shared object, or library. These shared objects may be loaded into a process at runtime. When loaded into memory, these processes have access to the complete process memory.
Methods, systems, and products for computer processing are disclosed herein. Embodiments of the present disclosure may be initiated through a kernel interface. In one general embodiment, the method comprises running an inner process in the context of an executing thread wherein the thread has an original address space in memory and hiding at least a portion of the memory from the inner process. The inner process may run on the same credentials as the thread. Running the inner process may include creating a new address space for the inner process in the memory and assigning the new address space to the thread, so that the inner process comprises its on address space. The inner process may be allowed to access only the new address space. The kernel may maintain the thread's original address space along with the new address space, so that multiple address spaces exist for a particular thread. The kernel may pass selected data from the thread to the inner process. The new address space may comprise a heap and a stack. Passing data selected by a user from the thread to the inner process may be carried out by exporting pointers corresponding to the selected data to the data section of the new address space. Another general embodiment includes a computer program product disposed on a computer-readable medium for computer processing, the computer program product comprising computer program instructions for running an inner process in the context of an executing thread and computer program instructions for hiding at least a portion of the memory from the inner process. Another general embodiment includes a data processing system for computer processing. The system includes a processor; and a computer memory operatively coupled to the processor. The computer memory has disposed within it computer program instructions for running an inner process in the context of an executing thread wherein the thread has an original address space in memory and computer program instructions for hiding at least a portion of the memory from the inner process.
The foregoing and other objects, features and advantages of the disclosure will be apparent from the following more particular descriptions of exemplary embodiments of the invention as illustrated in the accompanying drawings wherein like reference numbers generally represent like parts of exemplary embodiments of the invention.
Exemplary methods, systems, and computer products for computer processing are described with reference to the accompanying drawings. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an”, and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiment was chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
Generally embodiments of the present invention relate to an inner process running in the context of an executing thread. The inner process includes its own address space, which is assigned to the thread. Thus, a thread may have multiple process address spaces. The thread may be the only thread for a given task (for example, as in the case of a heavyweight process) or may be one of many threads existing for a task (i.e. a lightweight process). Although the thread has access to process memory, the inner process has access only to its own address space, so that the process memory as a whole is hidden from the inner process. Third-party extensions (such as shared objects) dynamically loaded into the inner process are therefore denied access to the process memory as a whole. A portion of the process memory may be exported from the thread to the inner process, such as by copying selected data or pointers representing data to the new address space, so that only data selected (by a developer, for example) is exposed to the third-party extension. Overhead and complexity associated with inter-process communication is avoided, and the inner process may run on the same credentials as the thread. The inner process may also be used to perform impersonation, or executing part of the code under different credentials, by including a credential change in an invocation of the inner process. For example, embodiments of the present disclosure may be initiated through a kernel interface. The code section (text) invoking the inner process may include arguments or options for credential change which are supported by the operating system.
Embodiments of the presently disclosed invention are implemented to some extent as software modules installed and running on one or more data processing systems (“computers”), such as servers, workstations, tablet computers, PCs, personal digital assistants (“PDAs”), smart phones, and so on.
An operating system 208 is stored in computer memory. Operating system 208 may be any appropriate operating system such as Windows XP, Windows Vista, Mac OS X, UNIX, LINUX, or AIX from International Business Machines Corporation (Armonk, N.Y.).
Computing device 202 may also include one or more input/output interface adapters 256. Input/output interface adapters 256 may implement user-oriented input/output through software drivers and computer hardware for controlling output to output devices 272 such as computer display screens, as well as user input from input devices 270, such as keyboards and mice.
Computing device 202 may also include a communications adapter 252 for implementing data communications with other devices 260. Communications adapter 252 implements the hardware level of data communications through which one computer sends data communications to another computer through a network.
Also stored in computer memory is an inner process module 206, which may operate at least partially in kernel mode. The inner process module 206 includes computer program instructions for enabling an inner process as described herein. The module may include computer program instructions for creating a new address space for the inner process in the memory of the computer and assigning the new address space to the thread. The module includes computer program instructions for running an inner process in the context of an executing thread within the new address space. The computer program instructions may allow the inner process to access only the new address space so that the memory available to the thread is hidden from the inner process. The computer program instructions may provide for exporting a copy of selected data to the new address space for use by the inner process.
Inner process module 206 may be implemented as one or more sub-modules operating in separate software layers or in the same layer. Although depicted as being incorporated into the operating system 208 in
The thread has an original address space 330 in memory 320. For example the original address space 330 may include a code section 322, a data section 324, and a stack 326. The thread may share the code section 322 and data section 324 with other threads in the same task. In one implementation, the code section 322 includes instances of one or more invocations of an inner process system call. During normal execution of the code in a thread, the system call is invoked. When invoked, the executing thread requests an implementation of the inner process system call in kernel mode through a system call interface.
Running an inner process in the context of an executing thread (block 302) may include creating a new address space 340 for the inner process in the memory 320 (block 306) and assigning the new address space 340 to the thread (block 308). Running an inner process in the context of an executing thread (block 302) may also include passing selected data 312 from the thread to the inner process (block 310). Passing the selected data 312 from the thread to the inner process (block 310) may be carried out by obtaining a pointer to the starting address of the data section and retrieving data until the end of the data file is reached. Selected data is copied to the data section of the new address space. The copy of the selected data may be a deep copy (a copy of the actual data), a shallow copy (a copy of pointers referencing the data), or a combination of each type. A new stack and heap may be created in the new address space (not shown). The new stack may contain the data passed to the inner process.
Hiding at least a portion of the memory 320 from the inner process (block 304) may be carried out by allowing the inner process to access only the new address space 340 (block 314). The translation look-aside buffer (‘TLB’) of the processor may also be flushed. The TLB is a table in the processor's memory that contains information about the pages in memory the processor has accessed recently.
Exported data 406 is stored in the address space 422, and non-exported data 408 is stored in the address space 424. Exported heap 412 is stored in the address space 426, and non-exported heap 414 is stored in address space 428. Address spaces 422-428 contain pointers that reference address spaces elsewhere in memory (such as in actual data storage 430) containing the actual information. Thread address space 420 and actual data storage 440 may be parts of the same memory structure and are only shown as separate for illustration. The exported data 406 contained by address space 422 of the thread address space 420 is a pointer pointing to the actual data stored at address space 432. Similarly, the pointer for non-exported data 408 is at address space 424 and points at address space 434, the pointer for exported heap 412 is at 426 and points at address space 436, and the pointer for non-exported heap 414 is at 428 and points at address 438. In other implementations, data may be stored without the use of pointers.
As described above, upon creation of the inner process, selected data in the data section and the heap are exported to the inner process. A new address space is created and assigned to the inner process. Thread address space 440 is identical to thread address space 420, except for the addition of the new address space. The new address space includes address spaces 442 and 446. Pointers pointing to address space 432 and 436 are stored in the new address space at address spaces 442 and 446, respectively.
In some embodiments, only stdin and stdout file descriptors are exposed to the inner process. Alternatively, all or a subset of the file descriptors may be exposed, either by default or by listing them as parameters of a call to the kernel interface.
As discussed above with reference to
The code section above contains a main function where program execution begins. At some point within the main program, a functionality provided by a third-party extension (the library, “somelib”) is needed. Before loading the library, the code section invokes the inner process using the statement “start_innerprocess”, and passes as arguments a function containing the code section to be run in the inner process (“function1”) along with data from the data section required by the function to operate. Data may be passed as pointers, so that the data section of the inner process includes pointers that point to the physical address of the data a user wishes to expose. The function running within the inner process includes statements for loading the dynamic library file (“dlopen(somelib)”) and obtaining the address of a function within the library (“dlsym(somelibfunction)”). The function also includes a statement. “somelibfunction(exported_data.main_exported_pointer)”, for calling the function with the exported data and pointer as arguments.
It should be understood that the inventive concepts disclosed herein are capable of many modifications. To the extent such modifications fall within the scope of the appended claims and their equivalents, they are intended to be covered by this patent.
