block: remove QUEUE_FLAG_BYPASS and ->bypass (8f4236d9) · Commits · 戴 / test

block/blk-cgroup.c

+0 −15

Original line number	Diff line number	Diff line
		@@ -270,13 +270,6 @@ struct blkcg_gq blkg_lookup_create(struct blkcg blkcg,
		WARN_ON_ONCE(!rcu_read_lock_held());
		lockdep_assert_held(q->queue_lock);

		/*
		* This could be the first entry point of blkcg implementation and
		* we shouldn't allow anything to go through for a bypassing queue.
		*/
		if (unlikely(blk_queue_bypass(q)))
		return ERR_PTR(blk_queue_dying(q) ? -ENODEV : -EBUSY);

		blkg = __blkg_lookup(blkcg, q, true);
		if (blkg)
		return blkg;
		@@ -741,14 +734,6 @@ static struct blkcg_gq blkg_lookup_check(struct blkcg blkcg,

		if (!blkcg_policy_enabled(q, pol))
		return ERR_PTR(-EOPNOTSUPP);

		/*
		* This could be the first entry point of blkcg implementation and
		* we shouldn't allow anything to go through for a bypassing queue.
		*/
		if (unlikely(blk_queue_bypass(q)))
		return ERR_PTR(blk_queue_dying(q) ? -ENODEV : -EBUSY);

		return __blkg_lookup(blkcg, q, true /* update_hint */);
		}

+0 −21

Original line number	Diff line number	Diff line
		@@ -370,18 +370,6 @@ void blk_cleanup_queue(struct request_queue *q)
		blk_set_queue_dying(q);
		spin_lock_irq(lock);

		/*
		* A dying queue is permanently in bypass mode till released. Note
		* that, unlike blk_queue_bypass_start(), we aren't performing
		* synchronize_rcu() after entering bypass mode to avoid the delay
		* as some drivers create and destroy a lot of queues while
		* probing. This is still safe because blk_release_queue() will be
		* called only after the queue refcnt drops to zero and nothing,
		* RCU or not, would be traversing the queue by then.
		*/
		q->bypass_depth++;
		queue_flag_set(QUEUE_FLAG_BYPASS, q);

		queue_flag_set(QUEUE_FLAG_NOMERGES, q);
		queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
		queue_flag_set(QUEUE_FLAG_DYING, q);
		@@ -589,15 +577,6 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id,

		q->queue_lock = lock ? : &q->__queue_lock;

		/*
		* A queue starts its life with bypass turned on to avoid
		* unnecessary bypass on/off overhead and nasty surprises during
		* init. The initial bypass will be finished when the queue is
		* registered by blk_register_queue().
		*/
		q->bypass_depth = 1;
		queue_flag_set_unlocked(QUEUE_FLAG_BYPASS, q);

		init_waitqueue_head(&q->mq_freeze_wq);

		/*

+0 −1

Original line number	Diff line number	Diff line
		@@ -114,7 +114,6 @@ static int queue_pm_only_show(void data, struct seq_file m)
		static const char *const blk_queue_flag_name[] = {
		QUEUE_FLAG_NAME(STOPPED),
		QUEUE_FLAG_NAME(DYING),
		QUEUE_FLAG_NAME(BYPASS),
		QUEUE_FLAG_NAME(BIDI),
		QUEUE_FLAG_NAME(NOMERGES),
		QUEUE_FLAG_NAME(SAME_COMP),

+0 −3

Original line number	Diff line number	Diff line
		@@ -2145,9 +2145,6 @@ bool blk_throtl_bio(struct request_queue q, struct blkcg_gq blkg,

		throtl_update_latency_buckets(td);

		if (unlikely(blk_queue_bypass(q)))
		goto out_unlock;

		blk_throtl_assoc_bio(tg, bio);
		blk_throtl_update_idletime(tg);

+1 −5

Original line number	Diff line number	Diff line
		@@ -325,16 +325,12 @@ static inline struct blkcg_gq __blkg_lookup(struct blkcg blkcg,
		* @q: request_queue of interest
		*
		* Lookup blkg for the @blkcg - @q pair. This function should be called
		* under RCU read lock and is guaranteed to return %NULL if @q is bypassing
		* - see blk_queue_bypass_start() for details.
		* under RCU read loc.
		*/
		static inline struct blkcg_gq blkg_lookup(struct blkcg blkcg,
		struct request_queue *q)
		{
		WARN_ON_ONCE(!rcu_read_lock_held());

		if (unlikely(blk_queue_bypass(q)))
		return NULL;
		return __blkg_lookup(blkcg, q, false);
		}