On Tue, 06 Nov 2007 20:19:32 +0200 Boaz Harrosh <bharrosh@xxxxxxxxxxx> wrote: > > In preparation for bidi we abstract all IO members of scsi_cmnd, > that will need to duplicate, into a substructure. > > - Group all IO members of scsi_cmnd into a scsi_data_buffer > structure. > - Adjust accessors to new members. > - scsi_{alloc,free}_sgtable receive a scsi_data_buffer instead of > scsi_cmnd. And work on it. > - Adjust scsi_init_io() and scsi_release_buffers() for above > change. > - Fix other parts of scsi_lib/scsi.c to members migration. Use > accessors where appropriate. > > - fix Documentation about scsi_cmnd in scsi_host.h > > - scsi_error.c > * Changed needed members of struct scsi_eh_save. > * Careful considerations in scsi_eh_prep/restore_cmnd. > > - sd.c and sr.c > * sd and sr would adjust IO size to align on device's block > size so code needs to change once we move to scsi_data_buff > implementation. > * Convert code to use scsi_for_each_sg > * Use data accessors where appropriate. > * Remove dead code (req_data_dir() != READ && != WRITE) > > - tgt: convert libsrp to use scsi_data_buffer > - isd200: This driver still bangs on scsi_cmnd IO members, > so need changing > > Signed-off-by: Boaz Harrosh <bharrosh@xxxxxxxxxxx> > Signed-off-by: FUJITA Tomonori <fujita.tomonori@xxxxxxxxxxxxx> Hmm, checkpatch.pl complains reasonably: ./scripts/checkpatch.pl ~/Mail/kernel/scsi/28815 ERROR: use tabs not spaces #177: FILE: drivers/scsi/scsi_error.c:629: +^I^I scmd->sdb.length);$ ERROR: use tabs not spaces #237: FILE: drivers/scsi/scsi_lib.c:741: + unsigned short sg_count, gfp_t gfp_mask)$ WARNING: no space between function name and open parenthesis '(' #487: FILE: drivers/scsi/sr.c:377: + scsi_for_each_sg (SCpnt, sg, sg_count, i) ERROR: "foo* bar" should be "foo *bar" #563: FILE: include/scsi/scsi_cmnd.h:20: + struct scatterlist* sglist; total: 3 errors, 1 warnings, 482 lines checked > diff --git a/drivers/scsi/libsrp.c b/drivers/scsi/libsrp.c > index 5cff020..8a8562a 100644 > --- a/drivers/scsi/libsrp.c > +++ b/drivers/scsi/libsrp.c > @@ -426,8 +426,8 @@ int srp_cmd_queue(struct Scsi_Host *shost, struct srp_cmd *cmd, void *info, > > sc->SCp.ptr = info; > memcpy(sc->cmnd, cmd->cdb, MAX_COMMAND_SIZE); > - sc->request_bufflen = len; > - sc->request_buffer = (void *) (unsigned long) addr; > + sc->sdb.length = len; > + sc->sdb.sglist = (void *) (unsigned long) addr; > sc->tag = tag; > err = scsi_tgt_queue_command(sc, itn_id, (struct scsi_lun *)&cmd->lun, > cmd->tag); > diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c > index 1929488..73d2216 100644 > --- a/drivers/scsi/scsi.c > +++ b/drivers/scsi/scsi.c > @@ -698,7 +698,7 @@ void scsi_finish_command(struct scsi_cmnd *cmd) > "Notifying upper driver of completion " > "(result %x)\n", cmd->result)); > > - good_bytes = cmd->request_bufflen; > + good_bytes = scsi_bufflen(cmd); > if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) { > drv = scsi_cmd_to_driver(cmd); > if (drv->done) > diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c > index ebaca4c..e7b87ea 100644 > --- a/drivers/scsi/scsi_error.c > +++ b/drivers/scsi/scsi_error.c > @@ -617,29 +617,25 @@ void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses, > ses->cmd_len = scmd->cmd_len; > memcpy(ses->cmnd, scmd->cmnd, sizeof(scmd->cmnd)); > ses->data_direction = scmd->sc_data_direction; > - ses->bufflen = scmd->request_bufflen; > - ses->buffer = scmd->request_buffer; > - ses->use_sg = scmd->use_sg; > - ses->resid = scmd->resid; > + ses->sdb = scmd->sdb; > ses->result = scmd->result; > > + memset(&scmd->sdb, 0, sizeof(scmd->sdb)); > + > if (sense_bytes) { > - scmd->request_bufflen = min_t(unsigned, > + scmd->sdb.length = min_t(unsigned, > sizeof(scmd->sense_buffer), sense_bytes); > sg_init_one(&ses->sense_sgl, scmd->sense_buffer, > - scmd->request_bufflen); > - scmd->request_buffer = &ses->sense_sgl; > + scmd->sdb.length); > + scmd->sdb.sglist = &ses->sense_sgl; > scmd->sc_data_direction = DMA_FROM_DEVICE; > - scmd->use_sg = 1; > + scmd->sdb.sg_count = 1; > memset(scmd->cmnd, 0, sizeof(scmd->cmnd)); > scmd->cmnd[0] = REQUEST_SENSE; > - scmd->cmnd[4] = scmd->request_bufflen; > + scmd->cmnd[4] = scmd->sdb.length; > scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]); > } else { > - scmd->request_buffer = NULL; > - scmd->request_bufflen = 0; > scmd->sc_data_direction = DMA_NONE; > - scmd->use_sg = 0; > if (cmnd) { > memset(scmd->cmnd, 0, sizeof(scmd->cmnd)); > memcpy(scmd->cmnd, cmnd, cmnd_size); > @@ -676,10 +672,7 @@ void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses) > scmd->cmd_len = ses->cmd_len; > memcpy(scmd->cmnd, ses->cmnd, sizeof(scmd->cmnd)); > scmd->sc_data_direction = ses->data_direction; > - scmd->request_bufflen = ses->bufflen; > - scmd->request_buffer = ses->buffer; > - scmd->use_sg = ses->use_sg; > - scmd->resid = ses->resid; > + scmd->sdb = ses->sdb; > scmd->result = ses->result; > } > EXPORT_SYMBOL(scsi_eh_restore_cmnd); > @@ -1699,8 +1692,7 @@ scsi_reset_provider(struct scsi_device *dev, int flag) > memset(&scmd->cmnd, '\0', sizeof(scmd->cmnd)); > > scmd->scsi_done = scsi_reset_provider_done_command; > - scmd->request_buffer = NULL; > - scmd->request_bufflen = 0; > + memset(&scmd->sdb, 0, sizeof(scmd->sdb)); > > scmd->cmd_len = 0; > > diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c > index a8bf7cb..f904692 100644 > --- a/drivers/scsi/scsi_lib.c > +++ b/drivers/scsi/scsi_lib.c > @@ -438,7 +438,7 @@ EXPORT_SYMBOL_GPL(scsi_execute_async); > static void scsi_init_cmd_errh(struct scsi_cmnd *cmd) > { > cmd->serial_number = 0; > - cmd->resid = 0; > + scsi_set_resid(cmd, 0); > memset(cmd->sense_buffer, 0, sizeof cmd->sense_buffer); > if (cmd->cmd_len == 0) > cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]); > @@ -737,17 +737,15 @@ static inline unsigned int scsi_sgtable_index(unsigned short nents) > return index; > } > > -static struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, > - gfp_t gfp_mask) > +static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, > + unsigned short sg_count, gfp_t gfp_mask) > { > struct scsi_host_sg_pool *sgp; > struct scatterlist *sgl, *prev, *ret; > unsigned int index; > int this, left; > > - BUG_ON(!cmd->use_sg); > - > - left = cmd->use_sg; > + left = sg_count; > ret = prev = NULL; > do { > this = left; > @@ -801,8 +799,9 @@ static struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, > * ->use_sg may get modified after dma mapping has potentially > * shrunk the number of segments, so keep a copy of it for free. > */ > - cmd->__use_sg = cmd->use_sg; > - return ret; > + sdb->alloc_sg_count = sdb->sg_count = sg_count; > + sdb->sglist = ret; > + return 0; > enomem: > if (ret) { > /* > @@ -821,24 +820,24 @@ enomem: > > mempool_free(prev, sgp->pool); > } > - return NULL; > + return -1; I think that -ENOMEM is better. The other functions in scsi_lib.c (even static functions) use proper error values. > } > > -static void scsi_free_sgtable(struct scsi_cmnd *cmd) > +static void scsi_free_sgtable(struct scsi_data_buffer *sdb) > { > - struct scatterlist *sgl = cmd->request_buffer; > + struct scatterlist *sgl = sdb->sglist; > struct scsi_host_sg_pool *sgp; > > /* > * if this is the biggest size sglist, check if we have > * chained parts we need to free > */ > - if (cmd->__use_sg > SCSI_MAX_SG_SEGMENTS) { > + if (sdb->alloc_sg_count > SCSI_MAX_SG_SEGMENTS) { > unsigned short this, left; > struct scatterlist *next; > unsigned int index; > > - left = cmd->__use_sg - (SCSI_MAX_SG_SEGMENTS - 1); > + left = sdb->alloc_sg_count - (SCSI_MAX_SG_SEGMENTS - 1); > next = sg_chain_ptr(&sgl[SCSI_MAX_SG_SEGMENTS - 1]); > while (left && next) { > sgl = next; > @@ -862,10 +861,10 @@ static void scsi_free_sgtable(struct scsi_cmnd *cmd) > /* > * Restore original, will be freed below > */ > - sgl = cmd->request_buffer; > + sgl = sdb->sglist; > sgp = scsi_sg_pools + SG_MEMPOOL_NR - 1; > } else > - sgp = scsi_sg_pools + scsi_sgtable_index(cmd->__use_sg); > + sgp = scsi_sg_pools + scsi_sgtable_index(sdb->alloc_sg_count); > > mempool_free(sgl, sgp->pool); > } > @@ -889,15 +888,10 @@ static void scsi_free_sgtable(struct scsi_cmnd *cmd) > */ > void scsi_release_buffers(struct scsi_cmnd *cmd) > { > - if (cmd->use_sg) > - scsi_free_sgtable(cmd); > + if (cmd->sdb.sglist) > + scsi_free_sgtable(&cmd->sdb); > > - /* > - * Zero these out. They now point to freed memory, and it is > - * dangerous to hang onto the pointers. > - */ > - cmd->request_buffer = NULL; > - cmd->request_bufflen = 0; > + memset(&cmd->sdb, 0, sizeof(cmd->sdb)); > } > EXPORT_SYMBOL(scsi_release_buffers); > > @@ -932,7 +926,7 @@ EXPORT_SYMBOL(scsi_release_buffers); > void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) > { > int result = cmd->result; > - int this_count = cmd->request_bufflen; > + int this_count = scsi_bufflen(cmd); > struct request_queue *q = cmd->device->request_queue; > struct request *req = cmd->request; > int clear_errors = 1; > @@ -940,8 +934,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) > int sense_valid = 0; > int sense_deferred = 0; > > - scsi_release_buffers(cmd); > - > if (result) { > sense_valid = scsi_command_normalize_sense(cmd, &sshdr); > if (sense_valid) > @@ -964,9 +956,11 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) > req->sense_len = len; > } > } > - req->data_len = cmd->resid; > + req->data_len = scsi_get_resid(cmd); > } > > + scsi_release_buffers(cmd); > + > /* > * Next deal with any sectors which we were able to correctly > * handle. > @@ -974,7 +968,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) > SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, " > "%d bytes done.\n", > req->nr_sectors, good_bytes)); > - SCSI_LOG_HLCOMPLETE(1, printk("use_sg is %d\n", cmd->use_sg)); > > if (clear_errors) > req->errors = 0; > @@ -1106,41 +1099,31 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask) > { > struct request *req = cmd->request; > int count; > + struct scsi_data_buffer *sdb = &cmd->sdb; > > - /* > - * We used to not use scatter-gather for single segment request, > - * but now we do (it makes highmem I/O easier to support without > - * kmapping pages) > - */ > - cmd->use_sg = req->nr_phys_segments; > - > - /* > - * If sg table allocation fails, requeue request later. > - */ > - cmd->request_buffer = scsi_alloc_sgtable(cmd, gfp_mask); > - if (unlikely(!cmd->request_buffer)) { > + if (scsi_alloc_sgtable(sdb, req->nr_phys_segments, gfp_mask)) { IIRC, preferable style is: ret = scsi_alloc_sgtable(sdb, req->nr_phys_segments, gfp_mask); if (ret) { > scsi_unprep_request(req); > return BLKPREP_DEFER; > } > > req->buffer = NULL; > if (blk_pc_request(req)) > - cmd->request_bufflen = req->data_len; > + sdb->length = req->data_len; > else > - cmd->request_bufflen = req->nr_sectors << 9; > + sdb->length = req->nr_sectors << 9; > > /* > * Next, walk the list, and fill in the addresses and sizes of > * each segment. > */ > - count = blk_rq_map_sg(req->q, req, cmd->request_buffer); > - if (likely(count <= cmd->use_sg)) { > - cmd->use_sg = count; > + count = blk_rq_map_sg(req->q, req, sdb->sglist); > + if (likely(count <= sdb->sg_count)) { > + sdb->sg_count = count; > return BLKPREP_OK; > } > > printk(KERN_ERR "Incorrect number of segments after building list\n"); > - printk(KERN_ERR "counted %d, received %d\n", count, cmd->use_sg); > + printk(KERN_ERR "counted %d, received %d\n", count, sdb->sg_count); > printk(KERN_ERR "req nr_sec %lu, cur_nr_sec %u\n", req->nr_sectors, > req->current_nr_sectors); > > @@ -1199,9 +1182,7 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req) > BUG_ON(req->data_len); > BUG_ON(req->data); > > - cmd->request_bufflen = 0; > - cmd->request_buffer = NULL; > - cmd->use_sg = 0; > + memset(&cmd->sdb, 0, sizeof(cmd->sdb)); > req->buffer = NULL; > } > > diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c > index 18343a6..28cf6fe 100644 > --- a/drivers/scsi/sd.c > +++ b/drivers/scsi/sd.c > @@ -448,9 +448,6 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq) > } else if (rq_data_dir(rq) == READ) { > SCpnt->cmnd[0] = READ_6; > SCpnt->sc_data_direction = DMA_FROM_DEVICE; > - } else { > - scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags); > - goto out; This should go to the bidi patch? > } > > SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, > @@ -510,7 +507,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq) > SCpnt->cmnd[4] = (unsigned char) this_count; > SCpnt->cmnd[5] = 0; > } > - SCpnt->request_bufflen = this_count * sdp->sector_size; > + SCpnt->sdb.length = this_count * sdp->sector_size; > > /* > * We shouldn't disconnect in the middle of a sector, so with a dumb > @@ -910,7 +907,7 @@ static struct block_device_operations sd_fops = { > static int sd_done(struct scsi_cmnd *SCpnt) > { > int result = SCpnt->result; > - unsigned int xfer_size = SCpnt->request_bufflen; > + unsigned int xfer_size = scsi_bufflen(SCpnt); > unsigned int good_bytes = result ? 0 : xfer_size; > u64 start_lba = SCpnt->request->sector; > u64 bad_lba; > diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c > index 7702681..6d3bf41 100644 > --- a/drivers/scsi/sr.c > +++ b/drivers/scsi/sr.c > @@ -226,7 +226,7 @@ out: > static int sr_done(struct scsi_cmnd *SCpnt) > { > int result = SCpnt->result; > - int this_count = SCpnt->request_bufflen; > + int this_count = scsi_bufflen(SCpnt); > int good_bytes = (result == 0 ? this_count : 0); > int block_sectors = 0; > long error_sector; > @@ -368,23 +368,21 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq) > } else if (rq_data_dir(rq) == READ) { > SCpnt->cmnd[0] = READ_10; > SCpnt->sc_data_direction = DMA_FROM_DEVICE; > - } else { > - blk_dump_rq_flags(rq, "Unknown sr command"); > - goto out; Ditto. > } > > { > - struct scatterlist *sg = SCpnt->request_buffer; > - int i, size = 0; > - for (i = 0; i < SCpnt->use_sg; i++) > - size += sg[i].length; > + struct scatterlist *sg; > + int i, size = 0, sg_count = scsi_sg_count(SCpnt); > + > + scsi_for_each_sg (SCpnt, sg, sg_count, i) > + size += sg->length; > > - if (size != SCpnt->request_bufflen && SCpnt->use_sg) { > + if (size != scsi_bufflen(SCpnt)) { > scmd_printk(KERN_ERR, SCpnt, > "mismatch count %d, bytes %d\n", > - size, SCpnt->request_bufflen); > - if (SCpnt->request_bufflen > size) > - SCpnt->request_bufflen = size; > + size, scsi_bufflen(SCpnt)); > + if (scsi_bufflen(SCpnt) > size) > + SCpnt->sdb.length = size; > } > } > > @@ -392,12 +390,12 @@ 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)) || > - (SCpnt->request_bufflen % s_size)) { > + (scsi_bufflen(SCpnt) % s_size)) { > scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n"); > goto out; > } > > - this_count = (SCpnt->request_bufflen >> 9) / (s_size >> 9); > + this_count = (scsi_bufflen(SCpnt) >> 9) / (s_size >> 9); > > > SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n", > @@ -411,7 +409,7 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq) > > if (this_count > 0xffff) { > this_count = 0xffff; > - SCpnt->request_bufflen = this_count * s_size; > + SCpnt->sdb.length = this_count * s_size; > } > > SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff; > diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c > index 178e8c2..2d9a32b 100644 > --- a/drivers/usb/storage/isd200.c > +++ b/drivers/usb/storage/isd200.c > @@ -415,14 +415,14 @@ static void isd200_set_srb(struct isd200_info *info, > sg_init_one(&info->sg, buff, bufflen); > > srb->sc_data_direction = dir; > - srb->request_buffer = buff ? &info->sg : NULL; > - srb->request_bufflen = bufflen; > - srb->use_sg = buff ? 1 : 0; > + srb->sdb.sglist = buff ? &info->sg : NULL; > + srb->sdb.length = bufflen; > + srb->sdb.sg_count = buff ? 1 : 0; > } > > static void isd200_srb_set_bufflen(struct scsi_cmnd *srb, unsigned bufflen) > { > - srb->request_bufflen = bufflen; > + srb->sdb.length = bufflen; > } > > > diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h > index a7be605..4e3cf43 100644 > --- a/include/scsi/scsi_cmnd.h > +++ b/include/scsi/scsi_cmnd.h > @@ -12,6 +12,13 @@ struct scatterlist; > struct Scsi_Host; > struct scsi_device; > > +struct scsi_data_buffer { > + unsigned length; > + int resid; > + unsigned short sg_count; > + unsigned short alloc_sg_count; sg_count and alloc_sg_count are a bit lengthy? My suggestion is using nr_* like the block layer (nr_sg and nr_alloc_sg ?). > + struct scatterlist* sglist; > +}; > > /* embedded in scsi_cmnd */ > struct scsi_pointer { > @@ -62,15 +69,10 @@ struct scsi_cmnd { > /* These elements define the operation we are about to perform */ > #define MAX_COMMAND_SIZE 16 > unsigned char cmnd[MAX_COMMAND_SIZE]; > - unsigned request_bufflen; /* Actual request size */ > > struct timer_list eh_timeout; /* Used to time out the command. */ > - void *request_buffer; /* Actual requested buffer */ > > /* These elements define the operation we ultimately want to perform */ > - unsigned short use_sg; /* Number of pieces of scatter-gather */ > - unsigned short __use_sg; > - > unsigned underflow; /* Return error if less than > this amount is transferred */ > > @@ -80,10 +82,6 @@ struct scsi_cmnd { > reconnects. Probably == sector > size */ > > - int resid; /* Number of bytes requested to be > - transferred less actual number > - transferred (0 if not supported) */ > - > struct request *request; /* The command we are > working on */ > > @@ -114,6 +112,8 @@ struct scsi_cmnd { > int result; /* Status code from lower level driver */ > > unsigned char tag; /* SCSI-II queued command tag */ > + > + struct scsi_data_buffer sdb; > }; > > extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t); > @@ -134,18 +134,29 @@ extern void scsi_release_buffers(struct scsi_cmnd *cmd); > extern int scsi_dma_map(struct scsi_cmnd *cmd); > extern void scsi_dma_unmap(struct scsi_cmnd *cmd); > > -#define scsi_sg_count(cmd) ((cmd)->use_sg) > -#define scsi_sglist(cmd) ((struct scatterlist *)(cmd)->request_buffer) > -#define scsi_bufflen(cmd) ((cmd)->request_bufflen) > +static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd) > +{ > + return cmd->sdb.sg_count; > +} > + > +static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd) > +{ > + return cmd->sdb.sglist; > +} > + > +static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd) > +{ > + return cmd->sdb.length; > +} > > static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid) > { > - cmd->resid = resid; > + cmd->sdb.resid = resid; > } > > static inline int scsi_get_resid(struct scsi_cmnd *cmd) > { > - return cmd->resid; > + return cmd->sdb.resid; > } > > #define scsi_for_each_sg(cmd, sg, nseg, __i) \ > diff --git a/include/scsi/scsi_eh.h b/include/scsi/scsi_eh.h > index d21b891..1e08be1 100644 > --- a/include/scsi/scsi_eh.h > +++ b/include/scsi/scsi_eh.h > @@ -68,16 +68,14 @@ extern int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len, > extern int scsi_reset_provider(struct scsi_device *, int); > > struct scsi_eh_save { > + /* saved state */ > int result; > enum dma_data_direction data_direction; > unsigned char cmd_len; > unsigned char cmnd[MAX_COMMAND_SIZE]; > + struct scsi_data_buffer sdb; > > - void *buffer; > - unsigned bufflen; > - unsigned short use_sg; > - int resid; > - > + /* new command support */ > struct scatterlist sense_sgl; > }; > > diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h > index 0fd4746..cb2bcab 100644 > --- a/include/scsi/scsi_host.h > +++ b/include/scsi/scsi_host.h > @@ -136,9 +136,9 @@ struct scsi_host_template { > * the done callback is invoked. > * > * This is called to inform the LLD to transfer > - * cmd->request_bufflen bytes. The cmd->use_sg speciefies the > + * scsi_bufflen(cmd) bytes. scsi_sg_count(cmd) speciefies the > * number of scatterlist entried in the command and > - * cmd->request_buffer contains the scatterlist. > + * scsi_sglist(cmd) returns the scatterlist. > * > * return values: see queuecommand > * > -- > 1.5.3.1 > > > - > To unsubscribe from this list: send the line "unsubscribe linux-scsi" in > the body of a message to majordomo@xxxxxxxxxxxxxxx > More majordomo info at http://vger.kernel.org/majordomo-info.html - To unsubscribe from this list: send the line "unsubscribe linux-scsi" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html