mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 02:32:09 -04:00
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.
This commit is contained in:
Linus Torvalds
commit
2f9e825d3e
154 changed files with 4286 additions and 3211 deletions
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
if (sdkp->unmap) {
|
||||
char *buf = kmap_atomic(bio_page(bio), KM_USER0);
|
||||
page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
|
||||
if (!page)
|
||||
return BLKPREP_DEFER;
|
||||
|
||||
if (sdkp->unmap) {
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Reference in a new issue