Manual merge for problems between Al Viro's blocksize removal and

Douglas Gilbert's SCSI cleanups

drivers/scsi/sd.c

@@ -5,29 +5,28 @@
  *      Linux scsi disk driver
  *              Initial versions: Drew Eckhardt
  *              Subsequent revisions: Eric Youngdale
+ *	Modification history:
+ *       - Drew Eckhardt <drew@colorado.edu> original
+ *       - Eric Youngdale <eric@andante.org> add scatter-gather, multiple 
+ *         outstanding request, and other enhancements.
+ *         Support loadable low-level scsi drivers.
+ *       - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using 
+ *         eight major numbers.
+ *       - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
+ *	 - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in 
+ *	   sd_init and cleanups.
+ *	 - Alex Davis <letmein@erols.com> Fix problem where partition info
+ *	   not being read in sd_open. Fix problem where removable media 
+ *	   could be ejected after sd_open.
+ *	 - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5 series
  *
- *      <drew@colorado.edu>
- *
- *       Modified by Eric Youngdale ericy@andante.org to
- *       add scatter-gather, multiple outstanding request, and other
- *       enhancements.
- *
- *       Modified by Eric Youngdale eric@andante.org to support loadable
- *       low-level scsi drivers.
- *
- *       Modified by Jirka Hanika geo@ff.cuni.cz to support more
- *       scsi disks using eight major numbers.
- *
- *       Modified by Richard Gooch rgooch@atnf.csiro.au to support devfs.
- *	
- *	 Modified by Torben Mathiasen tmm@image.dk
- *       Resource allocation fixes in sd_init and cleanups.
- *	
- *	 Modified by Alex Davis <letmein@erols.com>
- *       Fix problem where partition info not being read in sd_open.
- *	
- *	 Modified by Alex Davis <letmein@erols.com>
- *       Fix problem where removable media could be ejected after sd_open.
+ *	Logging policy (needs CONFIG_SCSI_LOGGING defined):
+ *	 - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
+ *	 - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
+ *	 - entering sd_ioctl: SCSI_LOG_IOCTL level 1
+ *	 - entering other commands: SCSI_LOG_HLQUEUE level 3
+ *	Note: when the logging level is set by the user, it must be greater
+ *	than the level indicated above to trigger output.	
  */
 
 #include <linux/config.h>
@@ -50,6 +49,7 @@
 #include <asm/io.h>
 
 #define MAJOR_NR SCSI_DISK0_MAJOR
+#define LOCAL_END_REQUEST
 #include <linux/blk.h>
 #include <linux/blkpg.h>
 #include "scsi.h"
@@ -61,6 +61,8 @@
 
 #include <linux/genhd.h>
 
+static char sd_version_str[] = "Version: 2.0.3 (20020417)";
+
 #define SD_MAJOR(i) (!(i) ? SCSI_DISK0_MAJOR : SCSI_DISK1_MAJOR-1+(i))
 
 #define SCSI_DISKS_PER_MAJOR	16
@@ -79,16 +81,21 @@
 #define SD_TIMEOUT (30 * HZ)
 #define SD_MOD_TIMEOUT (75 * HZ)
 
+#define SD_DSK_ARR_LUMP 6 /* amount to over allocate sd_dsk_arr by */
+
+
 struct hd_struct *sd;
 
-static Scsi_Disk *rscsi_disks;
+static Scsi_Disk ** sd_dsk_arr;
+static rwlock_t sd_dsk_arr_lock = RW_LOCK_UNLOCKED;
+
 static int *sd_sizes;
 static int *sd_max_sectors;
 
 static int check_scsidisk_media_change(kdev_t);
 static int fop_revalidate_scsidisk(kdev_t);
 
-static int sd_init_onedisk(int);
+static int sd_init_onedisk(Scsi_Disk * sdkp, int dsk_nr);
 
 static int sd_init(void);
 static void sd_finish(void);
@@ -117,36 +124,81 @@ static struct Scsi_Device_Template sd_template = {
 	init_command:sd_init_command,
 };
 
-static void rw_intr(Scsi_Cmnd * SCpnt);
+static void sd_rw_intr(Scsi_Cmnd * SCpnt);
+
+static Scsi_Disk * sd_get_sdisk(int index);
+
 
 #if defined(CONFIG_PPC)
-/*
- * Moved from arch/ppc/pmac_setup.c.  This is where it really belongs.
- */
+/**
+ *	sd_find_target - find kdev_t of first scsi disk that matches
+ *	given host and scsi_id. 
+ *	@host: Scsi_Host object pointer that owns scsi device of interest
+ *	@scsi_id: scsi (target) id number of device of interest
+ *
+ *	Returns kdev_t of first scsi device that matches arguments or
+ *	NODEV of no match.
+ *
+ *	Notes: Looks like a hack, should scan for <host,channel,id,lin>
+ *	tuple.
+ *	[Architectural dependency: ppc only.] Moved here from 
+ *	arch/ppc/pmac_setup.c.
+ **/
 kdev_t __init
-sd_find_target(void *host, int tgt)
+sd_find_target(void *hp, int scsi_id)
 {
-    Scsi_Disk *dp;
-    int i;
-    for (dp = rscsi_disks, i = 0; i < sd_template.dev_max; ++i, ++dp)
-        if (dp->device != NULL && dp->device->host == host
-            && dp->device->id == tgt)
-            return MKDEV_SD(i);
-    return NODEV;
+	Scsi_Disk *sdkp;
+	Scsi_Device *sdp;
+	Scsi_Host *shp = hp;
+	int dsk_nr;
+	unsigned long iflags;
+
+	SCSI_LOG_HLQUEUE(3, printk("sd_find_target: host_nr=%d, "
+			    "scsi_id=%d\n", shp->host_no, scsi_id));
+	read_lock_irqsave(&sd_dsk_arr_lock, iflags);
+	for (dsk_nr = 0; dsk_nr < sd_template.dev_max; ++dsk_nr) {
+		if (NULL == (sdkp = sd_dsk_arr[dsk_nr]))
+			continue;
+		sdp = sdkp->device;
+		if (sdp && (sdp->host == shp) && (sdp->id == scsi_id)) {
+			read_unlock_irqrestore(&sd_dsk_arr_lock, iflags);
+			return MKDEV_SD(k);
+		}
+	}
+	read_unlock_irqrestore(&sd_dsk_arr_lock, iflags);
+	return NODEV;
 }
 #endif
 
-static int sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
+/**
+ *	sd_ioctl - process an ioctl
+ *	@inode: only i_rdev member may be used
+ *	@filp: only f_mode and f_flags may be used
+ *	@cmd: ioctl command number
+ *	@arg: this is third argument given to ioctl(2) system call.
+ *	Often contains a pointer.
+ *
+ *	Returns 0 if successful (some ioctls return postive numbers on
+ *	success as well). Returns a negated errno value in case of error.
+ *
+ *	Note: most ioctls are forward onto the block subsystem or further
+ *	down in the scsi subsytem.
+ **/
+static int sd_ioctl(struct inode * inode, struct file * filp, 
+		    unsigned int cmd, unsigned long arg)
 {
 	kdev_t dev = inode->i_rdev;
+        Scsi_Disk * sdkp;
 	struct Scsi_Host * host;
-	Scsi_Device * SDev;
+	Scsi_Device * sdp;
 	int diskinfo[4];
+	int dsk_nr = DEVICE_NR(dev);
     
-	SDev = rscsi_disks[DEVICE_NR(dev)].device;
-	if (!SDev)
+	SCSI_LOG_IOCTL(1, printk("sd_ioctl: dsk_nr=%d, cmd=0x%x\n",
+		       dsk_nr, cmd));
+	sdkp = sd_get_sdisk(dsk_nr);
+	if ((NULL == sdkp) || (NULL == (sdp = sdkp->device)))
 		return -ENODEV;
-
 	/*
 	 * If we are in the middle of error recovery, don't let anyone
 	 * else try and use this device.  Also, if error recovery fails, it
@@ -154,10 +206,8 @@ static int sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
 	 * access to the device is prohibited.
 	 */
 
-	if( !scsi_block_when_processing_errors(SDev) )
-	{
+	if( !scsi_block_when_processing_errors(sdp) )
 		return -ENODEV;
-	}
 
 	switch (cmd) 
 	{
@@ -167,58 +217,59 @@ static int sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
 			if(!loc)
 				return -EINVAL;
 
-			host = rscsi_disks[DEVICE_NR(dev)].device->host;
+			host = sdp->host;
 	
 			/* default to most commonly used values */
 	
 		        diskinfo[0] = 0x40;
 	        	diskinfo[1] = 0x20;
-	        	diskinfo[2] = rscsi_disks[DEVICE_NR(dev)].capacity >> 11;
+	        	diskinfo[2] = sdkp->capacity >> 11;
 	
-			/* override with calculated, extended default, or driver values */
+			/* override with calculated, extended default, 
+			   or driver values */
 	
 			if(host->hostt->bios_param != NULL)
-				host->hostt->bios_param(&rscsi_disks[DEVICE_NR(dev)],
-					    dev,
-					    &diskinfo[0]);
-			else scsicam_bios_param(&rscsi_disks[DEVICE_NR(dev)],
-					dev, &diskinfo[0]);
+				host->hostt->bios_param(sdkp, dev, 
+							&diskinfo[0]);
+			else
+				scsicam_bios_param(sdkp, dev, &diskinfo[0]);
 			if (put_user(diskinfo[0], &loc->heads) ||
 				put_user(diskinfo[1], &loc->sectors) ||
 				put_user(diskinfo[2], &loc->cylinders) ||
-				put_user((unsigned) get_start_sect(inode->i_rdev),
+				put_user((unsigned) 
+					     get_start_sect(inode->i_rdev),
 					 (unsigned long *) &loc->start))
 				return -EFAULT;
 			return 0;
 		}
 		case HDIO_GETGEO_BIG:
 		{
-			struct hd_big_geometry *loc = (struct hd_big_geometry *) arg;
+			struct hd_big_geometry *loc = 
+					(struct hd_big_geometry *) arg;
 
 			if(!loc)
 				return -EINVAL;
-
-			host = rscsi_disks[DEVICE_NR(dev)].device->host;
+			host = sdp->host;
 
 			/* default to most commonly used values */
-
 			diskinfo[0] = 0x40;
 			diskinfo[1] = 0x20;
-			diskinfo[2] = rscsi_disks[DEVICE_NR(dev)].capacity >> 11;
+			diskinfo[2] = sdkp->capacity >> 11;
 
-			/* override with calculated, extended default, or driver values */
-
-			if(host->hostt->bios_param != NULL)
-				host->hostt->bios_param(&rscsi_disks[DEVICE_NR(dev)],
-					    dev,
-					    &diskinfo[0]);
-			else scsicam_bios_param(&rscsi_disks[DEVICE_NR(dev)],
-					dev, &diskinfo[0]);
+			/* override with calculated, extended default, 
+			   or driver values */
+			if(host->hostt->bios_param != NULL) 
+				host->hostt->bios_param(sdkp, dev,
+							&diskinfo[0]);
+			else
+				scsicam_bios_param(sdkp, dev, &diskinfo[0]);
 
 			if (put_user(diskinfo[0], &loc->heads) ||
 				put_user(diskinfo[1], &loc->sectors) ||
-				put_user(diskinfo[2], (unsigned int *) &loc->cylinders) ||
-				put_user((unsigned)get_start_sect(inode->i_rdev),
+				put_user(diskinfo[2], 
+					 (unsigned int *) &loc->cylinders) ||
+				put_user((unsigned)
+					   get_start_sect(inode->i_rdev),
 					 (unsigned long *)&loc->start))
 				return -EFAULT;
 			return 0;
@@ -242,15 +293,14 @@ static int sd_ioctl(struct inode * inode, struct file * file, unsigned int cmd,
 			return revalidate_scsidisk(dev, 1);
 
 		default:
-			return scsi_ioctl(rscsi_disks[DEVICE_NR(dev)].device,
-					  cmd, (void *) arg);
+			return scsi_ioctl(sdp, cmd, (void *) arg);
 	}
 }
 
-static void sd_devname(unsigned int disknum, char *buffer)
+static void sd_dskname(unsigned int dsk_nr, char *buffer)
 {
-	if (disknum < 26)
-		sprintf(buffer, "sd%c", 'a' + disknum);
+	if (dsk_nr < 26)
+		sprintf(buffer, "sd%c", 'a' + dsk_nr);
 	else {
 		unsigned int min1;
 		unsigned int min2;
@@ -258,67 +308,88 @@ static void sd_devname(unsigned int disknum, char *buffer)
 		 * For larger numbers of disks, we need to go to a new
 		 * naming scheme.
 		 */
-		min1 = disknum / 26;
-		min2 = disknum % 26;
+		min1 = dsk_nr / 26;
+		min2 = dsk_nr % 26;
 		sprintf(buffer, "sd%c%c", 'a' + min1 - 1, 'a' + min2);
 	}
 }
 
+/**
+ *	sd_find_queue - yields queue associated with device
+ *	@dev: kernel device descriptor (kdev_t)
+ *
+ *	Returns NULL if no match, otherwise returns pointer to associated
+ *	request queue.
+ *
+ *	Note: this function is invoked (often) from the block subsystem
+ *	and should not wait on anything (sd_get_sdisk() does have a read
+ *	spinlock).
+ **/
 static request_queue_t *sd_find_queue(kdev_t dev)
 {
-	Scsi_Disk *dpnt;
- 	int target;
- 	target = DEVICE_NR(dev);
+	Scsi_Disk *sdkp;
+ 	int dsk_nr = DEVICE_NR(dev);
 
-	dpnt = &rscsi_disks[target];
-	if (!dpnt)
+	sdkp = sd_get_sdisk(dsk_nr);
+	if (sdkp && sdkp->device)
+		return &sdkp->device->request_queue;
+	else
 		return NULL;	/* No such device */
-	return &dpnt->device->request_queue;
 }
 
+/**
+ *	sd_init_command - build a scsi (read or write) command from
+ *	information in the request structure.
+ *	@SCpnt: pointer to mid-level's per scsi command structure that
+ *	contains request and into which the scsi command is written
+ *
+ *	Returns 1 if successful and 0 if error (or cannot be done now).
+ **/
 static int sd_init_command(Scsi_Cmnd * SCpnt)
 {
-	int dev, devm, block, this_count;
-	Scsi_Disk *dpnt;
+	int dsk_nr, part_nr, block, this_count;
+	Scsi_Device *sdp;
 #if CONFIG_SCSI_LOGGING
 	char nbuff[6];
 #endif
-
 	/*
 	 * don't support specials for nwo
 	 */
 	if (!(SCpnt->request.flags & REQ_CMD))
 		return 0;
 
-	devm = SD_PARTITION(SCpnt->request.rq_dev);
-	dev = DEVICE_NR(SCpnt->request.rq_dev);
+	part_nr = SD_PARTITION(SCpnt->request.rq_dev);
+	dsk_nr = DEVICE_NR(SCpnt->request.rq_dev);
 
 	block = SCpnt->request.sector;
 	this_count = SCpnt->request_bufflen >> 9;
 
-	SCSI_LOG_HLQUEUE(1, printk("Doing sd request, dev = %d, block = %d\n", devm, block));
-
-	dpnt = &rscsi_disks[dev];
-	if (devm >= (sd_template.dev_max << 4) || (devm & 0xf) ||
-	    !dpnt ||
-	    !dpnt->device->online ||
- 	    block + SCpnt->request.nr_sectors > sd[devm].nr_sects) {
-		SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n", SCpnt->request.nr_sectors));
+	SCSI_LOG_HLQUEUE(1, printk("sd_command_init: dsk_nr=%d, block=%d, "
+			    "count=%d\n", dsk_nr, block, this_count));
+
+	sdp = SCpnt->device;
+	/* >>>>> the "(part_nr & 0xf)" excludes 15th partition, why?? */
+	/* >>>>> this change is not in the lk 2.5 series */
+	if (part_nr >= (sd_template.dev_max << 4) || (part_nr & 0xf) ||
+	    !sdp || !sdp->online ||
+ 	    block + SCpnt->request.nr_sectors > sd[part_nr].nr_sects) {
+		SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n", 
+				 SCpnt->request.nr_sectors));
 		SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
 		return 0;
 	}
 
-	if (dpnt->device->changed) {
+	if (sdp->changed) {
 		/*
-		 * quietly refuse to do anything to a changed disc until the changed
-		 * bit has been reset
+		 * quietly refuse to do anything to a changed disc until 
+		 * the changed bit has been reset
 		 */
 		/* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
 		return 0;
 	}
-	SCSI_LOG_HLQUEUE(2, sd_devname(devm, nbuff));
-	SCSI_LOG_HLQUEUE(2, printk("%s : real dev = /dev/%d, block = %d\n",
-				   nbuff, dev, block));
+	SCSI_LOG_HLQUEUE(2, sd_dskname(dsk_nr, nbuff));
+	SCSI_LOG_HLQUEUE(2, printk("%s : [part_nr=%d], block=%d\n",
+				   nbuff, part_nr, block));
 
 	/*
 	 * If we have a 1K hardware sectorsize, prevent access to single
@@ -331,27 +402,27 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 	 * and not force the scsi disk driver to use bounce buffers
 	 * for this.
 	 */
-	if (dpnt->device->sector_size == 1024) {
+	if (sdp->sector_size == 1024) {
 		if ((block & 1) || (SCpnt->request.nr_sectors & 1)) {
-			printk("sd.c:Bad block number requested");
+			printk(KERN_ERR "sd: Bad block number requested");
 			return 0;
 		} else {
 			block = block >> 1;
 			this_count = this_count >> 1;
 		}
 	}
-	if (dpnt->device->sector_size == 2048) {
+	if (sdp->sector_size == 2048) {
 		if ((block & 3) || (SCpnt->request.nr_sectors & 3)) {
-			printk("sd.c:Bad block number requested");
+			printk(KERN_ERR "sd: Bad block number requested");
 			return 0;
 		} else {
 			block = block >> 2;
 			this_count = this_count >> 2;
 		}
 	}
-	if (dpnt->device->sector_size == 4096) {
+	if (sdp->sector_size == 4096) {
 		if ((block & 7) || (SCpnt->request.nr_sectors & 7)) {
-			printk("sd.c:Bad block number requested");
+			printk(KERN_ERR "sd: Bad block number requested");
 			return 0;
 		} else {
 			block = block >> 3;
@@ -359,7 +430,7 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 		}
 	}
 	if (rq_data_dir(&SCpnt->request) == WRITE) {
-		if (!dpnt->device->writeable) {
+		if (!sdp->writeable) {
 			return 0;
 		}
 		SCpnt->cmnd[0] = WRITE_6;
@@ -367,13 +438,16 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 	} else if (rq_data_dir(&SCpnt->request) == READ) {
 		SCpnt->cmnd[0] = READ_6;
 		SCpnt->sc_data_direction = SCSI_DATA_READ;
-	} else
-		panic("Unknown sd command %lx\n", SCpnt->request.flags);
+	} else {
+		printk(KERN_ERR "sd: Unknown command %lx\n", 
+		       SCpnt->request.flags);
+/* overkill 	panic("Unknown sd command %lx\n", SCpnt->request.flags); */
+		return 0;
+	}
 
-	SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n",
-				   nbuff,
-		   (rq_data_dir(&SCpnt->request) == WRITE) ? "writing" : "reading",
-				 this_count, SCpnt->request.nr_sectors));
+	SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n", 
+		nbuff, (rq_data_dir(&SCpnt->request) == WRITE) ? 
+		"writing" : "reading", this_count, SCpnt->request.nr_sectors));
 
 	SCpnt->cmnd[1] = (SCpnt->device->scsi_level <= SCSI_2) ?
 			 ((SCpnt->lun << 5) & 0xe0) : 0;
@@ -406,7 +480,7 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 	 * host adapter, it's safe to assume that we can at least transfer
 	 * this many bytes between each connect / disconnect.
 	 */
-	SCpnt->transfersize = dpnt->device->sector_size;
+	SCpnt->transfersize = sdp->sector_size;
 	SCpnt->underflow = this_count << 9;
 
 	SCpnt->allowed = MAX_RETRIES;
@@ -417,7 +491,7 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 	 * This is the completion routine we use.  This is matched in terms
 	 * of capability to this function.
 	 */
-	SCpnt->done = rw_intr;
+	SCpnt->done = sd_rw_intr;
 
 	/*
 	 * This indicates that the command is ready from our end to be
@@ -426,31 +500,46 @@ static int sd_init_command(Scsi_Cmnd * SCpnt)
 	return 1;
 }
 
+/**
+ *	sd_open - open a scsi disk device
+ *	@inode: only i_rdev member may be used
+ *	@filp: only f_mode and f_flags may be used
+ *
+ *	Returns 0 if successful. Returns a negated errno value in case 
+ *	of error.
+ *
+ *	Note: This can be called from a user context (e.g. fsck(1) )
+ *	or from within the kernel (e.g. as a result of a mount(1) ).
+ *	In the latter case @inode and @filp carry an abridged amount
+ *	of information as noted above.
+ **/
 static int sd_open(struct inode *inode, struct file *filp)
 {
-	int target, retval = -ENXIO;
-	Scsi_Device * SDev;
-	target = DEVICE_NR(inode->i_rdev);
+	int retval = -ENXIO;
+	Scsi_Device * sdp;
+	Scsi_Disk * sdkp;
+	int dsk_nr = DEVICE_NR(inode->i_rdev);
 
-	SCSI_LOG_HLQUEUE(1, printk("target=%d, max=%d\n", target, sd_template.dev_max));
+	SCSI_LOG_HLQUEUE(3, printk("sd_open: dsk_nr=%d, part_nr=%d\n", 
+			    dsk_nr, SD_PARTITION(inode->i_rdev)));
 
-	if (target >= sd_template.dev_max || !rscsi_disks[target].device)
+	sdkp = sd_get_sdisk(dsk_nr);
+	if ((NULL == sdkp) || (NULL == (sdp = sdkp->device)))
 		return -ENXIO;	/* No such device */
 
 	/*
 	 * If the device is in error recovery, wait until it is done.
 	 * If the device is offline, then disallow any access to it.
 	 */
-	if (!scsi_block_when_processing_errors(rscsi_disks[target].device)) {
+	if (!scsi_block_when_processing_errors(sdp))
 		return -ENXIO;
-	}
 	/*
-	 * Make sure that only one process can do a check_change_disk at one time.
-	 * This is also used to lock out further access when the partition table
-	 * is being re-read.
+	 * Make sure that only one process can do a check_change_disk at 
+	 * one time.  This is also used to lock out further access when 
+	 * the partition table is being re-read.
 	 */
 
-	while (rscsi_disks[target].device->busy) {
+	while (sdp->busy) {
 		barrier();
 		cpu_relax();
 	}
@@ -458,22 +547,21 @@ static int sd_open(struct inode *inode, struct file *filp)
 	 * The following code can sleep.
 	 * Module unloading must be prevented
 	 */
-	SDev = rscsi_disks[target].device;
-	if (SDev->host->hostt->module)
-		__MOD_INC_USE_COUNT(SDev->host->hostt->module);
+	if (sdp->host->hostt->module)
+		__MOD_INC_USE_COUNT(sdp->host->hostt->module);
 	if (sd_template.module)
 		__MOD_INC_USE_COUNT(sd_template.module);
-	SDev->access_count++;
+	sdp->access_count++;
 
-	if (rscsi_disks[target].device->removable) {
-		SDev->allow_revalidate = 1;
+	if (sdp->removable) {
+		sdp->allow_revalidate = 1;
 		check_disk_change(inode->i_rdev);
-		SDev->allow_revalidate = 0;
+		sdp->allow_revalidate = 0;
 
 		/*
 		 * If the drive is empty, just let the open fail.
 		 */
-		if ((!rscsi_disks[target].ready) && !(filp->f_flags & O_NDELAY)) {
+		if ((!sdkp->ready) && !(filp->f_flags & O_NDELAY)) {
 			retval = -ENOMEDIUM;
 			goto error_out;
 		}
@@ -483,7 +571,7 @@ static int sd_open(struct inode *inode, struct file *filp)
 		 * have the open fail if the user expects to be able to write
 		 * to the thing.
 		 */
-		if ((rscsi_disks[target].write_prot) && (filp->f_mode & 2)) {
+		if ((sdkp->write_prot) && (filp->f_mode & FMODE_WRITE)) {
 			retval = -EROFS;
 			goto error_out;
 		}
@@ -494,7 +582,7 @@ static int sd_open(struct inode *inode, struct file *filp)
 	 * and don't pretend that
 	 * the open actually succeeded.
 	 */
-	if (!SDev->online) {
+	if (!sdp->online) {
 		goto error_out;
 	}
 	/*
@@ -505,42 +593,57 @@ static int sd_open(struct inode *inode, struct file *filp)
 		goto error_out;
 	}
 
-	if (SDev->removable)
-		if (SDev->access_count==1)
-			if (scsi_block_when_processing_errors(SDev))
-				scsi_ioctl(SDev, SCSI_IOCTL_DOORLOCK, NULL);
+	if (sdp->removable)
+		if (sdp->access_count==1)
+			if (scsi_block_when_processing_errors(sdp))
+				scsi_ioctl(sdp, SCSI_IOCTL_DOORLOCK, NULL);
 
-	
 	return 0;
 
 error_out:
-	SDev->access_count--;
-	if (SDev->host->hostt->module)
-		__MOD_DEC_USE_COUNT(SDev->host->hostt->module);
+	sdp->access_count--;
+	if (sdp->host->hostt->module)
+		__MOD_DEC_USE_COUNT(sdp->host->hostt->module);
 	if (sd_template.module)
 		__MOD_DEC_USE_COUNT(sd_template.module);
 	return retval;	
 }
 
-static int sd_release(struct inode *inode, struct file *file)
+/**
+ *	sd_release - invoked when the (last) close(2) is called on this
+ *	scsi disk.
+ *	@inode: only i_rdev member may be used
+ *	@filp: only f_mode and f_flags may be used
+ *
+ *	Returns 0. 
+ *
+ *	Note: may block (uninterruptible) if error recovery is underway
+ *	on this disk.
+ **/
+static int sd_release(struct inode *inode, struct file *filp)
 {
-	int target;
-	Scsi_Device * SDev;
+	Scsi_Disk * sdkp;
+	int dsk_nr = DEVICE_NR(inode->i_rdev);
+	Scsi_Device * sdp;
 
-	target = DEVICE_NR(inode->i_rdev);
-	SDev = rscsi_disks[target].device;
-	if (!SDev)
-		return -ENODEV;
+	SCSI_LOG_HLQUEUE(3, printk("sd_release: dsk_nr=%d, part_nr=%d\n", 
+			    dsk_nr, SD_PARTITION(inode->i_rdev)));
+	sdkp = sd_get_sdisk(dsk_nr);
+	if ((NULL == sdkp) || (NULL == (sdp = sdkp->device)))
+		return -ENODEV; /* open uses ENXIO ?? */
+
+	/* ... and what if there are packets in flight and this close()
+	 * is followed by a "rmmod sd_mod" */
 
-	SDev->access_count--;
+	sdp->access_count--;
 
-	if (SDev->removable) {
-		if (!SDev->access_count)
-			if (scsi_block_when_processing_errors(SDev))
-				scsi_ioctl(SDev, SCSI_IOCTL_DOORUNLOCK, NULL);
+	if (sdp->removable) {
+		if (!sdp->access_count)
+			if (scsi_block_when_processing_errors(sdp))
+				scsi_ioctl(sdp, SCSI_IOCTL_DOORUNLOCK, NULL);
 	}
-	if (SDev->host->hostt->module)
-		__MOD_DEC_USE_COUNT(SDev->host->hostt->module);
+	if (sdp->host->hostt->module)
+		__MOD_DEC_USE_COUNT(sdp->host->hostt->module);
 	if (sd_template.module)
 		__MOD_DEC_USE_COUNT(sd_template.module);
 	return 0;
@@ -558,7 +661,7 @@ static struct block_device_operations sd_fops =
 
 /*
  *    If we need more than one SCSI disk major (i.e. more than
- *      16 SCSI disks), we'll have to kmalloc() more gendisks later.
+ *      16 SCSI disks), we'll have to vmalloc() more gendisks later.
  */
 
 static struct gendisk sd_gendisk =
@@ -573,30 +676,34 @@ static struct gendisk *sd_gendisks = &sd_gendisk;
 
 #define SD_GENDISK(i)    sd_gendisks[(i) / SCSI_DISKS_PER_MAJOR]
 
-/*
- * rw_intr is the interrupt routine for the device driver.
- * It will be notified on the end of a SCSI read / write, and
- * will take one of several actions based on success or failure.
- */
-
-static void rw_intr(Scsi_Cmnd * SCpnt)
+/**
+ *	sd_rw_intr - bottom half handler: called when the lower level
+ *	driver has completed (successfully or otherwise) a scsi command.
+ *	@SCpnt: mid-level's per command structure.
+ *
+ *	Note: potentially run from within an ISR. Must not block.
+ **/
+static void sd_rw_intr(Scsi_Cmnd * SCpnt)
 {
 	int result = SCpnt->result;
-#if CONFIG_SCSI_LOGGING
-	char nbuff[6];
-#endif
 	int this_count = SCpnt->bufflen >> 9;
 	int good_sectors = (result == 0 ? this_count : 0);
 	int block_sectors = 1;
+	long error_sector;
+#if CONFIG_SCSI_LOGGING
+	char nbuff[6];
 
-	SCSI_LOG_HLCOMPLETE(1, sd_devname(DEVICE_NR(SCpnt->request.rq_dev), nbuff));
-
-	SCSI_LOG_HLCOMPLETE(1, printk("%s : rw_intr(%d, %x [%x %x])\n", nbuff,
-				      SCpnt->host->host_no,
-				      result,
-				      SCpnt->sense_buffer[0],
-				      SCpnt->sense_buffer[2]));
-
+	SCSI_LOG_HLCOMPLETE(1, sd_dskname(DEVICE_NR(SCpnt->request.rq_dev), 
+			    nbuff));
+	SCSI_LOG_HLCOMPLETE(1, printk("sd_rw_intr: %s: res=0x%x\n", 
+				      nbuff, result));
+	if (0 != result) {
+		SCSI_LOG_HLCOMPLETE(1, printk("sd_rw_intr: sb[0,2,asc,ascq]"
+				"=%x,%x,%x,%x\n", SCpnt->sense_buffer[0],
+			SCpnt->sense_buffer[2], SCpnt->sense_buffer[12],
+			SCpnt->sense_buffer[13]));
+	}
+#endif
 	/*
 	   Handle MEDIUM ERRORs that indicate partial success.  Since this is a
 	   relatively rare error condition, no care is taken to avoid
@@ -604,10 +711,11 @@ static void rw_intr(Scsi_Cmnd * SCpnt)
 	 */
 
 	/* An error occurred */
-	if (driver_byte(result) != 0) {
-		/* Sense data is valid */
-		if (SCpnt->sense_buffer[0] == 0xF0 && SCpnt->sense_buffer[2] == MEDIUM_ERROR) {
-			long error_sector = (SCpnt->sense_buffer[3] << 24) |
+	if (driver_byte(result) != 0 && 	/* An error occured */
+	    SCpnt->sense_buffer[0] != 0xF0) {	/* Sense data is valid */
+		switch (SCpnt->sense_buffer[2]) {
+		case MEDIUM_ERROR:
+			error_sector = (SCpnt->sense_buffer[3] << 24) |
 			(SCpnt->sense_buffer[4] << 16) |
 			(SCpnt->sense_buffer[5] << 8) |
 			SCpnt->sense_buffer[6];
@@ -640,13 +748,30 @@ static void rw_intr(Scsi_Cmnd * SCpnt)
 			good_sectors = error_sector - SCpnt->request.sector;
 			if (good_sectors < 0 || good_sectors >= this_count)
 				good_sectors = 0;
-		}
-		if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
+			break;
+
+		case RECOVERED_ERROR:
+			/*
+			 * An error occured, but it recovered.  Inform the
+			 * user, but make sure that it's not treated as a
+			 * hard error.
+			 */
+			print_sense("sd", SCpnt);
+			result = 0;
+			SCpnt->sense_buffer[0] = 0x0;
+			good_sectors = this_count;
+			break;
+
+		case ILLEGAL_REQUEST:
 			if (SCpnt->device->ten == 1) {
 				if (SCpnt->cmnd[0] == READ_10 ||
 				    SCpnt->cmnd[0] == WRITE_10)
 					SCpnt->device->ten = 0;
 			}
+			break;
+
+		default:
+			break;
 		}
 	}
 	/*
@@ -656,28 +781,33 @@ static void rw_intr(Scsi_Cmnd * SCpnt)
 	 */
 	scsi_io_completion(SCpnt, good_sectors, block_sectors);
 }
-/*
- * requeue_sd_request() is the request handler function for the sd driver.
- * Its function in life is to take block device requests, and translate
- * them to SCSI commands.
- */
-
 
+/**
+ *	check_scsidisk_media_change - self descriptive
+ *	@full_dev: kernel device descriptor (kdev_t)
+ *
+ *	Returns 0 if not applicable or no change; 1 if change
+ *
+ *	Note: this function is invoked from the block subsystem.
+ **/
 static int check_scsidisk_media_change(kdev_t full_dev)
 {
 	int retval;
-	int target;
-	int flag = 0;
-	Scsi_Device * SDev;
-
-	target = DEVICE_NR(full_dev);
-	SDev = rscsi_disks[target].device;
-
-	if (target >= sd_template.dev_max || !SDev) {
-		printk("SCSI disk request error: invalid device.\n");
+	int flag = 0;	/* <<<< what is this for?? */
+	Scsi_Disk * sdkp;
+	Scsi_Device * sdp;
+	int dsk_nr = DEVICE_NR(full_dev);
+
+	sdkp = sd_get_sdisk(dsk_nr);
+
+	SCSI_LOG_HLQUEUE(3, printk("check_scsidisk_media_change: "
+			    "dsk_nr=%d\n", dsk_nr));
+	if ((NULL == sdkp) || (NULL == (sdp = sdkp->device))) {
+		printk(KERN_ERR "check_scsidisk_media_change: dsk_nr=%d, "
+		       "invalid device\n", dsk_nr);
 		return 0;
 	}
-	if (!SDev->removable)
+	if (!sdp->removable)
 		return 0;
 
 	/*
@@ -686,9 +816,9 @@ static int check_scsidisk_media_change(kdev_t full_dev)
 	 * can deal with it then.  It is only because of unrecoverable errors
 	 * that we would ever take a device offline in the first place.
 	 */
-	if (SDev->online == FALSE) {
-		rscsi_disks[target].ready = 0;
-		SDev->changed = 1;
+	if (sdp->online == FALSE) {
+		sdkp->ready = 0;
+		sdp->changed = 1;
 		return 1;	/* This will force a flush, if called from
 				 * check_disk_change */
 	}
@@ -700,8 +830,8 @@ static int check_scsidisk_media_change(kdev_t full_dev)
 	 * as this will spin up the drive.
 	 */
 	retval = -ENODEV;
-	if (scsi_block_when_processing_errors(SDev))
-		retval = scsi_ioctl(SDev, SCSI_IOCTL_START_UNIT, NULL);
+	if (scsi_block_when_processing_errors(sdp))
+		retval = scsi_ioctl(sdp, SCSI_IOCTL_START_UNIT, NULL);
 
 	if (retval) {		/* Unable to test, unit probably not ready.
 				 * This usually means there is no disc in the
@@ -709,8 +839,8 @@ static int check_scsidisk_media_change(kdev_t full_dev)
 				 * it out later once the drive is available
 				 * again.  */
 
-		rscsi_disks[target].ready = 0;
-		SDev->changed = 1;
+		sdkp->ready = 0;
+		sdp->changed = 1;
 		return 1;	/* This will force a flush, if called from
 				 * check_disk_change */
 	}
@@ -720,15 +850,26 @@ static int check_scsidisk_media_change(kdev_t full_dev)
 	 * struct and tested at open !  Daniel Roche ( dan@lectra.fr )
 	 */
 
-	rscsi_disks[target].ready = 1;	/* FLOPTICAL */
+	sdkp->ready = 1;	/* FLOPTICAL */
 
-	retval = SDev->changed;
+	retval = sdp->changed;
 	if (!flag)
-		SDev->changed = 0;
+		sdp->changed = 0;
 	return retval;
 }
 
-static int sd_init_onedisk(int i)
+/**
+ *	sd_init_onedisk - called the first time a new disk is seen,
+ *	performs read_capacity, disk spin up (as required), etc.
+ *	@sdkp: pointer to associated Scsi_Disk object
+ *	@dsk_nr: disk number within this driver (e.g. 0->/dev/sda,
+ *	1->/dev/sdb, etc)
+ *
+ *	Returns dsk_nr (pointless)
+ *
+ *	Note: this function is local to this driver.
+ **/
+static int sd_init_onedisk(Scsi_Disk * sdkp, int dsk_nr)
 {
 	unsigned char cmd[10];
 	char nbuff[6];
@@ -736,19 +877,23 @@ static int sd_init_onedisk(int i)
 	unsigned long spintime_value = 0;
 	int the_result, retries, spintime;
 	int sector_size;
+	Scsi_Device *sdp;
 	Scsi_Request *SRpnt;
 
+	SCSI_LOG_HLQUEUE(3, printk("sd_init_onedisk: dsk_nr=%d\n", 
+			    dsk_nr));
 	/*
 	 * Get the name of the disk, in case we need to log it somewhere.
 	 */
-	sd_devname(i, nbuff);
+	sd_dskname(dsk_nr, nbuff);
 
 	/*
 	 * If the device is offline, don't try and read capacity or any
 	 * of the other niceties.
 	 */
-	if (rscsi_disks[i].device->online == FALSE)
-		return i;
+	sdp = sdkp->device;
+	if (sdp->online == FALSE)
+		return dsk_nr;
 
 	/*
 	 * We need to retry the READ_CAPACITY because a UNIT_ATTENTION is
@@ -756,17 +901,19 @@ static int sd_init_onedisk(int i)
 	 * just after a scsi bus reset.
 	 */
 
-	SRpnt = scsi_allocate_request(rscsi_disks[i].device);
+	SRpnt = scsi_allocate_request(sdp);
 	if (!SRpnt) {
-		printk(KERN_WARNING "(sd_init_onedisk:) Request allocation failure.\n");
-		return i;
+		printk(KERN_WARNING "(sd_init_onedisk:) Request allocation "
+		       "failure.\n");
+		return dsk_nr;
 	}
 
 	buffer = kmalloc(512, GFP_DMA);
 	if (!buffer) {
-		printk(KERN_WARNING "(sd_init_onedisk:) Memory allocation failure.\n");
+		printk(KERN_WARNING "(sd_init_onedisk:) Memory allocation "
+		       "failure.\n");
 		scsi_release_request(SRpnt);
-		return i;
+		return dsk_nr;
 	}
 
 	spintime = 0;
@@ -778,8 +925,8 @@ static int sd_init_onedisk(int i)
 
 		while (retries < 3) {
 			cmd[0] = TEST_UNIT_READY;
-			cmd[1] = (rscsi_disks[i].device->scsi_level <= SCSI_2) ?
-				 ((rscsi_disks[i].device->lun << 5) & 0xe0) : 0;
+			cmd[1] = (sdp->scsi_level <= SCSI_2) ?
+				 ((sdp->lun << 5) & 0xe0) : 0;
 			memset((void *) &cmd[2], 0, 8);
 			SRpnt->sr_cmd_len = 0;
 			SRpnt->sr_sense_buffer[0] = 0;
@@ -805,23 +952,24 @@ static int sd_init_onedisk(int i)
 		    && ((driver_byte(the_result) & DRIVER_SENSE) != 0)
 		    && SRpnt->sr_sense_buffer[2] == UNIT_ATTENTION
 		    && SRpnt->sr_sense_buffer[12] == 0x3A ) {
-			rscsi_disks[i].capacity = 0x1fffff;
+			sdkp->capacity = 0x1fffff;
 			sector_size = 512;
-			rscsi_disks[i].device->changed = 1;
-			rscsi_disks[i].ready = 0;
+			sdp->changed = 1;
+			sdkp->ready = 0;
 			break;
 		}
 
 		/* Look for non-removable devices that return NOT_READY.
 		 * Issue command to spin up drive for these cases. */
-		if (the_result && !rscsi_disks[i].device->removable &&
+		if (the_result && !sdp->removable &&
 		    SRpnt->sr_sense_buffer[2] == NOT_READY) {
 			unsigned long time1;
 			if (!spintime) {
-				printk("%s: Spinning up disk...", nbuff);
+				printk(KERN_NOTICE "%s: Spinning up disk...",
+				       nbuff);
 				cmd[0] = START_STOP;
-				cmd[1] = (rscsi_disks[i].device->scsi_level <= SCSI_2) ?
-				 	 ((rscsi_disks[i].device->lun << 5) & 0xe0) : 0;
+				cmd[1] = (sdp->scsi_level <= SCSI_2) ?
+				 	 ((sdp->lun << 5) & 0xe0) : 0;
 				cmd[1] |= 1;	/* Return immediately */
 				memset((void *) &cmd[2], 0, 8);
 				cmd[4] = 1;	/* Start spin cycle */
@@ -830,8 +978,9 @@ static int sd_init_onedisk(int i)
 				SRpnt->sr_sense_buffer[2] = 0;
 
 				SRpnt->sr_data_direction = SCSI_DATA_READ;
-				scsi_wait_req(SRpnt, (void *) cmd, (void *) buffer,
-					    0/*512*/, SD_TIMEOUT, MAX_RETRIES);
+				scsi_wait_req(SRpnt, (void *)cmd, 
+					      (void *) buffer, 0/*512*/, 
+					      SD_TIMEOUT, MAX_RETRIES);
 				spintime_value = jiffies;
 			}
 			spintime = 1;
@@ -854,8 +1003,8 @@ static int sd_init_onedisk(int i)
 	retries = 3;
 	do {
 		cmd[0] = READ_CAPACITY;
-		cmd[1] = (rscsi_disks[i].device->scsi_level <= SCSI_2) ?
-			 ((rscsi_disks[i].device->lun << 5) & 0xe0) : 0;
+		cmd[1] = (sdp->scsi_level <= SCSI_2) ?
+			 ((sdp->lun << 5) & 0xe0) : 0;
 		memset((void *) &cmd[2], 0, 8);
 		memset((void *) buffer, 0, 8);
 		SRpnt->sr_cmd_len = 0;
@@ -887,8 +1036,8 @@ static int sd_init_onedisk(int i)
 	 */
 
 	if (the_result) {
-		printk("%s : READ CAPACITY failed.\n"
-		       "%s : status = %x, message = %02x, host = %d, driver = %02x \n",
+		printk(KERN_NOTICE "%s : READ CAPACITY failed.\n"
+		       "%s : status=%x, message=%02x, host=%d, driver=%02x \n",
 		       nbuff, nbuff,
 		       status_byte(the_result),
 		       msg_byte(the_result),
@@ -900,50 +1049,50 @@ static int sd_init_onedisk(int i)
 		else
 			printk("%s : sense not available. \n", nbuff);
 
-		printk("%s : block size assumed to be 512 bytes, disk size 1GB.  \n",
-		       nbuff);
-		rscsi_disks[i].capacity = 0x1fffff;
+		printk(KERN_NOTICE "%s : block size assumed to be 512 "
+		       "bytes, disk size 1GB.  \n", nbuff);
+		sdkp->capacity = 0x1fffff;
 		sector_size = 512;
 
 		/* Set dirty bit for removable devices if not ready -
 		 * sometimes drives will not report this properly. */
-		if (rscsi_disks[i].device->removable &&
+		if (sdp->removable &&
 		    SRpnt->sr_sense_buffer[2] == NOT_READY)
-			rscsi_disks[i].device->changed = 1;
+			sdp->changed = 1;
 
 	} else {
 		/*
 		 * FLOPTICAL, if read_capa is ok, drive is assumed to be ready
 		 */
-		rscsi_disks[i].ready = 1;
+		sdkp->ready = 1;
 
-		rscsi_disks[i].capacity = 1 + ((buffer[0] << 24) |
-					       (buffer[1] << 16) |
-					       (buffer[2] << 8) |
-					       buffer[3]);
+		sdkp->capacity = 1 + ((buffer[0] << 24) |
+				      (buffer[1] << 16) |
+				      (buffer[2] << 8) |
+				      buffer[3]);
 
 		sector_size = (buffer[4] << 24) |
 		    (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
 
 		if (sector_size == 0) {
 			sector_size = 512;
-			printk("%s : sector size 0 reported, assuming 512.\n",
-			       nbuff);
+			printk(KERN_NOTICE "%s : sector size 0 reported, "
+			       "assuming 512.\n", nbuff);
 		}
 		if (sector_size != 512 &&
 		    sector_size != 1024 &&
 		    sector_size != 2048 &&
 		    sector_size != 4096 &&
 		    sector_size != 256) {
-			printk("%s : unsupported sector size %d.\n",
-			       nbuff, sector_size);
+			printk(KERN_NOTICE "%s : unsupported sector size "
+			       "%d.\n", nbuff, sector_size);
 			/*
 			 * The user might want to re-format the drive with
 			 * a supported sectorsize.  Once this happens, it
 			 * would be relatively trivial to set the thing up.
 			 * For this reason, we leave the thing in the table.
 			 */
-			rscsi_disks[i].capacity = 0;
+			sdkp->capacity = 0;
 		}
 		{
 			/*
@@ -952,33 +1101,33 @@ static int sd_init_onedisk(int i)
 			 * Jacques Gelinas (Jacques@solucorp.qc.ca)
 			 */
 			int hard_sector = sector_size;
-			int sz = rscsi_disks[i].capacity * (hard_sector/256);
-			request_queue_t *queue = &rscsi_disks[i].device->request_queue;
+			int sz = sdkp->capacity * (hard_sector/256);
+			request_queue_t *queue = &sdp->request_queue;
 
 			blk_queue_hardsect_size(queue, hard_sector);
-			printk("SCSI device %s: "
+			printk(KERN_NOTICE "SCSI device %s: "
 			       "%d %d-byte hdwr sectors (%d MB)\n",
-			       nbuff, rscsi_disks[i].capacity,
+			       nbuff, sdkp->capacity,
 			       hard_sector, (sz/2 - sz/1250 + 974)/1950);
 		}
 
 		/* Rescale capacity to 512-byte units */
 		if (sector_size == 4096)
-			rscsi_disks[i].capacity <<= 3;
+			sdkp->capacity <<= 3;
 		if (sector_size == 2048)
-			rscsi_disks[i].capacity <<= 2;
+			sdkp->capacity <<= 2;
 		if (sector_size == 1024)
-			rscsi_disks[i].capacity <<= 1;
+			sdkp->capacity <<= 1;
 		if (sector_size == 256)
-			rscsi_disks[i].capacity >>= 1;
+			sdkp->capacity >>= 1;
 	}
 
 
 	/*
 	 * Unless otherwise specified, this is not write protected.
 	 */
-	rscsi_disks[i].write_prot = 0;
-	if (rscsi_disks[i].device->removable && rscsi_disks[i].ready) {
+	sdkp->write_prot = 0;
+	if (sdp->removable && sdkp->ready) {
 		/* FLOPTICAL */
 
 		/*
@@ -996,8 +1145,8 @@ static int sd_init_onedisk(int i)
 
 		memset((void *) &cmd[0], 0, 8);
 		cmd[0] = MODE_SENSE;
-		cmd[1] = (rscsi_disks[i].device->scsi_level <= SCSI_2) ?
-			 ((rscsi_disks[i].device->lun << 5) & 0xe0) : 0;
+		cmd[1] = (sdp->scsi_level <= SCSI_2) ?
+			 ((sdp->lun << 5) & 0xe0) : 0;
 		cmd[2] = 0x3f;	/* Get all pages */
 		cmd[4] = 255;   /* Ask for 255 bytes, even tho we want just the first 8 */
 		SRpnt->sr_cmd_len = 0;
@@ -1012,11 +1161,12 @@ static int sd_init_onedisk(int i)
 		the_result = SRpnt->sr_result;
 
 		if (the_result) {
-			printk("%s: test WP failed, assume Write Enabled\n", nbuff);
+			printk(KERN_NOTICE "%s: test WP failed, assume "
+			       "Write Enabled\n", nbuff);
 		} else {
-			rscsi_disks[i].write_prot = ((buffer[2] & 0x80) != 0);
-			printk("%s: Write Protect is %s\n", nbuff,
-			       rscsi_disks[i].write_prot ? "on" : "off");
+			sdkp->write_prot = ((buffer[2] & 0x80) != 0);
+			printk(KERN_NOTICE "%s: Write Protect is %s\n", nbuff,
+			       sdkp->write_prot ? "on" : "off");
 		}
 
 	}			/* check for write protect */
@@ -1028,7 +1178,7 @@ static int sd_init_onedisk(int i)
 	SRpnt = NULL;
 
 	kfree(buffer);
-	return i;
+	return dsk_nr;
 }
 
 /*
@@ -1038,14 +1188,25 @@ static int sd_init_onedisk(int i)
 
 static int sd_registered;
 
+/**
+ *	sd_init- called during driver initialization (after
+ *	sd_detect() is called for each scsi device present).
+ *
+ *	Returns 0 is successful (or already called); 1 if error
+ *
+ *	Note: this function is invoked from the scsi mid-level.
+ **/
 static int sd_init()
 {
-	int i, maxparts;
+	int k, maxparts;
+	Scsi_Disk * sdkp;
 
+	SCSI_LOG_HLQUEUE(3, printk("sd_init: dev_noticed=%d\n",
+			    sd_template.dev_noticed));
 	if (sd_template.dev_noticed == 0)
 		return 0;
 
-	if (!rscsi_disks)
+	if (NULL == sd_dsk_arr)
 		sd_template.dev_max = sd_template.dev_noticed + SD_EXTRA_DEVS;
 
 	if (sd_template.dev_max > N_SD_MAJORS * SCSI_DISKS_PER_MAJOR)
@@ -1057,71 +1218,80 @@ static int sd_init()
 		return 0;
 
 	if (!sd_registered) {
-		for (i = 0; i < N_USED_SD_MAJORS; i++) {
-			if (devfs_register_blkdev(SD_MAJOR(i), "sd",
+		for (k = 0; k < N_USED_SD_MAJORS; k++) {
+			if (devfs_register_blkdev(SD_MAJOR(k), "sd",
 						  &sd_fops)) {
-				printk("Unable to get major %d for SCSI disk\n",
-				       SD_MAJOR(i));
+				printk(KERN_NOTICE "Unable to get major %d "
+				       "for SCSI disk\n", SD_MAJOR(k));
 				return 1;
 			}
 		}
 		sd_registered++;
 	}
 	/* We do not support attaching loadable devices yet. */
-	if (rscsi_disks)
+	if (sd_dsk_arr)
 		return 0;
 
 	/* allocate memory */
-#define init_mem_lth(x,n)	x = kmalloc((n) * sizeof(*x), GFP_ATOMIC)
+#define init_mem_lth(x,n)	x = vmalloc((n) * sizeof(*x))
 #define zero_mem_lth(x,n)	memset(x, 0, (n) * sizeof(*x))
 
-	init_mem_lth(rscsi_disks, sd_template.dev_max);
+	init_mem_lth(sd_dsk_arr, sd_template.dev_max);
+	if (sd_dsk_arr) {
+		zero_mem_lth(sd_dsk_arr, sd_template.dev_max);
+		for (k = 0; k < sd_template.dev_max; ++k) {
+			sdkp = vmalloc(sizeof(Scsi_Disk));
+			if (NULL == sdkp)
+				goto cleanup_mem;
+			memset(sdkp, 0, sizeof(Scsi_Disk));
+			sd_dsk_arr[k] = sdkp;
+		}
+	}
 	init_mem_lth(sd_sizes, maxparts);
 	init_mem_lth(sd, maxparts);
 	init_mem_lth(sd_gendisks, N_USED_SD_MAJORS);
 	init_mem_lth(sd_max_sectors, sd_template.dev_max << 4);
 
-	if (!rscsi_disks || !sd_sizes || !sd || !sd_gendisks)
+	if (!sd_dsk_arr || !sd_sizes || !sd || !sd_gendisks)
 		goto cleanup_mem;
 
-	zero_mem_lth(rscsi_disks, sd_template.dev_max);
 	zero_mem_lth(sd_sizes, maxparts);
 	zero_mem_lth(sd, maxparts);
 
-	for (i = 0; i < maxparts; i++) {
+	for (k = 0; k < maxparts; k++) {
 		/*
 		 * Allow lowlevel device drivers to generate 512k large scsi
 		 * commands if they know what they're doing and they ask for it
 		 * explicitly via the SHpnt->max_sectors API.
 		 */
-		sd_max_sectors[i] = MAX_PHYS_SEGMENTS*8;
+		sd_max_sectors[k] = MAX_PHYS_SEGMENTS*8;
 	}
 
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
-		request_queue_t *q = blk_get_queue(mk_kdev(SD_MAJOR(i), 0));
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
+		request_queue_t *q = blk_get_queue(mk_kdev(SD_MAJOR(k), 0));
 		blk_queue_hardsect_size(q, 512);
  	}
 
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
 		int N = SCSI_DISKS_PER_MAJOR;
 
-		sd_gendisks[i] = sd_gendisk;
+		sd_gendisks[k] = sd_gendisk;
 
-		init_mem_lth(sd_gendisks[i].de_arr, N);
-		init_mem_lth(sd_gendisks[i].flags, N);
+		init_mem_lth(sd_gendisks[k].de_arr, N);
+		init_mem_lth(sd_gendisks[k].flags, N);
 
-		if (!sd_gendisks[i].de_arr || !sd_gendisks[i].flags)
+		if (!sd_gendisks[k].de_arr || !sd_gendisks[k].flags)
 			goto cleanup_gendisks;
 
-		zero_mem_lth(sd_gendisks[i].de_arr, N);
-		zero_mem_lth(sd_gendisks[i].flags, N);
+		zero_mem_lth(sd_gendisks[k].de_arr, N);
+		zero_mem_lth(sd_gendisks[k].flags, N);
 
-		sd_gendisks[i].major = SD_MAJOR(i);
-		sd_gendisks[i].major_name = "sd";
-		sd_gendisks[i].minor_shift = 4;
-		sd_gendisks[i].part = sd + i * (N << 4);
-		sd_gendisks[i].sizes = sd_sizes + i * (N << 4);
-		sd_gendisks[i].nr_real = 0;
+		sd_gendisks[k].major = SD_MAJOR(k);
+		sd_gendisks[k].major_name = "sd";
+		sd_gendisks[k].minor_shift = 4;
+		sd_gendisks[k].part = sd + k * (N << 4);
+		sd_gendisks[k].sizes = sd_sizes + k * (N << 4);
+		sd_gendisks[k].nr_real = 0;
 	}
 
 	return 0;
@@ -1130,129 +1300,197 @@ static int sd_init()
 #undef zero_mem_lth
 
 cleanup_gendisks:
-	/* kfree can handle NULL, so no test is required here */
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
-		kfree(sd_gendisks[i].de_arr);
-		kfree(sd_gendisks[i].flags);
+	/* vfree can handle NULL, so no test is required here */
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
+		vfree(sd_gendisks[k].de_arr);
+		vfree(sd_gendisks[k].flags);
 	}
 cleanup_mem:
-	kfree(sd_gendisks);
-	kfree(sd);
-	kfree(sd_sizes);
-	kfree(rscsi_disks);
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
-		devfs_unregister_blkdev(SD_MAJOR(i), "sd");
+	if (sd_gendisks) vfree(sd_gendisks);
+	sd_gendisks = NULL;
+	if (sd) vfree(sd);
+	sd = NULL;
+	sd_blocksizes = NULL;
+	if (sd_sizes) vfree(sd_sizes);
+	sd_sizes = NULL;
+	if (sd_dsk_arr) {
+                for (k = 0; k < sd_template.dev_max; ++k) {
+			sdkp = sd_dsk_arr[k];
+			if (sdkp)
+				vfree(sdkp);
+		}
+		vfree(sd_dsk_arr);
+		sd_dsk_arr = NULL;
+	}
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
+		devfs_unregister_blkdev(SD_MAJOR(k), "sd");
 	}
 	sd_registered--;
 	return 1;
 }
 
-
+/**
+ *	sd_finish- called during driver initialization, after all
+ *	the sd_attach() calls are finished.
+ *
+ *	Note: this function is invoked from the scsi mid-level.
+ *	This function is not called after driver initialization has completed.
+ *	Specifically later device attachments invoke sd_attach() but not
+ *	this function.
+ **/
 static void sd_finish()
 {
-	int i;
+	int k;
+	Scsi_Disk * sdkp;
 
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
-		blk_dev[SD_MAJOR(i)].queue = sd_find_queue;
-		add_gendisk(&(sd_gendisks[i]));
+	SCSI_LOG_HLQUEUE(3, printk("sd_finish: \n"));
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
+		blk_dev[SD_MAJOR(k)].queue = sd_find_queue;
+		add_gendisk(&(sd_gendisks[k]));
 	}
 
-	for (i = 0; i < sd_template.dev_max; ++i)
-		if (!rscsi_disks[i].capacity && rscsi_disks[i].device) {
-			sd_init_onedisk(i);
-			if (!rscsi_disks[i].has_part_table) {
-				sd_sizes[i << 4] = rscsi_disks[i].capacity;
-				register_disk(&SD_GENDISK(i), MKDEV_SD(i),
+	for (k = 0; k < sd_template.dev_max; ++k) {
+		sdkp = sd_get_sdisk(k);
+		if (sdkp && (0 == sdkp->capacity) && sdkp->device) {
+			sd_init_onedisk(sdkp, k);
+			if (!sdkp->has_part_table) {
+				sd_sizes[k << 4] = sdkp->capacity;
+				register_disk(&SD_GENDISK(k), MKDEV_SD(k),
 						1<<4, &sd_fops,
-						rscsi_disks[i].capacity);
-				rscsi_disks[i].has_part_table = 1;
+						sdkp->capacity);
+				sdkp->has_part_table = 1;
 			}
 		}
-
+	}
 	return;
 }
 
-static int sd_detect(Scsi_Device * SDp)
+/**
+ *	sd_detect- called at the start of driver initialization, once 
+ *	for each scsi device (not just disks) present.
+ *
+ *	Returns 0 if not interested in this scsi device (e.g. scanner);
+ *	1 if this device is of interest (e.g. a disk).
+ *
+ *	Note: this function is invoked from the scsi mid-level.
+ *	This function is called before sd_init() so very little is available.
+ **/
+static int sd_detect(Scsi_Device * sdp)
 {
-	if (SDp->type != TYPE_DISK && SDp->type != TYPE_MOD)
+	SCSI_LOG_HLQUEUE(3, printk("sd_detect: type=%d\n", sdp->type));
+	if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD)
 		return 0;
 	sd_template.dev_noticed++;
 	return 1;
 }
 
-static int sd_attach(Scsi_Device * SDp)
+/**
+ *	sd_attach- called during driver initialization and whenever a
+ *	new scsi device is attached to the system. It is called once
+ *	for each scsi device (not just disks) present.
+ *	@sdp: pointer to mid level scsi device object
+ *
+ *	Returns 0 if successful (or not interested in this scsi device 
+ *	(e.g. scanner)); 1 when there is an error.
+ *
+ *	Note: this function is invoked from the scsi mid-level.
+ *	This function sets up the mapping between a given 
+ *	<host,channel,id,lun> (found in sdp) and new device name 
+ *	(e.g. /dev/sda). More precisely it is the block device major 
+ *	and minor number that is chosen here.
+ **/
+static int sd_attach(Scsi_Device * sdp)
 {
         unsigned int devnum;
-	Scsi_Disk *dpnt;
-	int i;
+	Scsi_Disk *sdkp;
+	int dsk_nr;
 	char nbuff[6];
+	unsigned long iflags;
 
-	if (SDp->type != TYPE_DISK && SDp->type != TYPE_MOD)
+	if ((NULL == sdp) ||
+	    ((sdp->type != TYPE_DISK) && (sdp->type != TYPE_MOD)))
 		return 0;
 
+	SCSI_LOG_HLQUEUE(3, printk("sd_attach: scsi device: <%d,%d,%d,%d>\n", 
+			 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun));
 	if (sd_template.nr_dev >= sd_template.dev_max) {
-		SDp->attached--;
+		sdp->attached--;
+		printk(KERN_ERR "sd_init: no more room for device\n");
 		return 1;
 	}
-	for (dpnt = rscsi_disks, i = 0; i < sd_template.dev_max; i++, dpnt++)
-		if (!dpnt->device)
+
+/* Assume sd_attach is not re-entrant (for time being) */
+/* Also think about sd_attach() and sd_detach() running coincidentally. */
+	write_lock_irqsave(&sd_dsk_arr_lock, iflags);
+	for (dsk_nr = 0; dsk_nr < sd_template.dev_max; dsk_nr++) {
+		sdkp = sd_dsk_arr[dsk_nr];
+		if (!sdkp->device) {
+			sdkp->device = sdp;
+			sdkp->has_part_table = 0;
 			break;
+		}
+	}
+	write_unlock_irqrestore(&sd_dsk_arr_lock, iflags);
 
-	if (i >= sd_template.dev_max)
-		panic("scsi_devices corrupt (sd)");
+	if (dsk_nr >= sd_template.dev_max) {
+		/* panic("scsi_devices corrupt (sd)");  overkill */
+		printk(KERN_ERR "sd_init: sd_dsk_arr corrupted\n");
+		return 1;
+	}
 
-	rscsi_disks[i].device = SDp;
-	rscsi_disks[i].has_part_table = 0;
 	sd_template.nr_dev++;
-	SD_GENDISK(i).nr_real++;
-        devnum = i % SCSI_DISKS_PER_MAJOR;
-        SD_GENDISK(i).de_arr[devnum] = SDp->de;
-        if (SDp->removable)
-		SD_GENDISK(i).flags[devnum] |= GENHD_FL_REMOVABLE;
-	sd_devname(i, nbuff);
-	printk("Attached scsi %sdisk %s at scsi%d, channel %d, id %d, lun %d\n",
-	       SDp->removable ? "removable " : "",
-	       nbuff, SDp->host->host_no, SDp->channel, SDp->id, SDp->lun);
+	SD_GENDISK(dsk_nr).nr_real++;
+        devnum = dsk_nr % SCSI_DISKS_PER_MAJOR;
+        SD_GENDISK(dsk_nr).de_arr[devnum] = sdp->de;
+        if (sdp->removable)
+		SD_GENDISK(dsk_nr).flags[devnum] |= GENHD_FL_REMOVABLE;
+	sd_dskname(dsk_nr, nbuff);
+	printk(KERN_NOTICE "Attached scsi %sdisk %s at scsi%d, channel %d, "
+	       "id %d, lun %d\n", sdp->removable ? "removable " : "",
+	       nbuff, sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
 	return 0;
 }
 
-#define DEVICE_BUSY rscsi_disks[target].device->busy
-#define ALLOW_REVALIDATE rscsi_disks[target].device->allow_revalidate
-#define USAGE rscsi_disks[target].device->access_count
-#define CAPACITY rscsi_disks[target].capacity
-#define MAYBE_REINIT  sd_init_onedisk(target)
-
-/* This routine is called to flush all partitions and partition tables
- * for a changed scsi disk, and then re-read the new partition table.
- * If we are revalidating a disk because of a media change, then we
- * enter with usage == 0.  If we are using an ioctl, we automatically have
- * usage == 1 (we need an open channel to use an ioctl :-), so this
- * is our limit.
+/**
+ *	revalidate_scsidisk- called to flush all partitions and partition 
+ *	tables for a changed scsi disk. sd_init_onedisk() is then called
+ *	followed by re-reading the new partition table.
+ *      @dev: kernel device descriptor (kdev_t)
+ *      @maxusage: 0 when called from block level, 1 when called from
+ *      sd_ioctl().
+ *
+ *	Returns 0 if successful; negated errno value otherwise.
  */
 int revalidate_scsidisk(kdev_t dev, int maxusage)
 {
-	int target;
+	int dsk_nr = DEVICE_NR(dev);
 	int res;
+	Scsi_Disk * sdkp;
+	Scsi_Device * sdp;
 
-	target = DEVICE_NR(dev);
+	 SCSI_LOG_HLQUEUE(3, printk("revalidate_scsidisk: dsk_nr=%d\n", 
+			     DEVICE_NR(dev)));
+	sdkp = sd_get_sdisk(dsk_nr);
+	if ((NULL == sdkp) || (NULL == (sdp = sdkp->device)))
+		return -ENODEV;
 
-	if (DEVICE_BUSY || (ALLOW_REVALIDATE == 0 && USAGE > maxusage)) {
-		printk("Device busy for revalidation (usage=%d)\n", USAGE);
+	if (sdp->busy || ((sdp->allow_revalidate == 0) && 
+			  (sdp->access_count > maxusage))) {
+		printk(KERN_WARNING "Device busy for revalidation "
+		       "(access_count=%d)\n", sdp->access_count);
 		return -EBUSY;
 	}
-	DEVICE_BUSY = 1;
+	sdp->busy = 1;
 
 	res = wipe_partitions(dev);
 	if (res)
 		goto leave;
 
-#ifdef MAYBE_REINIT
-	MAYBE_REINIT;
-#endif
+	sd_init_onedisk(sdkp, dsk_nr);
 
-	grok_partitions(dev, CAPACITY);
+	grok_partitions(dev, sdkp->capacity);
 leave:
-	DEVICE_BUSY = 0;
+	sdp->busy = 0;
 	return res;
 }
 
@@ -1260,68 +1498,125 @@ static int fop_revalidate_scsidisk(kdev_t dev)
 {
 	return revalidate_scsidisk(dev, 0);
 }
-static void sd_detach(Scsi_Device * SDp)
+
+/**
+ *	sd_detach- called whenever a scsi disk (previously recognized by
+ *	sd_attach) is detached from the system. It is called (potentially
+ *	multiple times) during sd module unload.
+ *	@sdp: pointer to mid level scsi device object
+ *
+ *	Note: this function is invoked from the scsi mid-level.
+ *	This function potentially frees up a device name (e.g. /dev/sdc)
+ *	that could be re-used by a subsequent sd_attach().
+ *	This function is not called when the built-in sd driver is "exit-ed".
+ **/
+static void sd_detach(Scsi_Device * sdp)
 {
-	Scsi_Disk *dpnt;
+	Scsi_Disk *sdkp = NULL;
 	kdev_t dev;
-	int i, j;
+	int dsk_nr, j;
 	int max_p;
 	int start;
-
-	for (dpnt = rscsi_disks, i = 0; i < sd_template.dev_max; i++, dpnt++)
-		if (dpnt->device == SDp) {
-
-			max_p = 1 << sd_gendisk.minor_shift;
-			start = i << sd_gendisk.minor_shift;
-			dev = MKDEV_SD_PARTITION(start);
-			wipe_partitions(dev);
-			for (j = max_p - 1; j >= 0; j--)
-				sd_sizes[start + j] = 0;
-
-                        devfs_register_partitions (&SD_GENDISK (i),
-                                                   SD_MINOR_NUMBER (start), 1);
-			/* unregister_disk() */
-			dpnt->has_part_table = 0;
-			dpnt->device = NULL;
-			dpnt->capacity = 0;
-			SDp->attached--;
-			sd_template.dev_noticed--;
-			sd_template.nr_dev--;
-			SD_GENDISK(i).nr_real--;
-			return;
+	unsigned long iflags;
+
+	SCSI_LOG_HLQUEUE(3, printk("sd_detach: <%d,%d,%d,%d>\n", 
+			    sdp->host->host_no, sdp->channel, sdp->id, 
+			    sdp->lun));
+	write_lock_irqsave(&sd_dsk_arr_lock, iflags);
+	for (dsk_nr = 0; dsk_nr < sd_template.dev_max; dsk_nr++) {
+		sdkp = sd_dsk_arr[dsk_nr];
+		if (sdkp->device == sdp) {
+			sdkp->has_part_table = 0;
+			sdkp->device = NULL;
+			sdkp->capacity = 0;
+			/* sdkp->detaching = 1; */
+			break;
 		}
+	}
+	write_unlock_irqrestore(&sd_dsk_arr_lock, iflags);
+	if (dsk_nr >= sd_template.dev_max)
+		return;
+
+	max_p = 1 << sd_gendisk.minor_shift;
+	start = dsk_nr << sd_gendisk.minor_shift;
+	dev = MKDEV_SD_PARTITION(start);
+	wipe_partitions(dev);
+	for (j = max_p - 1; j >= 0; j--)
+		sd_sizes[start + j] = 0;
+
+	devfs_register_partitions (&SD_GENDISK (dsk_nr),
+				   SD_MINOR_NUMBER (start), 1);
+	/* unregister_disk() */
+	sdp->attached--;
+	sd_template.dev_noticed--;
+	sd_template.nr_dev--;
+	SD_GENDISK(dsk_nr).nr_real--;
 }
 
+/**
+ *	init_sd- entry point for this driver (both when built in or when
+ *	a module).
+ *
+ *	Note: this function registers this driver with the scsi mid-level.
+ **/
 static int __init init_sd(void)
 {
+	SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
 	sd_template.module = THIS_MODULE;
 	return scsi_register_device(&sd_template);
 }
 
+/**
+ *	exit_sd- exit point for this driver (when it is	a module).
+ *
+ *	Note: this function unregisters this driver from the scsi mid-level.
+ **/
 static void __exit exit_sd(void)
 {
-	int i;
+	int k;
+	Scsi_Disk * sdkp;
 
+	SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
 	scsi_unregister_device(&sd_template);
-
-	for (i = 0; i < N_USED_SD_MAJORS; i++)
-		devfs_unregister_blkdev(SD_MAJOR(i), "sd");
+	for (k = 0; k < N_USED_SD_MAJORS; k++)
+		devfs_unregister_blkdev(SD_MAJOR(k), "sd");
 
 	sd_registered--;
-	if (rscsi_disks != NULL) {
-		kfree(rscsi_disks);
-		kfree(sd_sizes);
-		kfree((char *) sd);
+	if (sd_dsk_arr != NULL) {
+		for (k = 0; k < sd_template.dev_max; ++k) {
+			sdkp = sd_dsk_arr[k];
+			if (sdkp)
+				vfree(sdkp);
+		}
+		vfree(sd_dsk_arr);
 	}
-	for (i = 0; i < N_USED_SD_MAJORS; i++) {
-		del_gendisk(&(sd_gendisks[i]));
-		blk_clear(SD_MAJOR(i));
+	if (sd_sizes) vfree(sd_sizes);
+	if (sd) vfree((char *) sd);
+	for (k = 0; k < N_USED_SD_MAJORS; k++) {
+		blk_dev[SD_MAJOR(k)].queue = NULL;
+		del_gendisk(&(sd_gendisks[k]));
+		blk_clear(SD_MAJOR(k));
 	}
 	sd_template.dev_max = 0;
 	if (sd_gendisks != &sd_gendisk)
-		kfree(sd_gendisks);
+		vfree(sd_gendisks);
 }
 
+static Scsi_Disk * sd_get_sdisk(int index)
+{
+	Scsi_Disk * sdkp = NULL;
+	unsigned long iflags;
+
+	read_lock_irqsave(&sd_dsk_arr_lock, iflags);
+	if (sd_dsk_arr && (index >= 0) && (index < sd_template.dev_max))
+		sdkp = sd_dsk_arr[index];
+	read_unlock_irqrestore(&sd_dsk_arr_lock, iflags);
+	return sdkp;
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Eric Youngdale");
+MODULE_DESCRIPTION("SCSI disk (sd) driver");
+
 module_init(init_sd);
 module_exit(exit_sd);
-MODULE_LICENSE("GPL");