Method for providing exclusive access to a resource in a multiprocessor computer system

Abstract: A multiprocessor computing system has memory shared by all processors of the computing system and includes an symmetric multiprocessor (SMP) operating system and at least one external device controlled by a device driver. The device driver is typically written to run in a uniprocessor environment. A method for protecting the execution state of the device driver uses a pair of "collaborative" spinlocks, an interrupt time spinlock and a task time spinlock. At task time, prior to calling the device driver, the task time spinlock is acquired by the operating system. The operating system then waits until the interrupt time spinlock is in an "unowned" state before calling the device driver. Upon return from the device driver, the operating system releases the task time spinlock. At interrupt time, prior to calling the device driver's interrupt handler, the interrupt time spinlock is acquired by the operating system. The operating system then determines if the task time spinlock is owned. If it is owned, the operating system then issues an interprocessor interrupt (IPI) to the processor owning the task time spinlock, thus placing that processor into a predetermined "spin" state. The receiving processor remains in the spinning state until return of the device driver execution.

Description: The present invention relates generally to multiprocessor (MP) computer systems and more particularly to a method, in a symmetric multiprocessor (SMP)-based operating system, for preventing concurrent access to a resource (eg operating system kernel extension such as a device driver). A device driver is a known operating system kernel extension. Most device drivers in use today in multiprocessor (MP) computer systems were written for uniprocessor operating systems rather than a symmetric multiprocessor-based operating system. Consequently, the writers of these drivers never envisioned a situation where two processors would request the services of the driver concurrently. Such known device drivers include a "task time" component and an "interrupt time" component. The task time component is used to request services of a device managed by the device driver. The request typically completes asynchronously and, thereafter, the device driver is notified of such completion via external interrupt. Mutual exclusion to data structures shared by the task time component and the interrupt time component is typically provided by using the Intel CLI (disable interrupt) and STI (enable interrupt) instructions. In particular, issuing the CLI instruction prevents external interrupts, thus protecting the data structures from the interrupt time component. The use of the Intel CLI instruction to provide mutual exclusion to data structures will not work in a MP environment, however. In particular, an Intel CLI instruction executed from one processor in the system will not disable interrupts on every processor; therefore, the interrupt time component may be executing on one processor while the task time component is executing on another processor. Ultimately, the data structures will be corrupted. One possible method to solve this problem would be to force execution of both the task time and interrupt time components of all device drivers to a single processor. Such an approach, in effect, would emulate the environment for which the device driver was originally designed. The performance of the MP system using this approach is quite unacceptable. Another approach would be to use a single "spinlock" to protect both the task time and interrupt component of the device driver. As is known in the art, a spinlock is a software mechanism involving a shared memory location having a set of known states that imply "ownership" (or the lack thereof) with respect to a given resource associated with the spinlock. A single spinlock has been used in an MP environment to provide external interrupt serialization, as described in U.S. Patent No. 5,560,018. This approach, while satisfactory, does not provide optimal performance, in part because of the increased interrupt latency which is introduced while waiting for the device driver to release the single spinlock. Understandably, authors of existing device driver code are not interested in rewriting the driver simply to adapt it to a multiprocessor operating system. Therefore, another means of allowing the efficient use of these existing device drivers must be developed. The present invention addresses this important problem. According to a first aspect of the invention there is provided a method for protecting the execution state of an operating system kernel extension in a multiprocessor computing system having memory shared by all processors of the computing system and including an operating system, the operating system kernel extension being designed to run in a uniprocessor environment, the method comprising the steps of: at task time, prior to calling the kernel extension, having the operating system acquire a task time spinlock and then wait to call the kernel extension until an interrupt time spinlock is unowned; and at interrupt time, prior to calling the kernel extension, having the operating system acquire the interrupt time spinlock and wait to call the kernel extension until the task time spinlock is unowned or, if the task time spinlock is owned, a processor owning the task time spinlock is placed in a predetermined condition. The invention finds advantageous use in respect of controlling access to a device driver and therefore according to a second aspect of the invention there is provided a method for protecting the execution state of a device driver in a multiprocessor computing system having memory shared by all processors of the computing system and including a symmetric multiprocessor (SMP) operating system, the device driver being designed to run in a uniprocessor environment, the method comprising the steps of: at task time, determining whether the task time spinlock can be acquired by the operating system; if, at task time, the task time spinlock can be acquired by the operating system, having the operating system acquire the task time spinlock and then wait to call the device driver until the interrupt time spinlock is unowned; at interrupt time, determining whether the interrupt time spinlock can be acquired by the operating system; and if, at interrupt time, the interrupt time spinlock can be acquired by the operating system, having the operating system acquire the interrupt time spinlock and then wait to call the device driver until the task time spinlock is unowned or, if the task time spinlock is owned, the processor owning the task time spinlock is placed in a predetermined condition. Thus, it is a general object of this invention to control access to a system resource in a multiprocessor operating system environment. It is a more specific object of the invention to use two or more "collaborative" spinlocks to control access to the resource by the MP operating system. The first and second aspects of the invention relate to methods operable at task time and interrupt time. However a third aspect of the invention relates to a method operative at task time for protecting the execution state of a device driver using an interrupt time spinlock and a task time spinlock, the method comprising the steps of: determining whether the task time spinlock can be acquired by the operating system; if the task time spinlock cannot be acquired by the operating system, placing the task time spinlock in a spin on read condition; if the task time spinlock can be acquired by the operating system, having the operating system acquire the task time spinlock; determining whether the interrupt time spinlock is owned by another processor; and if the interrupt time spinlock is unowned, having the operating system call the device driver. The present invention also relates to a method for protecting the execution state of the device driver which is operative at interrupt time. According to a fourth aspect of the invention such a method comprises the steps of: determining whether the interrupt time spinlock can be acquired by the operating system; if the interrupt time spinlock cannot be acquired by the operating system, placing the interrupt time spinlock in a spin on read condition; if the interrupt time spinlock can be acquired by the operating system, determining whether the task time spinlock is owned by a given processor; if the task time spinlock is owned by the given processor, placing the given processor in a predetermined condition; and having the operating system call the device driver. As will be described below, access is controlled to an operating system kernel extension (e.g., a device driver) originally written for a uniprocessor environment but that is running in a multiprocessor environment without modification to the kernel extension. In the preferred embodiment a pair of collaborative spinlocks are used to prevent concurrent access to a device driver written for a uniprocessor environment. Yet another aspect of this invention is to allow different processors in a multiprocessor computer system to access a device driver without corrupting data structures associated with the task time and interrupt components of the device driver. The preferred embodiment of the invention is implemented in a multiprocessor computing system having memory shared by all processors of the system and including an symmetric multiprocessor (SMP) operating system. The computing system includes at least one external device controlled by a device driver having an interrupt handler. The device driver is typically written to run in a uniprocessor environment. A method for protecting the execution state of the device driver uses a pair of "collaborative" spinlocks, an "interrupt time" spinlock and a "task time" spinlock. At task time, and prior to calling the device driver, the task time spinlock is acquired by the operating system. The operating system then waits until the interrupt time spinlock is in an "unowned" state before calling the device driver. Upon return from the device driver, the operating system releases the task time spinlock. At interrupt time, and prior to calling the device driver's interrupt handler, the interrupt time spinlock is acquired by the operating system. The operating system then determines if the task time spinlock is owned. If the task time spinlock is unowned, the operating system calls the device driver's interrupt handler. If, however, the task time spinlock is owned, the operating system first issues an interprocessor interrupt (IPI) to the processor owning the task time spinlock, thus placing that processor into a predetermined "spin" state. In particular, the processor receiving the IPI is "spun" on a predetermined memory location until the memory location is cleared. Upon return from execution of the device driver, the interrupt time spinlock is released and the spun processor is returned to its prior operating state. A preferred embodiment of the invention will now be described, by way of example only, with reference to the accompanying drawings in which: Figure 1 is a block diagram of a representative multiprocessor computer system in which the present invention is implemented; Figure 2 is a flowchart of a known technique for acquiring a spinlock; Figure 3 is a flowchart of a known technique for releasing the spinlock acquired by the flowchart of Figure 2; Figure 4 is a flowchart of a preferred "task time" routine of the present invention; and Figure 5 is a flowchart of a preferred "interrupt time" routine of the present invention. Figure 1 illustrates a computer system 10 having multiple processors 12a...12n. The various processors 12 of the system 10 are preferably Intel x86-based microprocessors that are controlled by a multiprocessing operating system (OS) 14, such as the OS/2( SMP (symmetric multiprocessing) operating system available from IBM. The computer system has a number of associated external devices 16a....16n such as keyboards, disk and diskette drivers and printers. Each external device 16 is controlled by software run by the operating system. The software most frequently implemented for controlling an external device is called a device driver 18. The device driver typically consists of two sections, a "task time" section, which executes when an external interrupt is not in progress, and an "interrupt time" section, which executes (e.g., under the control of the device driver's interrupt handler) when an external interrupt is in progress. Computer system 10 also includes an interrupt mechanism 15 that allows a particular processor to respond to asynchronous events. When an interrupt signal is received, the processor immediately diverts its attention from the task currently executing, but in a manner that allows the future resumption of this task. The processor then executes a routine that is specific to each particular interrupt. Internal interrupts are those that originate inside the processor. External interrupts are those initiated by external hardware, and software interrupts are those initiated by certain software instructions. While the remainder of the description relates to a multiprocessor system running Intel x86 processor(s) and the OS/2 SMP operating system, the invention may be implemented in other multiprocessor systems running on non Intel-based processors (e.g., RISC-based) and/or other MP-based operating systems (e.g., MVS, AIX, Windows NT, Novell Netware and others). Moreover, although the present invention is described in the context of a device driver as the "resource" being controlled by the collaborative spinlocks, the skilled man will appreciate that a resource may mean any operating system kernel extension such as a physical device driver, a virtual device driver, an installable file system, an actual physical device (such as keyboard, disk, a network) and the like. The unit of execution for the x86 processor is called a task. The term thread of execution is sometimes used in a similar context. The microprocessor can execute only one task at a time. The CPU switches tasks as a result of an interrupt or of execution of certain instructions. The x86 hardware provides complete isolation between tasks. This isolation is based, among other things, on each task having its own independent address space. In advanced operating systems (like the SMP OS) where multiple threads are allowed to execute in a multiprogramming (multi-tasking) environment, one of the functions of the OS is to allocate the processor to the runnable threads. Two primary methods are used for making the decision. An operating system will typically use a hardware timer for determining when a thread should share the processor with a similar thread at the same priority (round robin). When an external interrupt occurs, it can signal the completion of an event for which some thread was waiting on. if the thread is higher in priority than the currently executing thread, a preemption should occur. In these environments, the programmer must use proper serialization techniques to protect his code/resources because at any given time the OS may decide to give the processor(s) to another runnable thread which may also require execution at the same code path or the use of the same resource. It is known in the prior art to use a so-called "spinlock" to provide external interrupt serialization compatibility in a multiprocessing environment. A spinlock is a software technique providing a low level and efficient method for serialization in a multiprocessor environment. Spinlocks are acquired and released. When "acquired," only the owner can execute a protected piece of code. All other requesters must wait for the owner to release ownership of the spinlock before they can acquire ownership. When the owner has completed execution of the protected code, the spinlock is said to be "released." The mechanism to acquire and/or release a spinlock is now described. A shared memory location must exist that is accessible by all processors, and the shared memory location's contents consists of two possible states: e.g., "Clear" and "Set." The flowchart in Figure 2 illustrates the act of "acquiring" the spinlock. It begins at step 20. At decision block 22, a determination is made if the spinlock is Clear or Set by examining the contents of the shared memory location. If the shared memory location is Set, then the lock is owned and the method cycles as illustrated. In particular, repeated attempts are made to acquire the spinlock. This technique is known as "spin on read." If the shared memory location is Clear, then the spinlock is not owned and a task can attempt to acquire ownership as follows. An attempt to own the spinlock entails executing a processor architected instruction which atomically swaps the contents of the shared memory location with a register that contains the value of Set. This is step 24. For the duration of the atomic swap, the system bus is locked to prevent access from any other source (e.g., another processor). A test is made at decision block 26 to determine if the attempt to acquire the spinlock succeeded. If not, the routine returns to step 22. If, however, the attempt to acquire the spinlock succeeded, the routine continues at step 28. In particular, what is returned in the register after the atomic swap is indication of the ownership status of the spinlock prior to the atomic swap. If Clear is returned, the spinlock was previously unowned and the task has become the new owner of the spinlock. If Set is returned, the spinlock was previously owned. Because in the latter case, the spinlock was originally Set and because a Set value was swapped in, no further modifications of the shared memory location are required. The routine then ends at step 29. This completes the description of "acquiring" the spinlock. The flowchart of Figure 3 illustrates the "releasing" of a spinlock. It begins at step 30. At step 32, a Clear is stored in the shared memory location, at which point the spinlock is considered to be unowned, and the routine ends at step 34. According to the present invention, at least two (2) distinct spinlocks "collaborate" to provide a given processor (and thus the operating system) with exclusive access to a given resource in the MP computer system. The first spinlock "S1" is the "interrupt time" spinlock. The second spinlock "S2" is the "task time" spinlock. Spinlocks S1 and S2, which are run under the operating system kernel, operate together to prevent concurrent access to the resource by multiple processors of the system. In particular, the invention involves two distinct operating routines (each of which use both spinlocks): a "task time" routine that occurs prior to calling a device driver at task time, and an "interrupt time" routine that runs prior to calling a device driver's interrupt handler at interrupt time. Figure 4 is the task time operation, which occurs at any point that execution transfers to a device driver. This is sometimes referred to herein as "at task time." This routine begins at step 40 whenever there is a need to call a device driver. At step 42, an attempt to acquire the task time spinlock S2 is made. At decision block 44, a test is made to determine whether the attempt to acquire the task time spinlock S2 was successful. If the outcome of the test at step 44 is negative, the attempt to acquire S2 was not successful, and the routine continues at step 46 to spin S2 on read waiting for the S2 memory location to indicate it is unowned. Control then returns back to before step 42. If, however, the attempt to acquire S2 was successful, which is indicated by a positive outcome of the test at step 44, the routines continues at step 48 to determine if spinlock S1 is owned. If spinlock S1 is owned, the routine cycles as shown. If, however, the outcome of the test at step 48 indicates that spinlock S1 is not owned, it is now safe to call the device driver. This occurs at step 50. After the device driver is executed, the routine releases spinlock S2 at step 52. This completes the task time processing. The interrupt time routine of the invention is shown in Figure 5. As noted above, this routine is run prior to calling a device driver's interrupt handler at interrupt time. It is sometimes referred to herein as "at interrupt time." The routine begins at step 60 upon an external interrupt (e.g., from a disk device driver or other network device driver). The routine continues at step 62 to attempt to acquire the interrupt time spinlock S1. The routine then continues at decision block 64 to test whether the S1 spinlock was acquired. If the outcome of the test at step 64 is negative, the attempt to acquire S1 was not successful, and the routine continues at step 66 to spin S1 on read waiting for the S1 memory location to indicate it is unowned. Control then returns back to before step 62. If, however, the attempt to acquire S1 was successful, which is indicated by a positive outcome of the test at step 64, the routine continues at decision block 68 to test whether the task time spinlock S2 is owned. If spinlock S2 is not owned, the routine continues at step 70 to call the device driver interrupt handler. If, however, spinlock S2 is owned, the routine branches to step 72 during which the interrupt manager sends an interprocessor interrupt (IPI) to the processor that owns spinlock S2. Step 72 thus "spins" the owner of spinlock S2. The routine then continues at decision block 74 to test whether the owner of spinlock S2 has entered the spin state. If not, the routine cycles as shown to continue executing block 74, If, however, the outcome of the test at block 74 indicates that the owner of spinlock S2 is spinning, the routine continues at step 70 to call the device driver interrupt handler, as previously described. After the interrupt handler executes, the routine continues at step 76 to release the S1 spinlock. Thereafter, a test is made at step 78 to determine whether the owner of spinlock S2 was spun (at step 72). If the outcome of the test at step 78 is negative, the routine is done. If, however, the outcome of the test at step 78 is positive, the routine continues at step 80 to unspin the S2 owner; thereafter, processing is complete. Thus, in the preferred embodiment, the pair of "collaborative" spinlocks are used to protect an execution state of the device driver. At task time, and prior to calling the device driver, the task time spinlock is acquired by the operating system, which then waits until the interrupt time spinlock is in an "unowned" state before calling the device driver. Upon return from the device driver, the operating system releases the task time spinlock. At interrupt time, and prior to calling the device driver's interrupt handler, the interrupt time spinlock is acquired by the operating system, which then determines whether the task time spinlock is owned. If the task time spinlock is unowned, the operating system calls the device driver. If, however, the task time spinlock is owned, the operating system then issues an interprocessor interrupt to the processor owning the task time spinlock. This places the "receiving" processor into a "spin" state. Upon return from the device driver, the interrupt time spinlock is released and the receiving processor is placed back into its original operating state. In the preferred embodiment, the receiving processor (i.e. the processor that owns the task time spinlock at interrupt time) spins on a predetermined or "first" memory location until that first memory location is cleared. The "sending" processor (i.e. the processor that issues the IPI to the receiving processor) uses a second memory location to determine when the receiving processor has entered the spin state. Thus, according to the preferred embodiment of the invention, at task time the device driver is called only after the operating system acquires the task time spinlock and determines that the interrupt time spinlock is unowned. At interrupt time, the device driver is called only after the operating system acquires the interrupt time spinlock and determines that the task time spinlock is either unowned or, if owned, the processor owning the task time spinlock has been placed in a predetermined "spin" condition. One of the preferred implementations of the invention is a client application, namely, a set of instructions (program code) in a code module which may, for example, be resident in the random access memory of the computer. Until required by the computer, the set of instructions may be stored in another computer memory, for example, in a hard disk drive, or in a removable memory such as an optical disk (for eventual use in a CD ROM) or floppy disk (for eventual use in a floppy disk drive), or downloaded via the Internet or other computer network. Thus, the present invention may be implemented as a computer program product for use in a computer. In addition, although the various methods described are conveniently implemented in a general purpose computer selectively activated or reconfigured by software, the skilled man will also recognize that such methods may be carried out in hardware, in firmware, or in more specialized apparatus constructed to perform the required method steps. Generalizing, the present invention covers any use of collaborative spinlocks to provide exclusive access to a resource in a computing system wherein multiple processors (or perhaps even multiple processes) contend for the resource. The term "spinlock" is intended to be broadly construed to cover any form of shared memory location (e.g, a single bit in a bit mask, a byte, a counter, etc.) having a set of known states (e.g., Set and Clear) whose values imply "ownership" or lack of ownership with respect to some resource. Moreover, although in the preferred embodiment, only a pair of spinlocks S1 and S2 are described, it should be appreciated that multiple spinlocks may be implemented to achieve the objects of the present invention. All that is required is that, with respect to any given resource, at least two of the spinlocks are available at task time and interrupt time. It should be appreciated by those skilled in the art that the specific embodiments disclosed above may be readily utilized as a basis for modifying or designing other techniques for carrying out the same purposes of the present invention. Further, and as noted above, although the invention has been described in terms of a preferred embodiment in a specific operating system environment, those skilled in the art will recognize that the invention can be practiced, with modification, in other and different system architectures with the scope of the appended claims.

Claims: A method for protecting the execution state of a resource for a multi-processor computing system wherein multiple processors contend for the resource, said computing system including an operating system, the method using a first spinlock (51) and a second spinlock (52) and comprising the steps of: at a first time, and prior to calling the resource, having the operating system acquire (42) the second spinlock (52) and then wait to call (50) the resource until the first spinlock (51) is unowned; and at a second time, and prior to calling the resource, having the operating system acquire (62) the first spinlock and wait to call the resource until the second spinlock is unowned or, if the second spinlock is owned, a processor owning the second spinlock is placed (80) in a predetermined condition. A method as claimed in claim 1 wherein the first time is a task time (52) and the second time is an interrupt time (51). A method as claimed in claim 2 where the resource is a operating system kernel extension being designed for a uniprocessor computing system, said multi-processor computing system having memory shared by all processors. A method as claimed in claim 3 wherein said predetermined condition is a spin on read. A method as claimed in claim 3 further including the step of having the operating system release the task time spinlock after the kernel extension is executed at task time. A method as claimed in claim 3 further including the step of having the operating system release the interrupt time spinlock after the kernel extension is executed at interrupt time. A method as claimed in claim 3 wherein the processor owning the task time spinlock at interrupt time is placed in the predetermined condition by an interrupt triggered by another processor. A method as claimed in any preceding claim wherein the operating system is a symmetric multiprocessor operating system. A method as claimed in any preceding claim wherein the kernel extension is a device driver. A computer system, comprising: a plurality of processors (12a...12n); a symmetric multiprocessing (SMP) operating system (14); at least one external device (16); a device driver (18) for controlling the at least one external device; and means for preventing concurrent access to the device driver by the plurality of processors, the preventing means comprising: an interrupt time spinlock (51); a task time spinlock (52); first code means, operative at task time and prior to calling the device driver, for controlling the operating system to acquire (42) the task time spinlock and then to wait to call (50) the device driver until the interrupt time spinlock is unowned; and second code means, operative at interrupt time and prior to calling the device driver, for controlling the operating system to acquire (62) the interrupt time spinlock and then to wait to call the device driver until either the task time spinlock is unowned or, if the task time spinlock is owned, a processor owning the task time spinlock is placed (80) in a predetermined condition. The computer system as claimed in claim 10 wherein the first code means includes means for controlling the operating system to release the task time spinlock after the device driver executes at task time. The computer system as claimed in claim 10 wherein the second code means includes means for controlling the operating system to release the interrupt time spinlock after the device driver executes at interrupt time. A computer program comprising code means adapted to perform all steps of any of the claims 1 to 9, when said program is run on a multi-processor computing system. A computer-readable medium embodying the computer program as claimed in claim 13.

Inventors: HARTNER WILLIAM, MACON JAMES JR, MEDINA DAVID, PELOQUIN MARK, SCHMITT CHARLES, HARTNER, WILLIAM, MACON, JAMES, JR., MEDINA, DAVID, PELOQUIN, MARK, SCHMITT, CHARLES
Applicants: IBM, INTERNATIONAL BUSINESS MACHINES CORPORATION
Application year: 1998
Main classification: G06F9
IPC codes: G06F9