Synchronization and locks

Drivers need to deal with various synchronization and timing issues, and both DDI and ODDI provide facilities for these. For a full reference list of the facilities that are provided, see ``Synchronization primitives''.

• The driver initiates an activity such as an I/O operation to the device and needs to block execution until the activity completes.

  DDI drivers use synchronization variables, described in ``Synchronization variables''. That article also includes a comparison of synchronization with the older sleep(D3) and wakeup(D3) mechanisms.

  ODDI drivers use sleep(D3oddi) to block the driver, and wakeupn(D3oddi) to unblock a single process that is waiting for that event or wakeup(D3oddi) to unblock all processes that are waiting for that event.

• A certain operation needs to complete before any other process accesses a particular resource such as a structure or counter. See ``Critical code section''.

  Critical code is usually protected with spin locks, where a lock is set and any other code that attempts to access that region spins until the resource is available. DDI spin locks are discussed in ``Spin locks (DDI)''; ODDI spin locks are discusssed in ``Spin locks (ODDI)''.

  Both DDI and ODDI also support the spl( ) function, which controls the interrupt-driven code that can execute and could prevent the critical code from executing atomically. See spl(D3) and spl(D3oddi).

• When the critical code is very small, such as incrementing a counter, atomic locks provide a more efficient mechanism. See ``Atomic locks'' for information about the atomic locking mechanisms that are provided for DDI and ODDI drivers.

• The driver needs to wait for a predefined amount of time and then execute some code. DDI and ODDI provide timeout, delay, and busy-wait mechanisms for such occasions; see ``Timeouts'' and ``Delays and busy-waits''.