Problems in writing a layered device driver in Linux

• Request function of a Pseudo device: request_fn for a device can be called from process context or interrupt context [5]. It is invoked from process context when the request function is not already running, i.e., when device queue is empty. At the end of the first request, if there are some pending requests in the queue, then it is the responsibility of interrupt handler to call request_fn. When writing a request_fn for a pseudo device, one have to take care that it will not block (as blocking routines cannot be called from interrupt context [6]). Hence a request_fn cannot call blocking routines like ll_rw_block(). This problem has been solved by making request_fn of our pseudo device use a loop that serves all the requests in the device queue one by one. Hence the request_fn will always be invoked from the process context and we can use blocking routines also.

• Performance penalty: For a layered device driver all the buffers will be first queued to pseudo device queue and, in request_fn, it will be put into the underlying device queue. Processing time for each buffer is now the delay of passing through two device queues.

• Dynamic introduction of modules: If we want to dynamically push a pseudo device on top of a real device, then the requests going to the real device have to be diverted to pass through the pseudo device. For example, for snapshots, the pseudo layer is required only when the snapshot is on for some extra work like COW push and logging. However, the introduction of dynamic layer is not easy in the current device driver interface framework in Linux. One solution (though not clean) for introduction of a dynamic layer is to interchange request_fn and queue function of the original device with the pseudo device.

  For example, if we are taking the snapshot of a SCSI device, before start of the snapshot (before introduction of the pseudo layer) SCSI major number will point to its own request_fn and queue function. Once the snapshot is on, SCSI major number will point to pseudo devices request_fn and queue function and the pseudo device major number will point to the SCSI device request_fn and queue function. We can thus introduce the pseudo device layer. But this is not a good solution. ll_rw_block() does different types of optimization's for different types of devices [5]. So, in this method ll_rw_block() code has to do all those optimization's for the original device major number if there is no pseudo layer and same optimization's has to be done for pseudo major number if there is a pseudo layer. Such an implementation will again become somewhat similar to implementation of LVM as explained in section 2 and thus will not be a simple, separate module and has to be (hacked!) integrated into the kernel.

  This problem has been solved by having a pseudo layer always on top of the original device driver layer. When ever snapshots are on, the required work such as COW push and logging will be effected by the driver. If there is no snapshot, the pseudo request function simply transfers the requests from the pseudo device to the original device.