mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-01 22:54:01 +00:00
Code Issues Releases Wiki Activity

Fixup rq_for_each_segment() indentation

Browse source 
Remove one level of nesting where appropriate.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Jens Axboe 2007-08-16 13:43:12 +02:00 committed by Jens Axboe
parent bc1c56fde6
commit 6c92e699b5
11 changed files with 133 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
block/ll_rw_blk.c
View file

@ -1364,28 +1364,28 @@ int blk_rq_map_sg(struct request_queue *q, struct request *rq,
*/ */
bvprv = NULL; bvprv = NULL;
rq_for_each_segment(bvec, rq, iter) { rq_for_each_segment(bvec, rq, iter) {
int nbytes = bvec->bv_len; int nbytes = bvec->bv_len;
if (bvprv && cluster) { if (bvprv && cluster) {
if (sg[nsegs - 1].length + nbytes > q->max_segment_size) if (sg[nsegs - 1].length + nbytes > q->max_segment_size)
goto new_segment; goto new_segment;
if (!BIOVEC_PHYS_MERGEABLE(bvprv, bvec)) if (!BIOVEC_PHYS_MERGEABLE(bvprv, bvec))
goto new_segment; goto new_segment;
if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bvec)) if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bvec))
goto new_segment; goto new_segment;
sg[nsegs - 1].length += nbytes; sg[nsegs - 1].length += nbytes;
} else { } else {
new_segment: new_segment:
memset(&sg[nsegs],0,sizeof(struct scatterlist)); memset(&sg[nsegs],0,sizeof(struct scatterlist));
sg[nsegs].page = bvec->bv_page; sg[nsegs].page = bvec->bv_page;
sg[nsegs].length = nbytes; sg[nsegs].length = nbytes;
sg[nsegs].offset = bvec->bv_offset; sg[nsegs].offset = bvec->bv_offset;
nsegs++; nsegs++;
} }
bvprv = bvec; bvprv = bvec;
} /* segments in rq */ } /* segments in rq */
return nsegs; return nsegs;

24
drivers/block/lguest_blk.c
View file

@ -147,18 +147,18 @@ static unsigned int req_to_dma(struct request *req, struct lguest_dma *dma)
struct bio_vec *bvec; struct bio_vec *bvec;
rq_for_each_segment(bvec, req, iter) { rq_for_each_segment(bvec, req, iter) {
/* We told the block layer not to give us too many. */ /* We told the block layer not to give us too many. */
BUG_ON(i == LGUEST_MAX_DMA_SECTIONS); BUG_ON(i == LGUEST_MAX_DMA_SECTIONS);
/* If we had a zero-length segment, it would look like /* If we had a zero-length segment, it would look like
* the end of the data referred to by the "struct * the end of the data referred to by the "struct
* lguest_dma", so make sure that doesn't happen. */ * lguest_dma", so make sure that doesn't happen. */
BUG_ON(!bvec->bv_len); BUG_ON(!bvec->bv_len);
/* Convert page & offset to a physical address */ /* Convert page & offset to a physical address */
dma->addr[i] = page_to_phys(bvec->bv_page) dma->addr[i] = page_to_phys(bvec->bv_page)
+ bvec->bv_offset; + bvec->bv_offset;
dma->len[i] = bvec->bv_len; dma->len[i] = bvec->bv_len;
len += bvec->bv_len; len += bvec->bv_len;
i++; i++;
} }
/* If the array isn't full, we mark the end with a 0 length */ /* If the array isn't full, we mark the end with a 0 length */
if (i < LGUEST_MAX_DMA_SECTIONS) if (i < LGUEST_MAX_DMA_SECTIONS)

43
drivers/block/nbd.c
View file

@ -212,19 +212,17 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
* whether to set MSG_MORE or not... * whether to set MSG_MORE or not...
*/ */
rq_for_each_segment(bvec, req, iter) { rq_for_each_segment(bvec, req, iter) {
flags = 0; flags = 0;
if (!rq_iter_last(req, iter)) if (!rq_iter_last(req, iter))
flags = MSG_MORE; flags = MSG_MORE;
dprintk(DBG_TX, "%s: request %p: sending %d bytes data\n", dprintk(DBG_TX, "%s: request %p: sending %d bytes data\n",
lo->disk->disk_name, req, lo->disk->disk_name, req, bvec->bv_len);
bvec->bv_len); result = sock_send_bvec(sock, bvec, flags);
result = sock_send_bvec(sock, bvec, flags); if (result <= 0) {
if (result <= 0) { printk(KERN_ERR "%s: Send data failed (result %d)\n",
printk(KERN_ERR "%s: Send data failed (result %d)\n", lo->disk->disk_name, result);
lo->disk->disk_name, goto error_out;
result); }
goto error_out;
}
} }
} }
return 0; return 0;
@ -323,16 +321,15 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
struct bio_vec *bvec; struct bio_vec *bvec;
rq_for_each_segment(bvec, req, iter) { rq_for_each_segment(bvec, req, iter) {
result = sock_recv_bvec(sock, bvec); result = sock_recv_bvec(sock, bvec);
if (result <= 0) { if (result <= 0) {
printk(KERN_ERR "%s: Receive data failed (result %d)\n", printk(KERN_ERR "%s: Receive data failed (result %d)\n",
lo->disk->disk_name, lo->disk->disk_name, result);
result); req->errors++;
req->errors++; return req;
return req; }
} dprintk(DBG_RX, "%s: request %p: got %d bytes data\n",
dprintk(DBG_RX, "%s: request %p: got %d bytes data\n", lo->disk->disk_name, req, bvec->bv_len);
lo->disk->disk_name, req, bvec->bv_len);
} }
} }
return req; return req;

19
drivers/block/ps3disk.c
View file

@ -105,16 +105,15 @@ static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
bio_sectors(iter.bio), bio_sectors(iter.bio),
(unsigned long)iter.bio->bi_sector); (unsigned long)iter.bio->bi_sector);
size = bvec->bv_len; size = bvec->bv_len;
buf = bvec_kmap_irq(bvec, &flags); buf = bvec_kmap_irq(bvec, &flags);
if (gather) if (gather)
memcpy(dev->bounce_buf+offset, buf, size); memcpy(dev->bounce_buf+offset, buf, size);
else else
memcpy(buf, dev->bounce_buf+offset, size); memcpy(buf, dev->bounce_buf+offset, size);
offset += size; offset += size;
flush_kernel_dcache_page(bvec->bv_page); flush_kernel_dcache_page(bvec->bv_page);
bvec_kunmap_irq(bvec, &flags); bvec_kunmap_irq(bvec, &flags);
i++; i++;
} }
} }

23
drivers/block/xen-blkfront.c
View file

@ -186,31 +186,30 @@ static int blkif_queue_request(struct request *req)
ring_req->nr_segments = 0; ring_req->nr_segments = 0;
rq_for_each_segment(bvec, req, iter) { rq_for_each_segment(bvec, req, iter) {
BUG_ON(ring_req->nr_segments BUG_ON(ring_req->nr_segments == BLKIF_MAX_SEGMENTS_PER_REQUEST);
== BLKIF_MAX_SEGMENTS_PER_REQUEST); buffer_mfn = pfn_to_mfn(page_to_pfn(bvec->bv_page));
buffer_mfn = pfn_to_mfn(page_to_pfn(bvec->bv_page)); fsect = bvec->bv_offset >> 9;
fsect = bvec->bv_offset >> 9; lsect = fsect + (bvec->bv_len >> 9) - 1;
lsect = fsect + (bvec->bv_len >> 9) - 1; /* install a grant reference. */
/* install a grant reference. */ ref = gnttab_claim_grant_reference(&gref_head);
ref = gnttab_claim_grant_reference(&gref_head); BUG_ON(ref == -ENOSPC);
BUG_ON(ref == -ENOSPC);
gnttab_grant_foreign_access_ref( gnttab_grant_foreign_access_ref(
ref, ref,
info->xbdev->otherend_id, info->xbdev->otherend_id,
buffer_mfn, buffer_mfn,
rq_data_dir(req) ); rq_data_dir(req) );
info->shadow[id].frame[ring_req->nr_segments] = info->shadow[id].frame[ring_req->nr_segments] =
mfn_to_pfn(buffer_mfn); mfn_to_pfn(buffer_mfn);
ring_req->seg[ring_req->nr_segments] = ring_req->seg[ring_req->nr_segments] =
(struct blkif_request_segment) { (struct blkif_request_segment) {
.gref = ref, .gref = ref,
.first_sect = fsect, .first_sect = fsect,
.last_sect = lsect }; .last_sect = lsect };
ring_req->nr_segments++; ring_req->nr_segments++;
} }
info->ring.req_prod_pvt++; info->ring.req_prod_pvt++;

36
drivers/ide/ide-floppy.c
View file

@ -612,18 +612,18 @@ static void idefloppy_input_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, uns
int count, done = 0; int count, done = 0;
rq_for_each_segment(bvec, rq, iter) { rq_for_each_segment(bvec, rq, iter) {
if (!bcount) if (!bcount)
break; break;
count = min(bvec->bv_len, bcount); count = min(bvec->bv_len, bcount);
data = bvec_kmap_irq(bvec, &flags); data = bvec_kmap_irq(bvec, &flags);
drive->hwif->atapi_input_bytes(drive, data, count); drive->hwif->atapi_input_bytes(drive, data, count);
bvec_kunmap_irq(data, &flags); bvec_kunmap_irq(data, &flags);
bcount -= count; bcount -= count;
pc->b_count += count; pc->b_count += count;
done += count; done += count;
} }
idefloppy_do_end_request(drive, 1, done >> 9); idefloppy_do_end_request(drive, 1, done >> 9);
@ -644,18 +644,18 @@ static void idefloppy_output_buffers (ide_drive_t *drive, idefloppy_pc_t *pc, un
char *data; char *data;
rq_for_each_segment(bvec, rq, iter) { rq_for_each_segment(bvec, rq, iter) {
if (!bcount) if (!bcount)
break; break;
count = min(bvec->bv_len, bcount); count = min(bvec->bv_len, bcount);
data = bvec_kmap_irq(bvec, &flags); data = bvec_kmap_irq(bvec, &flags);
drive->hwif->atapi_output_bytes(drive, data, count); drive->hwif->atapi_output_bytes(drive, data, count);
bvec_kunmap_irq(data, &flags); bvec_kunmap_irq(data, &flags);
bcount -= count; bcount -= count;
pc->b_count += count; pc->b_count += count;
done += count; done += count;
} }
idefloppy_do_end_request(drive, 1, done >> 9); idefloppy_do_end_request(drive, 1, done >> 9);

28
drivers/s390/block/dasd_diag.c
View file

@ -493,10 +493,10 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
/* Check struct bio and count the number of blocks for the request. */ /* Check struct bio and count the number of blocks for the request. */
count = 0; count = 0;
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
if (bv->bv_len & (blksize - 1)) if (bv->bv_len & (blksize - 1))
/* Fba can only do full blocks. */ /* Fba can only do full blocks. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
count += bv->bv_len >> (device->s2b_shift + 9); count += bv->bv_len >> (device->s2b_shift + 9);
} }
/* Paranoia. */ /* Paranoia. */
if (count != last_rec - first_rec + 1) if (count != last_rec - first_rec + 1)
@ -514,16 +514,16 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
dbio = dreq->bio; dbio = dreq->bio;
recid = first_rec; recid = first_rec;
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
dst = page_address(bv->bv_page) + bv->bv_offset; dst = page_address(bv->bv_page) + bv->bv_offset;
for (off = 0; off < bv->bv_len; off += blksize) { for (off = 0; off < bv->bv_len; off += blksize) {
memset(dbio, 0, sizeof (struct dasd_diag_bio)); memset(dbio, 0, sizeof (struct dasd_diag_bio));
dbio->type = rw_cmd; dbio->type = rw_cmd;
dbio->block_number = recid + 1; dbio->block_number = recid + 1;
dbio->buffer = dst; dbio->buffer = dst;
dbio++; dbio++;
dst += blksize; dst += blksize;
recid++; recid++;
} }
} }
cqr->retries = DIAG_MAX_RETRIES; cqr->retries = DIAG_MAX_RETRIES;
cqr->buildclk = get_clock(); cqr->buildclk = get_clock();

13
drivers/s390/block/dasd_eckd.c
View file

@ -1206,14 +1206,13 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
count = 0; count = 0;
cidaw = 0; cidaw = 0;
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
if (bv->bv_len & (blksize - 1)) if (bv->bv_len & (blksize - 1))
/* Eckd can only do full blocks. */ /* Eckd can only do full blocks. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
count += bv->bv_len >> (device->s2b_shift + 9); count += bv->bv_len >> (device->s2b_shift + 9);
#if defined(CONFIG_64BIT) #if defined(CONFIG_64BIT)
if (idal_is_needed (page_address(bv->bv_page), if (idal_is_needed (page_address(bv->bv_page), bv->bv_len))
bv->bv_len)) cidaw += bv->bv_len >> (device->s2b_shift + 9);
cidaw += bv->bv_len >> (device->s2b_shift + 9);
#endif #endif
} }
/* Paranoia. */ /* Paranoia. */

13
drivers/s390/block/dasd_fba.c
View file

@ -257,14 +257,13 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
count = 0; count = 0;
cidaw = 0; cidaw = 0;
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
if (bv->bv_len & (blksize - 1)) if (bv->bv_len & (blksize - 1))
/* Fba can only do full blocks. */ /* Fba can only do full blocks. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
count += bv->bv_len >> (device->s2b_shift + 9); count += bv->bv_len >> (device->s2b_shift + 9);
#if defined(CONFIG_64BIT) #if defined(CONFIG_64BIT)
if (idal_is_needed (page_address(bv->bv_page), if (idal_is_needed (page_address(bv->bv_page), bv->bv_len))
bv->bv_len)) cidaw += bv->bv_len / blksize;
cidaw += bv->bv_len / blksize;
#endif #endif
} }
/* Paranoia. */ /* Paranoia. */

19
drivers/s390/char/tape_34xx.c
View file

@ -1173,16 +1173,15 @@ tape_34xx_bread(struct tape_device *device, struct request *req)
ccw = tape_ccw_cc(ccw, NOP, 0, NULL); ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
dst = kmap(bv->bv_page) + bv->bv_offset; dst = kmap(bv->bv_page) + bv->bv_offset;
for (off = 0; off < bv->bv_len; for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
off += TAPEBLOCK_HSEC_SIZE) { ccw->flags = CCW_FLAG_CC;
ccw->flags = CCW_FLAG_CC; ccw->cmd_code = READ_FORWARD;
ccw->cmd_code = READ_FORWARD; ccw->count = TAPEBLOCK_HSEC_SIZE;
ccw->count = TAPEBLOCK_HSEC_SIZE; set_normalized_cda(ccw, (void*) __pa(dst));
set_normalized_cda(ccw, (void*) __pa(dst)); ccw++;
ccw++; dst += TAPEBLOCK_HSEC_SIZE;
dst += TAPEBLOCK_HSEC_SIZE; }
}
} }
ccw = tape_ccw_end(ccw, NOP, 0, NULL); ccw = tape_ccw_end(ccw, NOP, 0, NULL);

23
drivers/s390/char/tape_3590.c
View file

@ -652,18 +652,17 @@ tape_3590_bread(struct tape_device *device, struct request *req)
ccw = tape_ccw_cc(ccw, NOP, 0, NULL); ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
dst = page_address(bv->bv_page) + bv->bv_offset; dst = page_address(bv->bv_page) + bv->bv_offset;
for (off = 0; off < bv->bv_len; for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
off += TAPEBLOCK_HSEC_SIZE) { ccw->flags = CCW_FLAG_CC;
ccw->flags = CCW_FLAG_CC; ccw->cmd_code = READ_FORWARD;
ccw->cmd_code = READ_FORWARD; ccw->count = TAPEBLOCK_HSEC_SIZE;
ccw->count = TAPEBLOCK_HSEC_SIZE; set_normalized_cda(ccw, (void *) __pa(dst));
set_normalized_cda(ccw, (void *) __pa(dst)); ccw++;
ccw++; dst += TAPEBLOCK_HSEC_SIZE;
dst += TAPEBLOCK_HSEC_SIZE; }
} if (off > bv->bv_len)
if (off > bv->bv_len) BUG();
BUG();
} }
ccw = tape_ccw_end(ccw, NOP, 0, NULL); ccw = tape_ccw_end(ccw, NOP, 0, NULL);
DBF_EVENT(6, "xBREDccwg\n"); DBF_EVENT(6, "xBREDccwg\n");