mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 19:21:31 -04:00
Merge branch 'for-2.6.31' of git://git.kernel.dk/linux-2.6-block
* 'for-2.6.31' of git://git.kernel.dk/linux-2.6-block: (153 commits) block: add request clone interface (v2) floppy: fix hibernation ramdisk: remove long-deprecated "ramdisk=" boot-time parameter fs/bio.c: add missing __user annotation block: prevent possible io_context->refcount overflow Add serial number support for virtio_blk, V4a block: Add missing bounce_pfn stacking and fix comments Revert "block: Fix bounce limit setting in DM" cciss: decode unit attention in SCSI error handling code cciss: Remove no longer needed sendcmd reject processing code cciss: change SCSI error handling routines to work with interrupts enabled. cciss: separate error processing and command retrying code in sendcmd_withirq_core() cciss: factor out fix target status processing code from sendcmd functions cciss: simplify interface of sendcmd() and sendcmd_withirq() cciss: factor out core of sendcmd_withirq() for use by SCSI error handling code cciss: Use schedule_timeout_uninterruptible in SCSI error handling code block: needs to set the residual length of a bidi request Revert "block: implement blkdev_readpages" block: Fix bounce limit setting in DM Removed reference to non-existing file Documentation/PCI/PCI-DMA-mapping.txt ... Manually fix conflicts with tracing updates in: block/blk-sysfs.c drivers/ide/ide-atapi.c drivers/ide/ide-cd.c drivers/ide/ide-floppy.c drivers/ide/ide-tape.c include/trace/events/block.h kernel/trace/blktrace.c
This commit is contained in:
Linus Torvalds
commit
c9059598ea
158 changed files with 3790 additions and 2760 deletions
|
|
@ -1825,7 +1825,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
|
|||
if (linked_comm && SCpnt->device->queue_depth > 2
|
||||
&& TLDEV(SCpnt->device->type)) {
|
||||
ha->cp_stat[i] = READY;
|
||||
flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
|
||||
flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -2144,13 +2144,13 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
|
|||
if (!cpp->din)
|
||||
input_only = 0;
|
||||
|
||||
if (SCpnt->request->sector < minsec)
|
||||
minsec = SCpnt->request->sector;
|
||||
if (SCpnt->request->sector > maxsec)
|
||||
maxsec = SCpnt->request->sector;
|
||||
if (blk_rq_pos(SCpnt->request) < minsec)
|
||||
minsec = blk_rq_pos(SCpnt->request);
|
||||
if (blk_rq_pos(SCpnt->request) > maxsec)
|
||||
maxsec = blk_rq_pos(SCpnt->request);
|
||||
|
||||
sl[n] = SCpnt->request->sector;
|
||||
ioseek += SCpnt->request->nr_sectors;
|
||||
sl[n] = blk_rq_pos(SCpnt->request);
|
||||
ioseek += blk_rq_sectors(SCpnt->request);
|
||||
|
||||
if (!n)
|
||||
continue;
|
||||
|
|
@ -2190,7 +2190,7 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
|
|||
k = il[n];
|
||||
cpp = &ha->cp[k];
|
||||
SCpnt = cpp->SCpnt;
|
||||
ll[n] = SCpnt->request->nr_sectors;
|
||||
ll[n] = blk_rq_sectors(SCpnt->request);
|
||||
pl[n] = SCpnt->serial_number;
|
||||
|
||||
if (!n)
|
||||
|
|
@ -2236,12 +2236,12 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
|
|||
cpp = &ha->cp[k];
|
||||
SCpnt = cpp->SCpnt;
|
||||
scmd_printk(KERN_INFO, SCpnt,
|
||||
"%s pid %ld mb %d fc %d nr %d sec %ld ns %ld"
|
||||
"%s pid %ld mb %d fc %d nr %d sec %ld ns %u"
|
||||
" cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
|
||||
(ihdlr ? "ihdlr" : "qcomm"),
|
||||
SCpnt->serial_number, k, flushcount,
|
||||
n_ready, SCpnt->request->sector,
|
||||
SCpnt->request->nr_sectors, cursec, YESNO(s),
|
||||
n_ready, blk_rq_pos(SCpnt->request),
|
||||
blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
|
||||
YESNO(r), YESNO(rev), YESNO(input_only),
|
||||
YESNO(overlap), cpp->din);
|
||||
}
|
||||
|
|
@ -2408,7 +2408,7 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
|
|||
|
||||
if (linked_comm && SCpnt->device->queue_depth > 2
|
||||
&& TLDEV(SCpnt->device->type))
|
||||
flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
|
||||
flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 1);
|
||||
|
||||
tstatus = status_byte(spp->target_status);
|
||||
|
||||
|
|
|
|||
|
|
@ -1927,21 +1927,21 @@ int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
/* do we need to support multiple segments? */
|
||||
if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
|
||||
printk("%s: multiple segments req %u %u, rsp %u %u\n",
|
||||
__func__, req->bio->bi_vcnt, req->data_len,
|
||||
rsp->bio->bi_vcnt, rsp->data_len);
|
||||
__func__, req->bio->bi_vcnt, blk_rq_bytes(req),
|
||||
rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = smp_execute_task(dev, bio_data(req->bio), req->data_len,
|
||||
bio_data(rsp->bio), rsp->data_len);
|
||||
ret = smp_execute_task(dev, bio_data(req->bio), blk_rq_bytes(req),
|
||||
bio_data(rsp->bio), blk_rq_bytes(rsp));
|
||||
if (ret > 0) {
|
||||
/* positive number is the untransferred residual */
|
||||
rsp->data_len = ret;
|
||||
req->data_len = 0;
|
||||
rsp->resid_len = ret;
|
||||
req->resid_len = 0;
|
||||
ret = 0;
|
||||
} else if (ret == 0) {
|
||||
rsp->data_len = 0;
|
||||
req->data_len = 0;
|
||||
rsp->resid_len = 0;
|
||||
req->resid_len = 0;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -134,24 +134,24 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
{
|
||||
u8 *req_data = NULL, *resp_data = NULL, *buf;
|
||||
struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
|
||||
int error = -EINVAL, resp_data_len = rsp->data_len;
|
||||
int error = -EINVAL;
|
||||
|
||||
/* eight is the minimum size for request and response frames */
|
||||
if (req->data_len < 8 || rsp->data_len < 8)
|
||||
if (blk_rq_bytes(req) < 8 || blk_rq_bytes(rsp) < 8)
|
||||
goto out;
|
||||
|
||||
if (bio_offset(req->bio) + req->data_len > PAGE_SIZE ||
|
||||
bio_offset(rsp->bio) + rsp->data_len > PAGE_SIZE) {
|
||||
if (bio_offset(req->bio) + blk_rq_bytes(req) > PAGE_SIZE ||
|
||||
bio_offset(rsp->bio) + blk_rq_bytes(rsp) > PAGE_SIZE) {
|
||||
shost_printk(KERN_ERR, shost,
|
||||
"SMP request/response frame crosses page boundary");
|
||||
goto out;
|
||||
}
|
||||
|
||||
req_data = kzalloc(req->data_len, GFP_KERNEL);
|
||||
req_data = kzalloc(blk_rq_bytes(req), GFP_KERNEL);
|
||||
|
||||
/* make sure frame can always be built ... we copy
|
||||
* back only the requested length */
|
||||
resp_data = kzalloc(max(rsp->data_len, 128U), GFP_KERNEL);
|
||||
resp_data = kzalloc(max(blk_rq_bytes(rsp), 128U), GFP_KERNEL);
|
||||
|
||||
if (!req_data || !resp_data) {
|
||||
error = -ENOMEM;
|
||||
|
|
@ -160,7 +160,7 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
|
||||
local_irq_disable();
|
||||
buf = kmap_atomic(bio_page(req->bio), KM_USER0) + bio_offset(req->bio);
|
||||
memcpy(req_data, buf, req->data_len);
|
||||
memcpy(req_data, buf, blk_rq_bytes(req));
|
||||
kunmap_atomic(buf - bio_offset(req->bio), KM_USER0);
|
||||
local_irq_enable();
|
||||
|
||||
|
|
@ -178,15 +178,15 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
|
||||
switch (req_data[1]) {
|
||||
case SMP_REPORT_GENERAL:
|
||||
req->data_len -= 8;
|
||||
resp_data_len -= 32;
|
||||
req->resid_len -= 8;
|
||||
rsp->resid_len -= 32;
|
||||
resp_data[2] = SMP_RESP_FUNC_ACC;
|
||||
resp_data[9] = sas_ha->num_phys;
|
||||
break;
|
||||
|
||||
case SMP_REPORT_MANUF_INFO:
|
||||
req->data_len -= 8;
|
||||
resp_data_len -= 64;
|
||||
req->resid_len -= 8;
|
||||
rsp->resid_len -= 64;
|
||||
resp_data[2] = SMP_RESP_FUNC_ACC;
|
||||
memcpy(resp_data + 12, shost->hostt->name,
|
||||
SAS_EXPANDER_VENDOR_ID_LEN);
|
||||
|
|
@ -199,13 +199,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
break;
|
||||
|
||||
case SMP_DISCOVER:
|
||||
req->data_len -= 16;
|
||||
if ((int)req->data_len < 0) {
|
||||
req->data_len = 0;
|
||||
req->resid_len -= 16;
|
||||
if ((int)req->resid_len < 0) {
|
||||
req->resid_len = 0;
|
||||
error = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
resp_data_len -= 56;
|
||||
rsp->resid_len -= 56;
|
||||
sas_host_smp_discover(sas_ha, resp_data, req_data[9]);
|
||||
break;
|
||||
|
||||
|
|
@ -215,13 +215,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
break;
|
||||
|
||||
case SMP_REPORT_PHY_SATA:
|
||||
req->data_len -= 16;
|
||||
if ((int)req->data_len < 0) {
|
||||
req->data_len = 0;
|
||||
req->resid_len -= 16;
|
||||
if ((int)req->resid_len < 0) {
|
||||
req->resid_len = 0;
|
||||
error = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
resp_data_len -= 60;
|
||||
rsp->resid_len -= 60;
|
||||
sas_report_phy_sata(sas_ha, resp_data, req_data[9]);
|
||||
break;
|
||||
|
||||
|
|
@ -238,13 +238,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
break;
|
||||
|
||||
case SMP_PHY_CONTROL:
|
||||
req->data_len -= 44;
|
||||
if ((int)req->data_len < 0) {
|
||||
req->data_len = 0;
|
||||
req->resid_len -= 44;
|
||||
if ((int)req->resid_len < 0) {
|
||||
req->resid_len = 0;
|
||||
error = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
resp_data_len -= 8;
|
||||
rsp->resid_len -= 8;
|
||||
sas_phy_control(sas_ha, req_data[9], req_data[10],
|
||||
req_data[32] >> 4, req_data[33] >> 4,
|
||||
resp_data);
|
||||
|
|
@ -261,11 +261,10 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
|
|||
|
||||
local_irq_disable();
|
||||
buf = kmap_atomic(bio_page(rsp->bio), KM_USER0) + bio_offset(rsp->bio);
|
||||
memcpy(buf, resp_data, rsp->data_len);
|
||||
memcpy(buf, resp_data, blk_rq_bytes(rsp));
|
||||
flush_kernel_dcache_page(bio_page(rsp->bio));
|
||||
kunmap_atomic(buf - bio_offset(rsp->bio), KM_USER0);
|
||||
local_irq_enable();
|
||||
rsp->data_len = resp_data_len;
|
||||
|
||||
out:
|
||||
kfree(req_data);
|
||||
|
|
|
|||
|
|
@ -1312,10 +1312,10 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
|
|||
uint32_t bgstat = bgf->bgstat;
|
||||
uint64_t failing_sector = 0;
|
||||
|
||||
printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%lx "
|
||||
printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%x "
|
||||
"bgstat=0x%x bghm=0x%x\n",
|
||||
cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
|
||||
cmd->request->nr_sectors, bgstat, bghm);
|
||||
blk_rq_sectors(cmd->request), bgstat, bghm);
|
||||
|
||||
spin_lock(&_dump_buf_lock);
|
||||
if (!_dump_buf_done) {
|
||||
|
|
@ -2378,15 +2378,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
|
|||
if (cmnd->cmnd[0] == READ_10)
|
||||
lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
|
||||
"9035 BLKGRD: READ @ sector %llu, "
|
||||
"count %lu\n",
|
||||
(unsigned long long)scsi_get_lba(cmnd),
|
||||
cmnd->request->nr_sectors);
|
||||
"count %u\n",
|
||||
(unsigned long long)scsi_get_lba(cmnd),
|
||||
blk_rq_sectors(cmnd->request));
|
||||
else if (cmnd->cmnd[0] == WRITE_10)
|
||||
lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
|
||||
"9036 BLKGRD: WRITE @ sector %llu, "
|
||||
"count %lu cmd=%p\n",
|
||||
"count %u cmd=%p\n",
|
||||
(unsigned long long)scsi_get_lba(cmnd),
|
||||
cmnd->request->nr_sectors,
|
||||
blk_rq_sectors(cmnd->request),
|
||||
cmnd);
|
||||
|
||||
err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
|
||||
|
|
@ -2406,15 +2406,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
|
|||
if (cmnd->cmnd[0] == READ_10)
|
||||
lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
|
||||
"9040 dbg: READ @ sector %llu, "
|
||||
"count %lu\n",
|
||||
"count %u\n",
|
||||
(unsigned long long)scsi_get_lba(cmnd),
|
||||
cmnd->request->nr_sectors);
|
||||
blk_rq_sectors(cmnd->request));
|
||||
else if (cmnd->cmnd[0] == WRITE_10)
|
||||
lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
|
||||
"9041 dbg: WRITE @ sector %llu, "
|
||||
"count %lu cmd=%p\n",
|
||||
"count %u cmd=%p\n",
|
||||
(unsigned long long)scsi_get_lba(cmnd),
|
||||
cmnd->request->nr_sectors, cmnd);
|
||||
blk_rq_sectors(cmnd->request), cmnd);
|
||||
else
|
||||
lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
|
||||
"9042 dbg: parser not implemented\n");
|
||||
|
|
|
|||
|
|
@ -1041,7 +1041,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
|
||||
printk(MPT2SAS_ERR_FMT "%s: multiple segments req %u %u, "
|
||||
"rsp %u %u\n", ioc->name, __func__, req->bio->bi_vcnt,
|
||||
req->data_len, rsp->bio->bi_vcnt, rsp->data_len);
|
||||
blk_rq_bytes(req), rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -1104,7 +1104,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
*((u64 *)&mpi_request->SASAddress) = (rphy) ?
|
||||
cpu_to_le64(rphy->identify.sas_address) :
|
||||
cpu_to_le64(ioc->sas_hba.sas_address);
|
||||
mpi_request->RequestDataLength = cpu_to_le16(req->data_len - 4);
|
||||
mpi_request->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
|
||||
psge = &mpi_request->SGL;
|
||||
|
||||
/* WRITE sgel first */
|
||||
|
|
@ -1112,13 +1112,13 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
|
||||
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
||||
dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
|
||||
req->data_len, PCI_DMA_BIDIRECTIONAL);
|
||||
blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
|
||||
if (!dma_addr_out) {
|
||||
mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
|
||||
goto unmap;
|
||||
}
|
||||
|
||||
ioc->base_add_sg_single(psge, sgl_flags | (req->data_len - 4),
|
||||
ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(req) - 4),
|
||||
dma_addr_out);
|
||||
|
||||
/* incr sgel */
|
||||
|
|
@ -1129,14 +1129,14 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
|
||||
MPI2_SGE_FLAGS_END_OF_LIST);
|
||||
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
||||
dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
|
||||
rsp->data_len, PCI_DMA_BIDIRECTIONAL);
|
||||
dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
|
||||
blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
|
||||
if (!dma_addr_in) {
|
||||
mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
|
||||
goto unmap;
|
||||
}
|
||||
|
||||
ioc->base_add_sg_single(psge, sgl_flags | (rsp->data_len + 4),
|
||||
ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(rsp) + 4),
|
||||
dma_addr_in);
|
||||
|
||||
dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s - "
|
||||
|
|
@ -1170,9 +1170,8 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
|
||||
memcpy(req->sense, mpi_reply, sizeof(*mpi_reply));
|
||||
req->sense_len = sizeof(*mpi_reply);
|
||||
req->data_len = 0;
|
||||
rsp->data_len -= mpi_reply->ResponseDataLength;
|
||||
|
||||
req->resid_len = 0;
|
||||
rsp->resid_len -= mpi_reply->ResponseDataLength;
|
||||
} else {
|
||||
dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT
|
||||
"%s - no reply\n", ioc->name, __func__));
|
||||
|
|
@ -1188,10 +1187,10 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
|
|||
|
||||
unmap:
|
||||
if (dma_addr_out)
|
||||
pci_unmap_single(ioc->pdev, dma_addr_out, req->data_len,
|
||||
pci_unmap_single(ioc->pdev, dma_addr_out, blk_rq_bytes(req),
|
||||
PCI_DMA_BIDIRECTIONAL);
|
||||
if (dma_addr_in)
|
||||
pci_unmap_single(ioc->pdev, dma_addr_in, rsp->data_len,
|
||||
pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
|
||||
PCI_DMA_BIDIRECTIONAL);
|
||||
|
||||
out:
|
||||
|
|
|
|||
|
|
@ -889,26 +889,6 @@ int osd_req_add_set_attr_list(struct osd_request *or,
|
|||
}
|
||||
EXPORT_SYMBOL(osd_req_add_set_attr_list);
|
||||
|
||||
static int _append_map_kern(struct request *req,
|
||||
void *buff, unsigned len, gfp_t flags)
|
||||
{
|
||||
struct bio *bio;
|
||||
int ret;
|
||||
|
||||
bio = bio_map_kern(req->q, buff, len, flags);
|
||||
if (IS_ERR(bio)) {
|
||||
OSD_ERR("Failed bio_map_kern(%p, %d) => %ld\n", buff, len,
|
||||
PTR_ERR(bio));
|
||||
return PTR_ERR(bio);
|
||||
}
|
||||
ret = blk_rq_append_bio(req->q, req, bio);
|
||||
if (ret) {
|
||||
OSD_ERR("Failed blk_rq_append_bio(%p) => %d\n", bio, ret);
|
||||
bio_put(bio);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int _req_append_segment(struct osd_request *or,
|
||||
unsigned padding, struct _osd_req_data_segment *seg,
|
||||
struct _osd_req_data_segment *last_seg, struct _osd_io_info *io)
|
||||
|
|
@ -924,14 +904,14 @@ static int _req_append_segment(struct osd_request *or,
|
|||
else
|
||||
pad_buff = io->pad_buff;
|
||||
|
||||
ret = _append_map_kern(io->req, pad_buff, padding,
|
||||
ret = blk_rq_map_kern(io->req->q, io->req, pad_buff, padding,
|
||||
or->alloc_flags);
|
||||
if (ret)
|
||||
return ret;
|
||||
io->total_bytes += padding;
|
||||
}
|
||||
|
||||
ret = _append_map_kern(io->req, seg->buff, seg->total_bytes,
|
||||
ret = blk_rq_map_kern(io->req->q, io->req, seg->buff, seg->total_bytes,
|
||||
or->alloc_flags);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
|
@ -1293,6 +1273,21 @@ static int _osd_req_finalize_data_integrity(struct osd_request *or,
|
|||
/*
|
||||
* osd_finalize_request and helpers
|
||||
*/
|
||||
static struct request *_make_request(struct request_queue *q, bool has_write,
|
||||
struct _osd_io_info *oii, gfp_t flags)
|
||||
{
|
||||
if (oii->bio)
|
||||
return blk_make_request(q, oii->bio, flags);
|
||||
else {
|
||||
struct request *req;
|
||||
|
||||
req = blk_get_request(q, has_write ? WRITE : READ, flags);
|
||||
if (unlikely(!req))
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
return req;
|
||||
}
|
||||
}
|
||||
|
||||
static int _init_blk_request(struct osd_request *or,
|
||||
bool has_in, bool has_out)
|
||||
|
|
@ -1301,11 +1296,13 @@ static int _init_blk_request(struct osd_request *or,
|
|||
struct scsi_device *scsi_device = or->osd_dev->scsi_device;
|
||||
struct request_queue *q = scsi_device->request_queue;
|
||||
struct request *req;
|
||||
int ret = -ENOMEM;
|
||||
int ret;
|
||||
|
||||
req = blk_get_request(q, has_out, flags);
|
||||
if (!req)
|
||||
req = _make_request(q, has_out, has_out ? &or->out : &or->in, flags);
|
||||
if (IS_ERR(req)) {
|
||||
ret = PTR_ERR(req);
|
||||
goto out;
|
||||
}
|
||||
|
||||
or->request = req;
|
||||
req->cmd_type = REQ_TYPE_BLOCK_PC;
|
||||
|
|
@ -1318,9 +1315,10 @@ static int _init_blk_request(struct osd_request *or,
|
|||
or->out.req = req;
|
||||
if (has_in) {
|
||||
/* allocate bidi request */
|
||||
req = blk_get_request(q, READ, flags);
|
||||
if (!req) {
|
||||
req = _make_request(q, false, &or->in, flags);
|
||||
if (IS_ERR(req)) {
|
||||
OSD_DEBUG("blk_get_request for bidi failed\n");
|
||||
ret = PTR_ERR(req);
|
||||
goto out;
|
||||
}
|
||||
req->cmd_type = REQ_TYPE_BLOCK_PC;
|
||||
|
|
@ -1364,26 +1362,6 @@ int osd_finalize_request(struct osd_request *or,
|
|||
return ret;
|
||||
}
|
||||
|
||||
if (or->out.bio) {
|
||||
ret = blk_rq_append_bio(or->request->q, or->out.req,
|
||||
or->out.bio);
|
||||
if (ret) {
|
||||
OSD_DEBUG("blk_rq_append_bio out failed\n");
|
||||
return ret;
|
||||
}
|
||||
OSD_DEBUG("out bytes=%llu (bytes_req=%u)\n",
|
||||
_LLU(or->out.total_bytes), or->out.req->data_len);
|
||||
}
|
||||
if (or->in.bio) {
|
||||
ret = blk_rq_append_bio(or->request->q, or->in.req, or->in.bio);
|
||||
if (ret) {
|
||||
OSD_DEBUG("blk_rq_append_bio in failed\n");
|
||||
return ret;
|
||||
}
|
||||
OSD_DEBUG("in bytes=%llu (bytes_req=%u)\n",
|
||||
_LLU(or->in.total_bytes), or->in.req->data_len);
|
||||
}
|
||||
|
||||
or->out.pad_buff = sg_out_pad_buffer;
|
||||
or->in.pad_buff = sg_in_pad_buffer;
|
||||
|
||||
|
|
|
|||
|
|
@ -240,11 +240,11 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
|
|||
* is invalid. Prevent the garbage from being misinterpreted
|
||||
* and prevent security leaks by zeroing out the excess data.
|
||||
*/
|
||||
if (unlikely(req->data_len > 0 && req->data_len <= bufflen))
|
||||
memset(buffer + (bufflen - req->data_len), 0, req->data_len);
|
||||
if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
|
||||
memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
|
||||
|
||||
if (resid)
|
||||
*resid = req->data_len;
|
||||
*resid = req->resid_len;
|
||||
ret = req->errors;
|
||||
out:
|
||||
blk_put_request(req);
|
||||
|
|
@ -546,14 +546,9 @@ static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error,
|
|||
* to queue the remainder of them.
|
||||
*/
|
||||
if (blk_end_request(req, error, bytes)) {
|
||||
int leftover = (req->hard_nr_sectors << 9);
|
||||
|
||||
if (blk_pc_request(req))
|
||||
leftover = req->data_len;
|
||||
|
||||
/* kill remainder if no retrys */
|
||||
if (error && scsi_noretry_cmd(cmd))
|
||||
blk_end_request(req, error, leftover);
|
||||
blk_end_request_all(req, error);
|
||||
else {
|
||||
if (requeue) {
|
||||
/*
|
||||
|
|
@ -672,34 +667,6 @@ void scsi_release_buffers(struct scsi_cmnd *cmd)
|
|||
}
|
||||
EXPORT_SYMBOL(scsi_release_buffers);
|
||||
|
||||
/*
|
||||
* Bidi commands Must be complete as a whole, both sides at once.
|
||||
* If part of the bytes were written and lld returned
|
||||
* scsi_in()->resid and/or scsi_out()->resid this information will be left
|
||||
* in req->data_len and req->next_rq->data_len. The upper-layer driver can
|
||||
* decide what to do with this information.
|
||||
*/
|
||||
static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
|
||||
{
|
||||
struct request *req = cmd->request;
|
||||
unsigned int dlen = req->data_len;
|
||||
unsigned int next_dlen = req->next_rq->data_len;
|
||||
|
||||
req->data_len = scsi_out(cmd)->resid;
|
||||
req->next_rq->data_len = scsi_in(cmd)->resid;
|
||||
|
||||
/* The req and req->next_rq have not been completed */
|
||||
BUG_ON(blk_end_bidi_request(req, 0, dlen, next_dlen));
|
||||
|
||||
scsi_release_buffers(cmd);
|
||||
|
||||
/*
|
||||
* This will goose the queue request function at the end, so we don't
|
||||
* need to worry about launching another command.
|
||||
*/
|
||||
scsi_next_command(cmd);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: scsi_io_completion()
|
||||
*
|
||||
|
|
@ -739,7 +706,6 @@ static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
|
|||
void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
||||
{
|
||||
int result = cmd->result;
|
||||
int this_count;
|
||||
struct request_queue *q = cmd->device->request_queue;
|
||||
struct request *req = cmd->request;
|
||||
int error = 0;
|
||||
|
|
@ -773,12 +739,22 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
|||
if (!sense_deferred)
|
||||
error = -EIO;
|
||||
}
|
||||
|
||||
req->resid_len = scsi_get_resid(cmd);
|
||||
|
||||
if (scsi_bidi_cmnd(cmd)) {
|
||||
/* will also release_buffers */
|
||||
scsi_end_bidi_request(cmd);
|
||||
/*
|
||||
* Bidi commands Must be complete as a whole,
|
||||
* both sides at once.
|
||||
*/
|
||||
req->next_rq->resid_len = scsi_in(cmd)->resid;
|
||||
|
||||
blk_end_request_all(req, 0);
|
||||
|
||||
scsi_release_buffers(cmd);
|
||||
scsi_next_command(cmd);
|
||||
return;
|
||||
}
|
||||
req->data_len = scsi_get_resid(cmd);
|
||||
}
|
||||
|
||||
BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
|
||||
|
|
@ -787,9 +763,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
|||
* Next deal with any sectors which we were able to correctly
|
||||
* handle.
|
||||
*/
|
||||
SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, "
|
||||
SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, "
|
||||
"%d bytes done.\n",
|
||||
req->nr_sectors, good_bytes));
|
||||
blk_rq_sectors(req), good_bytes));
|
||||
|
||||
/*
|
||||
* Recovered errors need reporting, but they're always treated
|
||||
|
|
@ -812,7 +788,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
|||
*/
|
||||
if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL)
|
||||
return;
|
||||
this_count = blk_rq_bytes(req);
|
||||
|
||||
error = -EIO;
|
||||
|
||||
|
|
@ -922,7 +897,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
|
|||
if (driver_byte(result) & DRIVER_SENSE)
|
||||
scsi_print_sense("", cmd);
|
||||
}
|
||||
blk_end_request(req, -EIO, blk_rq_bytes(req));
|
||||
blk_end_request_all(req, -EIO);
|
||||
scsi_next_command(cmd);
|
||||
break;
|
||||
case ACTION_REPREP:
|
||||
|
|
@ -965,10 +940,7 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
|
|||
count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
|
||||
BUG_ON(count > sdb->table.nents);
|
||||
sdb->table.nents = count;
|
||||
if (blk_pc_request(req))
|
||||
sdb->length = req->data_len;
|
||||
else
|
||||
sdb->length = req->nr_sectors << 9;
|
||||
sdb->length = blk_rq_bytes(req);
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
|
||||
|
|
@ -1087,22 +1059,21 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
|
|||
if (unlikely(ret))
|
||||
return ret;
|
||||
} else {
|
||||
BUG_ON(req->data_len);
|
||||
BUG_ON(req->data);
|
||||
BUG_ON(blk_rq_bytes(req));
|
||||
|
||||
memset(&cmd->sdb, 0, sizeof(cmd->sdb));
|
||||
req->buffer = NULL;
|
||||
}
|
||||
|
||||
cmd->cmd_len = req->cmd_len;
|
||||
if (!req->data_len)
|
||||
if (!blk_rq_bytes(req))
|
||||
cmd->sc_data_direction = DMA_NONE;
|
||||
else if (rq_data_dir(req) == WRITE)
|
||||
cmd->sc_data_direction = DMA_TO_DEVICE;
|
||||
else
|
||||
cmd->sc_data_direction = DMA_FROM_DEVICE;
|
||||
|
||||
cmd->transfersize = req->data_len;
|
||||
cmd->transfersize = blk_rq_bytes(req);
|
||||
cmd->allowed = req->retries;
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
|
|
@ -1212,7 +1183,7 @@ int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
|
|||
break;
|
||||
case BLKPREP_DEFER:
|
||||
/*
|
||||
* If we defer, the elv_next_request() returns NULL, but the
|
||||
* If we defer, the blk_peek_request() returns NULL, but the
|
||||
* queue must be restarted, so we plug here if no returning
|
||||
* command will automatically do that.
|
||||
*/
|
||||
|
|
@ -1388,7 +1359,7 @@ static void scsi_kill_request(struct request *req, struct request_queue *q)
|
|||
struct scsi_target *starget = scsi_target(sdev);
|
||||
struct Scsi_Host *shost = sdev->host;
|
||||
|
||||
blkdev_dequeue_request(req);
|
||||
blk_start_request(req);
|
||||
|
||||
if (unlikely(cmd == NULL)) {
|
||||
printk(KERN_CRIT "impossible request in %s.\n",
|
||||
|
|
@ -1480,7 +1451,7 @@ static void scsi_request_fn(struct request_queue *q)
|
|||
|
||||
if (!sdev) {
|
||||
printk("scsi: killing requests for dead queue\n");
|
||||
while ((req = elv_next_request(q)) != NULL)
|
||||
while ((req = blk_peek_request(q)) != NULL)
|
||||
scsi_kill_request(req, q);
|
||||
return;
|
||||
}
|
||||
|
|
@ -1501,7 +1472,7 @@ static void scsi_request_fn(struct request_queue *q)
|
|||
* that the request is fully prepared even if we cannot
|
||||
* accept it.
|
||||
*/
|
||||
req = elv_next_request(q);
|
||||
req = blk_peek_request(q);
|
||||
if (!req || !scsi_dev_queue_ready(q, sdev))
|
||||
break;
|
||||
|
||||
|
|
@ -1517,7 +1488,7 @@ static void scsi_request_fn(struct request_queue *q)
|
|||
* Remove the request from the request list.
|
||||
*/
|
||||
if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
|
||||
blkdev_dequeue_request(req);
|
||||
blk_start_request(req);
|
||||
sdev->device_busy++;
|
||||
|
||||
spin_unlock(q->queue_lock);
|
||||
|
|
|
|||
|
|
@ -387,7 +387,7 @@ static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
|
|||
* we use REQ_TYPE_BLOCK_PC so scsi_init_io doesn't set the
|
||||
* length for us.
|
||||
*/
|
||||
cmd->sdb.length = rq->data_len;
|
||||
cmd->sdb.length = blk_rq_bytes(rq);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -163,12 +163,10 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
|
|||
int (*handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
|
||||
|
||||
while (!blk_queue_plugged(q)) {
|
||||
req = elv_next_request(q);
|
||||
req = blk_fetch_request(q);
|
||||
if (!req)
|
||||
break;
|
||||
|
||||
blkdev_dequeue_request(req);
|
||||
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
|
||||
handler = to_sas_internal(shost->transportt)->f->smp_handler;
|
||||
|
|
|
|||
|
|
@ -384,9 +384,9 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
struct scsi_device *sdp = q->queuedata;
|
||||
struct gendisk *disk = rq->rq_disk;
|
||||
struct scsi_disk *sdkp;
|
||||
sector_t block = rq->sector;
|
||||
sector_t block = blk_rq_pos(rq);
|
||||
sector_t threshold;
|
||||
unsigned int this_count = rq->nr_sectors;
|
||||
unsigned int this_count = blk_rq_sectors(rq);
|
||||
int ret, host_dif;
|
||||
|
||||
if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
|
||||
|
|
@ -413,10 +413,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
this_count));
|
||||
|
||||
if (!sdp || !scsi_device_online(sdp) ||
|
||||
block + rq->nr_sectors > get_capacity(disk)) {
|
||||
block + blk_rq_sectors(rq) > get_capacity(disk)) {
|
||||
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
||||
"Finishing %ld sectors\n",
|
||||
rq->nr_sectors));
|
||||
"Finishing %u sectors\n",
|
||||
blk_rq_sectors(rq)));
|
||||
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
||||
"Retry with 0x%p\n", SCpnt));
|
||||
goto out;
|
||||
|
|
@ -463,7 +463,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
* for this.
|
||||
*/
|
||||
if (sdp->sector_size == 1024) {
|
||||
if ((block & 1) || (rq->nr_sectors & 1)) {
|
||||
if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
|
||||
scmd_printk(KERN_ERR, SCpnt,
|
||||
"Bad block number requested\n");
|
||||
goto out;
|
||||
|
|
@ -473,7 +473,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
}
|
||||
}
|
||||
if (sdp->sector_size == 2048) {
|
||||
if ((block & 3) || (rq->nr_sectors & 3)) {
|
||||
if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
|
||||
scmd_printk(KERN_ERR, SCpnt,
|
||||
"Bad block number requested\n");
|
||||
goto out;
|
||||
|
|
@ -483,7 +483,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
}
|
||||
}
|
||||
if (sdp->sector_size == 4096) {
|
||||
if ((block & 7) || (rq->nr_sectors & 7)) {
|
||||
if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
|
||||
scmd_printk(KERN_ERR, SCpnt,
|
||||
"Bad block number requested\n");
|
||||
goto out;
|
||||
|
|
@ -512,10 +512,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
|||
}
|
||||
|
||||
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
||||
"%s %d/%ld 512 byte blocks.\n",
|
||||
"%s %d/%u 512 byte blocks.\n",
|
||||
(rq_data_dir(rq) == WRITE) ?
|
||||
"writing" : "reading", this_count,
|
||||
rq->nr_sectors));
|
||||
blk_rq_sectors(rq)));
|
||||
|
||||
/* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
|
||||
host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
|
||||
|
|
@ -971,8 +971,8 @@ static struct block_device_operations sd_fops = {
|
|||
|
||||
static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
|
||||
{
|
||||
u64 start_lba = scmd->request->sector;
|
||||
u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
|
||||
u64 start_lba = blk_rq_pos(scmd->request);
|
||||
u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
|
||||
u64 bad_lba;
|
||||
int info_valid;
|
||||
|
||||
|
|
@ -1510,7 +1510,7 @@ got_data:
|
|||
*/
|
||||
sector_size = 512;
|
||||
}
|
||||
blk_queue_hardsect_size(sdp->request_queue, sector_size);
|
||||
blk_queue_logical_block_size(sdp->request_queue, sector_size);
|
||||
|
||||
{
|
||||
char cap_str_2[10], cap_str_10[10];
|
||||
|
|
|
|||
|
|
@ -507,7 +507,7 @@ void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
|
|||
sector_sz = scmd->device->sector_size;
|
||||
sectors = good_bytes / sector_sz;
|
||||
|
||||
phys = scmd->request->sector & 0xffffffff;
|
||||
phys = blk_rq_pos(scmd->request) & 0xffffffff;
|
||||
if (sector_sz == 4096)
|
||||
phys >>= 3;
|
||||
|
||||
|
|
|
|||
|
|
@ -289,8 +289,8 @@ sg_open(struct inode *inode, struct file *filp)
|
|||
if (list_empty(&sdp->sfds)) { /* no existing opens on this device */
|
||||
sdp->sgdebug = 0;
|
||||
q = sdp->device->request_queue;
|
||||
sdp->sg_tablesize = min(q->max_hw_segments,
|
||||
q->max_phys_segments);
|
||||
sdp->sg_tablesize = min(queue_max_hw_segments(q),
|
||||
queue_max_phys_segments(q));
|
||||
}
|
||||
if ((sfp = sg_add_sfp(sdp, dev)))
|
||||
filp->private_data = sfp;
|
||||
|
|
@ -909,7 +909,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
|
|||
if (val < 0)
|
||||
return -EINVAL;
|
||||
val = min_t(int, val,
|
||||
sdp->device->request_queue->max_sectors * 512);
|
||||
queue_max_sectors(sdp->device->request_queue) * 512);
|
||||
if (val != sfp->reserve.bufflen) {
|
||||
if (sg_res_in_use(sfp) || sfp->mmap_called)
|
||||
return -EBUSY;
|
||||
|
|
@ -919,7 +919,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
case SG_GET_RESERVED_SIZE:
|
||||
val = min_t(int, sfp->reserve.bufflen,
|
||||
sdp->device->request_queue->max_sectors * 512);
|
||||
queue_max_sectors(sdp->device->request_queue) * 512);
|
||||
return put_user(val, ip);
|
||||
case SG_SET_COMMAND_Q:
|
||||
result = get_user(val, ip);
|
||||
|
|
@ -1059,7 +1059,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
|
|||
return -ENODEV;
|
||||
return scsi_ioctl(sdp->device, cmd_in, p);
|
||||
case BLKSECTGET:
|
||||
return put_user(sdp->device->request_queue->max_sectors * 512,
|
||||
return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
|
||||
ip);
|
||||
case BLKTRACESETUP:
|
||||
return blk_trace_setup(sdp->device->request_queue,
|
||||
|
|
@ -1261,7 +1261,7 @@ static void sg_rq_end_io(struct request *rq, int uptodate)
|
|||
|
||||
sense = rq->sense;
|
||||
result = rq->errors;
|
||||
resid = rq->data_len;
|
||||
resid = rq->resid_len;
|
||||
|
||||
SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
|
||||
sdp->disk->disk_name, srp->header.pack_id, result));
|
||||
|
|
@ -1378,7 +1378,8 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
|
|||
sdp->device = scsidp;
|
||||
INIT_LIST_HEAD(&sdp->sfds);
|
||||
init_waitqueue_head(&sdp->o_excl_wait);
|
||||
sdp->sg_tablesize = min(q->max_hw_segments, q->max_phys_segments);
|
||||
sdp->sg_tablesize = min(queue_max_hw_segments(q),
|
||||
queue_max_phys_segments(q));
|
||||
sdp->index = k;
|
||||
kref_init(&sdp->d_ref);
|
||||
|
||||
|
|
@ -2056,7 +2057,7 @@ sg_add_sfp(Sg_device * sdp, int dev)
|
|||
sg_big_buff = def_reserved_size;
|
||||
|
||||
bufflen = min_t(int, sg_big_buff,
|
||||
sdp->device->request_queue->max_sectors * 512);
|
||||
queue_max_sectors(sdp->device->request_queue) * 512);
|
||||
sg_build_reserve(sfp, bufflen);
|
||||
SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
|
||||
sfp->reserve.bufflen, sfp->reserve.k_use_sg));
|
||||
|
|
|
|||
|
|
@ -292,7 +292,8 @@ static int sr_done(struct scsi_cmnd *SCpnt)
|
|||
if (cd->device->sector_size == 2048)
|
||||
error_sector <<= 2;
|
||||
error_sector &= ~(block_sectors - 1);
|
||||
good_bytes = (error_sector - SCpnt->request->sector) << 9;
|
||||
good_bytes = (error_sector -
|
||||
blk_rq_pos(SCpnt->request)) << 9;
|
||||
if (good_bytes < 0 || good_bytes >= this_count)
|
||||
good_bytes = 0;
|
||||
/*
|
||||
|
|
@ -349,8 +350,8 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
|
|||
cd->disk->disk_name, block));
|
||||
|
||||
if (!cd->device || !scsi_device_online(cd->device)) {
|
||||
SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n",
|
||||
rq->nr_sectors));
|
||||
SCSI_LOG_HLQUEUE(2, printk("Finishing %u sectors\n",
|
||||
blk_rq_sectors(rq)));
|
||||
SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
|
||||
goto out;
|
||||
}
|
||||
|
|
@ -413,7 +414,7 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
|
|||
/*
|
||||
* request doesn't start on hw block boundary, add scatter pads
|
||||
*/
|
||||
if (((unsigned int)rq->sector % (s_size >> 9)) ||
|
||||
if (((unsigned int)blk_rq_pos(rq) % (s_size >> 9)) ||
|
||||
(scsi_bufflen(SCpnt) % s_size)) {
|
||||
scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n");
|
||||
goto out;
|
||||
|
|
@ -422,14 +423,14 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
|
|||
this_count = (scsi_bufflen(SCpnt) >> 9) / (s_size >> 9);
|
||||
|
||||
|
||||
SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n",
|
||||
SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%u 512 byte blocks.\n",
|
||||
cd->cdi.name,
|
||||
(rq_data_dir(rq) == WRITE) ?
|
||||
"writing" : "reading",
|
||||
this_count, rq->nr_sectors));
|
||||
this_count, blk_rq_sectors(rq)));
|
||||
|
||||
SCpnt->cmnd[1] = 0;
|
||||
block = (unsigned int)rq->sector / (s_size >> 9);
|
||||
block = (unsigned int)blk_rq_pos(rq) / (s_size >> 9);
|
||||
|
||||
if (this_count > 0xffff) {
|
||||
this_count = 0xffff;
|
||||
|
|
@ -726,7 +727,7 @@ static void get_sectorsize(struct scsi_cd *cd)
|
|||
}
|
||||
|
||||
queue = cd->device->request_queue;
|
||||
blk_queue_hardsect_size(queue, sector_size);
|
||||
blk_queue_logical_block_size(queue, sector_size);
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -463,7 +463,7 @@ static void st_scsi_execute_end(struct request *req, int uptodate)
|
|||
struct scsi_tape *STp = SRpnt->stp;
|
||||
|
||||
STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
|
||||
STp->buffer->cmdstat.residual = req->data_len;
|
||||
STp->buffer->cmdstat.residual = req->resid_len;
|
||||
|
||||
if (SRpnt->waiting)
|
||||
complete(SRpnt->waiting);
|
||||
|
|
@ -3983,8 +3983,8 @@ static int st_probe(struct device *dev)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
i = min(SDp->request_queue->max_hw_segments,
|
||||
SDp->request_queue->max_phys_segments);
|
||||
i = min(queue_max_hw_segments(SDp->request_queue),
|
||||
queue_max_phys_segments(SDp->request_queue));
|
||||
if (st_max_sg_segs < i)
|
||||
i = st_max_sg_segs;
|
||||
buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
|
||||
|
|
|
|||
|
|
@ -1306,7 +1306,7 @@ static int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scs
|
|||
if (linked_comm && SCpnt->device->queue_depth > 2
|
||||
&& TLDEV(SCpnt->device->type)) {
|
||||
HD(j)->cp_stat[i] = READY;
|
||||
flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE);
|
||||
flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, FALSE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1610,11 +1610,13 @@ static int reorder(unsigned int j, unsigned long cursec,
|
|||
|
||||
if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
|
||||
|
||||
if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector;
|
||||
if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector;
|
||||
if (blk_rq_pos(SCpnt->request) < minsec)
|
||||
minsec = blk_rq_pos(SCpnt->request);
|
||||
if (blk_rq_pos(SCpnt->request) > maxsec)
|
||||
maxsec = blk_rq_pos(SCpnt->request);
|
||||
|
||||
sl[n] = SCpnt->request->sector;
|
||||
ioseek += SCpnt->request->nr_sectors;
|
||||
sl[n] = blk_rq_pos(SCpnt->request);
|
||||
ioseek += blk_rq_sectors(SCpnt->request);
|
||||
|
||||
if (!n) continue;
|
||||
|
||||
|
|
@ -1642,7 +1644,7 @@ static int reorder(unsigned int j, unsigned long cursec,
|
|||
|
||||
if (!input_only) for (n = 0; n < n_ready; n++) {
|
||||
k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
|
||||
ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->serial_number;
|
||||
ll[n] = blk_rq_sectors(SCpnt->request); pl[n] = SCpnt->serial_number;
|
||||
|
||||
if (!n) continue;
|
||||
|
||||
|
|
@ -1666,12 +1668,12 @@ static int reorder(unsigned int j, unsigned long cursec,
|
|||
if (link_statistics && (overlap || !(flushcount % link_statistics)))
|
||||
for (n = 0; n < n_ready; n++) {
|
||||
k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
|
||||
printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\
|
||||
printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\
|
||||
" cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
|
||||
(ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
|
||||
SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready,
|
||||
SCpnt->request->sector, SCpnt->request->nr_sectors, cursec,
|
||||
YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
|
||||
blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
|
||||
cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
|
||||
YESNO(overlap), cpp->xdir);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1799,7 +1801,7 @@ static irqreturn_t ihdlr(unsigned int j)
|
|||
|
||||
if (linked_comm && SCpnt->device->queue_depth > 2
|
||||
&& TLDEV(SCpnt->device->type))
|
||||
flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE);
|
||||
flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, TRUE);
|
||||
|
||||
tstatus = status_byte(spp->target_status);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue