International Business Machines Corporation

Ernest Scott Bender

Donald Fred Ault

Michael Gary Spiegel

David B Emmes

Jeffrey David Aman

Jon K Franks

John Arthur Helmbold

Donna N Dillenberger

Richard Henry Guski

Chun-Kwan K Yee

Bruce Robert Wells

Deborah F Mapes

Donna N T E Dillenberger

Steven Walkowiak

In response to the detection of an external event by the first thread, the first thread sends a quiesce event to each additional thread of the application and suspends execution. The quiesce event may be either a suspension event requesting suspension of the additional threads or a termination event requesting termination of the additional threads. Each additional thread, upon receiving the quiesce event, checks its environment to determine whether it is holding any critical system resource. If the additional thread determines that is not holding any critical system resource and that it is therefore safe to quiesce, the additional thread quiesces. Before quiescing, the last additional thread to quiesce resumes the first thread, which is now free to perform critical operations without interference from the additional threads. If the quiesce type is suspension, the first thread resumes the additional threads upon completing its critical operations, whereupon the application resumes its normal operation.

Quiensce termination/suspension in a multithreaded enviroment

A method, system, and computer program product for implementing inter-process integrity serialization services is provided. The method includes enabling process states including a must-stay-controlled (MSC) state and an extended must-stay-controlled (EMSC) state for an invoking process when it is determined that only programs designated as controlled, if any, have been loaded for the invoking process. The invoking process requests loading of a target program into temporary storage for performing a security service. Based upon a control indicator of the target program, the MSC state, and the EMSC state, the method includes controlling one or more activities within the temporary storage. The activities include loading the target program into the temporary storage, executing a main program in the temporary storage, and resetting the MSC state and the EMSC state across execution of the main program during the lifetime of the invoking process.

Methods, systems, and computer program products for implementing inter-process integrity serialization

A multi-identity security environment is created for use in controlling access to resources. The multi-identity security environment enables one process that is spawned by another process to access resources security accessible to the one process, as well as resources security accessible to the another process. The multi-identity security environment includes an identity of the one process and an identity of the another process.

Accessing protected resources via multi-identity security environments

A method for managing the suspension and resumption of threads on an individual basis in an information handling system having an operating system (OS) kernel and a user process having multiple threads of execution. An originating thread issues a pthread_kill( ) service request to the OS kernel to send a specified signal (thread-stop or thread-continue) to a specified target thread within the same process to suspend or resume execution of the target thread. More particularly, in response to a request from a thread to suspend the execution of the target thread, the OS kernel sends a thread-stop signal (SIGTHSTOP) to the target thread, transferring control within the target thread from a normally executing program portion to a signal interrupt routine. Upon gaining control, the signal interrupt routine issues a service request to the kernel to stop the target thread. In response to a request from a thread to resume execution of the target thread, the OS kernel sends a thread-continue signal (SIGTHCONT) to the target thread to post the waiting target thread and return control to the signal interrupt routine. Upon regaining control, the signal interrupt routine returns control to the program at the point of interrupt.

Method and apparatus for managing thread execution in a multithread application

A method and apparatus for ensuring that a process interacting with a failing process is notified of the failure of that process. Each process has a unique process identifier (PID) associated with it. Each process optionally has an affinity list containing one or more entries, each of which contains the identifier of a process that is to be notified when the process fails. A process updates the affinity list of a target process (either itself or another process) by calling an affinity service of the operating system (OS) kernel, specifying the type of operation (add or delete), the identifier of the target process, the identifier of the process that is to notified, and the type of event that is to be generated for the process that is to be notified. When a process fails, a process termination service of the OS kernel examines the affinity list of the failing process and, for each entry in the list, generates an event of the specified type for the process specified as to be notified.

Method and apparatus for providing for notification of task termination

In a client/server system, a method and apparatus for a listening daemon to distribute work and client connectivity across multiple processes each supporting multiple threads. Upon receiving a request from a client, a listening daemonaccepts the conversation, thus creating a socket. The listening daemon then does a putwork( ) call which places a work request on a system managed work queue. The work request behaves in a manner very similar to spawn in that it provides for parameters to be passed as well as transfer of ownership of the socket. In the meantime, server processes that are created either manually or by the operating system create multiple threads, which invoke a getwork( ) service to retrieve work requests created by the listening daemon. The getwork( ) service transfers the socket to the calling process and notifies the thread which file descriptors it has inherited. The thread is then able to process the client request and respond directly to the client without requiring an intermediate process to provide the communication link. The present invention allows a server in a client/server system to spread the workload across multiple threads in multiple processes, avoiding the creation of too many processes or too many threads in a single process. The direct transfer of the socket eliminates the unnecessary overhead typically required to rebind a new process to the client application.

Method and apparatus for transferring file descriptors in a multiprocess, multithreaded client/server system

A method and apparatus for controlling the assignment of units of work to workload enclaves in a client/server system in which units of work are organized into enclaves with the units of work in each enclave being managed as a single entity. Incoming work requests are queued for processing by one or more worker threads of one or more server processes. In response to the receipt of an incoming work request, a putwork() service of the operating system kernel defines an workload enclave for the work request and adds the work request to a queue of incoming work requests to enqueue the request. In response to a request from a worker thread for more work, a getwork() service of the operating system kernel removes a work request from the queue to dequeue the request and associates the worker thread with the enclave defined for the request. If a worker thread must create a new unit of work while processing a work request, it calls an appropriate service of the operating system kernel, which creates the new unit of work and associates the new process with the enclave of the worker thread. The worker thread is disassociated from the enclave upon completion of the work request.

Method and apparatus for controlling the assignment of units of work to

A method and apparatus for enabling a listening daemon in a client/server system to execute a specified task on behalf of a user. Upon receiving a user request, the listening daemon sets an environment variable in accordance with the user identity specified in the request and issues a system call to the operating system kernel to spawn the user task specified in the request. In response to the system call, the operating system kernel creates a new address space for the specified user task and creates a security environment for the user task in accordance with the environment variable before starting the user task in the new address space.

Method and apparatus for creating a security environment for a user task

A method of controlling the execution of the threads of a first application such as a user application from a second application such as a debugger application running in a different address space. After initializing trace mode for the user application, the debugger waits for an event to occur on one of the threads of the user application. Upon the occurrence of an event on one of the user application threads, an event handler obtains control of the thread execution. The event handler suspends execution of the remaining threads in the application, posts the debugger and then suspends its own execution. When the debugger application has completed its debugging operations, it posts the event handler, which resumes execution of the suspended threads and returns control to the thread on which the event occurred. If a subsequent event occurs on one thread while a previous event on another thread is being processed, the event handler for the subsequent event places it in a deferred event queue for deferred processing. Events consisting of breakpoints are redriven rather than being placed on the deferred queue. The debugger application may hold selected threads in a suspended state following resumption of the remaining threads by setting hold flags associated with those threads.

Growing community of inventors

Saugerties, NY, United States of America

Ernest Scott Bender