Commit b4f42e28 authored by Jens Axboe's avatar Jens Axboe
Browse files

block: remove struct request buffer member 



This was used in the olden days, back when onions were proper
yellow. Basically it mapped to the current buffer to be
transferred. With highmem being added more than a decade ago,
most drivers map pages out of a bio, and rq->buffer isn't
pointing at anything valid.

Convert old style drivers to just use bio_data().

For the discard payload use case, just reference the page
in the bio.

Signed-off-by: default avatarJens Axboe <axboe@fb.com>
parent f89e0dd9

block/blk-core.c

+6 −15
Original line number Diff line number Diff line
@@ -146,8 +146,8 @@ void blk_dump_rq_flags(struct request *rq, char *msg) 
	printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",

	       (unsigned long long)blk_rq_pos(rq),

	       blk_rq_sectors(rq), blk_rq_cur_sectors(rq));

	printk(KERN_INFO "  bio %p, biotail %p, buffer %p, len %u\n",

	       rq->bio, rq->biotail, rq->buffer, blk_rq_bytes(rq));

	printk(KERN_INFO "  bio %p, biotail %p, len %u\n",

	       rq->bio, rq->biotail, blk_rq_bytes(rq));



	if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {

		printk(KERN_INFO "  cdb: ");
@@ -1360,7 +1360,6 @@ void blk_add_request_payload(struct request *rq, struct page *page, 


	rq->__data_len = rq->resid_len = len;

	rq->nr_phys_segments = 1;

	rq->buffer = bio_data(bio);

}

EXPORT_SYMBOL_GPL(blk_add_request_payload);
@@ -1402,12 +1401,6 @@ bool bio_attempt_front_merge(struct request_queue *q, struct request *req, 
	bio->bi_next = req->bio;

	req->bio = bio;



	/*

	 * may not be valid. if the low level driver said

	 * it didn't need a bounce buffer then it better

	 * not touch req->buffer either...

	 */

	req->buffer = bio_data(bio);

	req->__sector = bio->bi_iter.bi_sector;

	req->__data_len += bio->bi_iter.bi_size;

	req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));
@@ -2434,7 +2427,6 @@ bool blk_update_request(struct request *req, int error, unsigned int nr_bytes) 
	}



	req->__data_len -= total_bytes;

	req->buffer = bio_data(req->bio);



	/* update sector only for requests with clear definition of sector */

	if (req->cmd_type == REQ_TYPE_FS)
@@ -2752,10 +2744,9 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq, 
	/* Bit 0 (R/W) is identical in rq->cmd_flags and bio->bi_rw */

	rq->cmd_flags |= bio->bi_rw & REQ_WRITE;



	if (bio_has_data(bio)) {

	if (bio_has_data(bio))

		rq->nr_phys_segments = bio_phys_segments(q, bio);

		rq->buffer = bio_data(bio);

	}



	rq->__data_len = bio->bi_iter.bi_size;

	rq->bio = rq->biotail = bio;
@@ -2831,7 +2822,7 @@ EXPORT_SYMBOL_GPL(blk_rq_unprep_clone); 


/*

 * Copy attributes of the original request to the clone request.

 * The actual data parts (e.g. ->cmd, ->buffer, ->sense) are not copied.

 * The actual data parts (e.g. ->cmd, ->sense) are not copied.

 */

static void __blk_rq_prep_clone(struct request *dst, struct request *src)

{
@@ -2857,7 +2848,7 @@ static void __blk_rq_prep_clone(struct request *dst, struct request *src) 
 *

 * Description:

 *     Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq.

 *     The actual data parts of @rq_src (e.g. ->cmd, ->buffer, ->sense)

 *     The actual data parts of @rq_src (e.g. ->cmd, ->sense)

 *     are not copied, and copying such parts is the caller's responsibility.

 *     Also, pages which the original bios are pointing to are not copied

 *     and the cloned bios just point same pages.

block/blk-map.c

+0 −3
Original line number Diff line number Diff line
@@ -155,7 +155,6 @@ int blk_rq_map_user(struct request_queue *q, struct request *rq, 
	if (!bio_flagged(bio, BIO_USER_MAPPED))

		rq->cmd_flags |= REQ_COPY_USER;



	rq->buffer = NULL;

	return 0;

unmap_rq:

	blk_rq_unmap_user(bio);
@@ -238,7 +237,6 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq, 
	blk_queue_bounce(q, &bio);

	bio_get(bio);

	blk_rq_bio_prep(q, rq, bio);

	rq->buffer = NULL;

	return 0;

}

EXPORT_SYMBOL(blk_rq_map_user_iov);
@@ -325,7 +323,6 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf, 
	}



	blk_queue_bounce(q, &rq->bio);

	rq->buffer = NULL;

	return 0;

}

EXPORT_SYMBOL(blk_rq_map_kern);

drivers/block/amiflop.c

+1 −1
Original line number Diff line number Diff line
@@ -1406,7 +1406,7 @@ static void redo_fd_request(void) 


		track = block / (floppy->dtype->sects * floppy->type->sect_mult);

		sector = block % (floppy->dtype->sects * floppy->type->sect_mult);

		data = rq->buffer + 512 * cnt;

		data = bio_data(rq->bio) + 512 * cnt;

#ifdef DEBUG

		printk("access to track %d, sector %d, with buffer at "

		       "0x%08lx\n", track, sector, data);

drivers/block/ataflop.c

+1 −1
Original line number Diff line number Diff line
@@ -1484,7 +1484,7 @@ static void redo_fd_request(void) 
	ReqCnt = 0;

	ReqCmd = rq_data_dir(fd_request);

	ReqBlock = blk_rq_pos(fd_request);

	ReqBuffer = fd_request->buffer;

	ReqBuffer = bio_data(fd_request->bio);

	setup_req_params( drive );

	do_fd_action( drive );

drivers/block/floppy.c

+9 −9
Original line number Diff line number Diff line
@@ -2351,7 +2351,7 @@ static void rw_interrupt(void) 
	}



	if (CT(COMMAND) != FD_READ ||

	    raw_cmd->kernel_data == current_req->buffer) {

	    raw_cmd->kernel_data == bio_data(current_req->bio)) {

		/* transfer directly from buffer */

		cont->done(1);

	} else if (CT(COMMAND) == FD_READ) {
@@ -2640,7 +2640,7 @@ static int make_raw_rw_request(void) 
		raw_cmd->flags &= ~FD_RAW_WRITE;

		raw_cmd->flags |= FD_RAW_READ;

		COMMAND = FM_MODE(_floppy, FD_READ);

	} else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {

	} else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) {

		unsigned long dma_limit;

		int direct, indirect;
@@ -2654,13 +2654,13 @@ static int make_raw_rw_request(void) 
		 */

		max_size = buffer_chain_size();

		dma_limit = (MAX_DMA_ADDRESS -

			     ((unsigned long)current_req->buffer)) >> 9;

			     ((unsigned long)bio_data(current_req->bio))) >> 9;

		if ((unsigned long)max_size > dma_limit)

			max_size = dma_limit;

		/* 64 kb boundaries */

		if (CROSS_64KB(current_req->buffer, max_size << 9))

		if (CROSS_64KB(bio_data(current_req->bio), max_size << 9))

			max_size = (K_64 -

				    ((unsigned long)current_req->buffer) %

				    ((unsigned long)bio_data(current_req->bio)) %

				    K_64) >> 9;

		direct = transfer_size(ssize, max_sector, max_size) - fsector_t;

		/*
@@ -2677,7 +2677,7 @@ static int make_raw_rw_request(void) 
		       (DP->read_track & (1 << DRS->probed_format)))))) {

			max_size = blk_rq_sectors(current_req);

		} else {

			raw_cmd->kernel_data = current_req->buffer;

			raw_cmd->kernel_data = bio_data(current_req->bio);

			raw_cmd->length = current_count_sectors << 9;

			if (raw_cmd->length == 0) {

				DPRINT("%s: zero dma transfer attempted\n", __func__);
@@ -2731,7 +2731,7 @@ static int make_raw_rw_request(void) 
	raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;

	raw_cmd->length <<= 9;

	if ((raw_cmd->length < current_count_sectors << 9) ||

	    (raw_cmd->kernel_data != current_req->buffer &&

	    (raw_cmd->kernel_data != bio_data(current_req->bio) &&

	     CT(COMMAND) == FD_WRITE &&

	     (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||

	      aligned_sector_t < buffer_min)) ||
@@ -2739,7 +2739,7 @@ static int make_raw_rw_request(void) 
	    raw_cmd->length <= 0 || current_count_sectors <= 0) {

		DPRINT("fractionary current count b=%lx s=%lx\n",

		       raw_cmd->length, current_count_sectors);

		if (raw_cmd->kernel_data != current_req->buffer)

		if (raw_cmd->kernel_data != bio_data(current_req->bio))

			pr_info("addr=%d, length=%ld\n",

				(int)((raw_cmd->kernel_data -

				       floppy_track_buffer) >> 9),
@@ -2756,7 +2756,7 @@ static int make_raw_rw_request(void) 
		return 0;

	}



	if (raw_cmd->kernel_data != current_req->buffer) {

	if (raw_cmd->kernel_data != bio_data(current_req->bio)) {

		if (raw_cmd->kernel_data < floppy_track_buffer ||

		    current_count_sectors < 0 ||

		    raw_cmd->length < 0 ||