Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a0725ab0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-4.14/block' of git://git.kernel.dk/linux-block 

Pull block layer updates from Jens Axboe:
 "This is the first pull request for 4.14, containing most of the code
  changes. It's a quiet series this round, which I think we needed after
  the churn of the last few series. This contains:

   - Fix for a registration race in loop, from Anton Volkov.

   - Overflow complaint fix from Arnd for DAC960.

   - Series of drbd changes from the usual suspects.

   - Conversion of the stec/skd driver to blk-mq. From Bart.

   - A few BFQ improvements/fixes from Paolo.

   - CFQ improvement from Ritesh, allowing idling for group idle.

   - A few fixes found by Dan's smatch, courtesy of Dan.

   - A warning fixup for a race between changing the IO scheduler and
     device remova. From David Jeffery.

   - A few nbd fixes from Josef.

   - Support for cgroup info in blktrace, from Shaohua.

   - Also from Shaohua, new features in the null_blk driver to allow it
     to actually hold data, among other things.

   - Various corner cases and error handling fixes from Weiping Zhang.

   - Improvements to the IO stats tracking for blk-mq from me. Can
     drastically improve performance for fast devices and/or big
     machines.

   - Series from Christoph removing bi_bdev as being needed for IO
     submission, in preparation for nvme multipathing code.

   - Series from Bart, including various cleanups and fixes for switch
     fall through case complaints"

* 'for-4.14/block' of git://git.kernel.dk/linux-block: (162 commits)
  kernfs: checking for IS_ERR() instead of NULL
  drbd: remove BIOSET_NEED_RESCUER flag from drbd_{md_,}io_bio_set
  drbd: Fix allyesconfig build, fix recent commit
  drbd: switch from kmalloc() to kmalloc_array()
  drbd: abort drbd_start_resync if there is no connection
  drbd: move global variables to drbd namespace and make some static
  drbd: rename "usermode_helper" to "drbd_usermode_helper"
  drbd: fix race between handshake and admin disconnect/down
  drbd: fix potential deadlock when trying to detach during handshake
  drbd: A single dot should be put into a sequence.
  drbd: fix rmmod cleanup, remove _all_ debugfs entries
  drbd: Use setup_timer() instead of init_timer() to simplify the code.
  drbd: fix potential get_ldev/put_ldev refcount imbalance during attach
  drbd: new disk-option disable-write-same
  drbd: Fix resource role for newly created resources in events2
  drbd: mark symbols static where possible
  drbd: Send P_NEG_ACK upon write error in protocol != C
  drbd: add explicit plugging when submitting batches
  drbd: change list_for_each_safe to while(list_first_entry_or_null)
  drbd: introduce drbd_recv_header_maybe_unplug
  ...
parents 3ee31b89 ef13ecbc

MAINTAINERS

+6 −0
Original line number Diff line number Diff line
@@ -12561,6 +12561,12 @@ M: Ion Badulescu <ionut@badula.org> 
S:	Odd Fixes

F:	drivers/net/ethernet/adaptec/starfire*



STEC S1220 SKD DRIVER

M:	Bart Van Assche <bart.vanassche@wdc.com>

L:	linux-block@vger.kernel.org

S:	Maintained

F:	drivers/block/skd*[ch]



STI CEC DRIVER

M:	Benjamin Gaignard <benjamin.gaignard@linaro.org>

S:	Maintained

arch/powerpc/sysdev/axonram.c

+1 −1
Original line number Diff line number Diff line
@@ -110,7 +110,7 @@ axon_ram_irq_handler(int irq, void *dev) 
static blk_qc_t

axon_ram_make_request(struct request_queue *queue, struct bio *bio)

{

	struct axon_ram_bank *bank = bio->bi_bdev->bd_disk->private_data;

	struct axon_ram_bank *bank = bio->bi_disk->private_data;

	unsigned long phys_mem, phys_end;

	void *user_mem;

	struct bio_vec vec;

block/bfq-iosched.c

+100 −82
Original line number Diff line number Diff line
@@ -128,7 +128,7 @@ BFQ_BFQQ_FNS(busy); 
BFQ_BFQQ_FNS(wait_request);

BFQ_BFQQ_FNS(non_blocking_wait_rq);

BFQ_BFQQ_FNS(fifo_expire);

BFQ_BFQQ_FNS(idle_window);

BFQ_BFQQ_FNS(has_short_ttime);

BFQ_BFQQ_FNS(sync);

BFQ_BFQQ_FNS(IO_bound);

BFQ_BFQQ_FNS(in_large_burst);
@@ -731,10 +731,10 @@ bfq_bfqq_resume_state(struct bfq_queue *bfqq, struct bfq_data *bfqd, 
	unsigned int old_wr_coeff = bfqq->wr_coeff;

	bool busy = bfq_already_existing && bfq_bfqq_busy(bfqq);



	if (bic->saved_idle_window)

		bfq_mark_bfqq_idle_window(bfqq);

	if (bic->saved_has_short_ttime)

		bfq_mark_bfqq_has_short_ttime(bfqq);

	else

		bfq_clear_bfqq_idle_window(bfqq);

		bfq_clear_bfqq_has_short_ttime(bfqq);



	if (bic->saved_IO_bound)

		bfq_mark_bfqq_IO_bound(bfqq);
@@ -2012,7 +2012,7 @@ static void bfq_bfqq_save_state(struct bfq_queue *bfqq) 
		return;



	bic->saved_ttime = bfqq->ttime;

	bic->saved_idle_window = bfq_bfqq_idle_window(bfqq);

	bic->saved_has_short_ttime = bfq_bfqq_has_short_ttime(bfqq);

	bic->saved_IO_bound = bfq_bfqq_IO_bound(bfqq);

	bic->saved_in_large_burst = bfq_bfqq_in_large_burst(bfqq);

	bic->was_in_burst_list = !hlist_unhashed(&bfqq->burst_list_node);
@@ -3038,8 +3038,8 @@ void bfq_bfqq_expire(struct bfq_data *bfqd, 
	}



	bfq_log_bfqq(bfqd, bfqq,

		"expire (%d, slow %d, num_disp %d, idle_win %d)", reason,

		slow, bfqq->dispatched, bfq_bfqq_idle_window(bfqq));

		"expire (%d, slow %d, num_disp %d, short_ttime %d)", reason,

		slow, bfqq->dispatched, bfq_bfqq_has_short_ttime(bfqq));



	/*

	 * Increase, decrease or leave budget unchanged according to
@@ -3114,35 +3114,56 @@ static bool bfq_may_expire_for_budg_timeout(struct bfq_queue *bfqq) 
static bool bfq_bfqq_may_idle(struct bfq_queue *bfqq)

{

	struct bfq_data *bfqd = bfqq->bfqd;

	bool idling_boosts_thr, idling_boosts_thr_without_issues,

	bool rot_without_queueing =

		!blk_queue_nonrot(bfqd->queue) && !bfqd->hw_tag,

		bfqq_sequential_and_IO_bound,

		idling_boosts_thr, idling_boosts_thr_without_issues,

		idling_needed_for_service_guarantees,

		asymmetric_scenario;



	if (bfqd->strict_guarantees)

		return true;



	/*

	 * Idling is performed only if slice_idle > 0. In addition, we

	 * do not idle if

	 * (a) bfqq is async

	 * (b) bfqq is in the idle io prio class: in this case we do

	 * not idle because we want to minimize the bandwidth that

	 * queues in this class can steal to higher-priority queues

	 */

	if (bfqd->bfq_slice_idle == 0 || !bfq_bfqq_sync(bfqq) ||

	    bfq_class_idle(bfqq))

		return false;



	bfqq_sequential_and_IO_bound = !BFQQ_SEEKY(bfqq) &&

		bfq_bfqq_IO_bound(bfqq) && bfq_bfqq_has_short_ttime(bfqq);



	/*

	 * The next variable takes into account the cases where idling

	 * boosts the throughput.

	 *

	 * The value of the variable is computed considering, first, that

	 * idling is virtually always beneficial for the throughput if:

	 * (a) the device is not NCQ-capable, or

	 * (b) regardless of the presence of NCQ, the device is rotational

	 *     and the request pattern for bfqq is I/O-bound and sequential.

	 * (a) the device is not NCQ-capable and rotational, or

	 * (b) regardless of the presence of NCQ, the device is rotational and

	 *     the request pattern for bfqq is I/O-bound and sequential, or

	 * (c) regardless of whether it is rotational, the device is

	 *     not NCQ-capable and the request pattern for bfqq is

	 *     I/O-bound and sequential.

	 *

	 * Secondly, and in contrast to the above item (b), idling an

	 * NCQ-capable flash-based device would not boost the

	 * throughput even with sequential I/O; rather it would lower

	 * the throughput in proportion to how fast the device

	 * is. Accordingly, the next variable is true if any of the

	 * above conditions (a) and (b) is true, and, in particular,

	 * happens to be false if bfqd is an NCQ-capable flash-based

	 * device.

	 * above conditions (a), (b) or (c) is true, and, in

	 * particular, happens to be false if bfqd is an NCQ-capable

	 * flash-based device.

	 */

	idling_boosts_thr = !bfqd->hw_tag ||

		(!blk_queue_nonrot(bfqd->queue) && bfq_bfqq_IO_bound(bfqq) &&

		 bfq_bfqq_idle_window(bfqq));

	idling_boosts_thr = rot_without_queueing ||

		((!blk_queue_nonrot(bfqd->queue) || !bfqd->hw_tag) &&

		 bfqq_sequential_and_IO_bound);



	/*

	 * The value of the next variable,
@@ -3313,16 +3334,13 @@ static bool bfq_bfqq_may_idle(struct bfq_queue *bfqq) 
		asymmetric_scenario && !bfq_bfqq_in_large_burst(bfqq);



	/*

	 * We have now all the components we need to compute the return

	 * value of the function, which is true only if both the following

	 * conditions hold:

	 * 1) bfqq is sync, because idling make sense only for sync queues;

	 * 2) idling either boosts the throughput (without issues), or

	 *    is necessary to preserve service guarantees.

	 * We have now all the components we need to compute the

	 * return value of the function, which is true only if idling

	 * either boosts the throughput (without issues), or is

	 * necessary to preserve service guarantees.

	 */

	return bfq_bfqq_sync(bfqq) &&

		(idling_boosts_thr_without_issues ||

		 idling_needed_for_service_guarantees);

	return idling_boosts_thr_without_issues ||

		idling_needed_for_service_guarantees;

}



/*
@@ -3338,10 +3356,7 @@ static bool bfq_bfqq_may_idle(struct bfq_queue *bfqq) 
 */

static bool bfq_bfqq_must_idle(struct bfq_queue *bfqq)

{

	struct bfq_data *bfqd = bfqq->bfqd;



	return RB_EMPTY_ROOT(&bfqq->sort_list) && bfqd->bfq_slice_idle != 0 &&

	       bfq_bfqq_may_idle(bfqq);

	return RB_EMPTY_ROOT(&bfqq->sort_list) && bfq_bfqq_may_idle(bfqq);

}



/*
@@ -3783,7 +3798,6 @@ bfq_set_next_ioprio_data(struct bfq_queue *bfqq, struct bfq_io_cq *bic) 
	case IOPRIO_CLASS_IDLE:

		bfqq->new_ioprio_class = IOPRIO_CLASS_IDLE;

		bfqq->new_ioprio = 7;

		bfq_clear_bfqq_idle_window(bfqq);

		break;

	}
@@ -3843,8 +3857,14 @@ static void bfq_init_bfqq(struct bfq_data *bfqd, struct bfq_queue *bfqq, 
		bfq_set_next_ioprio_data(bfqq, bic);



	if (is_sync) {

		/*

		 * No need to mark as has_short_ttime if in

		 * idle_class, because no device idling is performed

		 * for queues in idle class

		 */

		if (!bfq_class_idle(bfqq))

			bfq_mark_bfqq_idle_window(bfqq);

			/* tentatively mark as has_short_ttime */

			bfq_mark_bfqq_has_short_ttime(bfqq);

		bfq_mark_bfqq_sync(bfqq);

		bfq_mark_bfqq_just_created(bfqq);

	} else
@@ -3985,18 +4005,19 @@ bfq_update_io_seektime(struct bfq_data *bfqd, struct bfq_queue *bfqq, 
		 blk_rq_sectors(rq) < BFQQ_SECT_THR_NONROT);

}



/*

 * Disable idle window if the process thinks too long or seeks so much that

 * it doesn't matter.

 */

static void bfq_update_idle_window(struct bfq_data *bfqd,

static void bfq_update_has_short_ttime(struct bfq_data *bfqd,

				       struct bfq_queue *bfqq,

				       struct bfq_io_cq *bic)

{

	int enable_idle;

	bool has_short_ttime = true;



	/* Don't idle for async or idle io prio class. */

	if (!bfq_bfqq_sync(bfqq) || bfq_class_idle(bfqq))

	/*

	 * No need to update has_short_ttime if bfqq is async or in

	 * idle io prio class, or if bfq_slice_idle is zero, because

	 * no device idling is performed for bfqq in this case.

	 */

	if (!bfq_bfqq_sync(bfqq) || bfq_class_idle(bfqq) ||

	    bfqd->bfq_slice_idle == 0)

		return;



	/* Idle window just restored, statistics are meaningless. */
@@ -4004,27 +4025,22 @@ static void bfq_update_idle_window(struct bfq_data *bfqd, 
				     bfqd->bfq_wr_min_idle_time))

		return;



	enable_idle = bfq_bfqq_idle_window(bfqq);



	/* Think time is infinite if no process is linked to

	 * bfqq. Otherwise check average think time to

	 * decide whether to mark as has_short_ttime

	 */

	if (atomic_read(&bic->icq.ioc->active_ref) == 0 ||

	    bfqd->bfq_slice_idle == 0 ||

		(bfqd->hw_tag && BFQQ_SEEKY(bfqq) &&

			bfqq->wr_coeff == 1))

		enable_idle = 0;

	else if (bfq_sample_valid(bfqq->ttime.ttime_samples)) {

		if (bfqq->ttime.ttime_mean > bfqd->bfq_slice_idle &&

			bfqq->wr_coeff == 1)

			enable_idle = 0;

		else

			enable_idle = 1;

	}

	bfq_log_bfqq(bfqd, bfqq, "update_idle_window: enable_idle %d",

		enable_idle);

	    (bfq_sample_valid(bfqq->ttime.ttime_samples) &&

	     bfqq->ttime.ttime_mean > bfqd->bfq_slice_idle))

		has_short_ttime = false;



	if (enable_idle)

		bfq_mark_bfqq_idle_window(bfqq);

	bfq_log_bfqq(bfqd, bfqq, "update_has_short_ttime: has_short_ttime %d",

		     has_short_ttime);



	if (has_short_ttime)

		bfq_mark_bfqq_has_short_ttime(bfqq);

	else

		bfq_clear_bfqq_idle_window(bfqq);

		bfq_clear_bfqq_has_short_ttime(bfqq);

}



/*
@@ -4040,14 +4056,12 @@ static void bfq_rq_enqueued(struct bfq_data *bfqd, struct bfq_queue *bfqq, 
		bfqq->meta_pending++;



	bfq_update_io_thinktime(bfqd, bfqq);

	bfq_update_has_short_ttime(bfqd, bfqq, bic);

	bfq_update_io_seektime(bfqd, bfqq, rq);

	if (bfqq->entity.service > bfq_max_budget(bfqd) / 8 ||

	    !BFQQ_SEEKY(bfqq))

		bfq_update_idle_window(bfqd, bfqq, bic);



	bfq_log_bfqq(bfqd, bfqq,

		     "rq_enqueued: idle_window=%d (seeky %d)",

		     bfq_bfqq_idle_window(bfqq), BFQQ_SEEKY(bfqq));

		     "rq_enqueued: has_short_ttime=%d (seeky %d)",

		     bfq_bfqq_has_short_ttime(bfqq), BFQQ_SEEKY(bfqq));



	bfqq->last_request_pos = blk_rq_pos(rq) + blk_rq_sectors(rq);
@@ -4787,16 +4801,13 @@ static ssize_t bfq_var_show(unsigned int var, char *page) 
	return sprintf(page, "%u\n", var);

}



static ssize_t bfq_var_store(unsigned long *var, const char *page,

			     size_t count)

static void bfq_var_store(unsigned long *var, const char *page)

{

	unsigned long new_val;

	int ret = kstrtoul(page, 10, &new_val);



	if (ret == 0)

		*var = new_val;



	return count;

}



#define SHOW_FUNCTION(__FUNC, __VAR, __CONV)				\
@@ -4838,7 +4849,7 @@ __FUNC(struct elevator_queue *e, const char *page, size_t count) \ 
{									\

	struct bfq_data *bfqd = e->elevator_data;			\

	unsigned long uninitialized_var(__data);			\

	int ret = bfq_var_store(&__data, (page), count);		\

	bfq_var_store(&__data, (page));					\

	if (__data < (MIN))						\

		__data = (MIN);						\

	else if (__data > (MAX))					\
@@ -4849,7 +4860,7 @@ __FUNC(struct elevator_queue *e, const char *page, size_t count) \ 
		*(__PTR) = (u64)__data * NSEC_PER_MSEC;			\

	else								\

		*(__PTR) = __data;					\

	return ret;							\

	return count;							\

}

STORE_FUNCTION(bfq_fifo_expire_sync_store, &bfqd->bfq_fifo_expire[1], 1,

		INT_MAX, 2);
@@ -4866,13 +4877,13 @@ static ssize_t __FUNC(struct elevator_queue *e, const char *page, size_t count)\ 
{									\

	struct bfq_data *bfqd = e->elevator_data;			\

	unsigned long uninitialized_var(__data);			\

	int ret = bfq_var_store(&__data, (page), count);		\

	bfq_var_store(&__data, (page));					\

	if (__data < (MIN))						\

		__data = (MIN);						\

	else if (__data > (MAX))					\

		__data = (MAX);						\

	*(__PTR) = (u64)__data * NSEC_PER_USEC;				\

	return ret;							\

	return count;							\

}

USEC_STORE_FUNCTION(bfq_slice_idle_us_store, &bfqd->bfq_slice_idle, 0,

		    UINT_MAX);
@@ -4883,7 +4894,8 @@ static ssize_t bfq_max_budget_store(struct elevator_queue *e, 
{

	struct bfq_data *bfqd = e->elevator_data;

	unsigned long uninitialized_var(__data);

	int ret = bfq_var_store(&__data, (page), count);



	bfq_var_store(&__data, (page));



	if (__data == 0)

		bfqd->bfq_max_budget = bfq_calc_max_budget(bfqd);
@@ -4895,7 +4907,7 @@ static ssize_t bfq_max_budget_store(struct elevator_queue *e, 


	bfqd->bfq_user_max_budget = __data;



	return ret;

	return count;

}



/*
@@ -4907,7 +4919,8 @@ static ssize_t bfq_timeout_sync_store(struct elevator_queue *e, 
{

	struct bfq_data *bfqd = e->elevator_data;

	unsigned long uninitialized_var(__data);

	int ret = bfq_var_store(&__data, (page), count);



	bfq_var_store(&__data, (page));



	if (__data < 1)

		__data = 1;
@@ -4918,7 +4931,7 @@ static ssize_t bfq_timeout_sync_store(struct elevator_queue *e, 
	if (bfqd->bfq_user_max_budget == 0)

		bfqd->bfq_max_budget = bfq_calc_max_budget(bfqd);



	return ret;

	return count;

}



static ssize_t bfq_strict_guarantees_store(struct elevator_queue *e,
@@ -4926,7 +4939,8 @@ static ssize_t bfq_strict_guarantees_store(struct elevator_queue *e, 
{

	struct bfq_data *bfqd = e->elevator_data;

	unsigned long uninitialized_var(__data);

	int ret = bfq_var_store(&__data, (page), count);



	bfq_var_store(&__data, (page));



	if (__data > 1)

		__data = 1;
@@ -4936,7 +4950,7 @@ static ssize_t bfq_strict_guarantees_store(struct elevator_queue *e, 


	bfqd->strict_guarantees = __data;



	return ret;

	return count;

}



static ssize_t bfq_low_latency_store(struct elevator_queue *e,
@@ -4944,7 +4958,8 @@ static ssize_t bfq_low_latency_store(struct elevator_queue *e, 
{

	struct bfq_data *bfqd = e->elevator_data;

	unsigned long uninitialized_var(__data);

	int ret = bfq_var_store(&__data, (page), count);



	bfq_var_store(&__data, (page));



	if (__data > 1)

		__data = 1;
@@ -4952,7 +4967,7 @@ static ssize_t bfq_low_latency_store(struct elevator_queue *e, 
		bfq_end_wr(bfqd);

	bfqd->low_latency = __data;



	return ret;

	return count;

}



#define BFQ_ATTR(name) \
@@ -4998,6 +5013,7 @@ static struct elevator_type iosched_bfq_mq = { 
	.elevator_name =	"bfq",

	.elevator_owner =	THIS_MODULE,

};

MODULE_ALIAS("bfq-iosched");



static int __init bfq_init(void)

{
@@ -5048,10 +5064,12 @@ static int __init bfq_init(void) 


	ret = elv_register(&iosched_bfq_mq);

	if (ret)

		goto err_pol_unreg;

		goto slab_kill;



	return 0;



slab_kill:

	bfq_slab_kill();

err_pol_unreg:

#ifdef CONFIG_BFQ_GROUP_IOSCHED

	blkcg_policy_unregister(&blkcg_policy_bfq);

block/bfq-iosched.h

+14 −11
Original line number Diff line number Diff line
@@ -360,11 +360,11 @@ struct bfq_io_cq { 
	uint64_t blkcg_serial_nr; /* the current blkcg serial */

#endif

	/*

	 * Snapshot of the idle window before merging; taken to

	 * remember this value while the queue is merged, so as to be

	 * able to restore it in case of split.

	 * Snapshot of the has_short_time flag before merging; taken

	 * to remember its value while the queue is merged, so as to

	 * be able to restore it in case of split.

	 */

	bool saved_idle_window;

	bool saved_has_short_ttime;

	/*

	 * Same purpose as the previous two fields for the I/O bound

	 * classification of a queue.
@@ -638,7 +638,7 @@ enum bfqq_state_flags { 
				     * without idling the device

				     */

	BFQQF_fifo_expire,	/* FIFO checked in this slice */

	BFQQF_idle_window,	/* slice idling enabled */

	BFQQF_has_short_ttime,	/* queue has a short think time */

	BFQQF_sync,		/* synchronous queue */

	BFQQF_IO_bound,		/*

				 * bfqq has timed-out at least once
@@ -667,7 +667,7 @@ BFQ_BFQQ_FNS(busy); 
BFQ_BFQQ_FNS(wait_request);

BFQ_BFQQ_FNS(non_blocking_wait_rq);

BFQ_BFQQ_FNS(fifo_expire);

BFQ_BFQQ_FNS(idle_window);

BFQ_BFQQ_FNS(has_short_ttime);

BFQ_BFQQ_FNS(sync);

BFQ_BFQQ_FNS(IO_bound);

BFQ_BFQQ_FNS(in_large_burst);
@@ -929,13 +929,16 @@ void bfq_add_bfqq_busy(struct bfq_data *bfqd, struct bfq_queue *bfqq); 
struct bfq_group *bfqq_group(struct bfq_queue *bfqq);



#define bfq_log_bfqq(bfqd, bfqq, fmt, args...)	do {			\

	blk_add_trace_msg((bfqd)->queue, "bfq%d%c %s " fmt, (bfqq)->pid,\

			bfq_bfqq_sync((bfqq)) ? 'S' : 'A',		\

			bfqq_group(bfqq)->blkg_path, ##args);		\

	blk_add_cgroup_trace_msg((bfqd)->queue,				\

			bfqg_to_blkg(bfqq_group(bfqq))->blkcg,		\

			"bfq%d%c " fmt, (bfqq)->pid,			\

			bfq_bfqq_sync((bfqq)) ? 'S' : 'A', ##args);	\

} while (0)



#define bfq_log_bfqg(bfqd, bfqg, fmt, args...)	\

	blk_add_trace_msg((bfqd)->queue, "%s " fmt, (bfqg)->blkg_path, ##args)

#define bfq_log_bfqg(bfqd, bfqg, fmt, args...)	do {			\

	blk_add_cgroup_trace_msg((bfqd)->queue,				\

		bfqg_to_blkg(bfqg)->blkcg, fmt, ##args);		\

} while (0)



#else /* CONFIG_BFQ_GROUP_IOSCHED */

block/bio-integrity.c

+12 −14
Original line number Diff line number Diff line
@@ -146,7 +146,7 @@ int bio_integrity_add_page(struct bio *bio, struct page *page, 
	iv = bip->bip_vec + bip->bip_vcnt;



	if (bip->bip_vcnt &&

	    bvec_gap_to_prev(bdev_get_queue(bio->bi_bdev),

	    bvec_gap_to_prev(bio->bi_disk->queue,

			     &bip->bip_vec[bip->bip_vcnt - 1], offset))

		return 0;
@@ -190,7 +190,7 @@ static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi, 
static blk_status_t bio_integrity_process(struct bio *bio,

		struct bvec_iter *proc_iter, integrity_processing_fn *proc_fn)

{

	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);

	struct blk_integrity_iter iter;

	struct bvec_iter bviter;

	struct bio_vec bv;
@@ -199,7 +199,7 @@ static blk_status_t bio_integrity_process(struct bio *bio, 
	void *prot_buf = page_address(bip->bip_vec->bv_page) +

		bip->bip_vec->bv_offset;



	iter.disk_name = bio->bi_bdev->bd_disk->disk_name;

	iter.disk_name = bio->bi_disk->disk_name;

	iter.interval = 1 << bi->interval_exp;

	iter.seed = proc_iter->bi_sector;

	iter.prot_buf = prot_buf;
@@ -236,8 +236,8 @@ static blk_status_t bio_integrity_process(struct bio *bio, 
bool bio_integrity_prep(struct bio *bio)

{

	struct bio_integrity_payload *bip;

	struct blk_integrity *bi;

	struct request_queue *q;

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);

	struct request_queue *q = bio->bi_disk->queue;

	void *buf;

	unsigned long start, end;

	unsigned int len, nr_pages;
@@ -245,8 +245,9 @@ bool bio_integrity_prep(struct bio *bio) 
	unsigned int intervals;

	blk_status_t status;



	bi = bdev_get_integrity(bio->bi_bdev);

	q = bdev_get_queue(bio->bi_bdev);

	if (!bi)

		return true;



	if (bio_op(bio) != REQ_OP_READ && bio_op(bio) != REQ_OP_WRITE)

		return true;
@@ -257,9 +258,6 @@ bool bio_integrity_prep(struct bio *bio) 
	if (bio_integrity(bio))

		return true;



	if (bi == NULL)

		return true;



	if (bio_data_dir(bio) == READ) {

		if (!bi->profile->verify_fn ||

		    !(bi->flags & BLK_INTEGRITY_VERIFY))
@@ -354,7 +352,7 @@ static void bio_integrity_verify_fn(struct work_struct *work) 
	struct bio_integrity_payload *bip =

		container_of(work, struct bio_integrity_payload, bip_work);

	struct bio *bio = bip->bip_bio;

	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);

	struct bvec_iter iter = bio->bi_iter;



	/*
@@ -387,7 +385,7 @@ static void bio_integrity_verify_fn(struct work_struct *work) 
 */

bool __bio_integrity_endio(struct bio *bio)

{

	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);

	struct bio_integrity_payload *bip = bio_integrity(bio);



	if (bio_op(bio) == REQ_OP_READ && !bio->bi_status &&
@@ -413,7 +411,7 @@ bool __bio_integrity_endio(struct bio *bio) 
void bio_integrity_advance(struct bio *bio, unsigned int bytes_done)

{

	struct bio_integrity_payload *bip = bio_integrity(bio);

	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);

	unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9);



	bip->bip_iter.bi_sector += bytes_done >> 9;
@@ -430,7 +428,7 @@ EXPORT_SYMBOL(bio_integrity_advance); 
void bio_integrity_trim(struct bio *bio)

{

	struct bio_integrity_payload *bip = bio_integrity(bio);

	struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);

	struct blk_integrity *bi = blk_get_integrity(bio->bi_disk);



	bip->bip_iter.bi_size = bio_integrity_bytes(bi, bio_sectors(bio));

}