Merge branch 'for-2.6.36' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.36' of git://git.kernel.dk/linux-2.6-block: (149 commits)
  block: make sure that REQ_* types are seen even with CONFIG_BLOCK=n
  xen-blkfront: fix missing out label
  blkdev: fix blkdev_issue_zeroout return value
  block: update request stacking methods to support discards
  block: fix missing export of blk_types.h
  writeback: fix bad _bh spinlock nesting
  drbd: revert "delay probes", feature is being re-implemented differently
  drbd: Initialize all members of sync_conf to their defaults [Bugz 315]
  drbd: Disable delay probes for the upcomming release
  writeback: cleanup bdi_register
  writeback: add new tracepoints
  writeback: remove unnecessary init_timer call
  writeback: optimize periodic bdi thread wakeups
  writeback: prevent unnecessary bdi threads wakeups
  writeback: move bdi threads exiting logic to the forker thread
  writeback: restructure bdi forker loop a little
  writeback: move last_active to bdi
  writeback: do not remove bdi from bdi_list
  writeback: simplify bdi code a little
  writeback: do not lose wake-ups in bdi threads
  ...

Fixed up pretty trivial conflicts in drivers/block/virtio_blk.c and
drivers/scsi/scsi_error.c as per Jens.

10 files changed, 124 insertions, 94 deletions

diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index 2a8cf137f609..4f785f254c1f 100644
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
@@ -52,22 +52,6 @@
 #define SCSI_BUF_PA(address)    isa_virt_to_bus(address)
 #define SCSI_SG_PA(sgent)       (isa_page_to_bus(sg_page((sgent))) + (sgent)->offset)
 
-static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
-                       struct scatterlist *sgp,
-                       int nseg,
-                       int badseg)
-{
-        printk(KERN_CRIT "sgpnt[%d:%d] page %p/0x%llx length %u\n",
-               badseg, nseg, sg_virt(sgp),
-               (unsigned long long)SCSI_SG_PA(sgp),
-               sgp->length);
-
-        /*
-         * Not safe to continue.
-         */
-        panic("Buffer at physical address > 16Mb used for aha1542");
-}
-
 #include<linux/stat.h>
 
 #ifdef DEBUG
@@ -691,8 +675,6 @@ static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
                 }
                 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
-                        if (SCSI_SG_PA(sg) + sg->length - 1 > ISA_DMA_THRESHOLD)
-                                BAD_SG_DMA(SCpnt, scsi_sglist(SCpnt), sg_count, i);
                         any2scsi(cptr[i].datalen, sg->length);
                 };
                 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
@@ -1133,16 +1115,9 @@ static int __init aha1542_detect(struct scsi_host_template * tpnt)
                                 release_region(bases[indx], 4);
                                 continue;
                         }
-                        /* For now we do this - until kmalloc is more intelligent
-                           we are resigned to stupid hacks like this */
-                        if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
-                                printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
-                                goto unregister;
-                        }
                         if (!aha1542_test_port(bases[indx], shpnt))
                                 goto unregister;
 
-
                         base_io = bases[indx];
 
                         /* Set the Bus on/off-times as not to ruin floppy performance */
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index ee4b6914667f..fda4de3440c4 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -716,7 +716,7 @@ static int _osd_req_list_objects(struct osd_request *or,
                 return PTR_ERR(bio);
         }
 
-        bio->bi_rw &= ~(1 << BIO_RW);
+        bio->bi_rw &= ~REQ_WRITE;
         or->in.bio = bio;
         or->in.total_bytes = bio->bi_size;
         return 0;
@@ -814,7 +814,7 @@ void osd_req_write(struct osd_request *or,
 {
         _osd_req_encode_common(or, OSD_ACT_WRITE, obj, offset, len);
         WARN_ON(or->out.bio || or->out.total_bytes);
-        WARN_ON(0 ==  bio_rw_flagged(bio, BIO_RW));
+        WARN_ON(0 == (bio->bi_rw & REQ_WRITE));
         or->out.bio = bio;
         or->out.total_bytes = len;
 }
@@ -829,7 +829,7 @@ int osd_req_write_kern(struct osd_request *or,
         if (IS_ERR(bio))
                 return PTR_ERR(bio);
 
-        bio->bi_rw |= (1 << BIO_RW); /* FIXME: bio_set_dir() */
+        bio->bi_rw |= REQ_WRITE; /* FIXME: bio_set_dir() */
         osd_req_write(or, obj, offset, bio, len);
         return 0;
 }
@@ -865,7 +865,7 @@ void osd_req_read(struct osd_request *or,
 {
         _osd_req_encode_common(or, OSD_ACT_READ, obj, offset, len);
         WARN_ON(or->in.bio || or->in.total_bytes);
-        WARN_ON(1 == bio_rw_flagged(bio, BIO_RW));
+        WARN_ON(1 == (bio->bi_rw & REQ_WRITE));
         or->in.bio = bio;
         or->in.total_bytes = len;
 }
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 2bf98469dc4c..bbbc186dbc1a 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -320,7 +320,7 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
                                     "changed. The Linux SCSI layer does not "
                                     "automatically adjust these parameters.\n");
 
-                if (blk_barrier_rq(scmd->request))
+                if (scmd->request->cmd_flags & REQ_HARDBARRIER)
                         /*
                          * barrier requests should always retry on UA
                          * otherwise block will get a spurious error
@@ -1331,16 +1331,16 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
         case DID_OK:
                 break;
         case DID_BUS_BUSY:
-                return blk_failfast_transport(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
         case DID_PARITY:
-                return blk_failfast_dev(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
         case DID_ERROR:
                 if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
                     status_byte(scmd->result) == RESERVATION_CONFLICT)
                         return 0;
                 /* fall through */
         case DID_SOFT_ERROR:
-                return blk_failfast_driver(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
         }
 
         switch (status_byte(scmd->result)) {
@@ -1349,7 +1349,9 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
                  * assume caller has checked sense and determinted
                  * the check condition was retryable.
                  */
-                return blk_failfast_dev(scmd->request);
+                if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
+                    scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
+                        return 1;
         }
 
         return 0;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 1646fe7cbd4b..b8de389636f8 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -85,7 +85,7 @@ static void scsi_unprep_request(struct request *req)
 {
         struct scsi_cmnd *cmd = req->special;
 
-        req->cmd_flags &= ~REQ_DONTPREP;
+        blk_unprep_request(req);
         req->special = NULL;
 
         scsi_put_command(cmd);
@@ -722,7 +722,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         sense_deferred = scsi_sense_is_deferred(&sshdr);
         }
 
-        if (blk_pc_request(req)) { /* SG_IO ioctl from block level */
+        if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */
                 req->errors = result;
                 if (result) {
                         if (sense_valid && req->sense) {
@@ -757,7 +757,8 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                 }
         }
 
-        BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
+        /* no bidi support for !REQ_TYPE_BLOCK_PC yet */
+        BUG_ON(blk_bidi_rq(req));
 
         /*
          * Next deal with any sectors which we were able to correctly
@@ -1010,11 +1011,8 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 
 err_exit:
         scsi_release_buffers(cmd);
-        if (error == BLKPREP_KILL)
-                scsi_put_command(cmd);
-        else /* BLKPREP_DEFER */
-                scsi_unprep_request(cmd->request);
-
+        scsi_put_command(cmd);
+        cmd->request->special = NULL;
         return error;
 }
 EXPORT_SYMBOL(scsi_init_io);
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index cc8a1d1d915a..8e2e893db9e7 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -46,6 +46,7 @@
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/delay.h>
+#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/string_helpers.h>
 #include <linux/async.h>
@@ -411,54 +412,85 @@ static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
 }
 
 /**
- * sd_prepare_discard - unmap blocks on thinly provisioned device
+ * scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device
+ * @sdp: scsi device to operate one
  * @rq: Request to prepare
  *
  * Will issue either UNMAP or WRITE SAME(16) depending on preference
  * indicated by target device.
  **/
-static int sd_prepare_discard(struct request *rq)
+static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
 {
         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
         struct bio *bio = rq->bio;
         sector_t sector = bio->bi_sector;
-        unsigned int num = bio_sectors(bio);
+        unsigned int nr_sectors = bio_sectors(bio);
+        unsigned int len;
+        int ret;
+        struct page *page;
 
         if (sdkp->device->sector_size == 4096) {
                 sector >>= 3;
-                num >>= 3;
+                nr_sectors >>= 3;
         }
 
-        rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->timeout = SD_TIMEOUT;
 
         memset(rq->cmd, 0, rq->cmd_len);
 
+        page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
+        if (!page)
+                return BLKPREP_DEFER;
+
         if (sdkp->unmap) {
-                char *buf = kmap_atomic(bio_page(bio), KM_USER0);
+                char *buf = page_address(page);
 
+                rq->cmd_len = 10;
                 rq->cmd[0] = UNMAP;
                 rq->cmd[8] = 24;
-                rq->cmd_len = 10;
-
-                /* Ensure that data length matches payload */
-                rq->__data_len = bio->bi_size = bio->bi_io_vec->bv_len = 24;
 
                 put_unaligned_be16(6 + 16, &buf[0]);
                 put_unaligned_be16(16, &buf[2]);
                 put_unaligned_be64(sector, &buf[8]);
-                put_unaligned_be32(num, &buf[16]);
+                put_unaligned_be32(nr_sectors, &buf[16]);
 
-                kunmap_atomic(buf, KM_USER0);
+                len = 24;
         } else {
+                rq->cmd_len = 16;
                 rq->cmd[0] = WRITE_SAME_16;
                 rq->cmd[1] = 0x8; /* UNMAP */
                 put_unaligned_be64(sector, &rq->cmd[2]);
-                put_unaligned_be32(num, &rq->cmd[10]);
-                rq->cmd_len = 16;
+                put_unaligned_be32(nr_sectors, &rq->cmd[10]);
+
+                len = sdkp->device->sector_size;
         }
 
-        return BLKPREP_OK;
+        blk_add_request_payload(rq, page, len);
+        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
+        rq->buffer = page_address(page);
+        if (ret != BLKPREP_OK) {
+                __free_page(page);
+                rq->buffer = NULL;
+        }
+        return ret;
+}
+
+static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
+{
+        rq->timeout = SD_TIMEOUT;
+        rq->retries = SD_MAX_RETRIES;
+        rq->cmd[0] = SYNCHRONIZE_CACHE;
+        rq->cmd_len = 10;
+
+        return scsi_setup_blk_pc_cmnd(sdp, rq);
+}
+
+static void sd_unprep_fn(struct request_queue *q, struct request *rq)
+{
+        if (rq->cmd_flags & REQ_DISCARD) {
+                free_page((unsigned long)rq->buffer);
+                rq->buffer = NULL;
+        }
 }
 
 /**
@@ -485,10 +517,13 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
          * Discard request come in as REQ_TYPE_FS but we turn them into
          * block PC requests to make life easier.
          */
-        if (blk_discard_rq(rq))
-                ret = sd_prepare_discard(rq);
-
-        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
+        if (rq->cmd_flags & REQ_DISCARD) {
+                ret = scsi_setup_discard_cmnd(sdp, rq);
+                goto out;
+        } else if (rq->cmd_flags & REQ_FLUSH) {
+                ret = scsi_setup_flush_cmnd(sdp, rq);
+                goto out;
+        } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
                 goto out;
         } else if (rq->cmd_type != REQ_TYPE_FS) {
@@ -636,7 +671,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
                 SCpnt->cmnd[7] = 0x18;
                 SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
-                SCpnt->cmnd[10] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
 
                 /* LBA */
                 SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
@@ -661,7 +696,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
         } else if (block > 0xffffffff) {
                 SCpnt->cmnd[0] += READ_16 - READ_6;
-                SCpnt->cmnd[1] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
                 SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
                 SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
                 SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
@@ -682,7 +717,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                         this_count = 0xffff;
 
                 SCpnt->cmnd[0] += READ_10 - READ_6;
-                SCpnt->cmnd[1] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
                 SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
                 SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
                 SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
@@ -691,7 +726,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
                 SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
         } else {
-                if (unlikely(blk_fua_rq(rq))) {
+                if (unlikely(rq->cmd_flags & REQ_FUA)) {
                         /*
                          * This happens only if this drive failed
                          * 10byte rw command with ILLEGAL_REQUEST
@@ -745,6 +780,8 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
  *      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.
+ *
+ *      Locking: called with bdev->bd_mutex held.
  **/
 static int sd_open(struct block_device *bdev, fmode_t mode)
 {
@@ -799,7 +836,7 @@ static int sd_open(struct block_device *bdev, fmode_t mode)
         if (!scsi_device_online(sdev))
                 goto error_out;
 
-        if (!sdkp->openers++ && sdev->removable) {
+        if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
                 if (scsi_block_when_processing_errors(sdev))
                         scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
         }
@@ -823,6 +860,8 @@ error_autopm:
  *
  *      Note: may block (uninterruptible) if error recovery is underway
  *      on this disk.
+ *
+ *      Locking: called with bdev->bd_mutex held.
  **/
 static int sd_release(struct gendisk *disk, fmode_t mode)
 {
@@ -831,7 +870,7 @@ static int sd_release(struct gendisk *disk, fmode_t mode)
 
         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
 
-        if (!--sdkp->openers && sdev->removable) {
+        if (atomic_dec_return(&sdkp->openers) && sdev->removable) {
                 if (scsi_block_when_processing_errors(sdev))
                         scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
         }
@@ -904,7 +943,7 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
         error = scsi_nonblockable_ioctl(sdp, cmd, p,
                                         (mode & FMODE_NDELAY) != 0);
         if (!scsi_block_when_processing_errors(sdp) || !error)
-                return error;
+                goto out;
 
         /*
          * Send SCSI addressing ioctls directly to mid level, send other
@@ -914,13 +953,17 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
         switch (cmd) {
                 case SCSI_IOCTL_GET_IDLUN:
                 case SCSI_IOCTL_GET_BUS_NUMBER:
-                        return scsi_ioctl(sdp, cmd, p);
+                        error = scsi_ioctl(sdp, cmd, p);
+                        break;
                 default:
                         error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
                         if (error != -ENOTTY)
-                                return error;
+                                break;
+                        error = scsi_ioctl(sdp, cmd, p);
+                        break;
         }
-        return scsi_ioctl(sdp, cmd, p);
+out:
+        return error;
 }
 
 static void set_media_not_present(struct scsi_disk *sdkp)
@@ -1045,15 +1088,6 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
         return 0;
 }
 
-static void sd_prepare_flush(struct request_queue *q, struct request *rq)
-{
-        rq->cmd_type = REQ_TYPE_BLOCK_PC;
-        rq->timeout = SD_TIMEOUT;
-        rq->retries = SD_MAX_RETRIES;
-        rq->cmd[0] = SYNCHRONIZE_CACHE;
-        rq->cmd_len = 10;
-}
-
 static void sd_rescan(struct device *dev)
 {
         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
@@ -1103,7 +1137,7 @@ static const struct block_device_operations sd_fops = {
         .owner                  = THIS_MODULE,
         .open                   = sd_open,
         .release                = sd_release,
-        .locked_ioctl           = sd_ioctl,
+        .ioctl                  = sd_ioctl,
         .getgeo                 = sd_getgeo,
 #ifdef CONFIG_COMPAT
         .compat_ioctl           = sd_compat_ioctl,
@@ -1120,7 +1154,7 @@ static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
         u64 bad_lba;
         int info_valid;
 
-        if (!blk_fs_request(scmd->request))
+        if (scmd->request->cmd_type != REQ_TYPE_FS)
                 return 0;
 
         info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
@@ -1171,6 +1205,12 @@ static int sd_done(struct scsi_cmnd *SCpnt)
         int sense_valid = 0;
         int sense_deferred = 0;
 
+        if (SCpnt->request->cmd_flags & REQ_DISCARD) {
+                if (!result)
+                        scsi_set_resid(SCpnt, 0);
+                return good_bytes;
+        }
+
         if (result) {
                 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
                 if (sense_valid)
@@ -2121,7 +2161,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         else
                 ordered = QUEUE_ORDERED_DRAIN;
 
-        blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush);
+        blk_queue_ordered(sdkp->disk->queue, ordered);
 
         set_capacity(disk, sdkp->capacity);
         kfree(buffer);
@@ -2234,6 +2274,7 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
         sd_revalidate_disk(gd);
 
         blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
+        blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);
 
         gd->driverfs_dev = &sdp->sdev_gendev;
         gd->flags = GENHD_FL_EXT_DEVT;
@@ -2313,7 +2354,7 @@ static int sd_probe(struct device *dev)
         sdkp->driver = &sd_template;
         sdkp->disk = gd;
         sdkp->index = index;
-        sdkp->openers = 0;
+        atomic_set(&sdkp->openers, 0);
         sdkp->previous_state = 1;
 
         if (!sdp->request_queue->rq_timeout) {
@@ -2372,6 +2413,7 @@ static int sd_remove(struct device *dev)
 
         async_synchronize_full();
         blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
+        blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
         device_del(&sdkp->dev);
         del_gendisk(sdkp->disk);
         sd_shutdown(dev);
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 43d3caf268ef..f81a9309e6de 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -47,7 +47,7 @@ struct scsi_disk {
         struct scsi_device *device;
         struct device   dev;
         struct gendisk  *disk;
-        unsigned int    openers;        /* protected by BKL for now, yuck */
+        atomic_t        openers;
         sector_t        capacity;       /* size in 512-byte sectors */
         u32             index;
         unsigned short  hw_sector_size;
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 0a90abc7f140..ba9c3e0387ce 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -44,6 +44,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <asm/uaccess.h>
 
@@ -466,22 +467,27 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
 
 static int sr_block_open(struct block_device *bdev, fmode_t mode)
 {
-        struct scsi_cd *cd = scsi_cd_get(bdev->bd_disk);
+        struct scsi_cd *cd;
         int ret = -ENXIO;
 
+        lock_kernel();
+        cd = scsi_cd_get(bdev->bd_disk);
         if (cd) {
                 ret = cdrom_open(&cd->cdi, bdev, mode);
                 if (ret)
                         scsi_cd_put(cd);
         }
+        unlock_kernel();
         return ret;
 }
 
 static int sr_block_release(struct gendisk *disk, fmode_t mode)
 {
         struct scsi_cd *cd = scsi_cd(disk);
+        lock_kernel();
         cdrom_release(&cd->cdi, mode);
         scsi_cd_put(cd);
+        unlock_kernel();
         return 0;
 }
 
@@ -493,6 +499,8 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         void __user *argp = (void __user *)arg;
         int ret;
 
+        lock_kernel();
+
         /*
          * Send SCSI addressing ioctls directly to mid level, send other
          * ioctls to cdrom/block level.
@@ -500,12 +508,13 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         switch (cmd) {
         case SCSI_IOCTL_GET_IDLUN:
         case SCSI_IOCTL_GET_BUS_NUMBER:
-                return scsi_ioctl(sdev, cmd, argp);
+                ret = scsi_ioctl(sdev, cmd, argp);
+                goto out;
         }
 
         ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);
         if (ret != -ENOSYS)
-                return ret;
+                goto out;
 
         /*
          * ENODEV means that we didn't recognise the ioctl, or that we
@@ -516,8 +525,12 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         ret = scsi_nonblockable_ioctl(sdev, cmd, argp,
                                         (mode & FMODE_NDELAY) != 0);
         if (ret != -ENODEV)
-                return ret;
-        return scsi_ioctl(sdev, cmd, argp);
+                goto out;
+        ret = scsi_ioctl(sdev, cmd, argp);
+
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int sr_block_media_changed(struct gendisk *disk)
@@ -531,7 +544,7 @@ static const struct block_device_operations sr_bdops =
         .owner          = THIS_MODULE,
         .open           = sr_block_open,
         .release        = sr_block_release,
-        .locked_ioctl   = sr_block_ioctl,
+        .ioctl          = sr_block_ioctl,
         .media_changed  = sr_block_media_changed,
         /* 
          * No compat_ioctl for now because sr_block_ioctl never
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index b5838d547c68..713620ed70d9 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -2022,7 +2022,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
                 if((count > SUN3_DMA_MINSIZE) && (sun3_dma_setup_done
                                                   != cmd))
                 {
-                        if(blk_fs_request(cmd->request)) {
+                        if (cmd->request->cmd_type == REQ_TYPE_FS) {
                                 sun3scsi_dma_setup(d, count,
                                                    rq_data_dir(cmd->request));
                                 sun3_dma_setup_done = cmd;
diff --git a/drivers/scsi/sun3_scsi.c b/drivers/scsi/sun3_scsi.c
index e606cf0a2eb7..613f5880d135 100644
--- a/drivers/scsi/sun3_scsi.c
+++ b/drivers/scsi/sun3_scsi.c
@@ -524,7 +524,7 @@ static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
                                                   struct scsi_cmnd *cmd,
                                                   int write_flag)
 {
-        if(blk_fs_request(cmd->request))
+        if (cmd->request->cmd_type == REQ_TYPE_FS)
                 return wanted;
         else
                 return 0;
diff --git a/drivers/scsi/sun3_scsi_vme.c b/drivers/scsi/sun3_scsi_vme.c
index aaa4fd0dd1b9..7c526b8e30ac 100644
--- a/drivers/scsi/sun3_scsi_vme.c
+++ b/drivers/scsi/sun3_scsi_vme.c
@@ -458,7 +458,7 @@ static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
                                                   struct scsi_cmnd *cmd,
                                                   int write_flag)
 {
-        if(blk_fs_request(cmd->request))
+        if (cmd->request->cmd_type == REQ_TYPE_FS)
                 return wanted;
         else
                 return 0;