Controlling Device Access

This section describes aspects of the open(9E) and close(9E) entry points that are specific to block device drivers. See Chapter 9, Drivers for Character Devices, for more information on open(9E) and close(9E).

open(9E)

int xxopen(dev_t *devp, int flag, int otyp, cred_t *credp)

The open(9E) entry point is used to gain access to a given device. The open(9E) routine of a block driver is called when a user thread issues an open(2) or mount(2) system call on a block special file associated with the minor device, or when a layered driver calls open(9E). See "File I/O" for more information.

The open(9E) entry point should check for the following:

• The device can be opened; for example, it is online and ready.

• The device can be opened as requested; the device supports the operation, and the device's current state does not conflict with the request.

• The caller has permission to open the device.

Example 10-2 demonstrates a block driver open(9E) entry point.

Example 10-2 Block Driver open(9E) Routine

static int
xxopen(dev_t *devp, int flags, int otyp, cred_t *credp)
{
	   minor_t             instance;
	   struct xxstate			*xsp;

 	instance = getminor(*devp);
 	xsp = ddi_get_soft_state(statep, instance);
 	if (xsp == NULL)
		       return (ENXIO);
 	mutex_enter(&xsp->mu);
 	/*
	    * only honor FEXCL. If a regular open or a layered open
	    * is still outstanding on the device, the exclusive open
	    * must fail.
	    */
 	if ((flags & FEXCL) && (xsp->open || xsp->nlayered)) {
	   	mutex_exit(&xsp->mu);
	   	return (EAGAIN);
 	}
 	switch (otyp) {
	   case OTYP_LYR:
	   	  xsp->nlayered++;
	   	  break;
  	case OTYP_BLK:
	   	  xsp->open = 1;
	   	  break;
 	default:
	   	  mutex_exit(&xsp->mu);
	   	  return (EINVAL);
 	}
   mutex_exit(&xsp->mu);
  	return (0);
}

The otyp argument is used to specify the type of open on the device. OTYP_BLK is the typical open type for a block device. A device may be opened several times with otyp set to OTYP_BLK, although close(9E) will be called only once when the final close of type OTYP_BLK has occurred for the device. otyp is set to OTYP_LYR if the device is being used as a layered device. For every open of type OTYP_LYR, the layering driver issues a corresponding close of type OTYP_LYR. The example keeps track of each type of open so the driver can determine when the device is not being used in close(9E). See the open(9E) manual page for more details about the otyp argument.

close(9E)

int xxclose(dev_t dev, int flag, int otyp, cred_t *credp)

The arguments of the close(9E) entry point are identical to arguments of open(9E), except that dev is the device number, as opposed to a pointer to the device number.

The close(9E) routine should verify otyp in the same way as was described for the open(9E) entry point. In Example 10-3, close(9E) must determine when the device can really be closed based on the number of block opens and layered opens.

Example 10-3 Block Device close(9E) Routine

static int
xxclose(dev_t dev, int flag, int otyp, cred_t *credp)
{
 	minor_t instance;
 	struct xxstate *xsp;

 	instance = getminor(dev);
 	xsp = ddi_get_soft_state(statep, instance);
	   if (xsp == NULL)
		      return (ENXIO);
 	mutex_enter(&xsp->mu);
 	switch (otyp) {
	   case OTYP_LYR:
	   	xsp->nlayered--;
	   	break;
  	case OTYP_BLK:
	   	xsp->open = 0;
	   	break;
 	default:
	   	mutex_exit(&xsp->mu);
	   	return (EINVAL);
	   }

 	if (xsp->open || xsp->nlayered) {
	   	/* not done yet */
	   	mutex_exit(&xsp->mu);
	   	return (0);
 	}
	   /* cleanup (rewind tape, free memory, etc.) */
   /* wait for I/O to drain */
 	mutex_exit(&xsp->mu);

 	return (0);
}