lael-labs/linux

Documentation/ABI/stable/sysfs-block+9−0

@@ -260,6 +260,15 @@ Description: · 259 unmodified lines
260	for discards, and don't read this file.	260	for discards, and don't read this file.
261		261
262		262
		263	What: /sys/block/<disk>/queue/dma_alignment
		264	Date: May 2022
		265	Contact: linux-block@vger.kernel.org
		266	Description:
		267	Reports the alignment that user space addresses must have to be
		268	used for raw block device access with O_DIRECT and other driver
		269	specific passthrough mechanisms.
		270
		271
263	What: /sys/block/<disk>/queue/fua	272	What: /sys/block/<disk>/queue/fua
264	Date: May 2018	273	Date: May 2018
265	Contact: linux-block@vger.kernel.org	274	Contact: linux-block@vger.kernel.org

Documentation/scsi/scsi_eh.rst+1−2

@@ -87,8 +87,7 @@ with the command. · 86 unmodified lines
87	1.2.2 Completing a scmd w/ timeout	87	1.2.2 Completing a scmd w/ timeout
88	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^	88	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
89		89
90	The timeout handler is scsi_times_out(). When a timeout occurs, this	90	The timeout handler is scsi_timeout(). When a timeout occurs, this function
91	function
92		91
93	1. invokes optional hostt->eh_timed_out() callback. Return value can	92	1. invokes optional hostt->eh_timed_out() callback. Return value can
94	be one of	93	be one of

Documentation/scsi/scsi_mid_low_api.rst+1−1

@@ -731,7 +731,7 @@ Details:: · 730 unmodified lines
731	* Notes: If 'no_async_abort' is defined this callback	731	* Notes: If 'no_async_abort' is defined this callback
732	* will be invoked from scsi_eh thread. No other commands	732	* will be invoked from scsi_eh thread. No other commands
733	* will then be queued on current host during eh.	733	* will then be queued on current host during eh.
734	* Otherwise it will be called whenever scsi_times_out()	734	* Otherwise it will be called whenever scsi_timeout()
735	* is called due to a command timeout.	735	* is called due to a command timeout.
736	*	736	*
737	* Optionally defined in: LLD	737	* Optionally defined in: LLD

MAINTAINERS+7−0

@@ -20539,6 +20539,13 @@ F: Documentation/filesystems/ubifs-authentication.rst · 20538 unmodified lines
20539	F: Documentation/filesystems/ubifs.rst	20539	F: Documentation/filesystems/ubifs.rst
20540	F: fs/ubifs/	20540	F: fs/ubifs/
20541		20541
		20542	UBLK USERSPACE BLOCK DRIVER
		20543	M: Ming Lei <ming.lei@redhat.com>
		20544	L: linux-block@vger.kernel.org
		20545	S: Maintained
		20546	F: drivers/block/ublk_drv.c
		20547	F: include/uapi/linux/ublk_cmd.h
		20548
20542	UCLINUX (M68KNOMMU AND COLDFIRE)	20549	UCLINUX (M68KNOMMU AND COLDFIRE)
20543	M: Greg Ungerer <gerg@linux-m68k.org>	20550	M: Greg Ungerer <gerg@linux-m68k.org>
20544	L: linux-m68k@lists.linux-m68k.org	20551	L: linux-m68k@lists.linux-m68k.org

arch/m68k/emu/nfblock.c+2−2

@@ -138,7 +138,7 @@ static int __init nfhd_init_one(int id, u32 blocks, u32 bsize) · 137 unmodified lines
138	return 0;	138	return 0;
139		139
140	out_cleanup_disk:	140	out_cleanup_disk:
141	blk_cleanup_disk(dev->disk);	141	put_disk(dev->disk);
142	free_dev:	142	free_dev:
143	kfree(dev);	143	kfree(dev);
144	out:	144	out:
@@ -180,7 +180,7 @@ static void __exit nfhd_exit(void) · 35 unmodified lines
180	list_for_each_entry_safe(dev, next, &nfhd_list, list) {	180	list_for_each_entry_safe(dev, next, &nfhd_list, list) {
181	list_del(&dev->list);	181	list_del(&dev->list);
182	del_gendisk(dev->disk);	182	del_gendisk(dev->disk);
183	blk_cleanup_disk(dev->disk);	183	put_disk(dev->disk);
184	kfree(dev);	184	kfree(dev);
185	}	185	}
186	unregister_blkdev(major_num, "nfhd");	186	unregister_blkdev(major_num, "nfhd");

arch/um/drivers/ubd_kern.c+4−4

@@ -925,7 +925,7 @@ static int ubd_add(int n, char **error_out) · 924 unmodified lines
925	return 0;	925	return 0;
926		926
927	out_cleanup_disk:	927	out_cleanup_disk:
928	blk_cleanup_disk(disk);	928	put_disk(disk);
929	out_cleanup_tags:	929	out_cleanup_tags:
930	blk_mq_free_tag_set(&ubd_dev->tag_set);	930	blk_mq_free_tag_set(&ubd_dev->tag_set);
931	out:	931	out:
@@ -1032,7 +1032,7 @@ static int ubd_remove(int n, char **error_out) · 100 unmodified lines
1032	ubd_gendisk[n] = NULL;	1032	ubd_gendisk[n] = NULL;
1033	if(disk != NULL){	1033	if(disk != NULL){
1034	del_gendisk(disk);	1034	del_gendisk(disk);
1035	blk_cleanup_disk(disk);	1035	put_disk(disk);
1036	}	1036	}
1037		1037
1038	err = 0;	1038	err = 0;
@@ -1262,7 +1262,7 @@ static void ubd_map_req(struct ubd dev, struct io_thread_req io_req, · 223 unmodified lines
1262	struct req_iterator iter;	1262	struct req_iterator iter;
1263	int i = 0;	1263	int i = 0;
1264	unsigned long byte_offset = io_req->offset;	1264	unsigned long byte_offset = io_req->offset;
1265	int op = req_op(req);	1265	enum req_op op = req_op(req);
1266		1266
1267	if (op == REQ_OP_WRITE_ZEROES \|\| op == REQ_OP_DISCARD) {	1267	if (op == REQ_OP_WRITE_ZEROES \|\| op == REQ_OP_DISCARD) {
1268	io_req->io_desc[0].buffer = NULL;	1268	io_req->io_desc[0].buffer = NULL;
@@ -1325,7 +1325,7 @@ static int ubd_submit_request(struct ubd dev, struct request req) · 56 unmodified lines
1325	int segs = 0;	1325	int segs = 0;
1326	struct io_thread_req *io_req;	1326	struct io_thread_req *io_req;
1327	int ret;	1327	int ret;
1328	int op = req_op(req);	1328	enum req_op op = req_op(req);
1329		1329
1330	if (op == REQ_OP_FLUSH)	1330	if (op == REQ_OP_FLUSH)
1331	segs = 0;	1331	segs = 0;

arch/xtensa/platforms/iss/simdisk.c+2−2

@@ -290,7 +290,7 @@ static int __init simdisk_setup(struct simdisk *dev, int which, · 289 unmodified lines
290	return 0;	290	return 0;
291		291
292	out_cleanup_disk:	292	out_cleanup_disk:
293	blk_cleanup_disk(dev->gd);	293	put_disk(dev->gd);
294	out:	294	out:
295	return err;	295	return err;
296	}	296	}
@@ -344,7 +344,7 @@ static void simdisk_teardown(struct simdisk *dev, int which, · 47 unmodified lines
344	simdisk_detach(dev);	344	simdisk_detach(dev);
345	if (dev->gd) {	345	if (dev->gd) {
346	del_gendisk(dev->gd);	346	del_gendisk(dev->gd);
347	blk_cleanup_disk(dev->gd);	347	put_disk(dev->gd);
348	}	348	}
349	remove_proc_entry(tmp, procdir);	349	remove_proc_entry(tmp, procdir);
350	}	350	}

block/Kconfig+0−1

@@ -147,7 +147,6 @@ config BLK_CGROUP_FC_APPID · 146 unmodified lines
147	config BLK_CGROUP_IOCOST	147	config BLK_CGROUP_IOCOST
148	bool "Enable support for cost model based cgroup IO controller"	148	bool "Enable support for cost model based cgroup IO controller"
149	depends on BLK_CGROUP	149	depends on BLK_CGROUP
150	select BLK_RQ_IO_DATA_LEN
151	select BLK_RQ_ALLOC_TIME	150	select BLK_RQ_ALLOC_TIME
152	help	151	help
153	Enabling this option enables the .weight interface for cost	152	Enabling this option enables the .weight interface for cost

block/bdev.c+4−6

 	while (inode->i_state & I_DIRTY) {
 		spin_unlock(&inode->i_lock);
 		ret = write_inode_now(inode, true);
-		if (ret) {
+		if (ret)
-			char name[BDEVNAME_SIZE];
+			pr_warn_ratelimited(
-			pr_warn_ratelimited("VFS: Dirty inode writeback failed "
+	"VFS: Dirty inode writeback failed for block device %pg (err=%d).\n",
-					    "for block device %s (err=%d).\n",
+				bdev, ret);
-					    bdevname(bdev, name), ret);
-		}
 		spin_lock(&inode->i_lock);
 	}
 	spin_unlock(&inode->i_lock);

block/bfq-cgroup.c+17−17

 }
 void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
-			      unsigned int op)
+			      blk_opf_t opf)
 {
-	blkg_rwstat_add(&bfqg->stats.queued, op, 1);
+	blkg_rwstat_add(&bfqg->stats.queued, opf, 1);
 	bfqg_stats_end_empty_time(&bfqg->stats);
 	if (!(bfqq == ((struct bfq_data *)bfqg->bfqd)->in_service_queue))
 		bfqg_stats_set_start_group_wait_time(bfqg, bfqq_group(bfqq));
 }
-void bfqg_stats_update_io_remove(struct bfq_group *bfqg, unsigned int op)
+void bfqg_stats_update_io_remove(struct bfq_group *bfqg, blk_opf_t opf)
 {
-	blkg_rwstat_add(&bfqg->stats.queued, op, -1);
+	blkg_rwstat_add(&bfqg->stats.queued, opf, -1);
 }
-void bfqg_stats_update_io_merged(struct bfq_group *bfqg, unsigned int op)
+void bfqg_stats_update_io_merged(struct bfq_group *bfqg, blk_opf_t opf)
 {
-	blkg_rwstat_add(&bfqg->stats.merged, op, 1);
+	blkg_rwstat_add(&bfqg->stats.merged, opf, 1);
 }
 void bfqg_stats_update_completion(struct bfq_group *bfqg, u64 start_time_ns,
-				  u64 io_start_time_ns, unsigned int op)
+				  u64 io_start_time_ns, blk_opf_t opf)
 {
 	struct bfqg_stats *stats = &bfqg->stats;
 	u64 now = ktime_get_ns();
 	if (now > io_start_time_ns)
-		blkg_rwstat_add(&stats->service_time, op,
+		blkg_rwstat_add(&stats->service_time, opf,
 				now - io_start_time_ns);
 	if (io_start_time_ns > start_time_ns)
-		blkg_rwstat_add(&stats->wait_time, op,
+		blkg_rwstat_add(&stats->wait_time, opf,
 				io_start_time_ns - start_time_ns);
 }
 #else /* CONFIG_BFQ_CGROUP_DEBUG */
 void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
-			      unsigned int op) { }
+			      blk_opf_t opf) { }
-void bfqg_stats_update_io_remove(struct bfq_group *bfqg, unsigned int op) { }
+void bfqg_stats_update_io_remove(struct bfq_group *bfqg, blk_opf_t opf) { }
-void bfqg_stats_update_io_merged(struct bfq_group *bfqg, unsigned int op) { }
+void bfqg_stats_update_io_merged(struct bfq_group *bfqg, blk_opf_t opf) { }
 void bfqg_stats_update_completion(struct bfq_group *bfqg, u64 start_time_ns,
-				  u64 io_start_time_ns, unsigned int op) { }
+				  u64 io_start_time_ns, blk_opf_t opf) { }
 void bfqg_stats_update_dequeue(struct bfq_group *bfqg) { }
 void bfqg_stats_set_start_empty_time(struct bfq_group *bfqg) { }
 void bfqg_stats_update_idle_time(struct bfq_group *bfqg) { }
 }
 /**
- * __bfq_bic_change_cgroup - move @bic to @cgroup.
+ * __bfq_bic_change_cgroup - move @bic to @bfqg.
  * @bfqd: the queue descriptor.
  * @bic: the bic to move.
- * @blkcg: the blk-cgroup to move to.
+ * @bfqg: the group to move to.
  *
  * Move bic to blkcg, assuming that bfqd->lock is held; which makes
  * sure that the reference to cgroup is valid across the call (see
  * @bfqd: the device data structure with the root group.
  * @entity: the entity to move, if entity is a leaf; or the parent entity
  *	    of an active leaf entity to move, if entity is not a leaf.
+ * @ioprio_class: I/O priority class to reparent.
  */
 static void bfq_reparent_leaf_entity(struct bfq_data *bfqd,
 				     struct bfq_entity *entity,
  * @bfqd: the device data structure with the root group.
  * @bfqg: the group to move from.
  * @st: the service tree to start the search from.
+ * @ioprio_class: I/O priority class to reparent.
  */
 static void bfq_reparent_active_queues(struct bfq_data *bfqd,
 				       struct bfq_group *bfqg,
 	return bfqq->bfqd->root_group;
 }
-void bfqg_and_blkg_get(struct bfq_group *bfqg) {}
 void bfqg_and_blkg_put(struct bfq_group *bfqg) {}
 struct bfq_group *bfq_create_group_hierarchy(struct bfq_data *bfqd, int node)

block/bfq-iosched.c+8−8

@@ -668,19 +668,19 @@ static bool bfqq_request_over_limit(struct bfq_queue *bfqq, int limit) · 667 unmodified lines
668	* significantly affect service guarantees coming from the BFQ scheduling	668	* significantly affect service guarantees coming from the BFQ scheduling
669	* algorithm.	669	* algorithm.
670	*/	670	*/
671	static void bfq_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)	671	static void bfq_limit_depth(blk_opf_t opf, struct blk_mq_alloc_data *data)
672	{	672	{
673	struct bfq_data *bfqd = data->q->elevator->elevator_data;	673	struct bfq_data *bfqd = data->q->elevator->elevator_data;
674	struct bfq_io_cq *bic = bfq_bic_lookup(data->q);	674	struct bfq_io_cq *bic = bfq_bic_lookup(data->q);
675	struct bfq_queue *bfqq = bic ? bic_to_bfqq(bic, op_is_sync(op)) : NULL;	675	struct bfq_queue *bfqq = bic ? bic_to_bfqq(bic, op_is_sync(opf)) : NULL;
676	int depth;	676	int depth;
677	unsigned limit = data->q->nr_requests;	677	unsigned limit = data->q->nr_requests;
678		678
679	/* Sync reads have full depth available */	679	/* Sync reads have full depth available */
680	if (op_is_sync(op) && !op_is_write(op)) {	680	if (op_is_sync(opf) && !op_is_write(opf)) {
681	depth = 0;	681	depth = 0;
682	} else {	682	} else {
683	depth = bfqd->word_depths[!!bfqd->wr_busy_queues][op_is_sync(op)];	683	depth = bfqd->word_depths[!!bfqd->wr_busy_queues][op_is_sync(opf)];
684	limit = (limit * depth) >> bfqd->full_depth_shift;	684	limit = (limit * depth) >> bfqd->full_depth_shift;
685	}	685	}
686		686
@@ -693,7 +693,7 @@ static void bfq_limit_depth(unsigned int op, struct blk_mq_alloc_data *data) · 6 unmodified lines
693	depth = 1;	693	depth = 1;
694		694
695	bfq_log(bfqd, "[%s] wr_busy %d sync %d depth %u",	695	bfq_log(bfqd, "[%s] wr_busy %d sync %d depth %u",
696	__func__, bfqd->wr_busy_queues, op_is_sync(op), depth);	696	__func__, bfqd->wr_busy_queues, op_is_sync(opf), depth);
697	if (depth)	697	if (depth)
698	data->shallow_depth = depth;	698	data->shallow_depth = depth;
699	}	699	}
@@ -6104,7 +6104,7 @@ static bool __bfq_insert_request(struct bfq_data bfqd, struct request rq) · 5404 unmodified lines
6104	static void bfq_update_insert_stats(struct request_queue *q,	6104	static void bfq_update_insert_stats(struct request_queue *q,
6105	struct bfq_queue *bfqq,	6105	struct bfq_queue *bfqq,
6106	bool idle_timer_disabled,	6106	bool idle_timer_disabled,
6107	unsigned int cmd_flags)	6107	blk_opf_t cmd_flags)
6108	{	6108	{
6109	if (!bfqq)	6109	if (!bfqq)
6110	return;	6110	return;
@@ -6129,7 +6129,7 @@ static void bfq_update_insert_stats(struct request_queue *q, · 18 unmodified lines
6129	static inline void bfq_update_insert_stats(struct request_queue *q,	6129	static inline void bfq_update_insert_stats(struct request_queue *q,
6130	struct bfq_queue *bfqq,	6130	struct bfq_queue *bfqq,
6131	bool idle_timer_disabled,	6131	bool idle_timer_disabled,
6132	unsigned int cmd_flags) {}	6132	blk_opf_t cmd_flags) {}
6133	#endif /* CONFIG_BFQ_CGROUP_DEBUG */	6133	#endif /* CONFIG_BFQ_CGROUP_DEBUG */
6134		6134
6135	static struct bfq_queue bfq_init_rq(struct request rq);	6135	static struct bfq_queue bfq_init_rq(struct request rq);
@@ -6141,7 +6141,7 @@ static void bfq_insert_request(struct blk_mq_hw_ctx hctx, struct request rq, · 5 unmodified lines
6141	struct bfq_data *bfqd = q->elevator->elevator_data;	6141	struct bfq_data *bfqd = q->elevator->elevator_data;
6142	struct bfq_queue *bfqq;	6142	struct bfq_queue *bfqq;
6143	bool idle_timer_disabled = false;	6143	bool idle_timer_disabled = false;
6144	unsigned int cmd_flags;	6144	blk_opf_t cmd_flags;
6145	LIST_HEAD(free);	6145	LIST_HEAD(free);
6146		6146
6147	#ifdef CONFIG_BFQ_GROUP_IOSCHED	6147	#ifdef CONFIG_BFQ_GROUP_IOSCHED

block/bfq-iosched.h+4−4

@@ -994,11 +994,11 @@ void bfq_put_async_queues(struct bfq_data bfqd, struct bfq_group bfqg); · 993 unmodified lines
994		994
995	void bfqg_stats_update_legacy_io(struct request_queue q, struct request rq);	995	void bfqg_stats_update_legacy_io(struct request_queue q, struct request rq);
996	void bfqg_stats_update_io_add(struct bfq_group bfqg, struct bfq_queue bfqq,	996	void bfqg_stats_update_io_add(struct bfq_group bfqg, struct bfq_queue bfqq,
997	unsigned int op);	997	blk_opf_t opf);
998	void bfqg_stats_update_io_remove(struct bfq_group *bfqg, unsigned int op);	998	void bfqg_stats_update_io_remove(struct bfq_group *bfqg, blk_opf_t opf);
999	void bfqg_stats_update_io_merged(struct bfq_group *bfqg, unsigned int op);	999	void bfqg_stats_update_io_merged(struct bfq_group *bfqg, blk_opf_t opf);
1000	void bfqg_stats_update_completion(struct bfq_group *bfqg, u64 start_time_ns,	1000	void bfqg_stats_update_completion(struct bfq_group *bfqg, u64 start_time_ns,
1001	u64 io_start_time_ns, unsigned int op);	1001	u64 io_start_time_ns, blk_opf_t opf);
1002	void bfqg_stats_update_dequeue(struct bfq_group *bfqg);	1002	void bfqg_stats_update_dequeue(struct bfq_group *bfqg);
1003	void bfqg_stats_set_start_empty_time(struct bfq_group *bfqg);	1003	void bfqg_stats_set_start_empty_time(struct bfq_group *bfqg);
1004	void bfqg_stats_update_idle_time(struct bfq_group *bfqg);	1004	void bfqg_stats_update_idle_time(struct bfq_group *bfqg);

block/bfq-wf2q.c+2−3

 /**
  * __bfq_lookup_next_entity - return the first eligible entity in @st.
  * @st: the service tree.
+ * @in_service: whether or not there is an in-service entity for the sched_data
+ *	this active tree belongs to.
  *
  * If there is no in-service entity for the sched_data st belongs to,
  * then return the entity that will be set in service if:
 			break;
 	}
-	if (!entity)
-		return NULL;
 	return entity;
 }

block/bio.c+57−69

  * when IO has completed, or when the bio is released.
  */
 void bio_init(struct bio *bio, struct block_device *bdev, struct bio_vec *table,
-	      unsigned short max_vecs, unsigned int opf)
+	      unsigned short max_vecs, blk_opf_t opf)
 {
 	bio->bi_next = NULL;
 	bio->bi_bdev = bdev;
  *   preserved are the ones that are initialized by bio_alloc_bioset(). See
  *   comment in struct bio.
  */
-void bio_reset(struct bio *bio, struct block_device *bdev, unsigned int opf)
+void bio_reset(struct bio *bio, struct block_device *bdev, blk_opf_t opf)
 {
 	bio_uninit(bio);
 	memset(bio, 0, BIO_RESET_BYTES);
 EXPORT_SYMBOL(bio_chain);
 struct bio *blk_next_bio(struct bio *bio, struct block_device *bdev,
-		unsigned int nr_pages, unsigned int opf, gfp_t gfp)
+		unsigned int nr_pages, blk_opf_t opf, gfp_t gfp)
 {
 	struct bio *new = bio_alloc(bdev, nr_pages, opf, gfp);
 }
 static struct bio *bio_alloc_percpu_cache(struct block_device *bdev,
-		unsigned short nr_vecs, unsigned int opf, gfp_t gfp,
+		unsigned short nr_vecs, blk_opf_t opf, gfp_t gfp,
 		struct bio_set *bs)
 {
 	struct bio_alloc_cache *cache;
  * Returns: Pointer to new bio on success, NULL on failure.
  */
 struct bio *bio_alloc_bioset(struct block_device *bdev, unsigned short nr_vecs,
-			     unsigned int opf, gfp_t gfp_mask,
+			     blk_opf_t opf, gfp_t gfp_mask,
 			     struct bio_set *bs)
 {
 	gfp_t saved_gfp = gfp_mask;
 	if (WARN_ON_ONCE(bio_op(bio) != REQ_OP_ZONE_APPEND))
 		return 0;
-	if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
+	if (WARN_ON_ONCE(!bdev_is_zoned(bio->bi_bdev)))
 		return 0;
 	return bio_add_hw_page(q, bio, page, len, offset,
 		put_page(pages[i]);
 }
+static int bio_iov_add_page(struct bio *bio, struct page *page,
+		unsigned int len, unsigned int offset)
+{
+	bool same_page = false;
+	if (!__bio_try_merge_page(bio, page, len, offset, &same_page)) {
+		if (WARN_ON_ONCE(bio_full(bio, len)))
+			return -EINVAL;
+		__bio_add_page(bio, page, len, offset);
+		return 0;
+	}
+	if (same_page)
+		put_page(page);
+	return 0;
+}
+static int bio_iov_add_zone_append_page(struct bio *bio, struct page *page,
+		unsigned int len, unsigned int offset)
+{
+	struct request_queue *q = bdev_get_queue(bio->bi_bdev);
+	bool same_page = false;
+	if (bio_add_hw_page(q, bio, page, len, offset,
+			queue_max_zone_append_sectors(q), &same_page) != len)
+		return -EINVAL;
+	if (same_page)
+		put_page(page);
+	return 0;
+}
 #define PAGE_PTRS_PER_BVEC     (sizeof(struct bio_vec) / sizeof(struct page *))
 /**
 	unsigned short entries_left = bio->bi_max_vecs - bio->bi_vcnt;
 	struct bio_vec *bv = bio->bi_io_vec + bio->bi_vcnt;
 	struct page **pages = (struct page **)bv;
-	bool same_page = false;
 	ssize_t size, left;
 	unsigned len, i;
 	size_t offset;
 	 * Move page array up in the allocated memory for the bio vecs as far as
 	 * possible so that we can start filling biovecs from the beginning
 	 * without overwriting the temporary page array.
-	*/
+	 */
 	BUILD_BUG_ON(PAGE_PTRS_PER_BVEC < 2);
 	pages += entries_left * (PAGE_PTRS_PER_BVEC - 1);
-	size = iov_iter_get_pages(iter, pages, LONG_MAX, nr_pages, &offset);
-	if (unlikely(size <= 0))
-		return size ? size : -EFAULT;
-	for (left = size, i = 0; left > 0; left -= len, i++) {
-		struct page *page = pages[i];
-		len = min_t(size_t, PAGE_SIZE - offset, left);
-		if (__bio_try_merge_page(bio, page, len, offset, &same_page)) {
-			if (same_page)
-				put_page(page);
-		} else {
-			if (WARN_ON_ONCE(bio_full(bio, len))) {
-				bio_put_pages(pages + i, left, offset);
-				return -EINVAL;
-			}
-			__bio_add_page(bio, page, len, offset);
-		}
-		offset = 0;
-	}
-	iov_iter_advance(iter, size);
-	return 0;
-}
-static int __bio_iov_append_get_pages(struct bio *bio, struct iov_iter *iter)
-{
-	unsigned short nr_pages = bio->bi_max_vecs - bio->bi_vcnt;
-	unsigned short entries_left = bio->bi_max_vecs - bio->bi_vcnt;
-	struct request_queue *q = bdev_get_queue(bio->bi_bdev);
-	unsigned int max_append_sectors = queue_max_zone_append_sectors(q);
-	struct bio_vec *bv = bio->bi_io_vec + bio->bi_vcnt;
-	struct page **pages = (struct page **)bv;
-	ssize_t size, left;
-	unsigned len, i;
-	size_t offset;
-	int ret = 0;
-	if (WARN_ON_ONCE(!max_append_sectors))
-		return 0;
 	/*
-	 * Move page array up in the allocated memory for the bio vecs as far as
+	 * Each segment in the iov is required to be a block size multiple.
-	 * possible so that we can start filling biovecs from the beginning
+	 * However, we may not be able to get the entire segment if it spans
-	 * without overwriting the temporary page array.
+	 * more pages than bi_max_vecs allows, so we have to ALIGN_DOWN the
+	 * result to ensure the bio's total size is correct. The remainder of
+	 * the iov data will be picked up in the next bio iteration.
 	 */
-	BUILD_BUG_ON(PAGE_PTRS_PER_BVEC < 2);
-	pages += entries_left * (PAGE_PTRS_PER_BVEC - 1);
 	size = iov_iter_get_pages(iter, pages, LONG_MAX, nr_pages, &offset);
+	if (size > 0)
+		size = ALIGN_DOWN(size, bdev_logical_block_size(bio->bi_bdev));
 	if (unlikely(size <= 0))
 		return size ? size : -EFAULT;
 	for (left = size, i = 0; left > 0; left -= len, i++) {
 		struct page *page = pages[i];
-		bool same_page = false;
+		int ret;
 		len = min_t(size_t, PAGE_SIZE - offset, left);
-		if (bio_add_hw_page(q, bio, page, len, offset,
+		if (bio_op(bio) == REQ_OP_ZONE_APPEND)
-				max_append_sectors, &same_page) != len) {
+			ret = bio_iov_add_zone_append_page(bio, page, len,
+					offset);
+		else
+			ret = bio_iov_add_page(bio, page, len, offset);
+		if (ret) {
 			bio_put_pages(pages + i, left, offset);
-			ret = -EINVAL;
+			return ret;
-			break;
 		}
-		if (same_page)
-			put_page(page);
 		offset = 0;
 	}
-	iov_iter_advance(iter, size - left);
+	iov_iter_advance(iter, size);
-	return ret;
+	return 0;
 }
 /**
 	}
 	do {
-		if (bio_op(bio) == REQ_OP_ZONE_APPEND)
+		ret = __bio_iov_iter_get_pages(bio, iter);
-			ret = __bio_iov_append_get_pages(bio, iter);
-		else
-			ret = __bio_iov_iter_get_pages(bio, iter);
 	} while (!ret && iov_iter_count(iter) && !bio_full(bio, 0));
 	/* don't account direct I/O as memory stall */

block/blk-cgroup-rwstat.h+4−4

@@ -59,20 +59,20 @@ void blkg_rwstat_recursive_sum(struct blkcg_gq blkg, struct blkcg_policy pol, · 58 unmodified lines
59	* caller is responsible for synchronizing calls to this function.	59	* caller is responsible for synchronizing calls to this function.
60	*/	60	*/
61	static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,	61	static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
62	unsigned int op, uint64_t val)	62	blk_opf_t opf, uint64_t val)
63	{	63	{
64	struct percpu_counter *cnt;	64	struct percpu_counter *cnt;
65		65
66	if (op_is_discard(op))	66	if (op_is_discard(opf))
67	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_DISCARD];	67	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_DISCARD];
68	else if (op_is_write(op))	68	else if (op_is_write(opf))
69	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_WRITE];	69	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_WRITE];
70	else	70	else
71	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_READ];	71	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_READ];
72		72
73	percpu_counter_add_batch(cnt, val, BLKG_STAT_CPU_BATCH);	73	percpu_counter_add_batch(cnt, val, BLKG_STAT_CPU_BATCH);
74		74
75	if (op_is_sync(op))	75	if (op_is_sync(opf))
76	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_SYNC];	76	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_SYNC];
77	else	77	else
78	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_ASYNC];	78	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_ASYNC];

block/blk-cgroup.c+40−36

@@ -846,6 +846,21 @@ static void blkg_iostat_sub(struct blkg_iostat dst, struct blkg_iostat src) · 845 unmodified lines
846	}	846	}
847	}	847	}
848		848
		849	static void blkcg_iostat_update(struct blkcg_gq blkg, struct blkg_iostat cur,
		850	struct blkg_iostat *last)
		851	{
		852	struct blkg_iostat delta;
		853	unsigned long flags;
		854
		855	/* propagate percpu delta to global */
		856	flags = u64_stats_update_begin_irqsave(&blkg->iostat.sync);
		857	blkg_iostat_set(&delta, cur);
		858	blkg_iostat_sub(&delta, last);
		859	blkg_iostat_add(&blkg->iostat.cur, &delta);
		860	blkg_iostat_add(last, &delta);
		861	u64_stats_update_end_irqrestore(&blkg->iostat.sync, flags);
		862	}
		863
849	static void blkcg_rstat_flush(struct cgroup_subsys_state *css, int cpu)	864	static void blkcg_rstat_flush(struct cgroup_subsys_state *css, int cpu)
850	{	865	{
851	struct blkcg *blkcg = css_to_blkcg(css);	866	struct blkcg *blkcg = css_to_blkcg(css);
@@ -860,8 +875,7 @@ static void blkcg_rstat_flush(struct cgroup_subsys_state *css, int cpu) · 8 unmodified lines
860	hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {	875	hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
861	struct blkcg_gq *parent = blkg->parent;	876	struct blkcg_gq *parent = blkg->parent;
862	struct blkg_iostat_set *bisc = per_cpu_ptr(blkg->iostat_cpu, cpu);	877	struct blkg_iostat_set *bisc = per_cpu_ptr(blkg->iostat_cpu, cpu);
863	struct blkg_iostat cur, delta;	878	struct blkg_iostat cur;
864	unsigned long flags;
865	unsigned int seq;	879	unsigned int seq;
866		880
867	/* fetch the current per-cpu values */	881	/* fetch the current per-cpu values */
@@ -870,23 +884,12 @@ static void blkcg_rstat_flush(struct cgroup_subsys_state *css, int cpu) · 2 unmodified lines
870	blkg_iostat_set(&cur, &bisc->cur);	884	blkg_iostat_set(&cur, &bisc->cur);
871	} while (u64_stats_fetch_retry(&bisc->sync, seq));	885	} while (u64_stats_fetch_retry(&bisc->sync, seq));
872		886
873	/* propagate percpu delta to global */	887	blkcg_iostat_update(blkg, &cur, &bisc->last);
874	flags = u64_stats_update_begin_irqsave(&blkg->iostat.sync);
875	blkg_iostat_set(&delta, &cur);
876	blkg_iostat_sub(&delta, &bisc->last);
877	blkg_iostat_add(&blkg->iostat.cur, &delta);
878	blkg_iostat_add(&bisc->last, &delta);
879	u64_stats_update_end_irqrestore(&blkg->iostat.sync, flags);
880		888
881	/* propagate global delta to parent (unless that's root) */	889	/* propagate global delta to parent (unless that's root) */
882	if (parent && parent->parent) {	890	if (parent && parent->parent)
883	flags = u64_stats_update_begin_irqsave(&parent->iostat.sync);	891	blkcg_iostat_update(parent, &blkg->iostat.cur,
884	blkg_iostat_set(&delta, &blkg->iostat.cur);	892	&blkg->iostat.last);
885	blkg_iostat_sub(&delta, &blkg->iostat.last);
886	blkg_iostat_add(&parent->iostat.cur, &delta);
887	blkg_iostat_add(&blkg->iostat.last, &delta);
888	u64_stats_update_end_irqrestore(&parent->iostat.sync, flags);
889	}
890	}	893	}
891		894
892	rcu_read_unlock();	895	rcu_read_unlock();
@@ -1299,6 +1302,7 @@ int blkcg_init_queue(struct request_queue *q) · 406 unmodified lines
1299	ret = blk_iolatency_init(q);	1302	ret = blk_iolatency_init(q);
1300	if (ret) {	1303	if (ret) {
1301	blk_throtl_exit(q);	1304	blk_throtl_exit(q);
		1305	blk_ioprio_exit(q);
1302	goto err_destroy_all;	1306	goto err_destroy_all;
1303	}	1307	}
1304		1308
@@ -1529,6 +1533,18 @@ void blkcg_deactivate_policy(struct request_queue *q, · 224 unmodified lines
1529	}	1533	}
1530	EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);	1534	EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
1531		1535
		1536	static void blkcg_free_all_cpd(struct blkcg_policy *pol)
		1537	{
		1538	struct blkcg *blkcg;
		1539
		1540	list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
		1541	if (blkcg->cpd[pol->plid]) {
		1542	pol->cpd_free_fn(blkcg->cpd[pol->plid]);
		1543	blkcg->cpd[pol->plid] = NULL;
		1544	}
		1545	}
		1546	}
		1547
1532	/**	1548	/**
1533	* blkcg_policy_register - register a blkcg policy	1549	* blkcg_policy_register - register a blkcg policy
1534	* @pol: blkcg policy to register	1550	* @pol: blkcg policy to register
@@ -1593,14 +1609,9 @@ int blkcg_policy_register(struct blkcg_policy *pol) · 58 unmodified lines
1593	return 0;	1609	return 0;
1594		1610
1595	err_free_cpds:	1611	err_free_cpds:
1596	if (pol->cpd_free_fn) {	1612	if (pol->cpd_free_fn)
1597	list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {	1613	blkcg_free_all_cpd(pol);
1598	if (blkcg->cpd[pol->plid]) {	1614
1599	pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1600	blkcg->cpd[pol->plid] = NULL;
1601	}
1602	}
1603	}
1604	blkcg_policy[pol->plid] = NULL;	1615	blkcg_policy[pol->plid] = NULL;
1605	err_unlock:	1616	err_unlock:
1606	mutex_unlock(&blkcg_pol_mutex);	1617	mutex_unlock(&blkcg_pol_mutex);
@@ -1617,8 +1628,6 @@ EXPORT_SYMBOL_GPL(blkcg_policy_register); · 10 unmodified lines
1617	*/	1628	*/
1618	void blkcg_policy_unregister(struct blkcg_policy *pol)	1629	void blkcg_policy_unregister(struct blkcg_policy *pol)
1619	{	1630	{
1620	struct blkcg *blkcg;
1621
1622	mutex_lock(&blkcg_pol_register_mutex);	1631	mutex_lock(&blkcg_pol_register_mutex);
1623		1632
1624	if (WARN_ON(blkcg_policy[pol->plid] != pol))	1633	if (WARN_ON(blkcg_policy[pol->plid] != pol))
@@ -1633,14 +1642,9 @@ void blkcg_policy_unregister(struct blkcg_policy *pol) · 8 unmodified lines
1633	/* remove cpds and unregister */	1642	/* remove cpds and unregister */
1634	mutex_lock(&blkcg_pol_mutex);	1643	mutex_lock(&blkcg_pol_mutex);
1635		1644
1636	if (pol->cpd_free_fn) {	1645	if (pol->cpd_free_fn)
1637	list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {	1646	blkcg_free_all_cpd(pol);
1638	if (blkcg->cpd[pol->plid]) {	1647
1639	pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1640	blkcg->cpd[pol->plid] = NULL;
1641	}
1642	}
1643	}
1644	blkcg_policy[pol->plid] = NULL;	1648	blkcg_policy[pol->plid] = NULL;
1645		1649
1646	mutex_unlock(&blkcg_pol_mutex);	1650	mutex_unlock(&blkcg_pol_mutex);
@@ -1696,7 +1700,7 @@ static void blkcg_scale_delay(struct blkcg_gq *blkg, u64 now) · 49 unmodified lines
1696	* everybody is happy with their IO latencies.	1700	* everybody is happy with their IO latencies.
1697	*/	1701	*/
1698	if (time_before64(old + NSEC_PER_SEC, now) &&	1702	if (time_before64(old + NSEC_PER_SEC, now) &&
1699	atomic64_cmpxchg(&blkg->delay_start, old, now) == old) {	1703	atomic64_try_cmpxchg(&blkg->delay_start, &old, now)) {
1700	u64 cur = atomic64_read(&blkg->delay_nsec);	1704	u64 cur = atomic64_read(&blkg->delay_nsec);
1701	u64 sub = min_t(u64, blkg->last_delay, now - old);	1705	u64 sub = min_t(u64, blkg->last_delay, now - old);
1702	int cur_use = atomic_read(&blkg->use_delay);	1706	int cur_use = atomic_read(&blkg->use_delay);

block/blk-cgroup.h+4−8

 	 * then check to see if we were the last delay so we can drop the
 	 * congestion count on the cgroup.
 	 */
-	while (old) {
+	while (old && !atomic_try_cmpxchg(&blkg->use_delay, &old, old - 1))
-		int cur = atomic_cmpxchg(&blkg->use_delay, old, old - 1);
+		;
-		if (cur == old)
-			break;
-		old = cur;
-	}
 	if (old == 0)
 		return 0;
 	int old = atomic_read(&blkg->use_delay);
 	/* We only want 1 person setting the congestion count for this blkg. */
-	if (!old && atomic_cmpxchg(&blkg->use_delay, old, -1) == old)
+	if (!old && atomic_try_cmpxchg(&blkg->use_delay, &old, -1))
 		atomic_inc(&blkg->blkcg->css.cgroup->congestion_count);
 	atomic64_set(&blkg->delay_nsec, delay);
 	int old = atomic_read(&blkg->use_delay);
 	/* We only want 1 person clearing the congestion count for this blkg. */
-	if (old && atomic_cmpxchg(&blkg->use_delay, old, 0) == old)
+	if (old && atomic_try_cmpxchg(&blkg->use_delay, &old, 0))
 		atomic_dec(&blkg->blkcg->css.cgroup->congestion_count);
 }

block/blk-core.c+17−63

  * string format. Useful in the debugging and tracing bio or request. For
  * invalid REQ_OP_XXX it returns string "UNKNOWN".
  */
-inline const char *blk_op_str(unsigned int op)
+inline const char *blk_op_str(enum req_op op)
 {
 	const char *op_str = "UNKNOWN";
 	wake_up_all(&q->mq_freeze_wq);
 }
-/**
- * blk_cleanup_queue - shutdown a request queue
- * @q: request queue to shutdown
- *
- * Mark @q DYING, drain all pending requests, mark @q DEAD, destroy and
- * put it.  All future requests will be failed immediately with -ENODEV.
- *
- * Context: can sleep
- */
-void blk_cleanup_queue(struct request_queue *q)
-{
-	/* cannot be called from atomic context */
-	might_sleep();
-	WARN_ON_ONCE(blk_queue_registered(q));
-	/* mark @q DYING, no new request or merges will be allowed afterwards */
-	blk_queue_flag_set(QUEUE_FLAG_DYING, q);
-	blk_queue_start_drain(q);
-	blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
-	blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
-	/*
-	 * Drain all requests queued before DYING marking. Set DEAD flag to
-	 * prevent that blk_mq_run_hw_queues() accesses the hardware queues
-	 * after draining finished.
-	 */
-	blk_freeze_queue(q);
-	blk_queue_flag_set(QUEUE_FLAG_DEAD, q);
-	blk_sync_queue(q);
-	if (queue_is_mq(q)) {
-		blk_mq_cancel_work_sync(q);
-		blk_mq_exit_queue(q);
-	}
-	/* @q is and will stay empty, shutdown and put */
-	blk_put_queue(q);
-}
-EXPORT_SYMBOL(blk_cleanup_queue);
 /**
  * blk_queue_enter() - try to increase q->q_usage_counter
  * @q: request queue pointer
 	q->last_merge = NULL;
-	q->id = ida_simple_get(&blk_queue_ida, 0, 0, GFP_KERNEL);
+	q->id = ida_alloc(&blk_queue_ida, GFP_KERNEL);
 	if (q->id < 0)
 		goto fail_srcu;
 fail_split:
 	bioset_exit(&q->bio_split);
 fail_id:
-	ida_simple_remove(&blk_queue_ida, q->id);
+	ida_free(&blk_queue_ida, q->id);
 fail_srcu:
 	if (alloc_srcu)
 		cleanup_srcu_struct(q->srcu);
  */
 bool blk_get_queue(struct request_queue *q)
 {
-	if (likely(!blk_queue_dying(q))) {
+	if (unlikely(blk_queue_dying(q)))
-		__blk_get_queue(q);
+		return false;
-		return true;
+	kobject_get(&q->kobj);
-	}
+	return true;
-	return false;
 }
 EXPORT_SYMBOL(blk_get_queue);
 static inline blk_status_t blk_check_zone_append(struct request_queue *q,
 						 struct bio *bio)
 {
-	sector_t pos = bio->bi_iter.bi_sector;
 	int nr_sectors = bio_sectors(bio);
 	/* Only applicable to zoned block devices */
-	if (!blk_queue_is_zoned(q))
+	if (!bdev_is_zoned(bio->bi_bdev))
 		return BLK_STS_NOTSUPP;
 	/* The bio sector must point to the start of a sequential zone */
-	if (pos & (blk_queue_zone_sectors(q) - 1) ||
+	if (bio->bi_iter.bi_sector & (bdev_zone_sectors(bio->bi_bdev) - 1) ||
-	    !blk_queue_zone_is_seq(q, pos))
+	    !bio_zone_is_seq(bio))
 		return BLK_STS_IOERR;
 	/*
 	might_sleep();
-	plug = blk_mq_plug(q, bio);
+	plug = blk_mq_plug(bio);
 	if (plug && plug->nowait)
 		bio->bi_opf |= REQ_NOWAIT;
 	case REQ_OP_ZONE_OPEN:
 	case REQ_OP_ZONE_CLOSE:
 	case REQ_OP_ZONE_FINISH:
-		if (!blk_queue_is_zoned(q))
+		if (!bdev_is_zoned(bio->bi_bdev))
 			goto not_supported;
 		break;
 	case REQ_OP_ZONE_RESET_ALL:
-		if (!blk_queue_is_zoned(q) || !blk_queue_zone_resetall(q))
+		if (!bdev_is_zoned(bio->bi_bdev) || !blk_queue_zone_resetall(q))
 			goto not_supported;
 		break;
 	case REQ_OP_WRITE_ZEROES:
 again:
 	stamp = READ_ONCE(part->bd_stamp);
 	if (unlikely(time_after(now, stamp))) {
-		if (likely(cmpxchg(&part->bd_stamp, stamp, now) == stamp))
+		if (likely(try_cmpxchg(&part->bd_stamp, &stamp, now)))
 			__part_stat_add(part, io_ticks, end ? now - stamp : 1);
 	}
 	if (part->bd_partno) {
 }
 unsigned long bdev_start_io_acct(struct block_device *bdev,
-				 unsigned int sectors, unsigned int op,
+				 unsigned int sectors, enum req_op op,
 				 unsigned long start_time)
 {
 	const int sgrp = op_stat_group(op);
 }
 EXPORT_SYMBOL_GPL(bio_start_io_acct);
-void bdev_end_io_acct(struct block_device *bdev, unsigned int op,
+void bdev_end_io_acct(struct block_device *bdev, enum req_op op,
 		      unsigned long start_time)
 {
 	const int sgrp = op_stat_group(op);
 int __init blk_dev_init(void)
 {
-	BUILD_BUG_ON(REQ_OP_LAST >= (1 << REQ_OP_BITS));
+	BUILD_BUG_ON((__force u32)REQ_OP_LAST >= (1 << REQ_OP_BITS));
 	BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
 			sizeof_field(struct request, cmd_flags));
 	BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *

block/blk-flush.c+3−3

@@ -94,7 +94,7 @@ enum { · 93 unmodified lines
94	};	94	};
95		95
96	static void blk_kick_flush(struct request_queue *q,	96	static void blk_kick_flush(struct request_queue *q,
97	struct blk_flush_queue *fq, unsigned int flags);	97	struct blk_flush_queue *fq, blk_opf_t flags);
98		98
99	static inline struct blk_flush_queue *	99	static inline struct blk_flush_queue *
100	blk_get_flush_queue(struct request_queue q, struct blk_mq_ctx ctx)	100	blk_get_flush_queue(struct request_queue q, struct blk_mq_ctx ctx)
@@ -173,7 +173,7 @@ static void blk_flush_complete_seq(struct request *rq, · 72 unmodified lines
173	{	173	{
174	struct request_queue *q = rq->q;	174	struct request_queue *q = rq->q;
175	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];	175	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
176	unsigned int cmd_flags;	176	blk_opf_t cmd_flags;
177		177
178	BUG_ON(rq->flush.seq & seq);	178	BUG_ON(rq->flush.seq & seq);
179	rq->flush.seq \|= seq;	179	rq->flush.seq \|= seq;
@@ -290,7 +290,7 @@ bool is_flush_rq(struct request *rq) · 110 unmodified lines
290	*	290	*
291	*/	291	*/
292	static void blk_kick_flush(struct request_queue q, struct blk_flush_queue fq,	292	static void blk_kick_flush(struct request_queue q, struct blk_flush_queue fq,
293	unsigned int flags)	293	blk_opf_t flags)
294	{	294	{
295	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];	295	struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
296	struct request *first_rq =	296	struct request *first_rq =

block/blk-ia-ranges.c+20−45

@@ -102,31 +102,18 @@ static struct kobj_type blk_ia_ranges_ktype = { · 101 unmodified lines
102	* disk_register_independent_access_ranges - register with sysfs a set of	102	* disk_register_independent_access_ranges - register with sysfs a set of
103	* independent access ranges	103	* independent access ranges
104	* @disk: Target disk	104	* @disk: Target disk
105	* @new_iars: New set of independent access ranges
106	*	105	*
107	* Register with sysfs a set of independent access ranges for @disk.	106	* Register with sysfs a set of independent access ranges for @disk.
108	* If @new_iars is not NULL, this set of ranges is registered and the old set
109	* specified by q->ia_ranges is unregistered. Otherwise, q->ia_ranges is
110	* registered if it is not already.
111	*/	107	*/
112	int disk_register_independent_access_ranges(struct gendisk *disk,	108	int disk_register_independent_access_ranges(struct gendisk *disk)
113	struct blk_independent_access_ranges *new_iars)
114	{	109	{
		110	struct blk_independent_access_ranges *iars = disk->ia_ranges;
115	struct request_queue *q = disk->queue;	111	struct request_queue *q = disk->queue;
116	struct blk_independent_access_ranges *iars;
117	int i, ret;	112	int i, ret;
118		113
119	lockdep_assert_held(&q->sysfs_dir_lock);	114	lockdep_assert_held(&q->sysfs_dir_lock);
120	lockdep_assert_held(&q->sysfs_lock);	115	lockdep_assert_held(&q->sysfs_lock);
121		116
122	/* If a new range set is specified, unregister the old one */
123	if (new_iars) {
124	if (q->ia_ranges)
125	disk_unregister_independent_access_ranges(disk);
126	q->ia_ranges = new_iars;
127	}
128
129	iars = q->ia_ranges;
130	if (!iars)	117	if (!iars)
131	return 0;	118	return 0;
132		119
@@ -138,7 +125,7 @@ int disk_register_independent_access_ranges(struct gendisk *disk, · 5 unmodified lines
138	ret = kobject_init_and_add(&iars->kobj, &blk_ia_ranges_ktype,	125	ret = kobject_init_and_add(&iars->kobj, &blk_ia_ranges_ktype,
139	&q->kobj, "%s", "independent_access_ranges");	126	&q->kobj, "%s", "independent_access_ranges");
140	if (ret) {	127	if (ret) {
141	q->ia_ranges = NULL;	128	disk->ia_ranges = NULL;
142	kobject_put(&iars->kobj);	129	kobject_put(&iars->kobj);
143	return ret;	130	return ret;
144	}	131	}
@@ -164,7 +151,7 @@ int disk_register_independent_access_ranges(struct gendisk *disk, · 19 unmodified lines
164	void disk_unregister_independent_access_ranges(struct gendisk *disk)	151	void disk_unregister_independent_access_ranges(struct gendisk *disk)
165	{	152	{
166	struct request_queue *q = disk->queue;	153	struct request_queue *q = disk->queue;
167	struct blk_independent_access_ranges *iars = q->ia_ranges;	154	struct blk_independent_access_ranges *iars = disk->ia_ranges;
168	int i;	155	int i;
169		156
170	lockdep_assert_held(&q->sysfs_dir_lock);	157	lockdep_assert_held(&q->sysfs_dir_lock);
@@ -182,7 +169,7 @@ void disk_unregister_independent_access_ranges(struct gendisk *disk) · 11 unmodified lines
182	kfree(iars);	169	kfree(iars);
183	}	170	}
184		171
185	q->ia_ranges = NULL;	172	disk->ia_ranges = NULL;
186	}	173	}
187		174
188	static struct blk_independent_access_range *	175	static struct blk_independent_access_range *
@@ -210,6 +197,9 @@ static bool disk_check_ia_ranges(struct gendisk *disk, · 21 unmodified lines
210	sector_t sector = 0;	197	sector_t sector = 0;
211	int i;	198	int i;
212		199
		200	if (WARN_ON_ONCE(!iars->nr_ia_ranges))
		201	return false;
		202
213	/*	203	/*
214	* While sorting the ranges in increasing LBA order, check that the	204	* While sorting the ranges in increasing LBA order, check that the
215	* ranges do not overlap, that there are no sector holes and that all	205	* ranges do not overlap, that there are no sector holes and that all
@@ -242,7 +232,7 @@ static bool disk_check_ia_ranges(struct gendisk *disk, · 26 unmodified lines
242	static bool disk_ia_ranges_changed(struct gendisk *disk,	232	static bool disk_ia_ranges_changed(struct gendisk *disk,
243	struct blk_independent_access_ranges *new)	233	struct blk_independent_access_ranges *new)
244	{	234	{
245	struct blk_independent_access_ranges *old = disk->queue->ia_ranges;	235	struct blk_independent_access_ranges *old = disk->ia_ranges;
246	int i;	236	int i;
247		237
248	if (!old)	238	if (!old)
@@ -298,25 +288,15 @@ void disk_set_independent_access_ranges(struct gendisk *disk, · 49 unmodified lines
298	{	288	{
299	struct request_queue *q = disk->queue;	289	struct request_queue *q = disk->queue;
300		290
301	if (WARN_ON_ONCE(iars && !iars->nr_ia_ranges)) {	291	mutex_lock(&q->sysfs_dir_lock);
		292	mutex_lock(&q->sysfs_lock);
		293	if (iars && !disk_check_ia_ranges(disk, iars)) {
302	kfree(iars);	294	kfree(iars);
303	iars = NULL;	295	iars = NULL;
304	}	296	}
305		297	if (iars && !disk_ia_ranges_changed(disk, iars)) {
306	mutex_lock(&q->sysfs_dir_lock);	298	kfree(iars);
307	mutex_lock(&q->sysfs_lock);	299	goto unlock;
308
309	if (iars) {
310	if (!disk_check_ia_ranges(disk, iars)) {
311	kfree(iars);
312	iars = NULL;
313	goto reg;
314	}
315
316	if (!disk_ia_ranges_changed(disk, iars)) {
317	kfree(iars);
318	goto unlock;
319	}
320	}	300	}
321		301
322	/*	302	/*
@@ -324,17 +304,12 @@ void disk_set_independent_access_ranges(struct gendisk *disk, · 1 unmodified line
324	* revalidation. If that is the case, we need to unregister the old	304	* revalidation. If that is the case, we need to unregister the old
325	* set of independent access ranges and register the new set. If the	305	* set of independent access ranges and register the new set. If the
326	* queue is not registered, registration of the device request queue	306	* queue is not registered, registration of the device request queue
327	* will register the independent access ranges, so only swap in the	307	* will register the independent access ranges.
328	* new set and free the old one.
329	*/	308	*/
330	reg:	309	disk_unregister_independent_access_ranges(disk);
331	if (blk_queue_registered(q)) {	310	disk->ia_ranges = iars;
332	disk_register_independent_access_ranges(disk, iars);	311	if (blk_queue_registered(q))
333	} else {	312	disk_register_independent_access_ranges(disk);
334	swap(q->ia_ranges, iars);
335	kfree(iars);
336	}
337
338	unlock:	313	unlock:
339	mutex_unlock(&q->sysfs_lock);	314	mutex_unlock(&q->sysfs_lock);
340	mutex_unlock(&q->sysfs_dir_lock);	315	mutex_unlock(&q->sysfs_dir_lock);

block/blk-ioc.c+2−0

@@ -247,6 +247,8 @@ static struct io_context *alloc_io_context(gfp_t gfp_flags, int node) · 246 unmodified lines
247	INIT_HLIST_HEAD(&ioc->icq_list);	247	INIT_HLIST_HEAD(&ioc->icq_list);
248	INIT_WORK(&ioc->release_work, ioc_release_fn);	248	INIT_WORK(&ioc->release_work, ioc_release_fn);
249	#endif	249	#endif
		250	ioc->ioprio = IOPRIO_DEFAULT;
		251
250	return ioc;	252	return ioc;
251	}	253	}
252		254

block/blk-iocost.c+14−8

 	if (!ioc->enabled || !rq->alloc_time_ns || !rq->start_time_ns)
 		return;
-	switch (req_op(rq) & REQ_OP_MASK) {
+	switch (req_op(rq)) {
 	case REQ_OP_READ:
 		pidx = QOS_RLAT;
 		rw = READ;
 	 * called before policy activation completion, can't assume that the
 	 * target bio has an iocg associated and need to test for NULL iocg.
 	 */
-	rq_qos_add(q, rqos);
+	ret = rq_qos_add(q, rqos);
+	if (ret)
+		goto err_free_ioc;
 	ret = blkcg_activate_policy(q, &blkcg_policy_iocost);
-	if (ret) {
+	if (ret)
-		rq_qos_del(q, rqos);
+		goto err_del_qos;
-		free_percpu(ioc->pcpu_stat);
-		kfree(ioc);
-		return ret;
-	}
 	return 0;
+err_del_qos:
+	rq_qos_del(q, rqos);
+err_free_ioc:
+	free_percpu(ioc->pcpu_stat);
+	kfree(ioc);
+	return ret;
 }
 static struct blkcg_policy_data *ioc_cpd_alloc(gfp_t gfp)

block/blk-iolatency.c+16−14

@@ -401,7 +401,6 @@ static void check_scale_change(struct iolatency_grp *iolat) · 400 unmodified lines
401	unsigned int cur_cookie;	401	unsigned int cur_cookie;
402	unsigned int our_cookie = atomic_read(&iolat->scale_cookie);	402	unsigned int our_cookie = atomic_read(&iolat->scale_cookie);
403	u64 scale_lat;	403	u64 scale_lat;
404	unsigned int old;
405	int direction = 0;	404	int direction = 0;
406		405
407	if (lat_to_blkg(iolat)->parent == NULL)	406	if (lat_to_blkg(iolat)->parent == NULL)
@@ -422,11 +421,10 @@ static void check_scale_change(struct iolatency_grp *iolat) · 14 unmodified lines
422	else	421	else
423	return;	422	return;
424		423
425	old = atomic_cmpxchg(&iolat->scale_cookie, our_cookie, cur_cookie);	424	if (!atomic_try_cmpxchg(&iolat->scale_cookie, &our_cookie, cur_cookie)) {
426		425	/* Somebody beat us to the punch, just bail. */
427	/* Somebody beat us to the punch, just bail. */
428	if (old != our_cookie)
429	return;	426	return;
		427	}
430		428
431	if (direction < 0 && iolat->min_lat_nsec) {	429	if (direction < 0 && iolat->min_lat_nsec) {
432	u64 samples_thresh;	430	u64 samples_thresh;
@@ -633,8 +631,8 @@ static void blkcg_iolatency_done_bio(struct rq_qos rqos, struct bio bio) · 200 unmodified lines
633	window_start = atomic64_read(&iolat->window_start);	631	window_start = atomic64_read(&iolat->window_start);
634	if (now > window_start &&	632	if (now > window_start &&
635	(now - window_start) >= iolat->cur_win_nsec) {	633	(now - window_start) >= iolat->cur_win_nsec) {
636	if (atomic64_cmpxchg(&iolat->window_start,	634	if (atomic64_try_cmpxchg(&iolat->window_start,
637	window_start, now) == window_start)	635	&window_start, now))
638	iolatency_check_latencies(iolat, now);	636	iolatency_check_latencies(iolat, now);
639	}	637	}
640	}	638	}
@@ -773,19 +771,23 @@ int blk_iolatency_init(struct request_queue *q) · 132 unmodified lines
773	rqos->ops = &blkcg_iolatency_ops;	771	rqos->ops = &blkcg_iolatency_ops;
774	rqos->q = q;	772	rqos->q = q;
775		773
776	rq_qos_add(q, rqos);	774	ret = rq_qos_add(q, rqos);
777		775	if (ret)
		776	goto err_free;
778	ret = blkcg_activate_policy(q, &blkcg_policy_iolatency);	777	ret = blkcg_activate_policy(q, &blkcg_policy_iolatency);
779	if (ret) {	778	if (ret)
780	rq_qos_del(q, rqos);	779	goto err_qos_del;
781	kfree(blkiolat);
782	return ret;
783	}
784		780
785	timer_setup(&blkiolat->timer, blkiolatency_timer_fn, 0);	781	timer_setup(&blkiolat->timer, blkiolatency_timer_fn, 0);
786	INIT_WORK(&blkiolat->enable_work, blkiolatency_enable_work_fn);	782	INIT_WORK(&blkiolat->enable_work, blkiolatency_enable_work_fn);
787		783
788	return 0;	784	return 0;
		785
		786	err_qos_del:
		787	rq_qos_del(q, rqos);
		788	err_free:
		789	kfree(blkiolat);
		790	return ret;
789	}	791	}
790		792
791	static void iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val)	793	static void iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val)

block/blk-ioprio.c+7−50

 struct ioprio_blkcg {
 	struct blkcg_policy_data cpd;
 	enum prio_policy	 prio_policy;
-	bool			 prio_set;
 };
 static inline struct ioprio_blkg *pd_to_ioprio(struct blkg_policy_data *pd)
 	if (ret < 0)
 		return ret;
 	blkcg->prio_policy = ret;
-	blkcg->prio_set = true;
 	return nbytes;
 }
 	.pd_free_fn	= ioprio_free_pd,
 };
-struct blk_ioprio {
+void blkcg_set_ioprio(struct bio *bio)
-	struct rq_qos rqos;
-};
-static void blkcg_ioprio_track(struct rq_qos *rqos, struct request *rq,
-			       struct bio *bio)
 {
 	struct ioprio_blkcg *blkcg = ioprio_blkcg_from_bio(bio);
 	u16 prio;
-	if (!blkcg->prio_set)
+	if (!blkcg || blkcg->prio_policy == POLICY_NO_CHANGE)
 		return;
 	/*
 	 * Except for IOPRIO_CLASS_NONE, higher I/O priority numbers
 	 * correspond to a lower priority. Hence, the max_t() below selects
 	 * the lower priority of bi_ioprio and the cgroup I/O priority class.
-	 * If the cgroup policy has been set to POLICY_NO_CHANGE == 0, the
+	 * If the bio I/O priority equals IOPRIO_CLASS_NONE, the cgroup I/O
-	 * bio I/O priority is not modified. If the bio I/O priority equals
+	 * priority is assigned to the bio.
-	 * IOPRIO_CLASS_NONE, the cgroup I/O priority is assigned to the bio.
 	 */
 	prio = max_t(u16, bio->bi_ioprio,
 			IOPRIO_PRIO_VALUE(blkcg->prio_policy, 0));
 		bio->bi_ioprio = prio;
 }
-static void blkcg_ioprio_exit(struct rq_qos *rqos)
+void blk_ioprio_exit(struct request_queue *q)
 {
-	struct blk_ioprio *blkioprio_blkg =
+	blkcg_deactivate_policy(q, &ioprio_policy);
-		container_of(rqos, typeof(*blkioprio_blkg), rqos);
-	blkcg_deactivate_policy(rqos->q, &ioprio_policy);
-	kfree(blkioprio_blkg);
 }
-static struct rq_qos_ops blkcg_ioprio_ops = {
-	.track	= blkcg_ioprio_track,
-	.exit	= blkcg_ioprio_exit,
-};
 int blk_ioprio_init(struct request_queue *q)
 {
-	struct blk_ioprio *blkioprio_blkg;
+	return blkcg_activate_policy(q, &ioprio_policy);
-	struct rq_qos *rqos;
-	int ret;
-	blkioprio_blkg = kzalloc(sizeof(*blkioprio_blkg), GFP_KERNEL);
-	if (!blkioprio_blkg)
-		return -ENOMEM;
-	ret = blkcg_activate_policy(q, &ioprio_policy);
-	if (ret) {
-		kfree(blkioprio_blkg);
-		return ret;
-	}
-	rqos = &blkioprio_blkg->rqos;
-	rqos->id = RQ_QOS_IOPRIO;
-	rqos->ops = &blkcg_ioprio_ops;
-	rqos->q = q;
-	/*
-	 * Registering the rq-qos policy after activating the blk-cgroup
-	 * policy guarantees that ioprio_blkcg_from_bio(bio) != NULL in the
-	 * rq-qos callbacks.
-	 */
-	rq_qos_add(q, rqos);
-	return 0;
 }
 static int __init ioprio_init(void)

block/blk-ioprio.h+9−0

 #include <linux/kconfig.h>
 struct request_queue;
+struct bio;
 #ifdef CONFIG_BLK_CGROUP_IOPRIO
 int blk_ioprio_init(struct request_queue *q);
+void blk_ioprio_exit(struct request_queue *q);
+void blkcg_set_ioprio(struct bio *bio);
 #else
 static inline int blk_ioprio_init(struct request_queue *q)
 {
 	return 0;
 }
+static inline void blk_ioprio_exit(struct request_queue *q)
+{
+}
+static inline void blkcg_set_ioprio(struct bio *bio)
+{
+}
 #endif
 #endif /* _BLK_IOPRIO_H_ */

block/blk-lib.c+2−4

@@ -48,10 +48,8 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, · 47 unmodified lines
48		48
49	/* In case the discard granularity isn't set by buggy device driver */	49	/* In case the discard granularity isn't set by buggy device driver */
50	if (WARN_ON_ONCE(!bdev_discard_granularity(bdev))) {	50	if (WARN_ON_ONCE(!bdev_discard_granularity(bdev))) {
51	char dev_name[BDEVNAME_SIZE];	51	pr_err_ratelimited("%pg: Error: discard_granularity is 0.\n",
52		52	bdev);
53	bdevname(bdev, dev_name);
54	pr_err_ratelimited("%s: Error: discard_granularity is 0.\n", dev_name);
55	return -EOPNOTSUPP;	53	return -EOPNOTSUPP;
56	}	54	}
57		55

block/blk-merge.c+46−33

@@ -164,18 +164,21 @@ static struct bio blk_bio_write_zeroes_split(struct request_queue q, · 163 unmodified lines
164	static inline unsigned get_max_io_size(struct request_queue *q,	164	static inline unsigned get_max_io_size(struct request_queue *q,
165	struct bio *bio)	165	struct bio *bio)
166	{	166	{
167	unsigned sectors = blk_max_size_offset(q, bio->bi_iter.bi_sector, 0);
168	unsigned max_sectors = sectors;
169	unsigned pbs = queue_physical_block_size(q) >> SECTOR_SHIFT;	167	unsigned pbs = queue_physical_block_size(q) >> SECTOR_SHIFT;
170	unsigned lbs = queue_logical_block_size(q) >> SECTOR_SHIFT;	168	unsigned lbs = queue_logical_block_size(q) >> SECTOR_SHIFT;
171	unsigned start_offset = bio->bi_iter.bi_sector & (pbs - 1);	169	unsigned max_sectors = queue_max_sectors(q), start, end;
172		170
173	max_sectors += start_offset;	171	if (q->limits.chunk_sectors) {
174	max_sectors &= ~(pbs - 1);	172	max_sectors = min(max_sectors,
175	if (max_sectors > start_offset)	173	blk_chunk_sectors_left(bio->bi_iter.bi_sector,
176	return max_sectors - start_offset;	174	q->limits.chunk_sectors));
		175	}
177		176
178	return sectors & ~(lbs - 1);	177	start = bio->bi_iter.bi_sector & (pbs - 1);
		178	end = (start + max_sectors) & ~(pbs - 1);
		179	if (end > start)
		180	return end - start;
		181	return max_sectors & ~(lbs - 1);
179	}	182	}
180		183
181	static inline unsigned get_max_segment_size(const struct request_queue *q,	184	static inline unsigned get_max_segment_size(const struct request_queue *q,
@@ -201,11 +204,11 @@ static inline unsigned get_max_segment_size(const struct request_queue *q, · 19 unmodified lines
201	* @nsegs: [in,out] Number of segments in the bio being built. Incremented	204	* @nsegs: [in,out] Number of segments in the bio being built. Incremented
202	* by the number of segments from @bv that may be appended to that	205	* by the number of segments from @bv that may be appended to that
203	* bio without exceeding @max_segs	206	* bio without exceeding @max_segs
204	* @sectors: [in,out] Number of sectors in the bio being built. Incremented	207	* @bytes: [in,out] Number of bytes in the bio being built. Incremented
205	* by the number of sectors from @bv that may be appended to that	208	* by the number of bytes from @bv that may be appended to that
206	* bio without exceeding @max_sectors	209	* bio without exceeding @max_bytes
207	* @max_segs: [in] upper bound for *@nsegs	210	* @max_segs: [in] upper bound for *@nsegs
208	* @max_sectors: [in] upper bound for *@sectors	211	* @max_bytes: [in] upper bound for *@bytes
209	*	212	*
210	* When splitting a bio, it can happen that a bvec is encountered that is too	213	* When splitting a bio, it can happen that a bvec is encountered that is too
211	* big to fit in a single segment and hence that it has to be split in the	214	* big to fit in a single segment and hence that it has to be split in the
@@ -216,10 +219,10 @@ static inline unsigned get_max_segment_size(const struct request_queue *q, · 4 unmodified lines
216	*/	219	*/
217	static bool bvec_split_segs(const struct request_queue *q,	220	static bool bvec_split_segs(const struct request_queue *q,
218	const struct bio_vec bv, unsigned nsegs,	221	const struct bio_vec bv, unsigned nsegs,
219	unsigned *sectors, unsigned max_segs,	222	unsigned *bytes, unsigned max_segs,
220	unsigned max_sectors)	223	unsigned max_bytes)
221	{	224	{
222	unsigned max_len = (min(max_sectors, UINT_MAX >> 9) - *sectors) << 9;	225	unsigned max_len = min(max_bytes, UINT_MAX) - *bytes;
223	unsigned len = min(bv->bv_len, max_len);	226	unsigned len = min(bv->bv_len, max_len);
224	unsigned total_len = 0;	227	unsigned total_len = 0;
225	unsigned seg_size = 0;	228	unsigned seg_size = 0;
@@ -237,7 +240,7 @@ static bool bvec_split_segs(const struct request_queue *q, · 11 unmodified lines
237	break;	240	break;
238	}	241	}
239		242
240	*sectors += total_len >> 9;	243	*bytes += total_len;
241		244
242	/* tell the caller to split the bvec if it is too big to fit */	245	/* tell the caller to split the bvec if it is too big to fit */
243	return len > 0 \|\| bv->bv_len > max_len;	246	return len > 0 \|\| bv->bv_len > max_len;
@@ -269,8 +272,8 @@ static struct bio blk_bio_segment_split(struct request_queue q, · 25 unmodified lines
269	{	272	{
270	struct bio_vec bv, bvprv, *bvprvp = NULL;	273	struct bio_vec bv, bvprv, *bvprvp = NULL;
271	struct bvec_iter iter;	274	struct bvec_iter iter;
272	unsigned nsegs = 0, sectors = 0;	275	unsigned nsegs = 0, bytes = 0;
273	const unsigned max_sectors = get_max_io_size(q, bio);	276	const unsigned max_bytes = get_max_io_size(q, bio) << 9;
274	const unsigned max_segs = queue_max_segments(q);	277	const unsigned max_segs = queue_max_segments(q);
275		278
276	bio_for_each_bvec(bv, bio, iter) {	279	bio_for_each_bvec(bv, bio, iter) {
@@ -282,12 +285,12 @@ static struct bio blk_bio_segment_split(struct request_queue q, · 5 unmodified lines
282	goto split;	285	goto split;
283		286
284	if (nsegs < max_segs &&	287	if (nsegs < max_segs &&
285	sectors + (bv.bv_len >> 9) <= max_sectors &&	288	bytes + bv.bv_len <= max_bytes &&
286	bv.bv_offset + bv.bv_len <= PAGE_SIZE) {	289	bv.bv_offset + bv.bv_len <= PAGE_SIZE) {
287	nsegs++;	290	nsegs++;
288	sectors += bv.bv_len >> 9;	291	bytes += bv.bv_len;
289	} else if (bvec_split_segs(q, &bv, &nsegs, &sectors, max_segs,	292	} else if (bvec_split_segs(q, &bv, &nsegs, &bytes, max_segs,
290	max_sectors)) {	293	max_bytes)) {
291	goto split;	294	goto split;
292	}	295	}
293		296
@@ -300,13 +303,20 @@ static struct bio blk_bio_segment_split(struct request_queue q, · 6 unmodified lines
300	split:	303	split:
301	*segs = nsegs;	304	*segs = nsegs;
302		305
		306	/*
		307	* Individual bvecs might not be logical block aligned. Round down the
		308	* split size so that each bio is properly block size aligned, even if
		309	* we do not use the full hardware limits.
		310	*/
		311	bytes = ALIGN_DOWN(bytes, queue_logical_block_size(q));
		312
303	/*	313	/*
304	* Bio splitting may cause subtle trouble such as hang when doing sync	314	* Bio splitting may cause subtle trouble such as hang when doing sync
305	* iopoll in direct IO routine. Given performance gain of iopoll for	315	* iopoll in direct IO routine. Given performance gain of iopoll for
306	* big IO can be trival, disable iopoll when split needed.	316	* big IO can be trival, disable iopoll when split needed.
307	*/	317	*/
308	bio_clear_polled(bio);	318	bio_clear_polled(bio);
309	return bio_split(bio, sectors, GFP_NOIO, bs);	319	return bio_split(bio, bytes >> SECTOR_SHIFT, GFP_NOIO, bs);
310	}	320	}
311		321
312	/**	322	/**
@@ -376,7 +386,7 @@ EXPORT_SYMBOL(blk_queue_split); · 63 unmodified lines
376	unsigned int blk_recalc_rq_segments(struct request *rq)	386	unsigned int blk_recalc_rq_segments(struct request *rq)
377	{	387	{
378	unsigned int nr_phys_segs = 0;	388	unsigned int nr_phys_segs = 0;
379	unsigned int nr_sectors = 0;	389	unsigned int bytes = 0;
380	struct req_iterator iter;	390	struct req_iterator iter;
381	struct bio_vec bv;	391	struct bio_vec bv;
382		392
@@ -396,10 +406,12 @@ unsigned int blk_recalc_rq_segments(struct request *rq) · 13 unmodified lines
396	return 1;	406	return 1;
397	case REQ_OP_WRITE_ZEROES:	407	case REQ_OP_WRITE_ZEROES:
398	return 0;	408	return 0;
		409	default:
		410	break;
399	}	411	}
400		412
401	rq_for_each_bvec(bv, rq, iter)	413	rq_for_each_bvec(bv, rq, iter)
402	bvec_split_segs(rq->q, &bv, &nr_phys_segs, &nr_sectors,	414	bvec_split_segs(rq->q, &bv, &nr_phys_segs, &bytes,
403	UINT_MAX, UINT_MAX);	415	UINT_MAX, UINT_MAX);
404	return nr_phys_segs;	416	return nr_phys_segs;
405	}	417	}
@@ -560,17 +572,18 @@ static inline unsigned int blk_rq_get_max_sectors(struct request *rq, · 154 unmodified lines
560	sector_t offset)	572	sector_t offset)
561	{	573	{
562	struct request_queue *q = rq->q;	574	struct request_queue *q = rq->q;
		575	unsigned int max_sectors;
563		576
564	if (blk_rq_is_passthrough(rq))	577	if (blk_rq_is_passthrough(rq))
565	return q->limits.max_hw_sectors;	578	return q->limits.max_hw_sectors;
566		579
		580	max_sectors = blk_queue_get_max_sectors(q, req_op(rq));
567	if (!q->limits.chunk_sectors \|\|	581	if (!q->limits.chunk_sectors \|\|
568	req_op(rq) == REQ_OP_DISCARD \|\|	582	req_op(rq) == REQ_OP_DISCARD \|\|
569	req_op(rq) == REQ_OP_SECURE_ERASE)	583	req_op(rq) == REQ_OP_SECURE_ERASE)
570	return blk_queue_get_max_sectors(q, req_op(rq));	584	return max_sectors;
571		585	return min(max_sectors,
572	return min(blk_max_size_offset(q, offset, 0),	586	blk_chunk_sectors_left(offset, q->limits.chunk_sectors));
573	blk_queue_get_max_sectors(q, req_op(rq)));
574	}	587	}
575		588
576	static inline int ll_new_hw_segment(struct request req, struct bio bio,	589	static inline int ll_new_hw_segment(struct request req, struct bio bio,
@@ -700,7 +713,7 @@ static int ll_merge_requests_fn(struct request_queue q, struct request req, · 123 unmodified lines
700	*/	713	*/
701	void blk_rq_set_mixed_merge(struct request *rq)	714	void blk_rq_set_mixed_merge(struct request *rq)
702	{	715	{
703	unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;	716	blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;
704	struct bio *bio;	717	struct bio *bio;
705		718
706	if (rq->rq_flags & RQF_MIXED_MERGE)	719	if (rq->rq_flags & RQF_MIXED_MERGE)
@@ -916,7 +929,7 @@ enum bio_merge_status { · 209 unmodified lines
916	static enum bio_merge_status bio_attempt_back_merge(struct request *req,	929	static enum bio_merge_status bio_attempt_back_merge(struct request *req,
917	struct bio *bio, unsigned int nr_segs)	930	struct bio *bio, unsigned int nr_segs)
918	{	931	{
919	const int ff = bio->bi_opf & REQ_FAILFAST_MASK;	932	const blk_opf_t ff = bio->bi_opf & REQ_FAILFAST_MASK;
920		933
921	if (!ll_back_merge_fn(req, bio, nr_segs))	934	if (!ll_back_merge_fn(req, bio, nr_segs))
922	return BIO_MERGE_FAILED;	935	return BIO_MERGE_FAILED;
@@ -940,7 +953,7 @@ static enum bio_merge_status bio_attempt_back_merge(struct request *req, · 17 unmodified lines
940	static enum bio_merge_status bio_attempt_front_merge(struct request *req,	953	static enum bio_merge_status bio_attempt_front_merge(struct request *req,
941	struct bio *bio, unsigned int nr_segs)	954	struct bio *bio, unsigned int nr_segs)
942	{	955	{
943	const int ff = bio->bi_opf & REQ_FAILFAST_MASK;	956	const blk_opf_t ff = bio->bi_opf & REQ_FAILFAST_MASK;
944		957
945	if (!ll_front_merge_fn(req, bio, nr_segs))	958	if (!ll_front_merge_fn(req, bio, nr_segs))
946	return BIO_MERGE_FAILED;	959	return BIO_MERGE_FAILED;
@@ -1041,7 +1054,7 @@ bool blk_attempt_plug_merge(struct request_queue q, struct bio bio, · 94 unmodified lines
1041	struct blk_plug *plug;	1054	struct blk_plug *plug;
1042	struct request *rq;	1055	struct request *rq;
1043		1056
1044	plug = blk_mq_plug(q, bio);	1057	plug = blk_mq_plug(bio);
1045	if (!plug \|\| rq_list_empty(plug->mq_list))	1058	if (!plug \|\| rq_list_empty(plug->mq_list))
1046	return false;	1059	return false;
1047		1060

block/blk-mq-debugfs-zoned.c+3−3

@@ -11,11 +11,11 @@ int queue_zone_wlock_show(void data, struct seq_file m) · 10 unmodified lines
11	struct request_queue *q = data;	11	struct request_queue *q = data;
12	unsigned int i;	12	unsigned int i;
13		13
14	if (!q->seq_zones_wlock)	14	if (!q->disk->seq_zones_wlock)
15	return 0;	15	return 0;
16		16
17	for (i = 0; i < q->nr_zones; i++)	17	for (i = 0; i < q->disk->nr_zones; i++)
18	if (test_bit(i, q->seq_zones_wlock))	18	if (test_bit(i, q->disk->seq_zones_wlock))
19	seq_printf(m, "%u\n", i);	19	seq_printf(m, "%u\n", i);
20		20
21	return 0;	21	return 0;

block/blk-mq-debugfs.c+10−9

 	QUEUE_FLAG_NAME(NOXMERGES),
 	QUEUE_FLAG_NAME(ADD_RANDOM),
 	QUEUE_FLAG_NAME(SAME_FORCE),
-	QUEUE_FLAG_NAME(DEAD),
 	QUEUE_FLAG_NAME(INIT_DONE),
 	QUEUE_FLAG_NAME(STABLE_WRITES),
 	QUEUE_FLAG_NAME(POLL),
 	char opbuf[16] = { }, *op;
 	/*
-	 * The "state" attribute is removed after blk_cleanup_queue() has called
+	 * The "state" attribute is removed when the queue is removed.  Don't
-	 * blk_mq_free_queue(). Return if QUEUE_FLAG_DEAD has been set to avoid
+	 * allow setting the state on a dying queue to avoid a use-after-free.
-	 * triggering a use-after-free.
 	 */
-	if (blk_queue_dead(q))
+	if (blk_queue_dying(q))
 		return -ENOENT;
 	if (count >= sizeof(opbuf)) {
 int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *rq)
 {
 	const struct blk_mq_ops *const mq_ops = rq->q->mq_ops;
-	const unsigned int op = req_op(rq);
+	const enum req_op op = req_op(rq);
 	const char *op_str = blk_op_str(op);
 	seq_printf(m, "%p {.op=", rq);
 	else
 		seq_printf(m, "%s", op_str);
 	seq_puts(m, ", .cmd_flags=");
-	blk_flags_show(m, rq->cmd_flags & ~REQ_OP_MASK, cmd_flag_name,
+	blk_flags_show(m, (__force unsigned int)(rq->cmd_flags & ~REQ_OP_MASK),
-		       ARRAY_SIZE(cmd_flag_name));
+		       cmd_flag_name, ARRAY_SIZE(cmd_flag_name));
 	seq_puts(m, ", .rq_flags=");
 	blk_flags_show(m, (__force unsigned int)rq->rq_flags, rqf_name,
 		       ARRAY_SIZE(rqf_name));
  * e.g. due to a concurrent blk_mq_finish_request() call. Returns true to
  * keep iterating requests.
  */
-static bool hctx_show_busy_rq(struct request *rq, void *data, bool reserved)
+static bool hctx_show_busy_rq(struct request *rq, void *data)
 {
 	const struct show_busy_params *params = data;
 	char name[20];
 	int i;
+	if (!q->debugfs_dir)
+		return;
 	snprintf(name, sizeof(name), "hctx%u", hctx->queue_num);
 	hctx->debugfs_dir = debugfs_create_dir(name, q->debugfs_dir);

block/blk-mq-sysfs.c+22−23

 	return ret;
 }
-void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)
-{
-	struct blk_mq_hw_ctx *hctx;
-	unsigned long i;
-	lockdep_assert_held(&q->sysfs_dir_lock);
-	queue_for_each_hw_ctx(q, hctx, i)
-		blk_mq_unregister_hctx(hctx);
-	kobject_uevent(q->mq_kobj, KOBJ_REMOVE);
-	kobject_del(q->mq_kobj);
-	kobject_put(&dev->kobj);
-	q->mq_sysfs_init_done = false;
-}
 void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx)
 {
 	kobject_init(&hctx->kobj, &blk_mq_hw_ktype);
 	}
 }
-int __blk_mq_register_dev(struct device *dev, struct request_queue *q)
+int blk_mq_sysfs_register(struct gendisk *disk)
 {
+	struct request_queue *q = disk->queue;
 	struct blk_mq_hw_ctx *hctx;
 	unsigned long i, j;
 	int ret;
-	WARN_ON_ONCE(!q->kobj.parent);
 	lockdep_assert_held(&q->sysfs_dir_lock);
-	ret = kobject_add(q->mq_kobj, kobject_get(&dev->kobj), "%s", "mq");
+	ret = kobject_add(q->mq_kobj, &disk_to_dev(disk)->kobj, "mq");
 	if (ret < 0)
 		goto out;
 	kobject_uevent(q->mq_kobj, KOBJ_REMOVE);
 	kobject_del(q->mq_kobj);
-	kobject_put(&dev->kobj);
 	return ret;
 }
-void blk_mq_sysfs_unregister(struct request_queue *q)
+void blk_mq_sysfs_unregister(struct gendisk *disk)
+{
+	struct request_queue *q = disk->queue;
+	struct blk_mq_hw_ctx *hctx;
+	unsigned long i;
+	lockdep_assert_held(&q->sysfs_dir_lock);
+	queue_for_each_hw_ctx(q, hctx, i)
+		blk_mq_unregister_hctx(hctx);
+	kobject_uevent(q->mq_kobj, KOBJ_REMOVE);
+	kobject_del(q->mq_kobj);
+	q->mq_sysfs_init_done = false;
+}
+void blk_mq_sysfs_unregister_hctxs(struct request_queue *q)
 {
 	struct blk_mq_hw_ctx *hctx;
 	unsigned long i;
 	mutex_unlock(&q->sysfs_dir_lock);
 }
-int blk_mq_sysfs_register(struct request_queue *q)
+int blk_mq_sysfs_register_hctxs(struct request_queue *q)
 {
 	struct blk_mq_hw_ctx *hctx;
 	unsigned long i;

block/blk-mq-tag.c+12−19

  * to get tag when first time, the other shared-tag users could reserve
  * budget for it.
  */
-bool __blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
+void __blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
 {
 	unsigned int users;
 	if (blk_mq_is_shared_tags(hctx->flags)) {
 		struct request_queue *q = hctx->queue;
-		if (test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags) ||
+		if (test_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags))
-		    test_and_set_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags)) {
+			return;
-			return true;
+		set_bit(QUEUE_FLAG_HCTX_ACTIVE, &q->queue_flags);
-		}
 	} else {
-		if (test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state) ||
+		if (test_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state))
-		    test_and_set_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state)) {
+			return;
-			return true;
+		set_bit(BLK_MQ_S_TAG_ACTIVE, &hctx->state);
-		}
 	}
 	users = atomic_inc_return(&hctx->tags->active_queues);
 	blk_mq_update_wake_batch(hctx->tags, users);
-	return true;
 }
 /*
 	struct blk_mq_hw_ctx *hctx = iter_data->hctx;
 	struct request_queue *q = iter_data->q;
 	struct blk_mq_tag_set *set = q->tag_set;
-	bool reserved = iter_data->reserved;
 	struct blk_mq_tags *tags;
 	struct request *rq;
 	bool ret = true;
 	else
 		tags = hctx->tags;
-	if (!reserved)
+	if (!iter_data->reserved)
 		bitnr += tags->nr_reserved_tags;
 	/*
 	 * We can hit rq == NULL here, because the tagging functions
 		return true;
 	if (rq->q == q && (!hctx || rq->mq_hctx == hctx))
-		ret = iter_data->fn(rq, iter_data->data, reserved);
+		ret = iter_data->fn(rq, iter_data->data);
 	blk_mq_put_rq_ref(rq);
 	return ret;
 }
 {
 	struct bt_tags_iter_data *iter_data = data;
 	struct blk_mq_tags *tags = iter_data->tags;
-	bool reserved = iter_data->flags & BT_TAG_ITER_RESERVED;
 	struct request *rq;
 	bool ret = true;
 	bool iter_static_rqs = !!(iter_data->flags & BT_TAG_ITER_STATIC_RQS);
-	if (!reserved)
+	if (!(iter_data->flags & BT_TAG_ITER_RESERVED))
 		bitnr += tags->nr_reserved_tags;
 	/*
 	if (!(iter_data->flags & BT_TAG_ITER_STARTED) ||
 	    blk_mq_request_started(rq))
-		ret = iter_data->fn(rq, iter_data->data, reserved);
+		ret = iter_data->fn(rq, iter_data->data);
 	if (!iter_static_rqs)
 		blk_mq_put_rq_ref(rq);
 	return ret;
 }
 EXPORT_SYMBOL(blk_mq_tagset_busy_iter);
-static bool blk_mq_tagset_count_completed_rqs(struct request *rq,
+static bool blk_mq_tagset_count_completed_rqs(struct request *rq, void *data)
-		void *data, bool reserved)
 {
 	unsigned *count = data;

block/blk-mq-tag.h+4−6

 	BLK_MQ_TAG_MAX		= BLK_MQ_NO_TAG - 1,
 };
-extern bool __blk_mq_tag_busy(struct blk_mq_hw_ctx *);
+extern void __blk_mq_tag_busy(struct blk_mq_hw_ctx *);
 extern void __blk_mq_tag_idle(struct blk_mq_hw_ctx *);
-static inline bool blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
+static inline void blk_mq_tag_busy(struct blk_mq_hw_ctx *hctx)
 {
-	if (!(hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED))
+	if (hctx->flags & BLK_MQ_F_TAG_QUEUE_SHARED)
-		return false;
+		__blk_mq_tag_busy(hctx);
-	return __blk_mq_tag_busy(hctx);
 }
 static inline void blk_mq_tag_idle(struct blk_mq_hw_ctx *hctx)

block/blk-mq.c+78−27

 #include "blk-stat.h"
 #include "blk-mq-sched.h"
 #include "blk-rq-qos.h"
+#include "blk-ioprio.h"
 static DEFINE_PER_CPU(struct llist_head, blk_cpu_done);
 	unsigned int inflight[2];
 };
-static bool blk_mq_check_inflight(struct request *rq, void *priv,
+static bool blk_mq_check_inflight(struct request *rq, void *priv)
-				  bool reserved)
 {
 	struct mq_inflight *mi = priv;
 	if (!(data->rq_flags & RQF_ELV))
 		blk_mq_tag_busy(data->hctx);
+	if (data->flags & BLK_MQ_REQ_RESERVED)
+		data->rq_flags |= RQF_RESV;
 	/*
 	 * Try batched alloc if we want more than 1 tag.
 	 */
 					alloc_time_ns);
 }
-struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
+struct request *blk_mq_alloc_request(struct request_queue *q, blk_opf_t opf,
 		blk_mq_req_flags_t flags)
 {
 	struct blk_mq_alloc_data data = {
 		.q		= q,
 		.flags		= flags,
-		.cmd_flags	= op,
+		.cmd_flags	= opf,
 		.nr_tags	= 1,
 	};
 	struct request *rq;
 EXPORT_SYMBOL(blk_mq_alloc_request);
 struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
-	unsigned int op, blk_mq_req_flags_t flags, unsigned int hctx_idx)
+	blk_opf_t opf, blk_mq_req_flags_t flags, unsigned int hctx_idx)
 {
 	struct blk_mq_alloc_data data = {
 		.q		= q,
 		.flags		= flags,
-		.cmd_flags	= op,
+		.cmd_flags	= opf,
 		.nr_tags	= 1,
 	};
 	u64 alloc_time_ns = 0;
 	else
 		data.rq_flags |= RQF_ELV;
+	if (flags & BLK_MQ_REQ_RESERVED)
+		data.rq_flags |= RQF_RESV;
 	ret = -EWOULDBLOCK;
 	tag = blk_mq_get_tag(&data);
 	if (tag == BLK_MQ_NO_TAG)
 {
 	printk(KERN_INFO "%s: dev %s: flags=%llx\n", msg,
 		rq->q->disk ? rq->q->disk->disk_name : "?",
-		(unsigned long long) rq->cmd_flags);
+		(__force unsigned long long) rq->cmd_flags);
 	printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",
 	       (unsigned long long)blk_rq_pos(rq),
 		"phys_seg %u prio class %u\n",
 		blk_status_to_str(status),
 		req->q->disk ? req->q->disk->disk_name : "?",
-		blk_rq_pos(req), req_op(req), blk_op_str(req_op(req)),
+		blk_rq_pos(req), (__force u32)req_op(req),
-		req->cmd_flags & ~REQ_OP_MASK,
+		blk_op_str(req_op(req)),
+		(__force u32)(req->cmd_flags & ~REQ_OP_MASK),
 		req->nr_phys_segments,
 		IOPRIO_PRIO_CLASS(req->ioprio));
 }
 }
 EXPORT_SYMBOL(blk_mq_delay_kick_requeue_list);
-static bool blk_mq_rq_inflight(struct request *rq, void *priv,
+static bool blk_mq_rq_inflight(struct request *rq, void *priv)
-			       bool reserved)
 {
 	/*
 	 * If we find a request that isn't idle we know the queue is busy
 }
 EXPORT_SYMBOL_GPL(blk_mq_queue_inflight);
-static void blk_mq_rq_timed_out(struct request *req, bool reserved)
+static void blk_mq_rq_timed_out(struct request *req)
 {
 	req->rq_flags |= RQF_TIMED_OUT;
 	if (req->q->mq_ops->timeout) {
 		enum blk_eh_timer_return ret;
-		ret = req->q->mq_ops->timeout(req, reserved);
+		ret = req->q->mq_ops->timeout(req);
 		if (ret == BLK_EH_DONE)
 			return;
 		WARN_ON_ONCE(ret != BLK_EH_RESET_TIMER);
 		__blk_mq_free_request(rq);
 }
-static bool blk_mq_check_expired(struct request *rq, void *priv, bool reserved)
+static bool blk_mq_check_expired(struct request *rq, void *priv)
 {
 	unsigned long *next = priv;
 	 * from blk_mq_check_expired().
 	 */
 	if (blk_mq_req_expired(rq, next))
-		blk_mq_rq_timed_out(rq, reserved);
+		blk_mq_rq_timed_out(rq);
 	return true;
 }
 		return;
 	if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) {
-		int cpu = get_cpu();
+		if (cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask)) {
-		if (cpumask_test_cpu(cpu, hctx->cpumask)) {
 			__blk_mq_run_hw_queue(hctx);
-			put_cpu();
 			return;
 		}
-		put_cpu();
 	}
 	kblockd_mod_delayed_work_on(blk_mq_hctx_next_cpu(hctx), &hctx->run_work,
 	 * just causes lock contention inside the scheduler and pointless cache
 	 * bouncing.
 	 */
-	struct blk_mq_hw_ctx *hctx = blk_mq_map_queue(q, 0, ctx);
+	struct blk_mq_hw_ctx *hctx = ctx->hctxs[HCTX_TYPE_DEFAULT];
 	if (!blk_mq_hctx_stopped(hctx))
 		return hctx;
 	return rq;
 }
+static void bio_set_ioprio(struct bio *bio)
+{
+	/* Nobody set ioprio so far? Initialize it based on task's nice value */
+	if (IOPRIO_PRIO_CLASS(bio->bi_ioprio) == IOPRIO_CLASS_NONE)
+		bio->bi_ioprio = get_current_ioprio();
+	blkcg_set_ioprio(bio);
+}
 /**
  * blk_mq_submit_bio - Create and send a request to block device.
  * @bio: Bio pointer.
 void blk_mq_submit_bio(struct bio *bio)
 {
 	struct request_queue *q = bdev_get_queue(bio->bi_bdev);
-	struct blk_plug *plug = blk_mq_plug(q, bio);
+	struct blk_plug *plug = blk_mq_plug(bio);
 	const int is_sync = op_is_sync(bio->bi_opf);
 	struct request *rq;
 	unsigned int nr_segs = 1;
 	if (!bio_integrity_prep(bio))
 		return;
+	bio_set_ioprio(bio);
 	rq = blk_mq_get_cached_request(q, plug, &bio, nr_segs);
 	if (!rq) {
 		if (!bio)
 	bool has_rq;
 };
-static bool blk_mq_has_request(struct request *rq, void *data, bool reserved)
+static bool blk_mq_has_request(struct request *rq, void *data)
 {
 	struct rq_iter_data *iter_data = data;
 	q->queuedata = queuedata;
 	ret = blk_mq_init_allocated_queue(set, q);
 	if (ret) {
-		blk_cleanup_queue(q);
+		blk_put_queue(q);
 		return ERR_PTR(ret);
 	}
 	return q;
 }
 EXPORT_SYMBOL(blk_mq_init_queue);
+/**
+ * blk_mq_destroy_queue - shutdown a request queue
+ * @q: request queue to shutdown
+ *
+ * This shuts down a request queue allocated by blk_mq_init_queue() and drops
+ * the initial reference.  All future requests will failed with -ENODEV.
+ *
+ * Context: can sleep
+ */
+void blk_mq_destroy_queue(struct request_queue *q)
+{
+	WARN_ON_ONCE(!queue_is_mq(q));
+	WARN_ON_ONCE(blk_queue_registered(q));
+	might_sleep();
+	blk_queue_flag_set(QUEUE_FLAG_DYING, q);
+	blk_queue_start_drain(q);
+	blk_freeze_queue(q);
+	blk_sync_queue(q);
+	blk_mq_cancel_work_sync(q);
+	blk_mq_exit_queue(q);
+	/* @q is and will stay empty, shutdown and put */
+	blk_put_queue(q);
+}
+EXPORT_SYMBOL(blk_mq_destroy_queue);
 struct gendisk *__blk_mq_alloc_disk(struct blk_mq_tag_set *set, void *queuedata,
 		struct lock_class_key *lkclass)
 {
 	disk = __alloc_disk_node(q, set->numa_node, lkclass);
 	if (!disk) {
-		blk_cleanup_queue(q);
+		blk_mq_destroy_queue(q);
 		return ERR_PTR(-ENOMEM);
 	}
+	set_bit(GD_OWNS_QUEUE, &disk->state);
 	return disk;
 }
 EXPORT_SYMBOL(__blk_mq_alloc_disk);
+struct gendisk *blk_mq_alloc_disk_for_queue(struct request_queue *q,
+		struct lock_class_key *lkclass)
+{
+	if (!blk_get_queue(q))
+		return NULL;
+	return __alloc_disk_node(q, NUMA_NO_NODE, lkclass);
+}
+EXPORT_SYMBOL(blk_mq_alloc_disk_for_queue);
 static struct blk_mq_hw_ctx *blk_mq_alloc_and_init_hctx(
 		struct blk_mq_tag_set *set, struct request_queue *q,
 		int hctx_idx, int node)
 	list_for_each_entry(q, &set->tag_list, tag_set_list) {
 		blk_mq_debugfs_unregister_hctxs(q);
-		blk_mq_sysfs_unregister(q);
+		blk_mq_sysfs_unregister_hctxs(q);
 	}
 	prev_nr_hw_queues = set->nr_hw_queues;
 reregister:
 	list_for_each_entry(q, &set->tag_list, tag_set_list) {
-		blk_mq_sysfs_register(q);
+		blk_mq_sysfs_register_hctxs(q);
 		blk_mq_debugfs_register_hctxs(q);
 	}

block/blk-mq.h+19−20

 	return xa_load(&q->hctx_table, q->tag_set->map[type].mq_map[cpu]);
 }
-static inline enum hctx_type blk_mq_get_hctx_type(unsigned int flags)
+static inline enum hctx_type blk_mq_get_hctx_type(blk_opf_t opf)
 {
 	enum hctx_type type = HCTX_TYPE_DEFAULT;
 	/*
 	 * The caller ensure that if REQ_POLLED, poll must be enabled.
 	 */
-	if (flags & REQ_POLLED)
+	if (opf & REQ_POLLED)
 		type = HCTX_TYPE_POLL;
-	else if ((flags & REQ_OP_MASK) == REQ_OP_READ)
+	else if ((opf & REQ_OP_MASK) == REQ_OP_READ)
 		type = HCTX_TYPE_READ;
 	return type;
 }
 /*
  * blk_mq_map_queue() - map (cmd_flags,type) to hardware queue
  * @q: request queue
- * @flags: request command flags
+ * @opf: operation type (REQ_OP_*) and flags (e.g. REQ_POLLED).
  * @ctx: software queue cpu ctx
  */
 static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,
-						     unsigned int flags,
+						     blk_opf_t opf,
 						     struct blk_mq_ctx *ctx)
 {
-	return ctx->hctxs[blk_mq_get_hctx_type(flags)];
+	return ctx->hctxs[blk_mq_get_hctx_type(opf)];
 }
 /*
  */
 extern void blk_mq_sysfs_init(struct request_queue *q);
 extern void blk_mq_sysfs_deinit(struct request_queue *q);
-extern int __blk_mq_register_dev(struct device *dev, struct request_queue *q);
+int blk_mq_sysfs_register(struct gendisk *disk);
-extern int blk_mq_sysfs_register(struct request_queue *q);
+void blk_mq_sysfs_unregister(struct gendisk *disk);
-extern void blk_mq_sysfs_unregister(struct request_queue *q);
+int blk_mq_sysfs_register_hctxs(struct request_queue *q);
+void blk_mq_sysfs_unregister_hctxs(struct request_queue *q);
 extern void blk_mq_hctx_kobj_init(struct blk_mq_hw_ctx *hctx);
 void blk_mq_free_plug_rqs(struct blk_plug *plug);
 void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);
 	struct request_queue *q;
 	blk_mq_req_flags_t flags;
 	unsigned int shallow_depth;
-	unsigned int cmd_flags;
+	blk_opf_t cmd_flags;
 	req_flags_t rq_flags;
 	/* allocate multiple requests/tags in one go */
 /*
  * blk_mq_plug() - Get caller context plug
- * @q: request queue
  * @bio : the bio being submitted by the caller context
  *
  * Plugging, by design, may delay the insertion of BIOs into the elevator in
  * order. While this is not a problem with regular block devices, this ordering
  * change can cause write BIO failures with zoned block devices as these
  * require sequential write patterns to zones. Prevent this from happening by
- * ignoring the plug state of a BIO issuing context if the target request queue
+ * ignoring the plug state of a BIO issuing context if it is for a zoned block
- * is for a zoned block device and the BIO to plug is a write operation.
+ * device and the BIO to plug is a write operation.
  *
  * Return current->plug if the bio can be plugged and NULL otherwise
  */
-static inline struct blk_plug *blk_mq_plug(struct request_queue *q,
+static inline struct blk_plug *blk_mq_plug( struct bio *bio)
-					   struct bio *bio)
 {
+	/* Zoned block device write operation case: do not plug the BIO */
+	if (bdev_is_zoned(bio->bi_bdev) && op_is_write(bio_op(bio)))
+		return NULL;
 	/*
 	 * For regular block devices or read operations, use the context plug
 	 * which may be NULL if blk_start_plug() was not executed.
 	 */
-	if (!blk_queue_is_zoned(q) || !op_is_write(bio_op(bio)))
+	return current->plug;
-		return current->plug;
-	/* Zoned block device write operation case: do not plug the BIO */
-	return NULL;
 }
 /* Free all requests on the list */

block/blk-rq-qos.c+2−8

 {
 	unsigned int cur = atomic_read(v);
-	for (;;) {
+	do {
-		unsigned int old;
 		if (cur >= below)
 			return false;
-		old = atomic_cmpxchg(v, cur, cur + 1);
+	} while (!atomic_try_cmpxchg(v, &cur, cur + 1));
-		if (old == cur)
-			break;
-		cur = old;
-	}
 	return true;
 }

block/blk-rq-qos.h+10−1

 	init_waitqueue_head(&rq_wait->wait);
 }
-static inline void rq_qos_add(struct request_queue *q, struct rq_qos *rqos)
+static inline int rq_qos_add(struct request_queue *q, struct rq_qos *rqos)
 {
 	/*
 	 * No IO can be in-flight when adding rqos, so freeze queue, which
 	blk_mq_freeze_queue(q);
 	spin_lock_irq(&q->queue_lock);
+	if (rq_qos_id(q, rqos->id))
+		goto ebusy;
 	rqos->next = q->rq_qos;
 	q->rq_qos = rqos;
 	spin_unlock_irq(&q->queue_lock);
 		blk_mq_debugfs_register_rqos(rqos);
 		mutex_unlock(&q->debugfs_mutex);
 	}
+	return 0;
+ebusy:
+	spin_unlock_irq(&q->queue_lock);
+	blk_mq_unfreeze_queue(q);
+	return -EBUSY;
 }
 static inline void rq_qos_del(struct request_queue *q, struct rq_qos *rqos)

block/blk-settings.c+6−5

 }
 /**
- * blk_queue_set_zoned - configure a disk queue zoned model.
+ * disk_set_zoned - configure the zoned model for a disk
  * @disk:	the gendisk of the queue to configure
  * @model:	the zoned model to set
  *
- * Set the zoned model of the request queue of @disk according to @model.
+ * Set the zoned model of @disk to @model.
+ *
  * When @model is BLK_ZONED_HM (host managed), this should be called only
  * if zoned block device support is enabled (CONFIG_BLK_DEV_ZONED option).
  * If @model specifies BLK_ZONED_HA (host aware), the effective model used
  * depends on CONFIG_BLK_DEV_ZONED settings and on the existence of partitions
  * on the disk.
  */
-void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model)
+void disk_set_zoned(struct gendisk *disk, enum blk_zoned_model model)
 {
 	struct request_queue *q = disk->queue;
 		blk_queue_zone_write_granularity(q,
 						queue_logical_block_size(q));
 	} else {
-		blk_queue_clear_zone_settings(q);
+		disk_clear_zone_settings(disk);
 	}
 }
-EXPORT_SYMBOL_GPL(blk_queue_set_zoned);
+EXPORT_SYMBOL_GPL(disk_set_zoned);
 int bdev_alignment_offset(struct block_device *bdev)
 {

block/blk-sysfs.c+23−37

@@ -274,6 +274,11 @@ static ssize_t queue_virt_boundary_mask_show(struct request_queue q, char page · 273 unmodified lines
274	return queue_var_show(q->limits.virt_boundary_mask, page);	274	return queue_var_show(q->limits.virt_boundary_mask, page);
275	}	275	}
276		276
		277	static ssize_t queue_dma_alignment_show(struct request_queue q, char page)
		278	{
		279	return queue_var_show(queue_dma_alignment(q), page);
		280	}
		281
277	#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \	282	#define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
278	static ssize_t \	283	static ssize_t \
279	queue_##name##_show(struct request_queue q, char page) \	284	queue_##name##_show(struct request_queue q, char page) \
@@ -320,17 +325,17 @@ static ssize_t queue_zoned_show(struct request_queue q, char page) · 40 unmodified lines
320		325
321	static ssize_t queue_nr_zones_show(struct request_queue q, char page)	326	static ssize_t queue_nr_zones_show(struct request_queue q, char page)
322	{	327	{
323	return queue_var_show(blk_queue_nr_zones(q), page);	328	return queue_var_show(disk_nr_zones(q->disk), page);
324	}	329	}
325		330
326	static ssize_t queue_max_open_zones_show(struct request_queue q, char page)	331	static ssize_t queue_max_open_zones_show(struct request_queue q, char page)
327	{	332	{
328	return queue_var_show(queue_max_open_zones(q), page);	333	return queue_var_show(bdev_max_open_zones(q->disk->part0), page);
329	}	334	}
330		335
331	static ssize_t queue_max_active_zones_show(struct request_queue q, char page)	336	static ssize_t queue_max_active_zones_show(struct request_queue q, char page)
332	{	337	{
333	return queue_var_show(queue_max_active_zones(q), page);	338	return queue_var_show(bdev_max_active_zones(q->disk->part0), page);
334	}	339	}
335		340
336	static ssize_t queue_nomerges_show(struct request_queue q, char page)	341	static ssize_t queue_nomerges_show(struct request_queue q, char page)
@@ -606,6 +611,7 @@ QUEUE_RO_ENTRY(queue_dax, "dax"); · 269 unmodified lines
606	QUEUE_RW_ENTRY(queue_io_timeout, "io_timeout");	611	QUEUE_RW_ENTRY(queue_io_timeout, "io_timeout");
607	QUEUE_RW_ENTRY(queue_wb_lat, "wbt_lat_usec");	612	QUEUE_RW_ENTRY(queue_wb_lat, "wbt_lat_usec");
608	QUEUE_RO_ENTRY(queue_virt_boundary_mask, "virt_boundary_mask");	613	QUEUE_RO_ENTRY(queue_virt_boundary_mask, "virt_boundary_mask");
		614	QUEUE_RO_ENTRY(queue_dma_alignment, "dma_alignment");
609		615
610	#ifdef CONFIG_BLK_DEV_THROTTLING_LOW	616	#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
611	QUEUE_RW_ENTRY(blk_throtl_sample_time, "throttle_sample_time");	617	QUEUE_RW_ENTRY(blk_throtl_sample_time, "throttle_sample_time");
@@ -667,6 +673,7 @@ static struct attribute *queue_attrs[] = { · 55 unmodified lines
667	&blk_throtl_sample_time_entry.attr,	673	&blk_throtl_sample_time_entry.attr,
668	#endif	674	#endif
669	&queue_virt_boundary_mask_entry.attr,	675	&queue_virt_boundary_mask_entry.attr,
		676	&queue_dma_alignment_entry.attr,
670	NULL,	677	NULL,
671	};	678	};
672		679
@@ -748,11 +755,6 @@ static void blk_free_queue_rcu(struct rcu_head *rcu_head) · 75 unmodified lines
748	* decremented with blk_put_queue(). Once the refcount reaches 0 this function	755	* decremented with blk_put_queue(). Once the refcount reaches 0 this function
749	* is called.	756	* is called.
750	*	757	*
751	* For drivers that have a request_queue on a gendisk and added with
752	* __device_add_disk() the refcount to request_queue will reach 0 with
753	* the last put_disk() called by the driver. For drivers which don't use
754	* __device_add_disk() this happens with blk_cleanup_queue().
755	*
756	* Drivers exist which depend on the release of the request_queue to be	758	* Drivers exist which depend on the release of the request_queue to be
757	* synchronous, it should not be deferred.	759	* synchronous, it should not be deferred.
758	*	760	*
@@ -774,8 +776,6 @@ static void blk_release_queue(struct kobject *kobj) · 15 unmodified lines
774	blk_free_queue_stats(q->stats);	776	blk_free_queue_stats(q->stats);
775	kfree(q->poll_stat);	777	kfree(q->poll_stat);
776		778
777	blk_queue_free_zone_bitmaps(q);
778
779	if (queue_is_mq(q))	779	if (queue_is_mq(q))
780	blk_mq_release(q);	780	blk_mq_release(q);
781		781
@@ -784,7 +784,7 @@ static void blk_release_queue(struct kobject *kobj) · 2 unmodified lines
784	if (blk_queue_has_srcu(q))	784	if (blk_queue_has_srcu(q))
785	cleanup_srcu_struct(q->srcu);	785	cleanup_srcu_struct(q->srcu);
786		786
787	ida_simple_remove(&blk_queue_ida, q->id);	787	ida_free(&blk_queue_ida, q->id);
788	call_rcu(&q->rcu_head, blk_free_queue_rcu);	788	call_rcu(&q->rcu_head, blk_free_queue_rcu);
789	}	789	}
790		790
@@ -793,7 +793,13 @@ static const struct sysfs_ops queue_sysfs_ops = { · 2 unmodified lines
793	.store = queue_attr_store,	793	.store = queue_attr_store,
794	};	794	};
795		795
		796	static const struct attribute_group *blk_queue_attr_groups[] = {
		797	&queue_attr_group,
		798	NULL
		799	};
		800
796	struct kobj_type blk_queue_ktype = {	801	struct kobj_type blk_queue_ktype = {
		802	.default_groups = blk_queue_attr_groups,
797	.sysfs_ops = &queue_sysfs_ops,	803	.sysfs_ops = &queue_sysfs_ops,
798	.release = blk_release_queue,	804	.release = blk_release_queue,
799	};	805	};
@@ -804,32 +810,17 @@ struct kobj_type blk_queue_ktype = { · 4 unmodified lines
804	*/	810	*/
805	int blk_register_queue(struct gendisk *disk)	811	int blk_register_queue(struct gendisk *disk)
806	{	812	{
807	int ret;
808	struct device *dev = disk_to_dev(disk);
809	struct request_queue *q = disk->queue;	813	struct request_queue *q = disk->queue;
810		814	int ret;
811	ret = blk_trace_init_sysfs(dev);
812	if (ret)
813	return ret;
814		815
815	mutex_lock(&q->sysfs_dir_lock);	816	mutex_lock(&q->sysfs_dir_lock);
816		817
817	ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");	818	ret = kobject_add(&q->kobj, &disk_to_dev(disk)->kobj, "queue");
818	if (ret < 0) {	819	if (ret < 0)
819	blk_trace_remove_sysfs(dev);
820	goto unlock;
821	}
822
823	ret = sysfs_create_group(&q->kobj, &queue_attr_group);
824	if (ret) {
825	blk_trace_remove_sysfs(dev);
826	kobject_del(&q->kobj);
827	kobject_put(&dev->kobj);
828	goto unlock;	820	goto unlock;
829	}
830		821
831	if (queue_is_mq(q))	822	if (queue_is_mq(q))
832	__blk_mq_register_dev(dev, q);	823	blk_mq_sysfs_register(disk);
833	mutex_lock(&q->sysfs_lock);	824	mutex_lock(&q->sysfs_lock);
834		825
835	mutex_lock(&q->debugfs_mutex);	826	mutex_lock(&q->debugfs_mutex);
@@ -839,7 +830,7 @@ int blk_register_queue(struct gendisk *disk) · 3 unmodified lines
839	blk_mq_debugfs_register(q);	830	blk_mq_debugfs_register(q);
840	mutex_unlock(&q->debugfs_mutex);	831	mutex_unlock(&q->debugfs_mutex);
841		832
842	ret = disk_register_independent_access_ranges(disk, NULL);	833	ret = disk_register_independent_access_ranges(disk);
843	if (ret)	834	if (ret)
844	goto put_dev;	835	goto put_dev;
845		836
@@ -888,8 +879,6 @@ put_dev: · 42 unmodified lines
888	mutex_unlock(&q->sysfs_lock);	879	mutex_unlock(&q->sysfs_lock);
889	mutex_unlock(&q->sysfs_dir_lock);	880	mutex_unlock(&q->sysfs_dir_lock);
890	kobject_del(&q->kobj);	881	kobject_del(&q->kobj);
891	blk_trace_remove_sysfs(dev);
892	kobject_put(&dev->kobj);
893		882
894	return ret;	883	return ret;
895	}	884	}
@@ -927,9 +916,8 @@ void blk_unregister_queue(struct gendisk *disk) · 31 unmodified lines
927	* structures that can be modified through sysfs.	916	* structures that can be modified through sysfs.
928	*/	917	*/
929	if (queue_is_mq(q))	918	if (queue_is_mq(q))
930	blk_mq_unregister_dev(disk_to_dev(disk), q);	919	blk_mq_sysfs_unregister(disk);
931	blk_crypto_sysfs_unregister(q);	920	blk_crypto_sysfs_unregister(q);
932	blk_trace_remove_sysfs(disk_to_dev(disk));
933		921
934	mutex_lock(&q->sysfs_lock);	922	mutex_lock(&q->sysfs_lock);
935	elv_unregister_queue(q);	923	elv_unregister_queue(q);
@@ -948,6 +936,4 @@ void blk_unregister_queue(struct gendisk *disk) · 12 unmodified lines
948	q->sched_debugfs_dir = NULL;	936	q->sched_debugfs_dir = NULL;
949	q->rqos_debugfs_dir = NULL;	937	q->rqos_debugfs_dir = NULL;
950	mutex_unlock(&q->debugfs_mutex);	938	mutex_unlock(&q->debugfs_mutex);
951
952	kobject_put(&disk_to_dev(disk)->kobj);
953	}	939	}

block/blk-throttle.c+4−3

 #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
 static void throtl_track_latency(struct throtl_data *td, sector_t size,
-	int op, unsigned long time)
+				 enum req_op op, unsigned long time)
 {
+	const bool rw = op_is_write(op);
 	struct latency_bucket *latency;
 	int index;
 	index = request_bucket_index(size);
-	latency = get_cpu_ptr(td->latency_buckets[op]);
+	latency = get_cpu_ptr(td->latency_buckets[rw]);
 	latency[index].total_latency += time;
 	latency[index].samples++;
-	put_cpu_ptr(td->latency_buckets[op]);
+	put_cpu_ptr(td->latency_buckets[rw]);
 }
 void blk_throtl_stat_add(struct request *rq, u64 time_ns)

block/blk-wbt.c+20−10

 #define REQ_HIPRIO	(REQ_SYNC | REQ_META | REQ_PRIO)
-static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw)
+static inline unsigned int get_limit(struct rq_wb *rwb, blk_opf_t opf)
 {
 	unsigned int limit;
 	if (!rwb_enabled(rwb))
 		return UINT_MAX;
-	if ((rw & REQ_OP_MASK) == REQ_OP_DISCARD)
+	if ((opf & REQ_OP_MASK) == REQ_OP_DISCARD)
 		return rwb->wb_background;
 	/*
 	 * the idle limit, or go to normal if we haven't had competing
 	 * IO for a bit.
 	 */
-	if ((rw & REQ_HIPRIO) || wb_recent_wait(rwb) || current_is_kswapd())
+	if ((opf & REQ_HIPRIO) || wb_recent_wait(rwb) || current_is_kswapd())
 		limit = rwb->rq_depth.max_depth;
-	else if ((rw & REQ_BACKGROUND) || close_io(rwb)) {
+	else if ((opf & REQ_BACKGROUND) || close_io(rwb)) {
 		/*
 		 * If less than 100ms since we completed unrelated IO,
 		 * limit us to half the depth for background writeback.
 struct wbt_wait_data {
 	struct rq_wb *rwb;
 	enum wbt_flags wb_acct;
-	unsigned long rw;
+	blk_opf_t opf;
 };
 static bool wbt_inflight_cb(struct rq_wait *rqw, void *private_data)
 {
 	struct wbt_wait_data *data = private_data;
-	return rq_wait_inc_below(rqw, get_limit(data->rwb, data->rw));
+	return rq_wait_inc_below(rqw, get_limit(data->rwb, data->opf));
 }
 static void wbt_cleanup_cb(struct rq_wait *rqw, void *private_data)
  * the timer to kick off queuing again.
  */
 static void __wbt_wait(struct rq_wb *rwb, enum wbt_flags wb_acct,
-		       unsigned long rw)
+		       blk_opf_t opf)
 {
 	struct rq_wait *rqw = get_rq_wait(rwb, wb_acct);
 	struct wbt_wait_data data = {
 		.rwb = rwb,
 		.wb_acct = wb_acct,
-		.rw = rw,
+		.opf = opf,
 	};
 	rq_qos_wait(rqw, &data, wbt_inflight_cb, wbt_cleanup_cb);
 static int wbt_data_dir(const struct request *rq)
 {
-	const int op = req_op(rq);
+	const enum req_op op = req_op(rq);
 	if (op == REQ_OP_READ)
 		return READ;
 {
 	struct rq_wb *rwb;
 	int i;
+	int ret;
 	rwb = kzalloc(sizeof(*rwb), GFP_KERNEL);
 	if (!rwb)
 	/*
 	 * Assign rwb and add the stats callback.
 	 */
-	rq_qos_add(q, &rwb->rqos);
+	ret = rq_qos_add(q, &rwb->rqos);
+	if (ret)
+		goto err_free;
 	blk_stat_add_callback(q, rwb->cb);
 	rwb->min_lat_nsec = wbt_default_latency_nsec(q);
 	wbt_set_write_cache(q, test_bit(QUEUE_FLAG_WC, &q->queue_flags));
 	return 0;
+err_free:
+	blk_stat_free_callback(rwb->cb);
+	kfree(rwb);
+	return ret;
 }

block/blk-zoned.c+46−46

  */
 bool blk_req_needs_zone_write_lock(struct request *rq)
 {
-	if (!rq->q->seq_zones_wlock)
+	if (blk_rq_is_passthrough(rq))
 		return false;
-	if (blk_rq_is_passthrough(rq))
+	if (!rq->q->disk->seq_zones_wlock)
 		return false;
 	switch (req_op(rq)) {
 {
 	unsigned int zno = blk_rq_zone_no(rq);
-	if (test_and_set_bit(zno, rq->q->seq_zones_wlock))
+	if (test_and_set_bit(zno, rq->q->disk->seq_zones_wlock))
 		return false;
 	WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
 void __blk_req_zone_write_lock(struct request *rq)
 {
 	if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
-					  rq->q->seq_zones_wlock)))
+					  rq->q->disk->seq_zones_wlock)))
 		return;
 	WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
 void __blk_req_zone_write_unlock(struct request *rq)
 {
 	rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
-	if (rq->q->seq_zones_wlock)
+	if (rq->q->disk->seq_zones_wlock)
 		WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
-						 rq->q->seq_zones_wlock));
+						 rq->q->disk->seq_zones_wlock));
 }
 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
 /**
- * blkdev_nr_zones - Get number of zones
+ * bdev_nr_zones - Get number of zones
- * @disk:	Target gendisk
+ * @bdev:	Target device
  *
  * Return the total number of zones of a zoned block device.  For a block
  * device without zone capabilities, the number of zones is always 0.
  */
-unsigned int blkdev_nr_zones(struct gendisk *disk)
+unsigned int bdev_nr_zones(struct block_device *bdev)
 {
-	sector_t zone_sectors = blk_queue_zone_sectors(disk->queue);
+	sector_t zone_sectors = bdev_zone_sectors(bdev);
-	if (!blk_queue_is_zoned(disk->queue))
+	if (!bdev_is_zoned(bdev))
 		return 0;
-	return (get_capacity(disk) + zone_sectors - 1) >> ilog2(zone_sectors);
+	return (bdev_nr_sectors(bdev) + zone_sectors - 1) >>
+		ilog2(zone_sectors);
 }
-EXPORT_SYMBOL_GPL(blkdev_nr_zones);
+EXPORT_SYMBOL_GPL(bdev_nr_zones);
 /**
  * blkdev_report_zones - Get zones information
 	struct gendisk *disk = bdev->bd_disk;
 	sector_t capacity = get_capacity(disk);
-	if (!blk_queue_is_zoned(bdev_get_queue(bdev)) ||
+	if (!bdev_is_zoned(bdev) || WARN_ON_ONCE(!disk->fops->report_zones))
-	    WARN_ON_ONCE(!disk->fops->report_zones))
 		return -EOPNOTSUPP;
 	if (!nr_zones || sector >= capacity)
 static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
 					  gfp_t gfp_mask)
 {
-	struct request_queue *q = bdev_get_queue(bdev);
+	struct gendisk *disk = bdev->bd_disk;
-	sector_t capacity = get_capacity(bdev->bd_disk);
+	sector_t capacity = bdev_nr_sectors(bdev);
-	sector_t zone_sectors = blk_queue_zone_sectors(q);
+	sector_t zone_sectors = bdev_zone_sectors(bdev);
 	unsigned long *need_reset;
 	struct bio *bio = NULL;
 	sector_t sector = 0;
 	int ret;
-	need_reset = blk_alloc_zone_bitmap(q->node, q->nr_zones);
+	need_reset = blk_alloc_zone_bitmap(disk->queue->node, disk->nr_zones);
 	if (!need_reset)
 		return -ENOMEM;
-	ret = bdev->bd_disk->fops->report_zones(bdev->bd_disk, 0,
+	ret = disk->fops->report_zones(disk, 0, disk->nr_zones,
-				q->nr_zones, blk_zone_need_reset_cb,
+				       blk_zone_need_reset_cb, need_reset);
-				need_reset);
 	if (ret < 0)
 		goto out_free_need_reset;
 	ret = 0;
 	while (sector < capacity) {
-		if (!test_bit(blk_queue_zone_no(q, sector), need_reset)) {
+		if (!test_bit(disk_zone_no(disk, sector), need_reset)) {
 			sector += zone_sectors;
 			continue;
 		}
  *    The operation to execute on each zone can be a zone reset, open, close
  *    or finish request.
  */
-int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
+int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
-		     sector_t sector, sector_t nr_sectors,
+		     sector_t sector, sector_t nr_sectors, gfp_t gfp_mask)
-		     gfp_t gfp_mask)
 {
 	struct request_queue *q = bdev_get_queue(bdev);
-	sector_t zone_sectors = blk_queue_zone_sectors(q);
+	sector_t zone_sectors = bdev_zone_sectors(bdev);
-	sector_t capacity = get_capacity(bdev->bd_disk);
+	sector_t capacity = bdev_nr_sectors(bdev);
 	sector_t end_sector = sector + nr_sectors;
 	struct bio *bio = NULL;
 	int ret = 0;
-	if (!blk_queue_is_zoned(q))
+	if (!bdev_is_zoned(bdev))
 		return -EOPNOTSUPP;
 	if (bdev_read_only(bdev))
 	if (!q)
 		return -ENXIO;
-	if (!blk_queue_is_zoned(q))
+	if (!bdev_is_zoned(bdev))
 		return -ENOTTY;
 	if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
 	void __user *argp = (void __user *)arg;
 	struct request_queue *q;
 	struct blk_zone_range zrange;
-	enum req_opf op;
+	enum req_op op;
 	int ret;
 	if (!argp)
 	if (!q)
 		return -ENXIO;
-	if (!blk_queue_is_zoned(q))
+	if (!bdev_is_zoned(bdev))
 		return -ENOTTY;
 	if (!(mode & FMODE_WRITE))
 	return ret;
 }
-void blk_queue_free_zone_bitmaps(struct request_queue *q)
+void disk_free_zone_bitmaps(struct gendisk *disk)
 {
-	kfree(q->conv_zones_bitmap);
+	kfree(disk->conv_zones_bitmap);
-	q->conv_zones_bitmap = NULL;
+	disk->conv_zones_bitmap = NULL;
-	kfree(q->seq_zones_wlock);
+	kfree(disk->seq_zones_wlock);
-	q->seq_zones_wlock = NULL;
+	disk->seq_zones_wlock = NULL;
 }
 struct blk_revalidate_zone_args {
 	blk_mq_freeze_queue(q);
 	if (ret > 0) {
 		blk_queue_chunk_sectors(q, args.zone_sectors);
-		q->nr_zones = args.nr_zones;
+		disk->nr_zones = args.nr_zones;
-		swap(q->seq_zones_wlock, args.seq_zones_wlock);
+		swap(disk->seq_zones_wlock, args.seq_zones_wlock);
-		swap(q->conv_zones_bitmap, args.conv_zones_bitmap);
+		swap(disk->conv_zones_bitmap, args.conv_zones_bitmap);
 		if (update_driver_data)
 			update_driver_data(disk);
 		ret = 0;
 	} else {
 		pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
-		blk_queue_free_zone_bitmaps(q);
+		disk_free_zone_bitmaps(disk);
 	}
 	blk_mq_unfreeze_queue(q);
 }
 EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);
-void blk_queue_clear_zone_settings(struct request_queue *q)
+void disk_clear_zone_settings(struct gendisk *disk)
 {
+	struct request_queue *q = disk->queue;
 	blk_mq_freeze_queue(q);
-	blk_queue_free_zone_bitmaps(q);
+	disk_free_zone_bitmaps(disk);
 	blk_queue_flag_clear(QUEUE_FLAG_ZONE_RESETALL, q);
 	q->required_elevator_features &= ~ELEVATOR_F_ZBD_SEQ_WRITE;
-	q->nr_zones = 0;
+	disk->nr_zones = 0;
-	q->max_open_zones = 0;
+	disk->max_open_zones = 0;
-	q->max_active_zones = 0;
+	disk->max_active_zones = 0;
 	q->limits.chunk_sectors = 0;
 	q->limits.zone_write_granularity = 0;
 	q->limits.max_zone_append_sectors = 0;

block/blk.h+23−11

 extern struct kobj_type blk_queue_ktype;
 extern struct ida blk_queue_ida;
-static inline void __blk_get_queue(struct request_queue *q)
-{
-	kobject_get(&q->kobj);
-}
 bool is_flush_rq(struct request *req);
 struct blk_flush_queue *blk_alloc_flush_queue(int node, int cmd_size,
 	return false;
 }
+static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
+						     enum req_op op)
+{
+	if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE))
+		return min(q->limits.max_discard_sectors,
+			   UINT_MAX >> SECTOR_SHIFT);
+	if (unlikely(op == REQ_OP_WRITE_ZEROES))
+		return q->limits.max_write_zeroes_sectors;
+	return q->limits.max_sectors;
+}
 #ifdef CONFIG_BLK_DEV_INTEGRITY
 void blk_flush_integrity(void);
 bool __bio_integrity_endio(struct bio *);
 #endif
 #ifdef CONFIG_BLK_DEV_ZONED
-void blk_queue_free_zone_bitmaps(struct request_queue *q);
+void disk_free_zone_bitmaps(struct gendisk *disk);
-void blk_queue_clear_zone_settings(struct request_queue *q);
+void disk_clear_zone_settings(struct gendisk *disk);
 #else
-static inline void blk_queue_free_zone_bitmaps(struct request_queue *q) {}
+static inline void disk_free_zone_bitmaps(struct gendisk *disk) {}
-static inline void blk_queue_clear_zone_settings(struct request_queue *q) {}
+static inline void disk_clear_zone_settings(struct gendisk *disk) {}
 #endif
 int blk_alloc_ext_minor(void);
 		sector_t length);
 void blk_drop_partitions(struct gendisk *disk);
+struct gendisk *__alloc_disk_node(struct request_queue *q, int node_id,
+		struct lock_class_key *lkclass);
 int bio_add_hw_page(struct request_queue *q, struct bio *bio,
 		struct page *page, unsigned int len, unsigned int offset,
 		unsigned int max_sectors, bool *same_page);
 extern struct device_attribute dev_attr_events_async;
 extern struct device_attribute dev_attr_events_poll_msecs;
+extern struct attribute_group blk_trace_attr_group;
 long blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg);
 long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg);
 extern const struct address_space_operations def_blk_aops;
-int disk_register_independent_access_ranges(struct gendisk *disk,
+int disk_register_independent_access_ranges(struct gendisk *disk);
-				struct blk_independent_access_ranges *new_iars);
 void disk_unregister_independent_access_ranges(struct gendisk *disk);
 #ifdef CONFIG_FAIL_MAKE_REQUEST

block/bounce.c+10−3

 	int rw = bio_data_dir(*bio_orig);
 	struct bio_vec *to, from;
 	struct bvec_iter iter;
-	unsigned i = 0;
+	unsigned i = 0, bytes = 0;
 	bool bounce = false;
-	int sectors = 0;
+	int sectors;
 	bio_for_each_segment(from, *bio_orig, iter) {
 		if (i++ < BIO_MAX_VECS)
-			sectors += from.bv_len >> 9;
+			bytes += from.bv_len;
 		if (PageHighMem(from.bv_page))
 			bounce = true;
 	}
 	if (!bounce)
 		return;
+	/*
+	 * Individual bvecs might not be logical block aligned. Round down
+	 * the split size so that each bio is properly block size aligned,
+	 * even if we do not use the full hardware limits.
+	 */
+	sectors = ALIGN_DOWN(bytes, queue_logical_block_size(q)) >>
+			SECTOR_SHIFT;
 	if (sectors < bio_sectors(*bio_orig)) {
 		bio = bio_split(*bio_orig, sectors, GFP_NOIO, &bounce_bio_split);
 		bio_chain(bio, *bio_orig);

block/bsg-lib.c+3−3

@@ -324,14 +324,14 @@ void bsg_remove_queue(struct request_queue *q) · 323 unmodified lines
324	container_of(q->tag_set, struct bsg_set, tag_set);	324	container_of(q->tag_set, struct bsg_set, tag_set);
325		325
326	bsg_unregister_queue(bset->bd);	326	bsg_unregister_queue(bset->bd);
327	blk_cleanup_queue(q);	327	blk_mq_destroy_queue(q);
328	blk_mq_free_tag_set(&bset->tag_set);	328	blk_mq_free_tag_set(&bset->tag_set);
329	kfree(bset);	329	kfree(bset);
330	}	330	}
331	}	331	}
332	EXPORT_SYMBOL_GPL(bsg_remove_queue);	332	EXPORT_SYMBOL_GPL(bsg_remove_queue);
333		333
334	static enum blk_eh_timer_return bsg_timeout(struct request *rq, bool reserved)	334	static enum blk_eh_timer_return bsg_timeout(struct request *rq)
335	{	335	{
336	struct bsg_set *bset =	336	struct bsg_set *bset =
337	container_of(rq->q->tag_set, struct bsg_set, tag_set);	337	container_of(rq->q->tag_set, struct bsg_set, tag_set);
@@ -399,7 +399,7 @@ struct request_queue bsg_setup_queue(struct device dev, const char *name, · 61 unmodified lines
399		399
400	return q;	400	return q;
401	out_cleanup_queue:	401	out_cleanup_queue:
402	blk_cleanup_queue(q);	402	blk_mq_destroy_queue(q);
403	out_queue:	403	out_queue:
404	blk_mq_free_tag_set(set);	404	blk_mq_free_tag_set(set);
405	out_tag_set:	405	out_tag_set:

block/elevator.h+1−1

@@ -34,7 +34,7 @@ struct elevator_mq_ops { · 33 unmodified lines
34	int (request_merge)(struct request_queue q, struct request *, struct bio );	34	int (request_merge)(struct request_queue q, struct request *, struct bio );
35	void (request_merged)(struct request_queue , struct request *, enum elv_merge);	35	void (request_merged)(struct request_queue , struct request *, enum elv_merge);
36	void (requests_merged)(struct request_queue , struct request , struct request );	36	void (requests_merged)(struct request_queue , struct request , struct request );
37	void (limit_depth)(unsigned int, struct blk_mq_alloc_data );	37	void (limit_depth)(blk_opf_t, struct blk_mq_alloc_data );
38	void (prepare_request)(struct request );	38	void (prepare_request)(struct request );
39	void (finish_request)(struct request );	39	void (finish_request)(struct request );
40	void (insert_requests)(struct blk_mq_hw_ctx , struct list_head *, bool);	40	void (insert_requests)(struct blk_mq_hw_ctx , struct list_head *, bool);

block/fops.c+16−12

 	return 0;
 }
-static unsigned int dio_bio_write_op(struct kiocb *iocb)
+static blk_opf_t dio_bio_write_op(struct kiocb *iocb)
 {
-	unsigned int op = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
+	blk_opf_t opf = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
 	/* avoid the need for a I/O completion work item */
 	if (iocb->ki_flags & IOCB_DSYNC)
-		op |= REQ_FUA;
+		opf |= REQ_FUA;
-	return op;
+	return opf;
+}
+static bool blkdev_dio_unaligned(struct block_device *bdev, loff_t pos,
+			      struct iov_iter *iter)
+{
+	return pos & (bdev_logical_block_size(bdev) - 1) ||
+		!bdev_iter_is_aligned(bdev, iter);
 }
 #define DIO_INLINE_BIO_VECS 4
 	struct bio bio;
 	ssize_t ret;
-	if ((pos | iov_iter_alignment(iter)) &
+	if (blkdev_dio_unaligned(bdev, pos, iter))
-	    (bdev_logical_block_size(bdev) - 1))
 		return -EINVAL;
 	if (nr_pages <= DIO_INLINE_BIO_VECS)
 	struct blkdev_dio *dio;
 	struct bio *bio;
 	bool is_read = (iov_iter_rw(iter) == READ), is_sync;
-	unsigned int opf = is_read ? REQ_OP_READ : dio_bio_write_op(iocb);
+	blk_opf_t opf = is_read ? REQ_OP_READ : dio_bio_write_op(iocb);
 	loff_t pos = iocb->ki_pos;
 	int ret = 0;
-	if ((pos | iov_iter_alignment(iter)) &
+	if (blkdev_dio_unaligned(bdev, pos, iter))
-	    (bdev_logical_block_size(bdev) - 1))
 		return -EINVAL;
 	if (iocb->ki_flags & IOCB_ALLOC_CACHE)
 {
 	struct block_device *bdev = iocb->ki_filp->private_data;
 	bool is_read = iov_iter_rw(iter) == READ;
-	unsigned int opf = is_read ? REQ_OP_READ : dio_bio_write_op(iocb);
+	blk_opf_t opf = is_read ? REQ_OP_READ : dio_bio_write_op(iocb);
 	struct blkdev_dio *dio;
 	struct bio *bio;
 	loff_t pos = iocb->ki_pos;
 	int ret = 0;
-	if ((pos | iov_iter_alignment(iter)) &
+	if (blkdev_dio_unaligned(bdev, pos, iter))
-	    (bdev_logical_block_size(bdev) - 1))
 		return -EINVAL;
 	if (iocb->ki_flags & IOCB_ALLOC_CACHE)

block/genhd.c+32−48

@@ -101,29 +101,6 @@ bool set_capacity_and_notify(struct gendisk *disk, sector_t size) · 100 unmodified lines
101	}	101	}
102	EXPORT_SYMBOL_GPL(set_capacity_and_notify);	102	EXPORT_SYMBOL_GPL(set_capacity_and_notify);
103		103
104	/*
105	* Format the device name of the indicated block device into the supplied buffer
106	* and return a pointer to that same buffer for convenience.
107	*
108	* Note: do not use this in new code, use the %pg specifier to sprintf and
109	* printk insted.
110	*/
111	const char bdevname(struct block_device bdev, char *buf)
112	{
113	struct gendisk *hd = bdev->bd_disk;
114	int partno = bdev->bd_partno;
115
116	if (!partno)
117	snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
118	else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
119	snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, partno);
120	else
121	snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, partno);
122
123	return buf;
124	}
125	EXPORT_SYMBOL(bdevname);
126
127	static void part_stat_read_all(struct block_device *part,	104	static void part_stat_read_all(struct block_device *part,
128	struct disk_stats *stat)	105	struct disk_stats *stat)
129	{	106	{
@@ -617,6 +594,8 @@ void del_gendisk(struct gendisk *disk) · 487 unmodified lines
617	* Fail any new I/O.	594	* Fail any new I/O.
618	*/	595	*/
619	set_bit(GD_DEAD, &disk->state);	596	set_bit(GD_DEAD, &disk->state);
		597	if (test_bit(GD_OWNS_QUEUE, &disk->state))
		598	blk_queue_flag_set(QUEUE_FLAG_DYING, q);
620	set_capacity(disk, 0);	599	set_capacity(disk, 0);
621		600
622	/*	601	/*
@@ -663,11 +642,16 @@ void del_gendisk(struct gendisk *disk) · 40 unmodified lines
663	blk_mq_unquiesce_queue(q);	642	blk_mq_unquiesce_queue(q);
664		643
665	/*	644	/*
666	* Allow using passthrough request again after the queue is torn down.	645	* If the disk does not own the queue, allow using passthrough requests
		646	* again. Else leave the queue frozen to fail all I/O.
667	*/	647	*/
668	blk_queue_flag_clear(QUEUE_FLAG_INIT_DONE, q);	648	if (!test_bit(GD_OWNS_QUEUE, &disk->state)) {
669	__blk_mq_unfreeze_queue(q, true);	649	blk_queue_flag_clear(QUEUE_FLAG_INIT_DONE, q);
670		650	__blk_mq_unfreeze_queue(q, true);
		651	} else {
		652	if (queue_is_mq(q))
		653	blk_mq_exit_queue(q);
		654	}
671	}	655	}
672	EXPORT_SYMBOL(del_gendisk);	656	EXPORT_SYMBOL(del_gendisk);
673		657
@@ -1127,6 +1111,9 @@ static struct attribute_group disk_attr_group = { · 453 unmodified lines
1127		1111
1128	static const struct attribute_group *disk_attr_groups[] = {	1112	static const struct attribute_group *disk_attr_groups[] = {
1129	&disk_attr_group,	1113	&disk_attr_group,
		1114	#ifdef CONFIG_BLK_DEV_IO_TRACE
		1115	&blk_trace_attr_group,
		1116	#endif
1130	NULL	1117	NULL
1131	};	1118	};
1132		1119
@@ -1151,10 +1138,23 @@ static void disk_release(struct device *dev) · 18 unmodified lines
1151	might_sleep();	1138	might_sleep();
1152	WARN_ON_ONCE(disk_live(disk));	1139	WARN_ON_ONCE(disk_live(disk));
1153		1140
		1141	/*
		1142	* To undo the all initialization from blk_mq_init_allocated_queue in
		1143	* case of a probe failure where add_disk is never called we have to
		1144	* call blk_mq_exit_queue here. We can't do this for the more common
		1145	* teardown case (yet) as the tagset can be gone by the time the disk
		1146	* is released once it was added.
		1147	*/
		1148	if (queue_is_mq(disk->queue) &&
		1149	test_bit(GD_OWNS_QUEUE, &disk->state) &&
		1150	!test_bit(GD_ADDED, &disk->state))
		1151	blk_mq_exit_queue(disk->queue);
		1152
1154	blkcg_exit_queue(disk->queue);	1153	blkcg_exit_queue(disk->queue);
1155		1154
1156	disk_release_events(disk);	1155	disk_release_events(disk);
1157	kfree(disk->random);	1156	kfree(disk->random);
		1157	disk_free_zone_bitmaps(disk);
1158	xa_destroy(&disk->part_tbl);	1158	xa_destroy(&disk->part_tbl);
1159		1159
1160	disk->queue->disk = NULL;	1160	disk->queue->disk = NULL;
@@ -1338,9 +1338,6 @@ struct gendisk __alloc_disk_node(struct request_queue q, int node_id, · 177 unmodified lines
1338	{	1338	{
1339	struct gendisk *disk;	1339	struct gendisk *disk;
1340		1340
1341	if (!blk_get_queue(q))
1342	return NULL;
1343
1344	disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);	1341	disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
1345	if (!disk)	1342	if (!disk)
1346	goto out_put_queue;	1343	goto out_put_queue;
@@ -1391,7 +1388,6 @@ out_put_queue: · 44 unmodified lines
1391	blk_put_queue(q);	1388	blk_put_queue(q);
1392	return NULL;	1389	return NULL;
1393	}	1390	}
1394	EXPORT_SYMBOL(__alloc_disk_node);
1395		1391
1396	struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass)	1392	struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass)
1397	{	1393	{
@@ -1404,9 +1400,10 @@ struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass) · 6 unmodified lines
1404		1400
1405	disk = __alloc_disk_node(q, node, lkclass);	1401	disk = __alloc_disk_node(q, node, lkclass);
1406	if (!disk) {	1402	if (!disk) {
1407	blk_cleanup_queue(q);	1403	blk_put_queue(q);
1408	return NULL;	1404	return NULL;
1409	}	1405	}
		1406	set_bit(GD_OWNS_QUEUE, &disk->state);
1410	return disk;	1407	return disk;
1411	}	1408	}
1412	EXPORT_SYMBOL(__blk_alloc_disk);	1409	EXPORT_SYMBOL(__blk_alloc_disk);
@@ -1418,6 +1415,9 @@ EXPORT_SYMBOL(__blk_alloc_disk); · 5 unmodified lines
1418	* This decrements the refcount for the struct gendisk. When this reaches 0	1415	* This decrements the refcount for the struct gendisk. When this reaches 0
1419	* we'll have disk_release() called.	1416	* we'll have disk_release() called.
1420	*	1417	*
		1418	* Note: for blk-mq disk put_disk must be called before freeing the tag_set
		1419	* when handling probe errors (that is before add_disk() is called).
		1420	*
1421	* Context: Any context, but the last reference must not be dropped from	1421	* Context: Any context, but the last reference must not be dropped from
1422	* atomic context.	1422	* atomic context.
1423	*/	1423	*/
@@ -1428,22 +1428,6 @@ void put_disk(struct gendisk *disk) · 4 unmodified lines
1428	}	1428	}
1429	EXPORT_SYMBOL(put_disk);	1429	EXPORT_SYMBOL(put_disk);
1430		1430
1431	/**
1432	* blk_cleanup_disk - shutdown a gendisk allocated by blk_alloc_disk
1433	* @disk: gendisk to shutdown
1434	*
1435	* Mark the queue hanging off @disk DYING, drain all pending requests, then mark
1436	* the queue DEAD, destroy and put it and the gendisk structure.
1437	*
1438	* Context: can sleep
1439	*/
1440	void blk_cleanup_disk(struct gendisk *disk)
1441	{
1442	blk_cleanup_queue(disk->queue);
1443	put_disk(disk);
1444	}
1445	EXPORT_SYMBOL(blk_cleanup_disk);
1446
1447	static void set_disk_ro_uevent(struct gendisk *gd, int ro)	1431	static void set_disk_ro_uevent(struct gendisk *gd, int ro)
1448	{	1432	{
1449	char event[] = "DISK_RO=1";	1433	char event[] = "DISK_RO=1";

block/ioctl.c+1−1

@@ -495,7 +495,7 @@ static int blkdev_common_ioctl(struct block_device *bdev, fmode_t mode, · 494 unmodified lines
495	case BLKGETZONESZ:	495	case BLKGETZONESZ:
496	return put_uint(argp, bdev_zone_sectors(bdev));	496	return put_uint(argp, bdev_zone_sectors(bdev));
497	case BLKGETNRZONES:	497	case BLKGETNRZONES:
498	return put_uint(argp, blkdev_nr_zones(bdev->bd_disk));	498	return put_uint(argp, bdev_nr_zones(bdev));
499	case BLKROGET:	499	case BLKROGET:
500	return put_int(argp, bdev_read_only(bdev) != 0);	500	return put_int(argp, bdev_read_only(bdev) != 0);
501	case BLKSSZGET: /* get block device logical block size */	501	case BLKSSZGET: /* get block device logical block size */

block/ioprio.c+50−8

@@ -138,6 +138,32 @@ out: · 137 unmodified lines
138	return ret;	138	return ret;
139	}	139	}
140		140
		141	/*
		142	* If the task has set an I/O priority, use that. Otherwise, return
		143	* the default I/O priority.
		144	*
		145	* Expected to be called for current task or with task_lock() held to keep
		146	* io_context stable.
		147	*/
		148	int __get_task_ioprio(struct task_struct *p)
		149	{
		150	struct io_context *ioc = p->io_context;
		151	int prio;
		152
		153	if (p != current)
		154	lockdep_assert_held(&p->alloc_lock);
		155	if (ioc)
		156	prio = ioc->ioprio;
		157	else
		158	prio = IOPRIO_DEFAULT;
		159
		160	if (IOPRIO_PRIO_CLASS(prio) == IOPRIO_CLASS_NONE)
		161	prio = IOPRIO_PRIO_VALUE(task_nice_ioclass(p),
		162	task_nice_ioprio(p));
		163	return prio;
		164	}
		165	EXPORT_SYMBOL_GPL(__get_task_ioprio);
		166
141	static int get_task_ioprio(struct task_struct *p)	167	static int get_task_ioprio(struct task_struct *p)
142	{	168	{
143	int ret;	169	int ret;
@@ -145,22 +171,38 @@ static int get_task_ioprio(struct task_struct *p) · 1 unmodified line
145	ret = security_task_getioprio(p);	171	ret = security_task_getioprio(p);
146	if (ret)	172	if (ret)
147	goto out;	173	goto out;
148	ret = IOPRIO_DEFAULT;	174	task_lock(p);
		175	ret = __get_task_ioprio(p);
		176	task_unlock(p);
		177	out:
		178	return ret;
		179	}
		180
		181	/*
		182	* Return raw IO priority value as set by userspace. We use this for
		183	* ioprio_get(pid, IOPRIO_WHO_PROCESS) so that we keep historical behavior and
		184	* also so that userspace can distinguish unset IO priority (which just gets
		185	* overriden based on task's nice value) from IO priority set to some value.
		186	*/
		187	static int get_task_raw_ioprio(struct task_struct *p)
		188	{
		189	int ret;
		190
		191	ret = security_task_getioprio(p);
		192	if (ret)
		193	goto out;
149	task_lock(p);	194	task_lock(p);
150	if (p->io_context)	195	if (p->io_context)
151	ret = p->io_context->ioprio;	196	ret = p->io_context->ioprio;
		197	else
		198	ret = IOPRIO_DEFAULT;
152	task_unlock(p);	199	task_unlock(p);
153	out:	200	out:
154	return ret;	201	return ret;
155	}	202	}
156		203
157	int ioprio_best(unsigned short aprio, unsigned short bprio)	204	static int ioprio_best(unsigned short aprio, unsigned short bprio)
158	{	205	{
159	if (!ioprio_valid(aprio))
160	aprio = IOPRIO_DEFAULT;
161	if (!ioprio_valid(bprio))
162	bprio = IOPRIO_DEFAULT;
163
164	return min(aprio, bprio);	206	return min(aprio, bprio);
165	}	207	}
166		208
@@ -181,7 +223,7 @@ SYSCALL_DEFINE2(ioprio_get, int, which, int, who) · 14 unmodified lines
181	else	223	else
182	p = find_task_by_vpid(who);	224	p = find_task_by_vpid(who);
183	if (p)	225	if (p)
184	ret = get_task_ioprio(p);	226	ret = get_task_raw_ioprio(p);
185	break;	227	break;
186	case IOPRIO_WHO_PGRP:	228	case IOPRIO_WHO_PGRP:
187	if (!who)	229	if (!who)

block/kyber-iosched.c+4−4

@@ -195,9 +195,9 @@ struct kyber_hctx_data { · 194 unmodified lines
195	static int kyber_domain_wake(wait_queue_entry_t *wait, unsigned mode, int flags,	195	static int kyber_domain_wake(wait_queue_entry_t *wait, unsigned mode, int flags,
196	void *key);	196	void *key);
197		197
198	static unsigned int kyber_sched_domain(unsigned int op)	198	static unsigned int kyber_sched_domain(blk_opf_t opf)
199	{	199	{
200	switch (op & REQ_OP_MASK) {	200	switch (opf & REQ_OP_MASK) {
201	case REQ_OP_READ:	201	case REQ_OP_READ:
202	return KYBER_READ;	202	return KYBER_READ;
203	case REQ_OP_WRITE:	203	case REQ_OP_WRITE:
@@ -553,13 +553,13 @@ static void rq_clear_domain_token(struct kyber_queue_data *kqd, · 349 unmodified lines
553	}	553	}
554	}	554	}
555		555
556	static void kyber_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)	556	static void kyber_limit_depth(blk_opf_t opf, struct blk_mq_alloc_data *data)
557	{	557	{
558	/*	558	/*
559	* We use the scheduler tags as per-hardware queue queueing tokens.	559	* We use the scheduler tags as per-hardware queue queueing tokens.
560	* Async requests can be limited at this stage.	560	* Async requests can be limited at this stage.
561	*/	561	*/
562	if (!op_is_sync(op)) {	562	if (!op_is_sync(opf)) {
563	struct kyber_queue_data *kqd = data->q->elevator->elevator_data;	563	struct kyber_queue_data *kqd = data->q->elevator->elevator_data;
564		564
565	data->shallow_depth = kqd->async_depth;	565	data->shallow_depth = kqd->async_depth;

block/mq-deadline.c+2−2

@@ -543,12 +543,12 @@ unlock: · 542 unmodified lines
543	* Called by __blk_mq_alloc_request(). The shallow_depth value set by this	543	* Called by __blk_mq_alloc_request(). The shallow_depth value set by this
544	* function is used by __blk_mq_get_tag().	544	* function is used by __blk_mq_get_tag().
545	*/	545	*/
546	static void dd_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)	546	static void dd_limit_depth(blk_opf_t opf, struct blk_mq_alloc_data *data)
547	{	547	{
548	struct deadline_data *dd = data->q->elevator->elevator_data;	548	struct deadline_data *dd = data->q->elevator->elevator_data;
549		549
550	/* Do not throttle synchronous reads. */	550	/* Do not throttle synchronous reads. */
551	if (op_is_sync(op) && !op_is_write(op))	551	if (op_is_sync(opf) && !op_is_write(opf))
552	return;	552	return;
553		553
554	/*	554	/*

block/partitions/core.c+1−2

 #include <linux/slab.h>
 #include <linux/ctype.h>
 #include <linux/vmalloc.h>
-#include <linux/blktrace_api.h>
 #include <linux/raid/detect.h>
 #include "check.h"
 	case BLK_ZONED_HA:
 		pr_info("%s: disabling host aware zoned block device support due to partitions\n",
 			disk->disk_name);
-		blk_queue_set_zoned(disk, BLK_ZONED_NONE);
+		disk_set_zoned(disk, BLK_ZONED_NONE);
 		break;
 	case BLK_ZONED_NONE:
 		break;

drivers/block/Kconfig+9−0

@@ -408,6 +408,15 @@ config BLK_DEV_RBD · 407 unmodified lines
408		408
409	If unsure, say N.	409	If unsure, say N.
410		410
		411	config BLK_DEV_UBLK
		412	tristate "Userspace block driver (Experimental)"
		413	select IO_URING
		414	help
		415	io_uring based userspace block driver. Together with ublk server, ublk
		416	has been working well, but interface with userspace or command data
		417	definition isn't finalized yet, and might change according to future
		418	requirement, so mark is as experimental now.
		419
411	source "drivers/block/rnbd/Kconfig"	420	source "drivers/block/rnbd/Kconfig"
412		421
413	endif # BLK_DEV	422	endif # BLK_DEV

drivers/block/Makefile+2−0

@@ -39,4 +39,6 @@ obj-$(CONFIG_BLK_DEV_RNBD) += rnbd/ · 38 unmodified lines
39		39
40	obj-$(CONFIG_BLK_DEV_NULL_BLK) += null_blk/	40	obj-$(CONFIG_BLK_DEV_NULL_BLK) += null_blk/
41		41
		42	obj-$(CONFIG_BLK_DEV_UBLK) += ublk_drv.o
		43
42	swim_mod-y := swim.o swim_asm.o	44	swim_mod-y := swim.o swim_asm.o

drivers/block/amiflop.c+1−1

@@ -1802,7 +1802,7 @@ static int fd_alloc_disk(int drive, int system) · 1801 unmodified lines
1802	unit[drive].gendisk[system] = disk;	1802	unit[drive].gendisk[system] = disk;
1803	err = add_disk(disk);	1803	err = add_disk(disk);
1804	if (err)	1804	if (err)
1805	blk_cleanup_disk(disk);	1805	put_disk(disk);
1806	return err;	1806	return err;
1807	}	1807	}
1808		1808

drivers/block/aoe/aoeblk.c+1−1

@@ -427,7 +427,7 @@ aoeblk_gdalloc(void *vp) · 426 unmodified lines
427	return;	427	return;
428		428
429	out_disk_cleanup:	429	out_disk_cleanup:
430	blk_cleanup_disk(gd);	430	put_disk(gd);
431	err_tagset:	431	err_tagset:
432	blk_mq_free_tag_set(set);	432	blk_mq_free_tag_set(set);
433	err_mempool:	433	err_mempool:

drivers/block/aoe/aoedev.c+1−1

@@ -277,7 +277,7 @@ freedev(struct aoedev *d) · 276 unmodified lines
277	if (d->gd) {	277	if (d->gd) {
278	aoedisk_rm_debugfs(d);	278	aoedisk_rm_debugfs(d);
279	del_gendisk(d->gd);	279	del_gendisk(d->gd);
280	blk_cleanup_disk(d->gd);	280	put_disk(d->gd);
281	blk_mq_free_tag_set(&d->tag_set);	281	blk_mq_free_tag_set(&d->tag_set);
282	}	282	}
283	t = d->targets;	283	t = d->targets;

drivers/block/ataflop.c+2−3

 	return;
 cleanup_disk:
-	blk_cleanup_disk(unit[drive].disk[type]);
+	put_disk(unit[drive].disk[type]);
 	unit[drive].disk[type] = NULL;
 }
 			if (!unit[i].disk[type])
 				continue;
 			del_gendisk(unit[i].disk[type]);
-			blk_cleanup_queue(unit[i].disk[type]->queue);
 			put_disk(unit[i].disk[type]);
 		}
 		blk_mq_free_tag_set(&unit[i].tag_set);
 			continue;
 		if (fs->registered[type])
 			del_gendisk(fs->disk[type]);
-		blk_cleanup_disk(fs->disk[type]);
+		put_disk(fs->disk[type]);
 	}
 	blk_mq_free_tag_set(&fs->tag_set);
 }

drivers/block/brd.c+4−4

@@ -256,7 +256,7 @@ static void copy_from_brd(void dst, struct brd_device brd, · 255 unmodified lines
256	* Process a single bvec of a bio.	256	* Process a single bvec of a bio.
257	*/	257	*/
258	static int brd_do_bvec(struct brd_device brd, struct page page,	258	static int brd_do_bvec(struct brd_device brd, struct page page,
259	unsigned int len, unsigned int off, unsigned int op,	259	unsigned int len, unsigned int off, enum req_op op,
260	sector_t sector)	260	sector_t sector)
261	{	261	{
262	void *mem;	262	void *mem;
@@ -310,7 +310,7 @@ static void brd_submit_bio(struct bio *bio) · 47 unmodified lines
310	}	310	}
311		311
312	static int brd_rw_page(struct block_device *bdev, sector_t sector,	312	static int brd_rw_page(struct block_device *bdev, sector_t sector,
313	struct page *page, unsigned int op)	313	struct page *page, enum req_op op)
314	{	314	{
315	struct brd_device *brd = bdev->bd_disk->private_data;	315	struct brd_device *brd = bdev->bd_disk->private_data;
316	int err;	316	int err;
@@ -419,7 +419,7 @@ static int brd_alloc(int i) · 102 unmodified lines
419	return 0;	419	return 0;
420		420
421	out_cleanup_disk:	421	out_cleanup_disk:
422	blk_cleanup_disk(disk);	422	put_disk(disk);
423	out_free_dev:	423	out_free_dev:
424	list_del(&brd->brd_list);	424	list_del(&brd->brd_list);
425	kfree(brd);	425	kfree(brd);
@@ -439,7 +439,7 @@ static void brd_cleanup(void) · 13 unmodified lines
439		439
440	list_for_each_entry_safe(brd, next, &brd_devices, brd_list) {	440	list_for_each_entry_safe(brd, next, &brd_devices, brd_list) {
441	del_gendisk(brd->brd_disk);	441	del_gendisk(brd->brd_disk);
442	blk_cleanup_disk(brd->brd_disk);	442	put_disk(brd->brd_disk);
443	brd_free_pages(brd);	443	brd_free_pages(brd);
444	list_del(&brd->brd_list);	444	list_del(&brd->brd_list);
445	kfree(brd);	445	kfree(brd);

drivers/block/drbd/drbd_actlog.c+5−4

 static int _drbd_md_sync_page_io(struct drbd_device *device,
 				 struct drbd_backing_dev *bdev,
-				 sector_t sector, int op)
+				 sector_t sector, enum req_op op)
 {
 	struct bio *bio;
 	/* we do all our meta data IO in aligned 4k blocks. */
 	const int size = 4096;
-	int err, op_flags = 0;
+	int err;
+	blk_opf_t op_flags = 0;
 	device->md_io.done = 0;
 	device->md_io.error = -ENODEV;
 }
 int drbd_md_sync_page_io(struct drbd_device *device, struct drbd_backing_dev *bdev,
-			 sector_t sector, int op)
+			 sector_t sector, enum req_op op)
 {
 	int err;
 	D_ASSERT(device, atomic_read(&device->md_io.in_use) == 1);
 		write_al_updates = rcu_dereference(device->ldev->disk_conf)->al_updates;
 		rcu_read_unlock();
 		if (write_al_updates) {
-			if (drbd_md_sync_page_io(device, device->ldev, sector, WRITE)) {
+			if (drbd_md_sync_page_io(device, device->ldev, sector, REQ_OP_WRITE)) {
 				err = -EIO;
 				drbd_chk_io_error(device, 1, DRBD_META_IO_ERROR);
 			} else {

drivers/block/drbd/drbd_bitmap.c+1−1

@@ -977,7 +977,7 @@ static void drbd_bm_endio(struct bio *bio) · 976 unmodified lines
977	static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_hold(local)	977	static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_hold(local)
978	{	978	{
979	struct drbd_device *device = ctx->device;	979	struct drbd_device *device = ctx->device;
980	unsigned int op = (ctx->flags & BM_AIO_READ) ? REQ_OP_READ : REQ_OP_WRITE;	980	enum req_op op = ctx->flags & BM_AIO_READ ? REQ_OP_READ : REQ_OP_WRITE;
981	struct bio *bio = bio_alloc_bioset(device->ldev->md_bdev, 1, op,	981	struct bio *bio = bio_alloc_bioset(device->ldev->md_bdev, 1, op,
982	GFP_NOIO, &drbd_md_io_bio_set);	982	GFP_NOIO, &drbd_md_io_bio_set);
983	struct drbd_bitmap *b = device->bitmap;	983	struct drbd_bitmap *b = device->bitmap;

drivers/block/drbd/drbd_int.h+2−3

 extern void *drbd_md_get_buffer(struct drbd_device *device, const char *intent);
 extern void drbd_md_put_buffer(struct drbd_device *device);
 extern int drbd_md_sync_page_io(struct drbd_device *device,
-		struct drbd_backing_dev *bdev, sector_t sector, int op);
+		struct drbd_backing_dev *bdev, sector_t sector, enum req_op op);
 extern void drbd_ov_out_of_sync_found(struct drbd_device *, sector_t, int);
 extern void wait_until_done_or_force_detached(struct drbd_device *device,
 		struct drbd_backing_dev *bdev, unsigned int *done);
 extern bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector,
 		bool throttle_if_app_is_waiting);
 extern int drbd_submit_peer_request(struct drbd_device *,
-				    struct drbd_peer_request *, const unsigned,
+				    struct drbd_peer_request *, blk_opf_t, int);
-				    const unsigned, const int);
 extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *);
 extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_peer_device *, u64,
 						     sector_t, unsigned int,

drivers/block/drbd/drbd_main.c+2−2

@@ -2207,7 +2207,7 @@ void drbd_destroy_device(struct kref *kref) · 2206 unmodified lines
2207	if (device->bitmap) /* should no longer be there. */	2207	if (device->bitmap) /* should no longer be there. */
2208	drbd_bm_cleanup(device);	2208	drbd_bm_cleanup(device);
2209	__free_page(device->md_io.page);	2209	__free_page(device->md_io.page);
2210	blk_cleanup_disk(device->vdisk);	2210	put_disk(device->vdisk);
2211	kfree(device->rs_plan_s);	2211	kfree(device->rs_plan_s);
2212		2212
2213	/* not for_each_connection(connection, resource):	2213	/* not for_each_connection(connection, resource):
@@ -2807,7 +2807,7 @@ out_no_minor_idr: · 593 unmodified lines
2807	out_no_bitmap:	2807	out_no_bitmap:
2808	__free_page(device->md_io.page);	2808	__free_page(device->md_io.page);
2809	out_no_io_page:	2809	out_no_io_page:
2810	blk_cleanup_disk(disk);	2810	put_disk(disk);
2811	out_no_disk:	2811	out_no_disk:
2812	kref_put(&resource->kref, drbd_destroy_resource);	2812	kref_put(&resource->kref, drbd_destroy_resource);
2813	kfree(device);	2813	kfree(device);

drivers/block/drbd/drbd_receiver.c+12−12

 /* TODO allocate from our own bio_set. */
 int drbd_submit_peer_request(struct drbd_device *device,
 			     struct drbd_peer_request *peer_req,
-			     const unsigned op, const unsigned op_flags,
+			     const blk_opf_t opf, const int fault_type)
-			     const int fault_type)
 {
 	struct bio *bios = NULL;
 	struct bio *bio;
 	 * generated bio, but a bio allocated on behalf of the peer.
 	 */
 next_bio:
-	bio = bio_alloc(device->ldev->backing_bdev, nr_pages, op | op_flags,
+	bio = bio_alloc(device->ldev->backing_bdev, nr_pages, opf, GFP_NOIO);
-			GFP_NOIO);
 	/* > peer_req->i.sector, unless this is the first bio */
 	bio->bi_iter.bi_sector = sector;
 	bio->bi_private = peer_req;
 	spin_unlock_irq(&device->resource->req_lock);
 	atomic_add(pi->size >> 9, &device->rs_sect_ev);
-	if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE, 0,
+	if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE,
 				     DRBD_FAULT_RS_WR) == 0)
 		return 0;
 /* see also bio_flags_to_wire()
  * DRBD_REQ_*, because we need to semantically map the flags to data packet
  * flags and back. We may replicate to other kernel versions. */
-static unsigned long wire_flags_to_bio_flags(u32 dpf)
+static blk_opf_t wire_flags_to_bio_flags(u32 dpf)
 {
 	return  (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
 		(dpf & DP_FUA ? REQ_FUA : 0) |
 		(dpf & DP_FLUSH ? REQ_PREFLUSH : 0);
 }
-static unsigned long wire_flags_to_bio_op(u32 dpf)
+static enum req_op wire_flags_to_bio_op(u32 dpf)
 {
 	if (dpf & DP_ZEROES)
 		return REQ_OP_WRITE_ZEROES;
 	struct drbd_peer_request *peer_req;
 	struct p_data *p = pi->data;
 	u32 peer_seq = be32_to_cpu(p->seq_num);
-	int op, op_flags;
+	enum req_op op;
+	blk_opf_t op_flags;
 	u32 dp_flags;
 	int err, tp;
 		peer_req->flags |= EE_CALL_AL_COMPLETE_IO;
 	}
-	err = drbd_submit_peer_request(device, peer_req, op, op_flags,
+	err = drbd_submit_peer_request(device, peer_req, op | op_flags,
 				       DRBD_FAULT_DT_WR);
 	if (!err)
 		return 0;
 submit:
 	update_receiver_timing_details(connection, drbd_submit_peer_request);
 	inc_unacked(device);
-	if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0,
+	if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ,
 				     fault_type) == 0)
 		return 0;
 	if (get_ldev(device)) {
 		struct drbd_peer_request *peer_req;
-		const int op = REQ_OP_WRITE_ZEROES;
+		const enum req_op op = REQ_OP_WRITE_ZEROES;
 		peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector,
 					       size, 0, GFP_NOIO);
 		spin_unlock_irq(&device->resource->req_lock);
 		atomic_add(pi->size >> 9, &device->rs_sect_ev);
-		err = drbd_submit_peer_request(device, peer_req, op, 0, DRBD_FAULT_RS_WR);
+		err = drbd_submit_peer_request(device, peer_req, op,
+					       DRBD_FAULT_RS_WR);
 		if (err) {
 			spin_lock_irq(&device->resource->req_lock);

drivers/block/drbd/drbd_req.c+2−4

 static void drbd_report_io_error(struct drbd_device *device, struct drbd_request *req)
 {
-        char b[BDEVNAME_SIZE];
 	if (!__ratelimit(&drbd_ratelimit_state))
 		return;
-	drbd_warn(device, "local %s IO error sector %llu+%u on %s\n",
+	drbd_warn(device, "local %s IO error sector %llu+%u on %pg\n",
 			(req->rq_state & RQ_WRITE) ? "WRITE" : "READ",
 			(unsigned long long)req->i.sector,
 			req->i.size >> 9,
-			bdevname(device->ldev->backing_bdev, b));
+			device->ldev->backing_bdev);
 }
 /* Helper for HANDED_OVER_TO_NETWORK.

drivers/block/drbd/drbd_worker.c+1−1

@@ -405,7 +405,7 @@ static int read_for_csum(struct drbd_peer_device *peer_device, sector_t sector, · 404 unmodified lines
405	spin_unlock_irq(&device->resource->req_lock);	405	spin_unlock_irq(&device->resource->req_lock);
406		406
407	atomic_add(size >> 9, &device->rs_sect_ev);	407	atomic_add(size >> 9, &device->rs_sect_ev);
408	if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0,	408	if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ,
409	DRBD_FAULT_RS_RD) == 0)	409	DRBD_FAULT_RS_RD) == 0)
410	return 0;	410	return 0;
411		411

drivers/block/floppy.c+4−4

@@ -2859,7 +2859,7 @@ static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx, · 2858 unmodified lines
2859	if (WARN(atomic_read(&usage_count) == 0,	2859	if (WARN(atomic_read(&usage_count) == 0,
2860	"warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",	2860	"warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",
2861	current_req, (long)blk_rq_pos(current_req),	2861	current_req, (long)blk_rq_pos(current_req),
2862	(unsigned long long) current_req->cmd_flags))	2862	(__force unsigned long long) current_req->cmd_flags))
2863	return BLK_STS_IOERR;	2863	return BLK_STS_IOERR;
2864		2864
2865	if (test_and_set_bit(0, &fdc_busy)) {	2865	if (test_and_set_bit(0, &fdc_busy)) {
@@ -4557,7 +4557,7 @@ out: · 1691 unmodified lines
4557	return;	4557	return;
4558		4558
4559	cleanup_disk:	4559	cleanup_disk:
4560	blk_cleanup_disk(disks[drive][type]);	4560	put_disk(disks[drive][type]);
4561	disks[drive][type] = NULL;	4561	disks[drive][type] = NULL;
4562	mutex_unlock(&floppy_probe_lock);	4562	mutex_unlock(&floppy_probe_lock);
4563	}	4563	}
@@ -4753,7 +4753,7 @@ out_put_disk: · 189 unmodified lines
4753	if (!disks[drive][0])	4753	if (!disks[drive][0])
4754	break;	4754	break;
4755	del_timer_sync(&motor_off_timer[drive]);	4755	del_timer_sync(&motor_off_timer[drive]);
4756	blk_cleanup_disk(disks[drive][0]);	4756	put_disk(disks[drive][0]);
4757	blk_mq_free_tag_set(&tag_sets[drive]);	4757	blk_mq_free_tag_set(&tag_sets[drive]);
4758	}	4758	}
4759	return err;	4759	return err;
@@ -4985,7 +4985,7 @@ static void __exit floppy_module_exit(void) · 225 unmodified lines
4985	}	4985	}
4986	for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {	4986	for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
4987	if (disks[drive][i])	4987	if (disks[drive][i])
4988	blk_cleanup_disk(disks[drive][i]);	4988	put_disk(disks[drive][i]);
4989	}	4989	}
4990	blk_mq_free_tag_set(&tag_sets[drive]);	4990	blk_mq_free_tag_set(&tag_sets[drive]);
4991	}	4991	}

drivers/block/loop.c+1−2

 	return i;
 out_cleanup_disk:
-	blk_cleanup_disk(disk);
+	put_disk(disk);
 out_cleanup_tags:
 	blk_mq_free_tag_set(&lo->tag_set);
 out_free_idr:
 {
 	/* Make this loop device unreachable from pathname. */
 	del_gendisk(lo->lo_disk);
-	blk_cleanup_queue(lo->lo_disk->queue);
 	blk_mq_free_tag_set(&lo->tag_set);
 	mutex_lock(&loop_ctl_mutex);

drivers/block/mtip32xx/mtip32xx.c+48−259

@@ -94,17 +94,12 @@ · 93 unmodified lines
94	/* Device instance number, incremented each time a device is probed. */	94	/* Device instance number, incremented each time a device is probed. */
95	static int instance;	95	static int instance;
96		96
97	static LIST_HEAD(online_list);
98	static LIST_HEAD(removing_list);
99	static DEFINE_SPINLOCK(dev_lock);
100
101	/*	97	/*
102	* Global variable used to hold the major block device number	98	* Global variable used to hold the major block device number
103	* allocated in mtip_init().	99	* allocated in mtip_init().
104	*/	100	*/
105	static int mtip_major;	101	static int mtip_major;
106	static struct dentry *dfs_parent;	102	static struct dentry *dfs_parent;
107	static struct dentry *dfs_device_status;
108		103
109	static u32 cpu_use[NR_CPUS];	104	static u32 cpu_use[NR_CPUS];
110		105
@@ -146,11 +141,8 @@ static bool mtip_check_surprise_removal(struct driver_data *dd) · 35 unmodified lines
146	pci_read_config_word(dd->pdev, 0x00, &vendor_id);	141	pci_read_config_word(dd->pdev, 0x00, &vendor_id);
147	if (vendor_id == 0xFFFF) {	142	if (vendor_id == 0xFFFF) {
148	dd->sr = true;	143	dd->sr = true;
149	if (dd->queue)	144	if (dd->disk)
150	blk_queue_flag_set(QUEUE_FLAG_DEAD, dd->queue);	145	blk_mark_disk_dead(dd->disk);
151	else
152	dev_warn(&dd->pdev->dev,
153	"%s: dd->queue is NULL\n", __func__);
154	return true; /* device removed */	146	return true; /* device removed */
155	}	147	}
156		148
@@ -2170,106 +2162,6 @@ static const struct attribute_group *mtip_disk_attr_groups[] = { · 2013 unmodified lines
2170	NULL,	2162	NULL,
2171	};	2163	};
2172		2164
2173	/* debugsfs entries */
2174
2175	static ssize_t show_device_status(struct device_driver drv, char buf)
2176	{
2177	int size = 0;
2178	struct driver_data dd, tmp;
2179	unsigned long flags;
2180	char id_buf[42];
2181	u16 status = 0;
2182
2183	spin_lock_irqsave(&dev_lock, flags);
2184	size += sprintf(&buf[size], "Devices Present:\n");
2185	list_for_each_entry_safe(dd, tmp, &online_list, online_list) {
2186	if (dd->pdev) {
2187	if (dd->port &&
2188	dd->port->identify &&
2189	dd->port->identify_valid) {
2190	strlcpy(id_buf,
2191	(char *) (dd->port->identify + 10), 21);
2192	status = *(dd->port->identify + 141);
2193	} else {
2194	memset(id_buf, 0, 42);
2195	status = 0;
2196	}
2197
2198	if (dd->port &&
2199	test_bit(MTIP_PF_REBUILD_BIT, &dd->port->flags)) {
2200	size += sprintf(&buf[size],
2201	" device %s %s (ftl rebuild %d %%)\n",
2202	dev_name(&dd->pdev->dev),
2203	id_buf,
2204	status);
2205	} else {
2206	size += sprintf(&buf[size],
2207	" device %s %s\n",
2208	dev_name(&dd->pdev->dev),
2209	id_buf);
2210	}
2211	}
2212	}
2213
2214	size += sprintf(&buf[size], "Devices Being Removed:\n");
2215	list_for_each_entry_safe(dd, tmp, &removing_list, remove_list) {
2216	if (dd->pdev) {
2217	if (dd->port &&
2218	dd->port->identify &&
2219	dd->port->identify_valid) {
2220	strlcpy(id_buf,
2221	(char *) (dd->port->identify+10), 21);
2222	status = *(dd->port->identify + 141);
2223	} else {
2224	memset(id_buf, 0, 42);
2225	status = 0;
2226	}
2227
2228	if (dd->port &&
2229	test_bit(MTIP_PF_REBUILD_BIT, &dd->port->flags)) {
2230	size += sprintf(&buf[size],
2231	" device %s %s (ftl rebuild %d %%)\n",
2232	dev_name(&dd->pdev->dev),
2233	id_buf,
2234	status);
2235	} else {
2236	size += sprintf(&buf[size],
2237	" device %s %s\n",
2238	dev_name(&dd->pdev->dev),
2239	id_buf);
2240	}
2241	}
2242	}
2243	spin_unlock_irqrestore(&dev_lock, flags);
2244
2245	return size;
2246	}
2247
2248	static ssize_t mtip_hw_read_device_status(struct file f, char __user ubuf,
2249	size_t len, loff_t *offset)
2250	{
2251	int size = *offset;
2252	char *buf;
2253	int rv = 0;
2254
2255	if (!len \|\| *offset)
2256	return 0;
2257
2258	buf = kzalloc(MTIP_DFS_MAX_BUF_SIZE, GFP_KERNEL);
2259	if (!buf)
2260	return -ENOMEM;
2261
2262	size += show_device_status(NULL, buf);
2263
2264	*offset = size <= len ? size : len;
2265	size = copy_to_user(ubuf, buf, *offset);
2266	if (size)
2267	rv = -EFAULT;
2268
2269	kfree(buf);
2270	return rv ? rv : *offset;
2271	}
2272
2273	static ssize_t mtip_hw_read_registers(struct file f, char __user ubuf,	2165	static ssize_t mtip_hw_read_registers(struct file f, char __user ubuf,
2274	size_t len, loff_t *offset)	2166	size_t len, loff_t *offset)
2275	{	2167	{
@@ -2363,13 +2255,6 @@ static ssize_t mtip_hw_read_flags(struct file f, char __user ubuf, · 87 unmodified lines
2363	return rv ? rv : *offset;	2255	return rv ? rv : *offset;
2364	}	2256	}
2365		2257
2366	static const struct file_operations mtip_device_status_fops = {
2367	.owner = THIS_MODULE,
2368	.open = simple_open,
2369	.read = mtip_hw_read_device_status,
2370	.llseek = no_llseek,
2371	};
2372
2373	static const struct file_operations mtip_regs_fops = {	2258	static const struct file_operations mtip_regs_fops = {
2374	.owner = THIS_MODULE,	2259	.owner = THIS_MODULE,
2375	.open = simple_open,	2260	.open = simple_open,
@@ -2556,7 +2441,7 @@ static void mtip_softirq_done_fn(struct request *rq) · 180 unmodified lines
2556	blk_mq_end_request(rq, cmd->status);	2441	blk_mq_end_request(rq, cmd->status);
2557	}	2442	}
2558		2443
2559	static bool mtip_abort_cmd(struct request req, void data, bool reserved)	2444	static bool mtip_abort_cmd(struct request req, void data)
2560	{	2445	{
2561	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);	2446	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);
2562	struct driver_data *dd = data;	2447	struct driver_data *dd = data;
@@ -2569,7 +2454,7 @@ static bool mtip_abort_cmd(struct request req, void data, bool reserved) · 6 unmodified lines
2569	return true;	2454	return true;
2570	}	2455	}
2571		2456
2572	static bool mtip_queue_cmd(struct request req, void data, bool reserved)	2457	static bool mtip_queue_cmd(struct request req, void data)
2573	{	2458	{
2574	struct driver_data *dd = data;	2459	struct driver_data *dd = data;
2575		2460
@@ -3297,26 +3182,12 @@ static int mtip_block_getgeo(struct block_device *dev, · 721 unmodified lines
3297	return 0;	3182	return 0;
3298	}	3183	}
3299		3184
3300	static int mtip_block_open(struct block_device *dev, fmode_t mode)	3185	static void mtip_block_free_disk(struct gendisk *disk)
3301	{	3186	{
3302	struct driver_data *dd;	3187	struct driver_data *dd = disk->private_data;
3303		3188
3304	if (dev && dev->bd_disk) {	3189	ida_free(&rssd_index_ida, dd->index);
3305	dd = (struct driver_data *) dev->bd_disk->private_data;	3190	kfree(dd);
3306
3307	if (dd) {
3308	if (test_bit(MTIP_DDF_REMOVAL_BIT,
3309	&dd->dd_flag)) {
3310	return -ENODEV;
3311	}
3312	return 0;
3313	}
3314	}
3315	return -ENODEV;
3316	}
3317
3318	static void mtip_block_release(struct gendisk *disk, fmode_t mode)
3319	{
3320	}	3191	}
3321		3192
3322	/*	3193	/*
@@ -3326,13 +3197,12 @@ static void mtip_block_release(struct gendisk *disk, fmode_t mode) · 3 unmodified lines
3326	* layer.	3197	* layer.
3327	*/	3198	*/
3328	static const struct block_device_operations mtip_block_ops = {	3199	static const struct block_device_operations mtip_block_ops = {
3329	.open = mtip_block_open,
3330	.release = mtip_block_release,
3331	.ioctl = mtip_block_ioctl,	3200	.ioctl = mtip_block_ioctl,
3332	#ifdef CONFIG_COMPAT	3201	#ifdef CONFIG_COMPAT
3333	.compat_ioctl = mtip_block_compat_ioctl,	3202	.compat_ioctl = mtip_block_compat_ioctl,
3334	#endif	3203	#endif
3335	.getgeo = mtip_block_getgeo,	3204	.getgeo = mtip_block_getgeo,
		3205	.free_disk = mtip_block_free_disk,
3336	.owner = THIS_MODULE	3206	.owner = THIS_MODULE
3337	};	3207	};
3338		3208
@@ -3487,12 +3357,11 @@ static int mtip_init_cmd(struct blk_mq_tag_set set, struct request rq, · 148 unmodified lines
3487	return 0;	3357	return 0;
3488	}	3358	}
3489		3359
3490	static enum blk_eh_timer_return mtip_cmd_timeout(struct request *req,	3360	static enum blk_eh_timer_return mtip_cmd_timeout(struct request *req)
3491	bool reserved)
3492	{	3361	{
3493	struct driver_data *dd = req->q->queuedata;	3362	struct driver_data *dd = req->q->queuedata;
3494		3363
3495	if (reserved) {	3364	if (blk_mq_is_reserved_rq(req)) {
3496	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);	3365	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(req);
3497		3366
3498	cmd->status = BLK_STS_TIMEOUT;	3367	cmd->status = BLK_STS_TIMEOUT;
@@ -3664,7 +3533,7 @@ init_hw_cmds_error: · 165 unmodified lines
3664	disk_index_error:	3533	disk_index_error:
3665	ida_free(&rssd_index_ida, index);	3534	ida_free(&rssd_index_ida, index);
3666	ida_get_error:	3535	ida_get_error:
3667	blk_cleanup_disk(dd->disk);	3536	put_disk(dd->disk);
3668	block_queue_alloc_init_error:	3537	block_queue_alloc_init_error:
3669	blk_mq_free_tag_set(&dd->tags);	3538	blk_mq_free_tag_set(&dd->tags);
3670	block_queue_alloc_tag_error:	3539	block_queue_alloc_tag_error:
@@ -3673,72 +3542,6 @@ protocol_init_error: · 2 unmodified lines
3673	return rv;	3542	return rv;
3674	}	3543	}
3675		3544
3676	static bool mtip_no_dev_cleanup(struct request rq, void data, bool reserv)
3677	{
3678	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(rq);
3679
3680	cmd->status = BLK_STS_IOERR;
3681	blk_mq_complete_request(rq);
3682	return true;
3683	}
3684
3685	/*
3686	* Block layer deinitialization function.
3687	*
3688	* Called by the PCI layer as each P320 device is removed.
3689	*
3690	* @dd Pointer to the driver data structure.
3691	*
3692	* return value
3693	* 0
3694	*/
3695	static int mtip_block_remove(struct driver_data *dd)
3696	{
3697	mtip_hw_debugfs_exit(dd);
3698
3699	if (dd->mtip_svc_handler) {
3700	set_bit(MTIP_PF_SVC_THD_STOP_BIT, &dd->port->flags);
3701	wake_up_interruptible(&dd->port->svc_wait);
3702	kthread_stop(dd->mtip_svc_handler);
3703	}
3704
3705	if (!dd->sr) {
3706	/*
3707	* Explicitly wait here for IOs to quiesce,
3708	* as mtip_standby_drive usually won't wait for IOs.
3709	*/
3710	if (!mtip_quiesce_io(dd->port, MTIP_QUIESCE_IO_TIMEOUT_MS))
3711	mtip_standby_drive(dd);
3712	}
3713	else
3714	dev_info(&dd->pdev->dev, "device %s surprise removal\n",
3715	dd->disk->disk_name);
3716
3717	blk_freeze_queue_start(dd->queue);
3718	blk_mq_quiesce_queue(dd->queue);
3719	blk_mq_tagset_busy_iter(&dd->tags, mtip_no_dev_cleanup, dd);
3720	blk_mq_unquiesce_queue(dd->queue);
3721
3722	if (dd->disk) {
3723	if (test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag))
3724	del_gendisk(dd->disk);
3725	if (dd->disk->queue) {
3726	blk_cleanup_queue(dd->queue);
3727	blk_mq_free_tag_set(&dd->tags);
3728	dd->queue = NULL;
3729	}
3730	put_disk(dd->disk);
3731	}
3732	dd->disk = NULL;
3733
3734	ida_free(&rssd_index_ida, dd->index);
3735
3736	/* De-initialize the protocol layer. */
3737	mtip_hw_exit(dd);
3738
3739	return 0;
3740	}
3741
3742	/*	3545	/*
3743	* Function called by the PCI layer when just before the	3546	* Function called by the PCI layer when just before the
3744	* machine shuts down.	3547	* machine shuts down.
@@ -3755,23 +3558,14 @@ static int mtip_block_shutdown(struct driver_data *dd) · 10 unmodified lines
3755	{	3558	{
3756	mtip_hw_shutdown(dd);	3559	mtip_hw_shutdown(dd);
3757		3560
3758	/* Delete our gendisk structure, and cleanup the blk queue. */	3561	dev_info(&dd->pdev->dev,
3759	if (dd->disk) {	3562	"Shutting down %s ...\n", dd->disk->disk_name);
3760	dev_info(&dd->pdev->dev,
3761	"Shutting down %s ...\n", dd->disk->disk_name);
3762		3563
3763	if (test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag))	3564	if (test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag))
3764	del_gendisk(dd->disk);	3565	del_gendisk(dd->disk);
3765	if (dd->disk->queue) {
3766	blk_cleanup_queue(dd->queue);
3767	blk_mq_free_tag_set(&dd->tags);
3768	}
3769	put_disk(dd->disk);
3770	dd->disk = NULL;
3771	dd->queue = NULL;
3772	}
3773		3566
3774	ida_free(&rssd_index_ida, dd->index);	3567	blk_mq_free_tag_set(&dd->tags);
		3568	put_disk(dd->disk);
3775	return 0;	3569	return 0;
3776	}	3570	}
3777		3571
@@ -3905,7 +3699,6 @@ static int mtip_pci_probe(struct pci_dev *pdev, · 127 unmodified lines
3905	const struct cpumask *node_mask;	3699	const struct cpumask *node_mask;
3906	int cpu, i = 0, j = 0;	3700	int cpu, i = 0, j = 0;
3907	int my_node = NUMA_NO_NODE;	3701	int my_node = NUMA_NO_NODE;
3908	unsigned long flags;
3909		3702
3910	/* Allocate memory for this devices private data. */	3703	/* Allocate memory for this devices private data. */
3911	my_node = pcibus_to_node(pdev->bus);	3704	my_node = pcibus_to_node(pdev->bus);
@@ -3952,9 +3745,6 @@ static int mtip_pci_probe(struct pci_dev *pdev, · 40 unmodified lines
3952	dd->pdev = pdev;	3745	dd->pdev = pdev;
3953	dd->numa_node = my_node;	3746	dd->numa_node = my_node;
3954		3747
3955	INIT_LIST_HEAD(&dd->online_list);
3956	INIT_LIST_HEAD(&dd->remove_list);
3957
3958	memset(dd->workq_name, 0, 32);	3748	memset(dd->workq_name, 0, 32);
3959	snprintf(dd->workq_name, 31, "mtipq%d", dd->instance);	3749	snprintf(dd->workq_name, 31, "mtipq%d", dd->instance);
3960		3750
@@ -4047,11 +3837,6 @@ static int mtip_pci_probe(struct pci_dev *pdev, · 86 unmodified lines
4047	else	3837	else
4048	rv = 0; /* device in rebuild state, return 0 from probe */	3838	rv = 0; /* device in rebuild state, return 0 from probe */
4049		3839
4050	/* Add to online list even if in ftl rebuild */
4051	spin_lock_irqsave(&dev_lock, flags);
4052	list_add(&dd->online_list, &online_list);
4053	spin_unlock_irqrestore(&dev_lock, flags);
4054
4055	goto done;	3840	goto done;
4056		3841
4057	block_initialize_err:	3842	block_initialize_err:
@@ -4085,14 +3870,7 @@ done: · 27 unmodified lines
4085	static void mtip_pci_remove(struct pci_dev *pdev)	3870	static void mtip_pci_remove(struct pci_dev *pdev)
4086	{	3871	{
4087	struct driver_data *dd = pci_get_drvdata(pdev);	3872	struct driver_data *dd = pci_get_drvdata(pdev);
4088	unsigned long flags, to;	3873	unsigned long to;
4089
4090	set_bit(MTIP_DDF_REMOVAL_BIT, &dd->dd_flag);
4091
4092	spin_lock_irqsave(&dev_lock, flags);
4093	list_del_init(&dd->online_list);
4094	list_add(&dd->remove_list, &removing_list);
4095	spin_unlock_irqrestore(&dev_lock, flags);
4096		3874
4097	mtip_check_surprise_removal(dd);	3875	mtip_check_surprise_removal(dd);
4098	synchronize_irq(dd->pdev->irq);	3876	synchronize_irq(dd->pdev->irq);
@@ -4109,11 +3887,35 @@ static void mtip_pci_remove(struct pci_dev *pdev) · 10 unmodified lines
4109	"Completion workers still active!\n");	3887	"Completion workers still active!\n");
4110	}	3888	}
4111		3889
4112	blk_mark_disk_dead(dd->disk);
4113	set_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag);	3890	set_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag);
4114		3891
4115	/* Clean up the block layer. */	3892	if (test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag))
4116	mtip_block_remove(dd);	3893	del_gendisk(dd->disk);
		3894
		3895	mtip_hw_debugfs_exit(dd);
		3896
		3897	if (dd->mtip_svc_handler) {
		3898	set_bit(MTIP_PF_SVC_THD_STOP_BIT, &dd->port->flags);
		3899	wake_up_interruptible(&dd->port->svc_wait);
		3900	kthread_stop(dd->mtip_svc_handler);
		3901	}
		3902
		3903	if (!dd->sr) {
		3904	/*
		3905	* Explicitly wait here for IOs to quiesce,
		3906	* as mtip_standby_drive usually won't wait for IOs.
		3907	*/
		3908	if (!mtip_quiesce_io(dd->port, MTIP_QUIESCE_IO_TIMEOUT_MS))
		3909	mtip_standby_drive(dd);
		3910	}
		3911	else
		3912	dev_info(&dd->pdev->dev, "device %s surprise removal\n",
		3913	dd->disk->disk_name);
		3914
		3915	blk_mq_free_tag_set(&dd->tags);
		3916
		3917	/* De-initialize the protocol layer. */
		3918	mtip_hw_exit(dd);
4117		3919
4118	if (dd->isr_workq) {	3920	if (dd->isr_workq) {
4119	destroy_workqueue(dd->isr_workq);	3921	destroy_workqueue(dd->isr_workq);
@@ -4124,14 +3926,10 @@ static void mtip_pci_remove(struct pci_dev *pdev) · 4 unmodified lines
4124		3926
4125	pci_disable_msi(pdev);	3927	pci_disable_msi(pdev);
4126		3928
4127	spin_lock_irqsave(&dev_lock, flags);
4128	list_del_init(&dd->remove_list);
4129	spin_unlock_irqrestore(&dev_lock, flags);
4130
4131	kfree(dd);
4132
4133	pcim_iounmap_regions(pdev, 1 << MTIP_ABAR);	3929	pcim_iounmap_regions(pdev, 1 << MTIP_ABAR);
4134	pci_set_drvdata(pdev, NULL);	3930	pci_set_drvdata(pdev, NULL);
		3931
		3932	put_disk(dd->disk);
4135	}	3933	}
4136		3934
4137	/*	3935	/*
@@ -4250,15 +4048,6 @@ static int __init mtip_init(void) · 112 unmodified lines
4250	pr_warn("Error creating debugfs parent\n");	4048	pr_warn("Error creating debugfs parent\n");
4251	dfs_parent = NULL;	4049	dfs_parent = NULL;
4252	}	4050	}
4253	if (dfs_parent) {
4254	dfs_device_status = debugfs_create_file("device_status",
4255	0444, dfs_parent, NULL,
4256	&mtip_device_status_fops);
4257	if (IS_ERR_OR_NULL(dfs_device_status)) {
4258	pr_err("Error creating device_status node\n");
4259	dfs_device_status = NULL;
4260	}
4261	}
4262		4051
4263	/* Register our PCI operations. */	4052	/* Register our PCI operations. */
4264	error = pci_register_driver(&mtip_pci_driver);	4053	error = pci_register_driver(&mtip_pci_driver);

drivers/block/mtip32xx/mtip32xx.h+0−5

 	MTIP_DDF_RESUME_BIT         = 6,
 	MTIP_DDF_INIT_DONE_BIT      = 7,
 	MTIP_DDF_REBUILD_FAILED_BIT = 8,
-	MTIP_DDF_REMOVAL_BIT	    = 9,
 	MTIP_DDF_STOP_IO      = ((1 << MTIP_DDF_REMOVE_PENDING_BIT) |
 				(1 << MTIP_DDF_SEC_LOCK_BIT) |
 	int isr_binding;
-	struct list_head online_list; /* linkage for online list */
-	struct list_head remove_list; /* linkage for removing list */
 	int unal_qdepth; /* qdepth of unaligned IO queue */
 };

drivers/block/n64cart.c+1−1

@@ -157,7 +157,7 @@ static int __init n64cart_probe(struct platform_device *pdev) · 156 unmodified lines
157	return 0;	157	return 0;
158		158
159	out_cleanup_disk:	159	out_cleanup_disk:
160	blk_cleanup_disk(disk);	160	put_disk(disk);
161	out:	161	out:
162	return err;	162	return err;
163	}	163	}

drivers/block/nbd.c+4−5

 	struct gendisk *disk = nbd->disk;
 	del_gendisk(disk);
-	blk_cleanup_disk(disk);
+	put_disk(disk);
 	blk_mq_free_tag_set(&nbd->tag_set);
 	/*
 	}
 }
-static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req,
+static enum blk_eh_timer_return nbd_xmit_timeout(struct request *req)
-						 bool reserved)
 {
 	struct nbd_cmd *cmd = blk_mq_rq_to_pdu(req);
 	struct nbd_device *nbd = cmd->nbd;
 	kfree(args);
 }
-static bool nbd_clear_req(struct request *req, void *data, bool reserved)
+static bool nbd_clear_req(struct request *req, void *data)
 {
 	struct nbd_cmd *cmd = blk_mq_rq_to_pdu(req);
 out_free_work:
 	destroy_workqueue(nbd->recv_workq);
 out_err_disk:
-	blk_cleanup_disk(disk);
+	put_disk(disk);
 out_free_idr:
 	mutex_lock(&nbd_index_mutex);
 	idr_remove(&nbd_index_idr, index);

drivers/block/null_blk/main.c+7−8

 }
 static inline blk_status_t null_handle_memory_backed(struct nullb_cmd *cmd,
-						     enum req_opf op,
+						     enum req_op op,
 						     sector_t sector,
 						     sector_t nr_sectors)
 {
 	}
 }
-blk_status_t null_process_cmd(struct nullb_cmd *cmd,
+blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
-			      enum req_opf op, sector_t sector,
+			      sector_t sector, unsigned int nr_sectors)
-			      unsigned int nr_sectors)
 {
 	struct nullb_device *dev = cmd->nq->dev;
 	blk_status_t ret;
 }
 static blk_status_t null_handle_cmd(struct nullb_cmd *cmd, sector_t sector,
-				    sector_t nr_sectors, enum req_opf op)
+				    sector_t nr_sectors, enum req_op op)
 {
 	struct nullb_device *dev = cmd->nq->dev;
 	struct nullb *nullb = dev->nullb;
 	return nr;
 }
-static enum blk_eh_timer_return null_timeout_rq(struct request *rq, bool res)
+static enum blk_eh_timer_return null_timeout_rq(struct request *rq)
 {
 	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;
 	struct nullb_cmd *cmd = blk_mq_rq_to_pdu(rq);
 		null_restart_queue_async(nullb);
 	}
-	blk_cleanup_disk(nullb->disk);
+	put_disk(nullb->disk);
 	if (dev->queue_mode == NULL_Q_MQ &&
 	    nullb->tag_set == &nullb->__tag_set)
 		blk_mq_free_tag_set(nullb->tag_set);
 out_cleanup_zone:
 	null_free_zoned_dev(dev);
 out_cleanup_disk:
-	blk_cleanup_disk(nullb->disk);
+	put_disk(nullb->disk);
 out_cleanup_tags:
 	if (dev->queue_mode == NULL_Q_MQ && nullb->tag_set == &nullb->__tag_set)
 		blk_mq_free_tag_set(nullb->tag_set);

drivers/block/null_blk/null_blk.h+5−7

 blk_status_t null_handle_discard(struct nullb_device *dev, sector_t sector,
 				 sector_t nr_sectors);
-blk_status_t null_process_cmd(struct nullb_cmd *cmd,
+blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
-			      enum req_opf op, sector_t sector,
+			      sector_t sector, unsigned int nr_sectors);
-			      unsigned int nr_sectors);
 #ifdef CONFIG_BLK_DEV_ZONED
 int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q);
 void null_free_zoned_dev(struct nullb_device *dev);
 int null_report_zones(struct gendisk *disk, sector_t sector,
 		      unsigned int nr_zones, report_zones_cb cb, void *data);
-blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd,
+blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
-				    enum req_opf op, sector_t sector,
+				    sector_t sector, sector_t nr_sectors);
-				    sector_t nr_sectors);
 size_t null_zone_valid_read_len(struct nullb *nullb,
 				sector_t sector, unsigned int len);
 #else
 }
 static inline void null_free_zoned_dev(struct nullb_device *dev) {}
 static inline blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd,
-			enum req_opf op, sector_t sector, sector_t nr_sectors)
+			enum req_op op, sector_t sector, sector_t nr_sectors)
 {
 	return BLK_STS_NOTSUPP;
 }

drivers/block/null_blk/trace.h+1−1

@@ -36,7 +36,7 @@ TRACE_EVENT(nullb_zone_op, · 35 unmodified lines
36	TP_ARGS(cmd, zone_no, zone_cond),	36	TP_ARGS(cmd, zone_no, zone_cond),
37	TP_STRUCT__entry(	37	TP_STRUCT__entry(
38	__array(char, disk, DISK_NAME_LEN)	38	__array(char, disk, DISK_NAME_LEN)
39	__field(enum req_opf, op)	39	__field(enum req_op, op)
40	__field(unsigned int, zone_no)	40	__field(unsigned int, zone_no)
41	__field(unsigned int, zone_cond)	41	__field(unsigned int, zone_cond)
42	),	42	),

drivers/block/null_blk/zoned.c+6−6

@@ -159,7 +159,7 @@ int null_register_zoned_dev(struct nullb *nullb) · 158 unmodified lines
159	struct nullb_device *dev = nullb->dev;	159	struct nullb_device *dev = nullb->dev;
160	struct request_queue *q = nullb->q;	160	struct request_queue *q = nullb->q;
161		161
162	blk_queue_set_zoned(nullb->disk, BLK_ZONED_HM);	162	disk_set_zoned(nullb->disk, BLK_ZONED_HM);
163	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);	163	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
164	blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE);	164	blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE);
165		165
@@ -170,12 +170,12 @@ int null_register_zoned_dev(struct nullb *nullb) · 4 unmodified lines
170	return ret;	170	return ret;
171	} else {	171	} else {
172	blk_queue_chunk_sectors(q, dev->zone_size_sects);	172	blk_queue_chunk_sectors(q, dev->zone_size_sects);
173	q->nr_zones = blkdev_nr_zones(nullb->disk);	173	nullb->disk->nr_zones = bdev_nr_zones(nullb->disk->part0);
174	}	174	}
175		175
176	blk_queue_max_zone_append_sectors(q, dev->zone_size_sects);	176	blk_queue_max_zone_append_sectors(q, dev->zone_size_sects);
177	blk_queue_max_open_zones(q, dev->zone_max_open);	177	disk_set_max_open_zones(nullb->disk, dev->zone_max_open);
178	blk_queue_max_active_zones(q, dev->zone_max_active);	178	disk_set_max_active_zones(nullb->disk, dev->zone_max_active);
179		179
180	return 0;	180	return 0;
181	}	181	}
@@ -600,7 +600,7 @@ static blk_status_t null_reset_zone(struct nullb_device *dev, · 418 unmodified lines
600	return BLK_STS_OK;	600	return BLK_STS_OK;
601	}	601	}
602		602
603	static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_opf op,	603	static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op,
604	sector_t sector)	604	sector_t sector)
605	{	605	{
606	struct nullb_device *dev = cmd->nq->dev;	606	struct nullb_device *dev = cmd->nq->dev;
@@ -653,7 +653,7 @@ static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_opf op, · 46 unmodified lines
653	return ret;	653	return ret;
654	}	654	}
655		655
656	blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_opf op,	656	blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
657	sector_t sector, sector_t nr_sectors)	657	sector_t sector, sector_t nr_sectors)
658	{	658	{
659	struct nullb_device *dev;	659	struct nullb_device *dev;

drivers/block/paride/pcd.c+2−2

@@ -956,7 +956,7 @@ out_unreg_cdrom: · 955 unmodified lines
956	out_pi_release:	956	out_pi_release:
957	pi_release(cd->pi);	957	pi_release(cd->pi);
958	out_free_disk:	958	out_free_disk:
959	blk_cleanup_disk(cd->disk);	959	put_disk(cd->disk);
960	out_free_tag_set:	960	out_free_tag_set:
961	blk_mq_free_tag_set(&cd->tag_set);	961	blk_mq_free_tag_set(&cd->tag_set);
962	return ret;	962	return ret;
@@ -1029,7 +1029,7 @@ static void __exit pcd_exit(void) · 66 unmodified lines
1029	unregister_cdrom(&cd->info);	1029	unregister_cdrom(&cd->info);
1030	del_gendisk(cd->disk);	1030	del_gendisk(cd->disk);
1031	pi_release(cd->pi);	1031	pi_release(cd->pi);
1032	blk_cleanup_disk(cd->disk);	1032	put_disk(cd->disk);
1033		1033
1034	blk_mq_free_tag_set(&cd->tag_set);	1034	blk_mq_free_tag_set(&cd->tag_set);
1035	}	1035	}

drivers/block/paride/pd.c+4−2

 			return do_pd_read_start();
 		else
 			return do_pd_write_start();
+	default:
+		break;
 	}
 	return Fail;
 }
 		goto cleanup_disk;
 	return 0;
 cleanup_disk:
-	blk_cleanup_disk(disk->gd);
+	put_disk(disk->gd);
 put_disk:
 	put_disk(p);
 	disk->gd = NULL;
 		if (p) {
 			disk->gd = NULL;
 			del_gendisk(p);
-			blk_cleanup_disk(p);
+			put_disk(p);
 			blk_mq_free_tag_set(&disk->tag_set);
 			pi_release(disk->pi);
 		}

drivers/block/paride/pf.c+2−2

@@ -975,7 +975,7 @@ static int __init pf_init_unit(struct pf_unit *pf, bool autoprobe, int port, · 974 unmodified lines
975	out_pi_release:	975	out_pi_release:
976	pi_release(pf->pi);	976	pi_release(pf->pi);
977	out_free_disk:	977	out_free_disk:
978	blk_cleanup_disk(pf->disk);	978	put_disk(pf->disk);
979	out_free_tag_set:	979	out_free_tag_set:
980	blk_mq_free_tag_set(&pf->tag_set);	980	blk_mq_free_tag_set(&pf->tag_set);
981	return ret;	981	return ret;
@@ -1044,7 +1044,7 @@ static void __exit pf_exit(void) · 62 unmodified lines
1044	if (!pf->present)	1044	if (!pf->present)
1045	continue;	1045	continue;
1046	del_gendisk(pf->disk);	1046	del_gendisk(pf->disk);
1047	blk_cleanup_disk(pf->disk);	1047	put_disk(pf->disk);
1048	blk_mq_free_tag_set(&pf->tag_set);	1048	blk_mq_free_tag_set(&pf->tag_set);
1049	pi_release(pf->pi);	1049	pi_release(pf->pi);
1050	}	1050	}

drivers/block/pktcdvd.c+5−9

 {
 	struct pktcdvd_device *pd = m->private;
 	char *msg;
-	char bdev_buf[BDEVNAME_SIZE];
 	int states[PACKET_NUM_STATES];
-	seq_printf(m, "Writer %s mapped to %s:\n", pd->name,
+	seq_printf(m, "Writer %s mapped to %pg:\n", pd->name, pd->bdev);
-		   bdevname(pd->bdev, bdev_buf));
 	seq_printf(m, "\nSettings:\n");
 	seq_printf(m, "\tpacket size:\t\t%dkB\n", pd->settings.size / 2);
 static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
 {
 	int i;
-	char b[BDEVNAME_SIZE];
 	struct block_device *bdev;
 	struct scsi_device *sdev;
 		if (!pd2)
 			continue;
 		if (pd2->bdev->bd_dev == dev) {
-			pkt_err(pd, "%s already setup\n",
+			pkt_err(pd, "%pg already setup\n", pd2->bdev);
-				bdevname(pd2->bdev, b));
 			return -EBUSY;
 		}
 		if (pd2->pkt_dev == dev) {
 	}
 	proc_create_single_data(pd->name, 0, pkt_proc, pkt_seq_show, pd);
-	pkt_dbg(1, pd, "writer mapped to %s\n", bdevname(bdev, b));
+	pkt_dbg(1, pd, "writer mapped to %pg\n", bdev);
 	return 0;
 out_mem:
 	return 0;
 out_mem2:
-	blk_cleanup_disk(disk);
+	put_disk(disk);
 out_mem:
 	mempool_exit(&pd->rb_pool);
 	kfree(pd);
 	pkt_dbg(1, pd, "writer unmapped\n");
 	del_gendisk(pd->disk);
-	blk_cleanup_disk(pd->disk);
+	put_disk(pd->disk);
 	mempool_exit(&pd->rb_pool);
 	kfree(pd);

drivers/block/ps3disk.c+2−2

@@ -473,7 +473,7 @@ static int ps3disk_probe(struct ps3_system_bus_device *_dev) · 472 unmodified lines
473		473
474	return 0;	474	return 0;
475	fail_cleanup_disk:	475	fail_cleanup_disk:
476	blk_cleanup_disk(gendisk);	476	put_disk(gendisk);
477	fail_free_tag_set:	477	fail_free_tag_set:
478	blk_mq_free_tag_set(&priv->tag_set);	478	blk_mq_free_tag_set(&priv->tag_set);
479	fail_teardown:	479	fail_teardown:
@@ -500,7 +500,7 @@ static void ps3disk_remove(struct ps3_system_bus_device *_dev) · 20 unmodified lines
500	&ps3disk_mask);	500	&ps3disk_mask);
501	mutex_unlock(&ps3disk_mask_mutex);	501	mutex_unlock(&ps3disk_mask_mutex);
502	del_gendisk(priv->gendisk);	502	del_gendisk(priv->gendisk);
503	blk_cleanup_disk(priv->gendisk);	503	put_disk(priv->gendisk);
504	blk_mq_free_tag_set(&priv->tag_set);	504	blk_mq_free_tag_set(&priv->tag_set);
505	dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");	505	dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");
506	ps3disk_sync_cache(dev);	506	ps3disk_sync_cache(dev);

drivers/block/ps3vram.c+2−2

@@ -761,7 +761,7 @@ static int ps3vram_probe(struct ps3_system_bus_device *dev) · 760 unmodified lines
761	return 0;	761	return 0;
762		762
763	out_cleanup_disk:	763	out_cleanup_disk:
764	blk_cleanup_disk(gendisk);	764	put_disk(gendisk);
765	out_cache_cleanup:	765	out_cache_cleanup:
766	remove_proc_entry(DEVICE_NAME, NULL);	766	remove_proc_entry(DEVICE_NAME, NULL);
767	ps3vram_cache_cleanup(dev);	767	ps3vram_cache_cleanup(dev);
@@ -792,7 +792,7 @@ static void ps3vram_remove(struct ps3_system_bus_device *dev) · 24 unmodified lines
792	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);	792	struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
793		793
794	del_gendisk(priv->gendisk);	794	del_gendisk(priv->gendisk);
795	blk_cleanup_disk(priv->gendisk);	795	put_disk(priv->gendisk);
796	remove_proc_entry(DEVICE_NAME, NULL);	796	remove_proc_entry(DEVICE_NAME, NULL);
797	ps3vram_cache_cleanup(dev);	797	ps3vram_cache_cleanup(dev);
798	iounmap(priv->reports);	798	iounmap(priv->reports);

drivers/block/rbd.c+1−1

@@ -4729,7 +4729,7 @@ static blk_status_t rbd_queue_rq(struct blk_mq_hw_ctx *hctx, · 4728 unmodified lines
4729		4729
4730	static void rbd_free_disk(struct rbd_device *rbd_dev)	4730	static void rbd_free_disk(struct rbd_device *rbd_dev)
4731	{	4731	{
4732	blk_cleanup_disk(rbd_dev->disk);	4732	put_disk(rbd_dev->disk);
4733	blk_mq_free_tag_set(&rbd_dev->tag_set);	4733	blk_mq_free_tag_set(&rbd_dev->tag_set);
4734	rbd_dev->disk = NULL;	4734	rbd_dev->disk = NULL;
4735	}	4735	}

drivers/block/rnbd/rnbd-clt.c+3−3

@@ -1408,7 +1408,7 @@ static int rnbd_clt_setup_gen_disk(struct rnbd_clt_dev *dev, int idx) · 1407 unmodified lines
1408	blk_queue_flag_set(QUEUE_FLAG_NONROT, dev->queue);	1408	blk_queue_flag_set(QUEUE_FLAG_NONROT, dev->queue);
1409	err = add_disk(dev->gd);	1409	err = add_disk(dev->gd);
1410	if (err)	1410	if (err)
1411	blk_cleanup_disk(dev->gd);	1411	put_disk(dev->gd);
1412		1412
1413	return err;	1413	return err;
1414	}	1414	}
@@ -1630,7 +1630,7 @@ put_sess: · 215 unmodified lines
1630	static void destroy_gen_disk(struct rnbd_clt_dev *dev)	1630	static void destroy_gen_disk(struct rnbd_clt_dev *dev)
1631	{	1631	{
1632	del_gendisk(dev->gd);	1632	del_gendisk(dev->gd);
1633	blk_cleanup_disk(dev->gd);	1633	put_disk(dev->gd);
1634	}	1634	}
1635		1635
1636	static void destroy_sysfs(struct rnbd_clt_dev *dev,	1636	static void destroy_sysfs(struct rnbd_clt_dev *dev,
@@ -1755,7 +1755,7 @@ static void rnbd_destroy_sessions(void) · 118 unmodified lines
1755	list_for_each_entry_safe(dev, tn, &sess->devs_list, list) {	1755	list_for_each_entry_safe(dev, tn, &sess->devs_list, list) {
1756	/*	1756	/*
1757	* Here unmap happens in parallel for only one reason:	1757	* Here unmap happens in parallel for only one reason:
1758	* blk_cleanup_queue() takes around half a second, so	1758	* del_gendisk() takes around half a second, so
1759	* on huge amount of devices the whole module unload	1759	* on huge amount of devices the whole module unload
1760	* procedure takes minutes.	1760	* procedure takes minutes.
1761	*/	1761	*/

drivers/block/rnbd/rnbd-proto.h+4−3

 	return true;
 }
-static inline u32 rnbd_to_bio_flags(u32 rnbd_opf)
+static inline blk_opf_t rnbd_to_bio_flags(u32 rnbd_opf)
 {
-	u32 bio_opf;
+	blk_opf_t bio_opf;
 	switch (rnbd_op(rnbd_opf)) {
 	case RNBD_OP_READ:
 		break;
 	default:
 		WARN(1, "Unknown request type %d (flags %llu)\n",
-		     req_op(rq), (unsigned long long)rq->cmd_flags);
+		     (__force u32)req_op(rq),
+		     (__force unsigned long long)rq->cmd_flags);
 		rnbd_opf = 0;
 	}

drivers/block/rnbd/rnbd-srv-dev.c+0−1

@@ -28,7 +28,6 @@ struct rnbd_dev rnbd_dev_open(const char path, fmode_t flags) · 27 unmodified lines
28	goto err;	28	goto err;
29		29
30	dev->blk_open_flags = flags;	30	dev->blk_open_flags = flags;
31	bdevname(dev->bdev, dev->name);
32		31
33	return dev;	32	return dev;
34		33

drivers/block/rnbd/rnbd-srv-dev.h+0−1

@@ -15,7 +15,6 @@ · 14 unmodified lines
15	struct rnbd_dev {	15	struct rnbd_dev {
16	struct block_device *bdev;	16	struct block_device *bdev;
17	fmode_t blk_open_flags;	17	fmode_t blk_open_flags;
18	char name[BDEVNAME_SIZE];
19	};	18	};
20		19
21	/**	20	/**

drivers/block/rnbd/rnbd-srv-sysfs.c+2−3

 };
 int rnbd_srv_create_dev_sysfs(struct rnbd_srv_dev *dev,
-			       struct block_device *bdev,
+			       struct block_device *bdev)
-			       const char *dev_name)
 {
 	struct kobject *bdev_kobj;
 	int ret;
 	ret = kobject_init_and_add(&dev->dev_kobj, &dev_ktype,
-				   rnbd_devs_kobj, dev_name);
+				   rnbd_devs_kobj, "%pg", bdev);
 	if (ret) {
 		kobject_put(&dev->dev_kobj);
 		return ret;

drivers/block/rnbd/rnbd-srv.c+4−5

 	return sess_dev;
 }
-static struct rnbd_srv_dev *rnbd_srv_init_srv_dev(const char *id)
+static struct rnbd_srv_dev *rnbd_srv_init_srv_dev(struct block_device *bdev)
 {
 	struct rnbd_srv_dev *dev;
 	if (!dev)
 		return ERR_PTR(-ENOMEM);
-	strscpy(dev->id, id, sizeof(dev->id));
+	snprintf(dev->id, sizeof(dev->id), "%pg", bdev);
 	kref_init(&dev->kref);
 	INIT_LIST_HEAD(&dev->sess_dev_list);
 	mutex_init(&dev->lock);
 	int ret;
 	struct rnbd_srv_dev *new_dev, *dev;
-	new_dev = rnbd_srv_init_srv_dev(rnbd_dev->name);
+	new_dev = rnbd_srv_init_srv_dev(rnbd_dev->bdev);
 	if (IS_ERR(new_dev))
 		return new_dev;
 	 */
 	mutex_lock(&srv_dev->lock);
 	if (!srv_dev->dev_kobj.state_in_sysfs) {
-		ret = rnbd_srv_create_dev_sysfs(srv_dev, rnbd_dev->bdev,
+		ret = rnbd_srv_create_dev_sysfs(srv_dev, rnbd_dev->bdev);
-						 rnbd_dev->name);
 		if (ret) {
 			mutex_unlock(&srv_dev->lock);
 			rnbd_srv_err(srv_sess_dev,

drivers/block/rnbd/rnbd-srv.h+1−2

@@ -68,8 +68,7 @@ void rnbd_srv_sess_dev_force_close(struct rnbd_srv_sess_dev *sess_dev, · 67 unmodified lines
68	/* rnbd-srv-sysfs.c */	68	/* rnbd-srv-sysfs.c */
69		69
70	int rnbd_srv_create_dev_sysfs(struct rnbd_srv_dev *dev,	70	int rnbd_srv_create_dev_sysfs(struct rnbd_srv_dev *dev,
71	struct block_device *bdev,	71	struct block_device *bdev);
72	const char *dir_name);
73	void rnbd_srv_destroy_dev_sysfs(struct rnbd_srv_dev *dev);	72	void rnbd_srv_destroy_dev_sysfs(struct rnbd_srv_dev *dev);
74	int rnbd_srv_create_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev);	73	int rnbd_srv_create_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev);
75	void rnbd_srv_destroy_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev);	74	void rnbd_srv_destroy_dev_session_sysfs(struct rnbd_srv_sess_dev *sess_dev);

drivers/block/sunvdc.c+2−2

@@ -886,7 +886,7 @@ static int probe_disk(struct vdc_port *port) · 885 unmodified lines
886	return 0;	886	return 0;
887		887
888	out_cleanup_disk:	888	out_cleanup_disk:
889	blk_cleanup_disk(g);	889	put_disk(g);
890	out_free_tag:	890	out_free_tag:
891	blk_mq_free_tag_set(&port->tag_set);	891	blk_mq_free_tag_set(&port->tag_set);
892	return err;	892	return err;
@@ -1070,7 +1070,7 @@ static void vdc_port_remove(struct vio_dev *vdev) · 177 unmodified lines
1070	del_timer_sync(&port->vio.timer);	1070	del_timer_sync(&port->vio.timer);
1071		1071
1072	del_gendisk(port->disk);	1072	del_gendisk(port->disk);
1073	blk_cleanup_disk(port->disk);	1073	put_disk(port->disk);
1074	blk_mq_free_tag_set(&port->tag_set);	1074	blk_mq_free_tag_set(&port->tag_set);
1075		1075
1076	vdc_free_tx_ring(port);	1076	vdc_free_tx_ring(port);

drivers/block/swim.c+1−1

@@ -783,7 +783,7 @@ static void swim_cleanup_floppy_disk(struct floppy_state *fs) · 782 unmodified lines
783	if (fs->registered)	783	if (fs->registered)
784	del_gendisk(fs->disk);	784	del_gendisk(fs->disk);
785		785
786	blk_cleanup_disk(disk);	786	put_disk(disk);
787	blk_mq_free_tag_set(&fs->tag_set);	787	blk_mq_free_tag_set(&fs->tag_set);
788	}	788	}
789		789

drivers/block/swim3.c+1−1

@@ -1238,7 +1238,7 @@ static int swim3_attach(struct macio_dev *mdev, · 1237 unmodified lines
1238	return 0;	1238	return 0;
1239		1239
1240	out_cleanup_disk:	1240	out_cleanup_disk:
1241	blk_cleanup_disk(disk);	1241	put_disk(disk);
1242	out_free_tag_set:	1242	out_free_tag_set:
1243	blk_mq_free_tag_set(&fs->tag_set);	1243	blk_mq_free_tag_set(&fs->tag_set);
1244	out_unregister:	1244	out_unregister:

drivers/block/sx8.c+3−3

@@ -1377,7 +1377,7 @@ static void carm_free_disk(struct carm_host *host, unsigned int port_no) · 1376 unmodified lines
1377		1377
1378	if (host->state > HST_DEV_ACTIVATE)	1378	if (host->state > HST_DEV_ACTIVATE)
1379	del_gendisk(disk);	1379	del_gendisk(disk);
1380	blk_cleanup_disk(disk);	1380	put_disk(disk);
1381	}	1381	}
1382		1382
1383	static int carm_init_shm(struct carm_host *host)	1383	static int carm_init_shm(struct carm_host *host)
@@ -1536,7 +1536,7 @@ err_out_free_majors: · 152 unmodified lines
1536	clear_bit(0, &carm_major_alloc);	1536	clear_bit(0, &carm_major_alloc);
1537	else if (host->major == 161)	1537	else if (host->major == 161)
1538	clear_bit(1, &carm_major_alloc);	1538	clear_bit(1, &carm_major_alloc);
1539	blk_cleanup_queue(host->oob_q);	1539	blk_mq_destroy_queue(host->oob_q);
1540	blk_mq_free_tag_set(&host->tag_set);	1540	blk_mq_free_tag_set(&host->tag_set);
1541	err_out_dma_free:	1541	err_out_dma_free:
1542	dma_free_coherent(&pdev->dev, CARM_SHM_SIZE, host->shm, host->shm_dma);	1542	dma_free_coherent(&pdev->dev, CARM_SHM_SIZE, host->shm, host->shm_dma);
@@ -1570,7 +1570,7 @@ static void carm_remove_one (struct pci_dev *pdev) · 27 unmodified lines
1570	clear_bit(0, &carm_major_alloc);	1570	clear_bit(0, &carm_major_alloc);
1571	else if (host->major == 161)	1571	else if (host->major == 161)
1572	clear_bit(1, &carm_major_alloc);	1572	clear_bit(1, &carm_major_alloc);
1573	blk_cleanup_queue(host->oob_q);	1573	blk_mq_destroy_queue(host->oob_q);
1574	blk_mq_free_tag_set(&host->tag_set);	1574	blk_mq_free_tag_set(&host->tag_set);
1575	dma_free_coherent(&pdev->dev, CARM_SHM_SIZE, host->shm, host->shm_dma);	1575	dma_free_coherent(&pdev->dev, CARM_SHM_SIZE, host->shm, host->shm_dma);
1576	iounmap(host->mmio);	1576	iounmap(host->mmio);

drivers/block/ublk_drv.c+1545−0

@@ -0,0 +1,1545 @@
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Userspace block device - block device which IO is handled from userspace
	4	*
	5	* Take full use of io_uring passthrough command for communicating with
	6	* ublk userspace daemon(ublksrvd) for handling basic IO request.
	7	*
	8	* Copyright 2022 Ming Lei <ming.lei@redhat.com>
	9	*
	10	* (part of code stolen from loop.c)
	11	*/
	12	#include <linux/module.h>
	13	#include <linux/moduleparam.h>
	14	#include <linux/sched.h>
	15	#include <linux/fs.h>
	16	#include <linux/pagemap.h>
	17	#include <linux/file.h>
	18	#include <linux/stat.h>
	19	#include <linux/errno.h>
	20	#include <linux/major.h>
	21	#include <linux/wait.h>
	22	#include <linux/blkdev.h>
	23	#include <linux/init.h>
	24	#include <linux/swap.h>
	25	#include <linux/slab.h>
	26	#include <linux/compat.h>
	27	#include <linux/mutex.h>
	28	#include <linux/writeback.h>
	29	#include <linux/completion.h>
	30	#include <linux/highmem.h>
	31	#include <linux/sysfs.h>
	32	#include <linux/miscdevice.h>
	33	#include <linux/falloc.h>
	34	#include <linux/uio.h>
	35	#include <linux/ioprio.h>
	36	#include <linux/sched/mm.h>
	37	#include <linux/uaccess.h>
	38	#include <linux/cdev.h>
	39	#include <linux/io_uring.h>
	40	#include <linux/blk-mq.h>
	41	#include <linux/delay.h>
	42	#include <linux/mm.h>
	43	#include <asm/page.h>
	44	#include <linux/task_work.h>
	45	#include <uapi/linux/ublk_cmd.h>
	46
	47	#define UBLK_MINORS (1U << MINORBITS)
	48
	49	/* All UBLK_F_* have to be included into UBLK_F_ALL */
	50	#define UBLK_F_ALL (UBLK_F_SUPPORT_ZERO_COPY \| UBLK_F_URING_CMD_COMP_IN_TASK)
	51
	52	struct ublk_rq_data {
	53	struct callback_head work;
	54	};
	55
	56	struct ublk_uring_cmd_pdu {
	57	struct request *req;
	58	};
	59
	60	/*
	61	* io command is active: sqe cmd is received, and its cqe isn't done
	62	*
	63	* If the flag is set, the io command is owned by ublk driver, and waited
	64	* for incoming blk-mq request from the ublk block device.
	65	*
	66	* If the flag is cleared, the io command will be completed, and owned by
	67	* ublk server.
	68	*/
	69	#define UBLK_IO_FLAG_ACTIVE 0x01
	70
	71	/*
	72	* IO command is completed via cqe, and it is being handled by ublksrv, and
	73	* not committed yet
	74	*
	75	* Basically exclusively with UBLK_IO_FLAG_ACTIVE, so can be served for
	76	* cross verification
	77	*/
	78	#define UBLK_IO_FLAG_OWNED_BY_SRV 0x02
	79
	80	/*
	81	* IO command is aborted, so this flag is set in case of
	82	* !UBLK_IO_FLAG_ACTIVE.
	83	*
	84	* After this flag is observed, any pending or new incoming request
	85	* associated with this io command will be failed immediately
	86	*/
	87	#define UBLK_IO_FLAG_ABORTED 0x04
	88
	89	struct ublk_io {
	90	/* userspace buffer address from io cmd */
	91	__u64 addr;
	92	unsigned int flags;
	93	int res;
	94
	95	struct io_uring_cmd *cmd;
	96	};
	97
	98	struct ublk_queue {
	99	int q_id;
	100	int q_depth;
	101
	102	unsigned long flags;
	103	struct task_struct *ubq_daemon;
	104	char *io_cmd_buf;
	105
	106	unsigned long io_addr; /* mapped vm address */
	107	unsigned int max_io_sz;
	108	bool abort_work_pending;
	109	unsigned short nr_io_ready; /* how many ios setup */
	110	struct ublk_device *dev;
	111	struct ublk_io ios[0];
	112	};
	113
	114	#define UBLK_DAEMON_MONITOR_PERIOD (5 * HZ)
	115
	116	struct ublk_device {
	117	struct gendisk *ub_disk;
	118
	119	char *__queues;
	120
	121	unsigned short queue_size;
	122	unsigned short bs_shift;
	123	struct ublksrv_ctrl_dev_info dev_info;
	124
	125	struct blk_mq_tag_set tag_set;
	126
	127	struct cdev cdev;
	128	struct device cdev_dev;
	129
	130	#define UB_STATE_OPEN 0
	131	#define UB_STATE_USED 1
	132	unsigned long state;
	133	int ub_number;
	134
	135	struct mutex mutex;
	136
	137	spinlock_t mm_lock;
	138	struct mm_struct *mm;
	139
	140	struct completion completion;
	141	unsigned int nr_queues_ready;
	142	atomic_t nr_aborted_queues;
	143
	144	/*
	145	* Our ubq->daemon may be killed without any notification, so
	146	* monitor each queue's daemon periodically
	147	*/
	148	struct delayed_work monitor_work;
	149	struct work_struct stop_work;
	150	};
	151
	152	static dev_t ublk_chr_devt;
	153	static struct class *ublk_chr_class;
	154
	155	static DEFINE_IDR(ublk_index_idr);
	156	static DEFINE_SPINLOCK(ublk_idr_lock);
	157	static wait_queue_head_t ublk_idr_wq; /* wait until one idr is freed */
	158
	159	static DEFINE_MUTEX(ublk_ctl_mutex);
	160
	161	static struct miscdevice ublk_misc;
	162
	163	static inline bool ublk_can_use_task_work(const struct ublk_queue *ubq)
	164	{
	165	if (IS_BUILTIN(CONFIG_BLK_DEV_UBLK) &&
	166	!(ubq->flags & UBLK_F_URING_CMD_COMP_IN_TASK))
	167	return true;
	168	return false;
	169	}
	170
	171	static struct ublk_device ublk_get_device(struct ublk_device ub)
	172	{
	173	if (kobject_get_unless_zero(&ub->cdev_dev.kobj))
	174	return ub;
	175	return NULL;
	176	}
	177
	178	static void ublk_put_device(struct ublk_device *ub)
	179	{
	180	put_device(&ub->cdev_dev);
	181	}
	182
	183	static inline struct ublk_queue ublk_get_queue(struct ublk_device dev,
	184	int qid)
	185	{
	186	return (struct ublk_queue )&(dev->__queues[qid dev->queue_size]);
	187	}
	188
	189	static inline bool ublk_rq_has_data(const struct request *rq)
	190	{
	191	return rq->bio && bio_has_data(rq->bio);
	192	}
	193
	194	static inline struct ublksrv_io_desc ublk_get_iod(struct ublk_queue ubq,
	195	int tag)
	196	{
	197	return (struct ublksrv_io_desc *)
	198	&(ubq->io_cmd_buf[tag * sizeof(struct ublksrv_io_desc)]);
	199	}
	200
	201	static inline char ublk_queue_cmd_buf(struct ublk_device ub, int q_id)
	202	{
	203	return ublk_get_queue(ub, q_id)->io_cmd_buf;
	204	}
	205
	206	static inline int ublk_queue_cmd_buf_size(struct ublk_device *ub, int q_id)
	207	{
	208	struct ublk_queue *ubq = ublk_get_queue(ub, q_id);
	209
	210	return round_up(ubq->q_depth * sizeof(struct ublksrv_io_desc),
	211	PAGE_SIZE);
	212	}
	213
	214	static void ublk_free_disk(struct gendisk *disk)
	215	{
	216	struct ublk_device *ub = disk->private_data;
	217
	218	clear_bit(UB_STATE_USED, &ub->state);
	219	put_device(&ub->cdev_dev);
	220	}
	221
	222	static const struct block_device_operations ub_fops = {
	223	.owner = THIS_MODULE,
	224	.free_disk = ublk_free_disk,
	225	};
	226
	227	#define UBLK_MAX_PIN_PAGES 32
	228
	229	struct ublk_map_data {
	230	const struct ublk_queue *ubq;
	231	const struct request *rq;
	232	const struct ublk_io *io;
	233	unsigned max_bytes;
	234	};
	235
	236	struct ublk_io_iter {
	237	struct page *pages[UBLK_MAX_PIN_PAGES];
	238	unsigned pg_off; /* offset in the 1st page in pages */
	239	int nr_pages; /* how many page pointers in pages */
	240	struct bio *bio;
	241	struct bvec_iter iter;
	242	};
	243
	244	static inline unsigned ublk_copy_io_pages(struct ublk_io_iter *data,
	245	unsigned max_bytes, bool to_vm)
	246	{
	247	const unsigned total = min_t(unsigned, max_bytes,
	248	PAGE_SIZE - data->pg_off +
	249	((data->nr_pages - 1) << PAGE_SHIFT));
	250	unsigned done = 0;
	251	unsigned pg_idx = 0;
	252
	253	while (done < total) {
	254	struct bio_vec bv = bio_iter_iovec(data->bio, data->iter);
	255	const unsigned int bytes = min3(bv.bv_len, total - done,
	256	(unsigned)(PAGE_SIZE - data->pg_off));
	257	void *bv_buf = bvec_kmap_local(&bv);
	258	void *pg_buf = kmap_local_page(data->pages[pg_idx]);
	259
	260	if (to_vm)
	261	memcpy(pg_buf + data->pg_off, bv_buf, bytes);
	262	else
	263	memcpy(bv_buf, pg_buf + data->pg_off, bytes);
	264
	265	kunmap_local(pg_buf);
	266	kunmap_local(bv_buf);
	267
	268	/* advance page array */
	269	data->pg_off += bytes;
	270	if (data->pg_off == PAGE_SIZE) {
	271	pg_idx += 1;
	272	data->pg_off = 0;
	273	}
	274
	275	done += bytes;
	276
	277	/* advance bio */
	278	bio_advance_iter_single(data->bio, &data->iter, bytes);
	279	if (!data->iter.bi_size) {
	280	data->bio = data->bio->bi_next;
	281	if (data->bio == NULL)
	282	break;
	283	data->iter = data->bio->bi_iter;
	284	}
	285	}
	286
	287	return done;
	288	}
	289
	290	static inline int ublk_copy_user_pages(struct ublk_map_data *data,
	291	bool to_vm)
	292	{
	293	const unsigned int gup_flags = to_vm ? FOLL_WRITE : 0;
	294	const unsigned long start_vm = data->io->addr;
	295	unsigned int done = 0;
	296	struct ublk_io_iter iter = {
	297	.pg_off = start_vm & (PAGE_SIZE - 1),
	298	.bio = data->rq->bio,
	299	.iter = data->rq->bio->bi_iter,
	300	};
	301	const unsigned int nr_pages = round_up(data->max_bytes +
	302	(start_vm & (PAGE_SIZE - 1)), PAGE_SIZE) >> PAGE_SHIFT;
	303
	304	while (done < nr_pages) {
	305	const unsigned to_pin = min_t(unsigned, UBLK_MAX_PIN_PAGES,
	306	nr_pages - done);
	307	unsigned i, len;
	308
	309	iter.nr_pages = get_user_pages_fast(start_vm +
	310	(done << PAGE_SHIFT), to_pin, gup_flags,
	311	iter.pages);
	312	if (iter.nr_pages <= 0)
	313	return done == 0 ? iter.nr_pages : done;
	314	len = ublk_copy_io_pages(&iter, data->max_bytes, to_vm);
	315	for (i = 0; i < iter.nr_pages; i++) {
	316	if (to_vm)
	317	set_page_dirty(iter.pages[i]);
	318	put_page(iter.pages[i]);
	319	}
	320	data->max_bytes -= len;
	321	done += iter.nr_pages;
	322	}
	323
	324	return done;
	325	}
	326
	327	static int ublk_map_io(const struct ublk_queue ubq, const struct request req,
	328	struct ublk_io *io)
	329	{
	330	const unsigned int rq_bytes = blk_rq_bytes(req);
	331	/*
	332	* no zero copy, we delay copy WRITE request data into ublksrv
	333	* context and the big benefit is that pinning pages in current
	334	* context is pretty fast, see ublk_pin_user_pages
	335	*/
	336	if (req_op(req) != REQ_OP_WRITE && req_op(req) != REQ_OP_FLUSH)
	337	return rq_bytes;
	338
	339	if (ublk_rq_has_data(req)) {
	340	struct ublk_map_data data = {
	341	.ubq = ubq,
	342	.rq = req,
	343	.io = io,
	344	.max_bytes = rq_bytes,
	345	};
	346
	347	ublk_copy_user_pages(&data, true);
	348
	349	return rq_bytes - data.max_bytes;
	350	}
	351	return rq_bytes;
	352	}
	353
	354	static int ublk_unmap_io(const struct ublk_queue *ubq,
	355	const struct request *req,
	356	struct ublk_io *io)
	357	{
	358	const unsigned int rq_bytes = blk_rq_bytes(req);
	359
	360	if (req_op(req) == REQ_OP_READ && ublk_rq_has_data(req)) {
	361	struct ublk_map_data data = {
	362	.ubq = ubq,
	363	.rq = req,
	364	.io = io,
	365	.max_bytes = io->res,
	366	};
	367
	368	WARN_ON_ONCE(io->res > rq_bytes);
	369
	370	ublk_copy_user_pages(&data, false);
	371
	372	return io->res - data.max_bytes;
	373	}
	374	return rq_bytes;
	375	}
	376
	377	static inline unsigned int ublk_req_build_flags(struct request *req)
	378	{
	379	unsigned flags = 0;
	380
	381	if (req->cmd_flags & REQ_FAILFAST_DEV)
	382	flags \|= UBLK_IO_F_FAILFAST_DEV;
	383
	384	if (req->cmd_flags & REQ_FAILFAST_TRANSPORT)
	385	flags \|= UBLK_IO_F_FAILFAST_TRANSPORT;
	386
	387	if (req->cmd_flags & REQ_FAILFAST_DRIVER)
	388	flags \|= UBLK_IO_F_FAILFAST_DRIVER;
	389
	390	if (req->cmd_flags & REQ_META)
	391	flags \|= UBLK_IO_F_META;
	392
	393	if (req->cmd_flags & REQ_FUA)
	394	flags \|= UBLK_IO_F_FUA;
	395
	396	if (req->cmd_flags & REQ_NOUNMAP)
	397	flags \|= UBLK_IO_F_NOUNMAP;
	398
	399	if (req->cmd_flags & REQ_SWAP)
	400	flags \|= UBLK_IO_F_SWAP;
	401
	402	return flags;
	403	}
	404
	405	static blk_status_t ublk_setup_iod(struct ublk_queue ubq, struct request req)
	406	{
	407	struct ublksrv_io_desc *iod = ublk_get_iod(ubq, req->tag);
	408	struct ublk_io *io = &ubq->ios[req->tag];
	409	u32 ublk_op;
	410
	411	switch (req_op(req)) {
	412	case REQ_OP_READ:
	413	ublk_op = UBLK_IO_OP_READ;
	414	break;
	415	case REQ_OP_WRITE:
	416	ublk_op = UBLK_IO_OP_WRITE;
	417	break;
	418	case REQ_OP_FLUSH:
	419	ublk_op = UBLK_IO_OP_FLUSH;
	420	break;
	421	case REQ_OP_DISCARD:
	422	ublk_op = UBLK_IO_OP_DISCARD;
	423	break;
	424	case REQ_OP_WRITE_ZEROES:
	425	ublk_op = UBLK_IO_OP_WRITE_ZEROES;
	426	break;
	427	default:
	428	return BLK_STS_IOERR;
	429	}
	430
	431	/* need to translate since kernel may change */
	432	iod->op_flags = ublk_op \| ublk_req_build_flags(req);
	433	iod->nr_sectors = blk_rq_sectors(req);
	434	iod->start_sector = blk_rq_pos(req);
	435	iod->addr = io->addr;
	436
	437	return BLK_STS_OK;
	438	}
	439
	440	static inline struct ublk_uring_cmd_pdu *ublk_get_uring_cmd_pdu(
	441	struct io_uring_cmd *ioucmd)
	442	{
	443	return (struct ublk_uring_cmd_pdu *)&ioucmd->pdu;
	444	}
	445
	446	static bool ubq_daemon_is_dying(struct ublk_queue *ubq)
	447	{
	448	return ubq->ubq_daemon->flags & PF_EXITING;
	449	}
	450
	451	/* todo: handle partial completion */
	452	static void ublk_complete_rq(struct request *req)
	453	{
	454	struct ublk_queue *ubq = req->mq_hctx->driver_data;
	455	struct ublk_io *io = &ubq->ios[req->tag];
	456	unsigned int unmapped_bytes;
	457
	458	/* failed read IO if nothing is read */
	459	if (!io->res && req_op(req) == REQ_OP_READ)
	460	io->res = -EIO;
	461
	462	if (io->res < 0) {
	463	blk_mq_end_request(req, errno_to_blk_status(io->res));
	464	return;
	465	}
	466
	467	/*
	468	* FLUSH or DISCARD usually won't return bytes returned, so end them
	469	* directly.
	470	*
	471	* Both the two needn't unmap.
	472	*/
	473	if (req_op(req) != REQ_OP_READ && req_op(req) != REQ_OP_WRITE) {
	474	blk_mq_end_request(req, BLK_STS_OK);
	475	return;
	476	}
	477
	478	/* for READ request, writing data in iod->addr to rq buffers */
	479	unmapped_bytes = ublk_unmap_io(ubq, req, io);
	480
	481	/*
	482	* Extremely impossible since we got data filled in just before
	483	*
	484	* Re-read simply for this unlikely case.
	485	*/
	486	if (unlikely(unmapped_bytes < io->res))
	487	io->res = unmapped_bytes;
	488
	489	if (blk_update_request(req, BLK_STS_OK, io->res))
	490	blk_mq_requeue_request(req, true);
	491	else
	492	__blk_mq_end_request(req, BLK_STS_OK);
	493	}
	494
	495	/*
	496	* __ublk_fail_req() may be called from abort context or ->ubq_daemon
	497	* context during exiting, so lock is required.
	498	*
	499	* Also aborting may not be started yet, keep in mind that one failed
	500	* request may be issued by block layer again.
	501	*/
	502	static void __ublk_fail_req(struct ublk_io io, struct request req)
	503	{
	504	WARN_ON_ONCE(io->flags & UBLK_IO_FLAG_ACTIVE);
	505
	506	if (!(io->flags & UBLK_IO_FLAG_ABORTED)) {
	507	io->flags \|= UBLK_IO_FLAG_ABORTED;
	508	blk_mq_end_request(req, BLK_STS_IOERR);
	509	}
	510	}
	511
	512	#define UBLK_REQUEUE_DELAY_MS 3
	513
	514	static inline void __ublk_rq_task_work(struct request *req)
	515	{
	516	struct ublk_queue *ubq = req->mq_hctx->driver_data;
	517	struct ublk_device *ub = ubq->dev;
	518	int tag = req->tag;
	519	struct ublk_io *io = &ubq->ios[tag];
	520	bool task_exiting = current != ubq->ubq_daemon \|\|
	521	(current->flags & PF_EXITING);
	522	unsigned int mapped_bytes;
	523
	524	pr_devel("%s: complete: op %d, qid %d tag %d io_flags %x addr %llx\n",
	525	__func__, io->cmd->cmd_op, ubq->q_id, req->tag, io->flags,
	526	ublk_get_iod(ubq, req->tag)->addr);
	527
	528	if (unlikely(task_exiting)) {
	529	blk_mq_end_request(req, BLK_STS_IOERR);
	530	mod_delayed_work(system_wq, &ub->monitor_work, 0);
	531	return;
	532	}
	533
	534	mapped_bytes = ublk_map_io(ubq, req, io);
	535
	536	/* partially mapped, update io descriptor */
	537	if (unlikely(mapped_bytes != blk_rq_bytes(req))) {
	538	/*
	539	* Nothing mapped, retry until we succeed.
	540	*
	541	* We may never succeed in mapping any bytes here because
	542	* of OOM. TODO: reserve one buffer with single page pinned
	543	* for providing forward progress guarantee.
	544	*/
	545	if (unlikely(!mapped_bytes)) {
	546	blk_mq_requeue_request(req, false);
	547	blk_mq_delay_kick_requeue_list(req->q,
	548	UBLK_REQUEUE_DELAY_MS);
	549	return;
	550	}
	551
	552	ublk_get_iod(ubq, req->tag)->nr_sectors =
	553	mapped_bytes >> 9;
	554	}
	555
	556	/* mark this cmd owned by ublksrv */
	557	io->flags \|= UBLK_IO_FLAG_OWNED_BY_SRV;
	558
	559	/*
	560	* clear ACTIVE since we are done with this sqe/cmd slot
	561	* We can only accept io cmd in case of being not active.
	562	*/
	563	io->flags &= ~UBLK_IO_FLAG_ACTIVE;
	564
	565	/* tell ublksrv one io request is coming */
	566	io_uring_cmd_done(io->cmd, UBLK_IO_RES_OK, 0);
	567	}
	568
	569	static void ublk_rq_task_work_cb(struct io_uring_cmd *cmd)
	570	{
	571	struct ublk_uring_cmd_pdu *pdu = ublk_get_uring_cmd_pdu(cmd);
	572
	573	__ublk_rq_task_work(pdu->req);
	574	}
	575
	576	static void ublk_rq_task_work_fn(struct callback_head *work)
	577	{
	578	struct ublk_rq_data *data = container_of(work,
	579	struct ublk_rq_data, work);
	580	struct request *req = blk_mq_rq_from_pdu(data);
	581
	582	__ublk_rq_task_work(req);
	583	}
	584
	585	static blk_status_t ublk_queue_rq(struct blk_mq_hw_ctx *hctx,
	586	const struct blk_mq_queue_data *bd)
	587	{
	588	struct ublk_queue *ubq = hctx->driver_data;
	589	struct request *rq = bd->rq;
	590	blk_status_t res;
	591
	592	/* fill iod to slot in io cmd buffer */
	593	res = ublk_setup_iod(ubq, rq);
	594	if (unlikely(res != BLK_STS_OK))
	595	return BLK_STS_IOERR;
	596
	597	blk_mq_start_request(bd->rq);
	598
	599	if (unlikely(ubq_daemon_is_dying(ubq))) {
	600	fail:
	601	mod_delayed_work(system_wq, &ubq->dev->monitor_work, 0);
	602	return BLK_STS_IOERR;
	603	}
	604
	605	if (ublk_can_use_task_work(ubq)) {
	606	struct ublk_rq_data *data = blk_mq_rq_to_pdu(rq);
	607	enum task_work_notify_mode notify_mode = bd->last ?
	608	TWA_SIGNAL_NO_IPI : TWA_NONE;
	609
	610	if (task_work_add(ubq->ubq_daemon, &data->work, notify_mode))
	611	goto fail;
	612	} else {
	613	struct io_uring_cmd *cmd = ubq->ios[rq->tag].cmd;
	614	struct ublk_uring_cmd_pdu *pdu = ublk_get_uring_cmd_pdu(cmd);
	615
	616	pdu->req = rq;
	617	io_uring_cmd_complete_in_task(cmd, ublk_rq_task_work_cb);
	618	}
	619
	620	return BLK_STS_OK;
	621	}
	622
	623	static void ublk_commit_rqs(struct blk_mq_hw_ctx *hctx)
	624	{
	625	struct ublk_queue *ubq = hctx->driver_data;
	626
	627	if (ublk_can_use_task_work(ubq))
	628	__set_notify_signal(ubq->ubq_daemon);
	629	}
	630
	631	static int ublk_init_hctx(struct blk_mq_hw_ctx hctx, void driver_data,
	632	unsigned int hctx_idx)
	633	{
	634	struct ublk_device *ub = driver_data;
	635	struct ublk_queue *ubq = ublk_get_queue(ub, hctx->queue_num);
	636
	637	hctx->driver_data = ubq;
	638	return 0;
	639	}
	640
	641	static int ublk_init_rq(struct blk_mq_tag_set set, struct request req,
	642	unsigned int hctx_idx, unsigned int numa_node)
	643	{
	644	struct ublk_rq_data *data = blk_mq_rq_to_pdu(req);
	645
	646	init_task_work(&data->work, ublk_rq_task_work_fn);
	647	return 0;
	648	}
	649
	650	static const struct blk_mq_ops ublk_mq_ops = {
	651	.queue_rq = ublk_queue_rq,
	652	.commit_rqs = ublk_commit_rqs,
	653	.init_hctx = ublk_init_hctx,
	654	.init_request = ublk_init_rq,
	655	};
	656
	657	static int ublk_ch_open(struct inode inode, struct file filp)
	658	{
	659	struct ublk_device *ub = container_of(inode->i_cdev,
	660	struct ublk_device, cdev);
	661
	662	if (test_and_set_bit(UB_STATE_OPEN, &ub->state))
	663	return -EBUSY;
	664	filp->private_data = ub;
	665	return 0;
	666	}
	667
	668	static int ublk_ch_release(struct inode inode, struct file filp)
	669	{
	670	struct ublk_device *ub = filp->private_data;
	671
	672	clear_bit(UB_STATE_OPEN, &ub->state);
	673	return 0;
	674	}
	675
	676	/* map pre-allocated per-queue cmd buffer to ublksrv daemon */
	677	static int ublk_ch_mmap(struct file filp, struct vm_area_struct vma)
	678	{
	679	struct ublk_device *ub = filp->private_data;
	680	size_t sz = vma->vm_end - vma->vm_start;
	681	unsigned max_sz = UBLK_MAX_QUEUE_DEPTH * sizeof(struct ublksrv_io_desc);
	682	unsigned long pfn, end, phys_off = vma->vm_pgoff << PAGE_SHIFT;
	683	int q_id, ret = 0;
	684
	685	spin_lock(&ub->mm_lock);
	686	if (!ub->mm)
	687	ub->mm = current->mm;
	688	if (current->mm != ub->mm)
	689	ret = -EINVAL;
	690	spin_unlock(&ub->mm_lock);
	691
	692	if (ret)
	693	return ret;
	694
	695	if (vma->vm_flags & VM_WRITE)
	696	return -EPERM;
	697
	698	end = UBLKSRV_CMD_BUF_OFFSET + ub->dev_info.nr_hw_queues * max_sz;
	699	if (phys_off < UBLKSRV_CMD_BUF_OFFSET \|\| phys_off >= end)
	700	return -EINVAL;
	701
	702	q_id = (phys_off - UBLKSRV_CMD_BUF_OFFSET) / max_sz;
	703	pr_devel("%s: qid %d, pid %d, addr %lx pg_off %lx sz %lu\n",
	704	__func__, q_id, current->pid, vma->vm_start,
	705	phys_off, (unsigned long)sz);
	706
	707	if (sz != ublk_queue_cmd_buf_size(ub, q_id))
	708	return -EINVAL;
	709
	710	pfn = virt_to_phys(ublk_queue_cmd_buf(ub, q_id)) >> PAGE_SHIFT;
	711	return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
	712	}
	713
	714	static void ublk_commit_completion(struct ublk_device *ub,
	715	struct ublksrv_io_cmd *ub_cmd)
	716	{
	717	u32 qid = ub_cmd->q_id, tag = ub_cmd->tag;
	718	struct ublk_queue *ubq = ublk_get_queue(ub, qid);
	719	struct ublk_io *io = &ubq->ios[tag];
	720	struct request *req;
	721
	722	/* now this cmd slot is owned by nbd driver */
	723	io->flags &= ~UBLK_IO_FLAG_OWNED_BY_SRV;
	724	io->res = ub_cmd->result;
	725
	726	/* find the io request and complete */
	727	req = blk_mq_tag_to_rq(ub->tag_set.tags[qid], tag);
	728
	729	if (req && likely(!blk_should_fake_timeout(req->q)))
	730	ublk_complete_rq(req);
	731	}
	732
	733	/*
	734	* When ->ubq_daemon is exiting, either new request is ended immediately,
	735	* or any queued io command is drained, so it is safe to abort queue
	736	* lockless
	737	*/
	738	static void ublk_abort_queue(struct ublk_device ub, struct ublk_queue ubq)
	739	{
	740	int i;
	741
	742	if (!ublk_get_device(ub))
	743	return;
	744
	745	for (i = 0; i < ubq->q_depth; i++) {
	746	struct ublk_io *io = &ubq->ios[i];
	747
	748	if (!(io->flags & UBLK_IO_FLAG_ACTIVE)) {
	749	struct request *rq;
	750
	751	/*
	752	* Either we fail the request or ublk_rq_task_work_fn
	753	* will do it
	754	*/
	755	rq = blk_mq_tag_to_rq(ub->tag_set.tags[ubq->q_id], i);
	756	if (rq)
	757	__ublk_fail_req(io, rq);
	758	}
	759	}
	760	ublk_put_device(ub);
	761	}
	762
	763	static void ublk_daemon_monitor_work(struct work_struct *work)
	764	{
	765	struct ublk_device *ub =
	766	container_of(work, struct ublk_device, monitor_work.work);
	767	int i;
	768
	769	for (i = 0; i < ub->dev_info.nr_hw_queues; i++) {
	770	struct ublk_queue *ubq = ublk_get_queue(ub, i);
	771
	772	if (ubq_daemon_is_dying(ubq)) {
	773	schedule_work(&ub->stop_work);
	774
	775	/* abort queue is for making forward progress */
	776	ublk_abort_queue(ub, ubq);
	777	}
	778	}
	779
	780	/*
	781	* We can't schedule monitor work after ublk_remove() is started.
	782	*
	783	* No need ub->mutex, monitor work are canceled after state is marked
	784	* as DEAD, so DEAD state is observed reliably.
	785	*/
	786	if (ub->dev_info.state != UBLK_S_DEV_DEAD)
	787	schedule_delayed_work(&ub->monitor_work,
	788	UBLK_DAEMON_MONITOR_PERIOD);
	789	}
	790
	791	static void ublk_cancel_queue(struct ublk_queue *ubq)
	792	{
	793	int i;
	794
	795	for (i = 0; i < ubq->q_depth; i++) {
	796	struct ublk_io *io = &ubq->ios[i];
	797
	798	if (io->flags & UBLK_IO_FLAG_ACTIVE)
	799	io_uring_cmd_done(io->cmd, UBLK_IO_RES_ABORT, 0);
	800	}
	801	}
	802
	803	/* Cancel all pending commands, must be called after del_gendisk() returns */
	804	static void ublk_cancel_dev(struct ublk_device *ub)
	805	{
	806	int i;
	807
	808	for (i = 0; i < ub->dev_info.nr_hw_queues; i++)
	809	ublk_cancel_queue(ublk_get_queue(ub, i));
	810	}
	811
	812	static void ublk_stop_dev(struct ublk_device *ub)
	813	{
	814	mutex_lock(&ub->mutex);
	815	if (ub->dev_info.state != UBLK_S_DEV_LIVE)
	816	goto unlock;
	817
	818	del_gendisk(ub->ub_disk);
	819	ub->dev_info.state = UBLK_S_DEV_DEAD;
	820	ub->dev_info.ublksrv_pid = -1;
	821	ublk_cancel_dev(ub);
	822	put_disk(ub->ub_disk);
	823	ub->ub_disk = NULL;
	824	unlock:
	825	mutex_unlock(&ub->mutex);
	826	cancel_delayed_work_sync(&ub->monitor_work);
	827	}
	828
	829	static inline bool ublk_queue_ready(struct ublk_queue *ubq)
	830	{
	831	return ubq->nr_io_ready == ubq->q_depth;
	832	}
	833
	834	/* device can only be started after all IOs are ready */
	835	static void ublk_mark_io_ready(struct ublk_device ub, struct ublk_queue ubq)
	836	{
	837	mutex_lock(&ub->mutex);
	838	ubq->nr_io_ready++;
	839	if (ublk_queue_ready(ubq)) {
	840	ubq->ubq_daemon = current;
	841	get_task_struct(ubq->ubq_daemon);
	842	ub->nr_queues_ready++;
	843	}
	844	if (ub->nr_queues_ready == ub->dev_info.nr_hw_queues)
	845	complete_all(&ub->completion);
	846	mutex_unlock(&ub->mutex);
	847	}
	848
	849	static int ublk_ch_uring_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)
	850	{
	851	struct ublksrv_io_cmd ub_cmd = (struct ublksrv_io_cmd )cmd->cmd;
	852	struct ublk_device *ub = cmd->file->private_data;
	853	struct ublk_queue *ubq;
	854	struct ublk_io *io;
	855	u32 cmd_op = cmd->cmd_op;
	856	unsigned tag = ub_cmd->tag;
	857	int ret = -EINVAL;
	858
	859	pr_devel("%s: received: cmd op %d queue %d tag %d result %d\n",
	860	__func__, cmd->cmd_op, ub_cmd->q_id, tag,
	861	ub_cmd->result);
	862
	863	if (!(issue_flags & IO_URING_F_SQE128))
	864	goto out;
	865
	866	if (ub_cmd->q_id >= ub->dev_info.nr_hw_queues)
	867	goto out;
	868
	869	ubq = ublk_get_queue(ub, ub_cmd->q_id);
	870	if (!ubq \|\| ub_cmd->q_id != ubq->q_id)
	871	goto out;
	872
	873	if (ubq->ubq_daemon && ubq->ubq_daemon != current)
	874	goto out;
	875
	876	if (tag >= ubq->q_depth)
	877	goto out;
	878
	879	io = &ubq->ios[tag];
	880
	881	/* there is pending io cmd, something must be wrong */
	882	if (io->flags & UBLK_IO_FLAG_ACTIVE) {
	883	ret = -EBUSY;
	884	goto out;
	885	}
	886
	887	switch (cmd_op) {
	888	case UBLK_IO_FETCH_REQ:
	889	/* UBLK_IO_FETCH_REQ is only allowed before queue is setup */
	890	if (ublk_queue_ready(ubq)) {
	891	ret = -EBUSY;
	892	goto out;
	893	}
	894	/*
	895	* The io is being handled by server, so COMMIT_RQ is expected
	896	* instead of FETCH_REQ
	897	*/
	898	if (io->flags & UBLK_IO_FLAG_OWNED_BY_SRV)
	899	goto out;
	900	/* FETCH_RQ has to provide IO buffer */
	901	if (!ub_cmd->addr)
	902	goto out;
	903	io->cmd = cmd;
	904	io->flags \|= UBLK_IO_FLAG_ACTIVE;
	905	io->addr = ub_cmd->addr;
	906
	907	ublk_mark_io_ready(ub, ubq);
	908	break;
	909	case UBLK_IO_COMMIT_AND_FETCH_REQ:
	910	/* FETCH_RQ has to provide IO buffer */
	911	if (!ub_cmd->addr)
	912	goto out;
	913	if (!(io->flags & UBLK_IO_FLAG_OWNED_BY_SRV))
	914	goto out;
	915	io->addr = ub_cmd->addr;
	916	io->flags \|= UBLK_IO_FLAG_ACTIVE;
	917	io->cmd = cmd;
	918	ublk_commit_completion(ub, ub_cmd);
	919	break;
	920	default:
	921	goto out;
	922	}
	923	return -EIOCBQUEUED;
	924
	925	out:
	926	io_uring_cmd_done(cmd, ret, 0);
	927	pr_devel("%s: complete: cmd op %d, tag %d ret %x io_flags %x\n",
	928	__func__, cmd_op, tag, ret, io->flags);
	929	return -EIOCBQUEUED;
	930	}
	931
	932	static const struct file_operations ublk_ch_fops = {
	933	.owner = THIS_MODULE,
	934	.open = ublk_ch_open,
	935	.release = ublk_ch_release,
	936	.llseek = no_llseek,
	937	.uring_cmd = ublk_ch_uring_cmd,
	938	.mmap = ublk_ch_mmap,
	939	};
	940
	941	static void ublk_deinit_queue(struct ublk_device *ub, int q_id)
	942	{
	943	int size = ublk_queue_cmd_buf_size(ub, q_id);
	944	struct ublk_queue *ubq = ublk_get_queue(ub, q_id);
	945
	946	if (ubq->ubq_daemon)
	947	put_task_struct(ubq->ubq_daemon);
	948	if (ubq->io_cmd_buf)
	949	free_pages((unsigned long)ubq->io_cmd_buf, get_order(size));
	950	}
	951
	952	static int ublk_init_queue(struct ublk_device *ub, int q_id)
	953	{
	954	struct ublk_queue *ubq = ublk_get_queue(ub, q_id);
	955	gfp_t gfp_flags = GFP_KERNEL \| __GFP_ZERO;
	956	void *ptr;
	957	int size;
	958
	959	ubq->flags = ub->dev_info.flags;
	960	ubq->q_id = q_id;
	961	ubq->q_depth = ub->dev_info.queue_depth;
	962	size = ublk_queue_cmd_buf_size(ub, q_id);
	963
	964	ptr = (void *) __get_free_pages(gfp_flags, get_order(size));
	965	if (!ptr)
	966	return -ENOMEM;
	967
	968	ubq->io_cmd_buf = ptr;
	969	ubq->dev = ub;
	970	return 0;
	971	}
	972
	973	static void ublk_deinit_queues(struct ublk_device *ub)
	974	{
	975	int nr_queues = ub->dev_info.nr_hw_queues;
	976	int i;
	977
	978	if (!ub->__queues)
	979	return;
	980
	981	for (i = 0; i < nr_queues; i++)
	982	ublk_deinit_queue(ub, i);
	983	kfree(ub->__queues);
	984	}
	985
	986	static int ublk_init_queues(struct ublk_device *ub)
	987	{
	988	int nr_queues = ub->dev_info.nr_hw_queues;
	989	int depth = ub->dev_info.queue_depth;
	990	int ubq_size = sizeof(struct ublk_queue) + depth * sizeof(struct ublk_io);
	991	int i, ret = -ENOMEM;
	992
	993	ub->queue_size = ubq_size;
	994	ub->__queues = kcalloc(nr_queues, ubq_size, GFP_KERNEL);
	995	if (!ub->__queues)
	996	return ret;
	997
	998	for (i = 0; i < nr_queues; i++) {
	999	if (ublk_init_queue(ub, i))
	1000	goto fail;
	1001	}
	1002
	1003	init_completion(&ub->completion);
	1004	return 0;
	1005
	1006	fail:
	1007	ublk_deinit_queues(ub);
	1008	return ret;
	1009	}
	1010
	1011	static int ublk_alloc_dev_number(struct ublk_device *ub, int idx)
	1012	{
	1013	int i = idx;
	1014	int err;
	1015
	1016	spin_lock(&ublk_idr_lock);
	1017	/* allocate id, if @id >= 0, we're requesting that specific id */
	1018	if (i >= 0) {
	1019	err = idr_alloc(&ublk_index_idr, ub, i, i + 1, GFP_NOWAIT);
	1020	if (err == -ENOSPC)
	1021	err = -EEXIST;
	1022	} else {
	1023	err = idr_alloc(&ublk_index_idr, ub, 0, 0, GFP_NOWAIT);
	1024	}
	1025	spin_unlock(&ublk_idr_lock);
	1026
	1027	if (err >= 0)
	1028	ub->ub_number = err;
	1029
	1030	return err;
	1031	}
	1032
	1033	static void ublk_free_dev_number(struct ublk_device *ub)
	1034	{
	1035	spin_lock(&ublk_idr_lock);
	1036	idr_remove(&ublk_index_idr, ub->ub_number);
	1037	wake_up_all(&ublk_idr_wq);
	1038	spin_unlock(&ublk_idr_lock);
	1039	}
	1040
	1041	static void ublk_cdev_rel(struct device *dev)
	1042	{
	1043	struct ublk_device *ub = container_of(dev, struct ublk_device, cdev_dev);
	1044
	1045	blk_mq_free_tag_set(&ub->tag_set);
	1046	ublk_deinit_queues(ub);
	1047	ublk_free_dev_number(ub);
	1048	mutex_destroy(&ub->mutex);
	1049	kfree(ub);
	1050	}
	1051
	1052	static int ublk_add_chdev(struct ublk_device *ub)
	1053	{
	1054	struct device *dev = &ub->cdev_dev;
	1055	int minor = ub->ub_number;
	1056	int ret;
	1057
	1058	dev->parent = ublk_misc.this_device;
	1059	dev->devt = MKDEV(MAJOR(ublk_chr_devt), minor);
	1060	dev->class = ublk_chr_class;
	1061	dev->release = ublk_cdev_rel;
	1062	device_initialize(dev);
	1063
	1064	ret = dev_set_name(dev, "ublkc%d", minor);
	1065	if (ret)
	1066	goto fail;
	1067
	1068	cdev_init(&ub->cdev, &ublk_ch_fops);
	1069	ret = cdev_device_add(&ub->cdev, dev);
	1070	if (ret)
	1071	goto fail;
	1072	return 0;
	1073	fail:
	1074	put_device(dev);
	1075	return ret;
	1076	}
	1077
	1078	static void ublk_stop_work_fn(struct work_struct *work)
	1079	{
	1080	struct ublk_device *ub =
	1081	container_of(work, struct ublk_device, stop_work);
	1082
	1083	ublk_stop_dev(ub);
	1084	}
	1085
	1086	/* align maximum I/O size to PAGE_SIZE */
	1087	static void ublk_align_max_io_size(struct ublk_device *ub)
	1088	{
	1089	unsigned int max_rq_bytes = ub->dev_info.rq_max_blocks << ub->bs_shift;
	1090
	1091	ub->dev_info.rq_max_blocks =
	1092	round_down(max_rq_bytes, PAGE_SIZE) >> ub->bs_shift;
	1093	}
	1094
	1095	static int ublk_add_tag_set(struct ublk_device *ub)
	1096	{
	1097	ub->tag_set.ops = &ublk_mq_ops;
	1098	ub->tag_set.nr_hw_queues = ub->dev_info.nr_hw_queues;
	1099	ub->tag_set.queue_depth = ub->dev_info.queue_depth;
	1100	ub->tag_set.numa_node = NUMA_NO_NODE;
	1101	ub->tag_set.cmd_size = sizeof(struct ublk_rq_data);
	1102	ub->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
	1103	ub->tag_set.driver_data = ub;
	1104	return blk_mq_alloc_tag_set(&ub->tag_set);
	1105	}
	1106
	1107	static void ublk_remove(struct ublk_device *ub)
	1108	{
	1109	ublk_stop_dev(ub);
	1110	cancel_work_sync(&ub->stop_work);
	1111	cdev_device_del(&ub->cdev, &ub->cdev_dev);
	1112	put_device(&ub->cdev_dev);
	1113	}
	1114
	1115	static struct ublk_device *ublk_get_device_from_id(int idx)
	1116	{
	1117	struct ublk_device *ub = NULL;
	1118
	1119	if (idx < 0)
	1120	return NULL;
	1121
	1122	spin_lock(&ublk_idr_lock);
	1123	ub = idr_find(&ublk_index_idr, idx);
	1124	if (ub)
	1125	ub = ublk_get_device(ub);
	1126	spin_unlock(&ublk_idr_lock);
	1127
	1128	return ub;
	1129	}
	1130
	1131	static int ublk_ctrl_start_dev(struct io_uring_cmd *cmd)
	1132	{
	1133	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1134	int ublksrv_pid = (int)header->data[0];
	1135	unsigned long dev_blocks = header->data[1];
	1136	struct ublk_device *ub;
	1137	struct gendisk *disk;
	1138	int ret = -EINVAL;
	1139
	1140	if (ublksrv_pid <= 0)
	1141	return -EINVAL;
	1142
	1143	ub = ublk_get_device_from_id(header->dev_id);
	1144	if (!ub)
	1145	return -EINVAL;
	1146
	1147	wait_for_completion_interruptible(&ub->completion);
	1148
	1149	schedule_delayed_work(&ub->monitor_work, UBLK_DAEMON_MONITOR_PERIOD);
	1150
	1151	mutex_lock(&ub->mutex);
	1152	if (ub->dev_info.state == UBLK_S_DEV_LIVE \|\|
	1153	test_bit(UB_STATE_USED, &ub->state)) {
	1154	ret = -EEXIST;
	1155	goto out_unlock;
	1156	}
	1157
	1158	/* We may get disk size updated */
	1159	if (dev_blocks)
	1160	ub->dev_info.dev_blocks = dev_blocks;
	1161
	1162	disk = blk_mq_alloc_disk(&ub->tag_set, ub);
	1163	if (IS_ERR(disk)) {
	1164	ret = PTR_ERR(disk);
	1165	goto out_unlock;
	1166	}
	1167	sprintf(disk->disk_name, "ublkb%d", ub->ub_number);
	1168	disk->fops = &ub_fops;
	1169	disk->private_data = ub;
	1170
	1171	blk_queue_logical_block_size(disk->queue, ub->dev_info.block_size);
	1172	blk_queue_physical_block_size(disk->queue, ub->dev_info.block_size);
	1173	blk_queue_io_min(disk->queue, ub->dev_info.block_size);
	1174	blk_queue_max_hw_sectors(disk->queue,
	1175	ub->dev_info.rq_max_blocks << (ub->bs_shift - 9));
	1176	disk->queue->limits.discard_granularity = PAGE_SIZE;
	1177	blk_queue_max_discard_sectors(disk->queue, UINT_MAX >> 9);
	1178	blk_queue_max_write_zeroes_sectors(disk->queue, UINT_MAX >> 9);
	1179
	1180	set_capacity(disk, ub->dev_info.dev_blocks << (ub->bs_shift - 9));
	1181
	1182	ub->dev_info.ublksrv_pid = ublksrv_pid;
	1183	ub->ub_disk = disk;
	1184	get_device(&ub->cdev_dev);
	1185	ret = add_disk(disk);
	1186	if (ret) {
	1187	put_disk(disk);
	1188	goto out_unlock;
	1189	}
	1190	set_bit(UB_STATE_USED, &ub->state);
	1191	ub->dev_info.state = UBLK_S_DEV_LIVE;
	1192	out_unlock:
	1193	mutex_unlock(&ub->mutex);
	1194	ublk_put_device(ub);
	1195	return ret;
	1196	}
	1197
	1198	static int ublk_ctrl_get_queue_affinity(struct io_uring_cmd *cmd)
	1199	{
	1200	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1201	void __user argp = (void __user )(unsigned long)header->addr;
	1202	struct ublk_device *ub;
	1203	cpumask_var_t cpumask;
	1204	unsigned long queue;
	1205	unsigned int retlen;
	1206	unsigned int i;
	1207	int ret = -EINVAL;
	1208
	1209	if (header->len * BITS_PER_BYTE < nr_cpu_ids)
	1210	return -EINVAL;
	1211	if (header->len & (sizeof(unsigned long)-1))
	1212	return -EINVAL;
	1213	if (!header->addr)
	1214	return -EINVAL;
	1215
	1216	ub = ublk_get_device_from_id(header->dev_id);
	1217	if (!ub)
	1218	return -EINVAL;
	1219
	1220	queue = header->data[0];
	1221	if (queue >= ub->dev_info.nr_hw_queues)
	1222	goto out_put_device;
	1223
	1224	ret = -ENOMEM;
	1225	if (!zalloc_cpumask_var(&cpumask, GFP_KERNEL))
	1226	goto out_put_device;
	1227
	1228	for_each_possible_cpu(i) {
	1229	if (ub->tag_set.map[HCTX_TYPE_DEFAULT].mq_map[i] == queue)
	1230	cpumask_set_cpu(i, cpumask);
	1231	}
	1232
	1233	ret = -EFAULT;
	1234	retlen = min_t(unsigned short, header->len, cpumask_size());
	1235	if (copy_to_user(argp, cpumask, retlen))
	1236	goto out_free_cpumask;
	1237	if (retlen != header->len &&
	1238	clear_user(argp + retlen, header->len - retlen))
	1239	goto out_free_cpumask;
	1240
	1241	ret = 0;
	1242	out_free_cpumask:
	1243	free_cpumask_var(cpumask);
	1244	out_put_device:
	1245	ublk_put_device(ub);
	1246	return ret;
	1247	}
	1248
	1249	static inline void ublk_dump_dev_info(struct ublksrv_ctrl_dev_info *info)
	1250	{
	1251	pr_devel("%s: dev id %d flags %llx\n", __func__,
	1252	info->dev_id, info->flags);
	1253	pr_devel("\t nr_hw_queues %d queue_depth %d block size %d dev_capacity %lld\n",
	1254	info->nr_hw_queues, info->queue_depth,
	1255	info->block_size, info->dev_blocks);
	1256	}
	1257
	1258	static int ublk_ctrl_add_dev(struct io_uring_cmd *cmd)
	1259	{
	1260	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1261	void __user argp = (void __user )(unsigned long)header->addr;
	1262	struct ublksrv_ctrl_dev_info info;
	1263	struct ublk_device *ub;
	1264	int ret = -EINVAL;
	1265
	1266	if (header->len < sizeof(info) \|\| !header->addr)
	1267	return -EINVAL;
	1268	if (header->queue_id != (u16)-1) {
	1269	pr_warn("%s: queue_id is wrong %x\n",
	1270	__func__, header->queue_id);
	1271	return -EINVAL;
	1272	}
	1273	if (copy_from_user(&info, argp, sizeof(info)))
	1274	return -EFAULT;
	1275	ublk_dump_dev_info(&info);
	1276	if (header->dev_id != info.dev_id) {
	1277	pr_warn("%s: dev id not match %u %u\n",
	1278	__func__, header->dev_id, info.dev_id);
	1279	return -EINVAL;
	1280	}
	1281
	1282	ret = mutex_lock_killable(&ublk_ctl_mutex);
	1283	if (ret)
	1284	return ret;
	1285
	1286	ret = -ENOMEM;
	1287	ub = kzalloc(sizeof(*ub), GFP_KERNEL);
	1288	if (!ub)
	1289	goto out_unlock;
	1290	mutex_init(&ub->mutex);
	1291	spin_lock_init(&ub->mm_lock);
	1292	INIT_WORK(&ub->stop_work, ublk_stop_work_fn);
	1293	INIT_DELAYED_WORK(&ub->monitor_work, ublk_daemon_monitor_work);
	1294
	1295	ret = ublk_alloc_dev_number(ub, header->dev_id);
	1296	if (ret < 0)
	1297	goto out_free_ub;
	1298
	1299	memcpy(&ub->dev_info, &info, sizeof(info));
	1300
	1301	/* update device id */
	1302	ub->dev_info.dev_id = ub->ub_number;
	1303
	1304	/*
	1305	* 64bit flags will be copied back to userspace as feature
	1306	* negotiation result, so have to clear flags which driver
	1307	* doesn't support yet, then userspace can get correct flags
	1308	* (features) to handle.
	1309	*/
	1310	ub->dev_info.flags &= UBLK_F_ALL;
	1311
	1312	/* We are not ready to support zero copy */
	1313	ub->dev_info.flags &= ~UBLK_F_SUPPORT_ZERO_COPY;
	1314
	1315	ub->bs_shift = ilog2(ub->dev_info.block_size);
	1316	ub->dev_info.nr_hw_queues = min_t(unsigned int,
	1317	ub->dev_info.nr_hw_queues, nr_cpu_ids);
	1318	ublk_align_max_io_size(ub);
	1319
	1320	ret = ublk_init_queues(ub);
	1321	if (ret)
	1322	goto out_free_dev_number;
	1323
	1324	ret = ublk_add_tag_set(ub);
	1325	if (ret)
	1326	goto out_deinit_queues;
	1327
	1328	ret = -EFAULT;
	1329	if (copy_to_user(argp, &ub->dev_info, sizeof(info)))
	1330	goto out_free_tag_set;
	1331
	1332	/*
	1333	* Add the char dev so that ublksrv daemon can be setup.
	1334	* ublk_add_chdev() will cleanup everything if it fails.
	1335	*/
	1336	ret = ublk_add_chdev(ub);
	1337	goto out_unlock;
	1338
	1339	out_free_tag_set:
	1340	blk_mq_free_tag_set(&ub->tag_set);
	1341	out_deinit_queues:
	1342	ublk_deinit_queues(ub);
	1343	out_free_dev_number:
	1344	ublk_free_dev_number(ub);
	1345	out_free_ub:
	1346	mutex_destroy(&ub->mutex);
	1347	kfree(ub);
	1348	out_unlock:
	1349	mutex_unlock(&ublk_ctl_mutex);
	1350	return ret;
	1351	}
	1352
	1353	static inline bool ublk_idr_freed(int id)
	1354	{
	1355	void *ptr;
	1356
	1357	spin_lock(&ublk_idr_lock);
	1358	ptr = idr_find(&ublk_index_idr, id);
	1359	spin_unlock(&ublk_idr_lock);
	1360
	1361	return ptr == NULL;
	1362	}
	1363
	1364	static int ublk_ctrl_del_dev(int idx)
	1365	{
	1366	struct ublk_device *ub;
	1367	int ret;
	1368
	1369	ret = mutex_lock_killable(&ublk_ctl_mutex);
	1370	if (ret)
	1371	return ret;
	1372
	1373	ub = ublk_get_device_from_id(idx);
	1374	if (ub) {
	1375	ublk_remove(ub);
	1376	ublk_put_device(ub);
	1377	ret = 0;
	1378	} else {
	1379	ret = -ENODEV;
	1380	}
	1381
	1382	/*
	1383	* Wait until the idr is removed, then it can be reused after
	1384	* DEL_DEV command is returned.
	1385	*/
	1386	if (!ret)
	1387	wait_event(ublk_idr_wq, ublk_idr_freed(idx));
	1388	mutex_unlock(&ublk_ctl_mutex);
	1389
	1390	return ret;
	1391	}
	1392
	1393	static inline void ublk_ctrl_cmd_dump(struct io_uring_cmd *cmd)
	1394	{
	1395	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1396
	1397	pr_devel("%s: cmd_op %x, dev id %d qid %d data %llx buf %llx len %u\n",
	1398	__func__, cmd->cmd_op, header->dev_id, header->queue_id,
	1399	header->data[0], header->addr, header->len);
	1400	}
	1401
	1402	static int ublk_ctrl_stop_dev(struct io_uring_cmd *cmd)
	1403	{
	1404	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1405	struct ublk_device *ub;
	1406
	1407	ub = ublk_get_device_from_id(header->dev_id);
	1408	if (!ub)
	1409	return -EINVAL;
	1410
	1411	ublk_stop_dev(ub);
	1412	cancel_work_sync(&ub->stop_work);
	1413
	1414	ublk_put_device(ub);
	1415	return 0;
	1416	}
	1417
	1418	static int ublk_ctrl_get_dev_info(struct io_uring_cmd *cmd)
	1419	{
	1420	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1421	void __user argp = (void __user )(unsigned long)header->addr;
	1422	struct ublk_device *ub;
	1423	int ret = 0;
	1424
	1425	if (header->len < sizeof(struct ublksrv_ctrl_dev_info) \|\| !header->addr)
	1426	return -EINVAL;
	1427
	1428	ub = ublk_get_device_from_id(header->dev_id);
	1429	if (!ub)
	1430	return -EINVAL;
	1431
	1432	if (copy_to_user(argp, &ub->dev_info, sizeof(ub->dev_info)))
	1433	ret = -EFAULT;
	1434	ublk_put_device(ub);
	1435
	1436	return ret;
	1437	}
	1438
	1439	static int ublk_ctrl_uring_cmd(struct io_uring_cmd *cmd,
	1440	unsigned int issue_flags)
	1441	{
	1442	struct ublksrv_ctrl_cmd header = (struct ublksrv_ctrl_cmd )cmd->cmd;
	1443	int ret = -EINVAL;
	1444
	1445	ublk_ctrl_cmd_dump(cmd);
	1446
	1447	if (!(issue_flags & IO_URING_F_SQE128))
	1448	goto out;
	1449
	1450	ret = -EPERM;
	1451	if (!capable(CAP_SYS_ADMIN))
	1452	goto out;
	1453
	1454	ret = -ENODEV;
	1455	switch (cmd->cmd_op) {
	1456	case UBLK_CMD_START_DEV:
	1457	ret = ublk_ctrl_start_dev(cmd);
	1458	break;
	1459	case UBLK_CMD_STOP_DEV:
	1460	ret = ublk_ctrl_stop_dev(cmd);
	1461	break;
	1462	case UBLK_CMD_GET_DEV_INFO:
	1463	ret = ublk_ctrl_get_dev_info(cmd);
	1464	break;
	1465	case UBLK_CMD_ADD_DEV:
	1466	ret = ublk_ctrl_add_dev(cmd);
	1467	break;
	1468	case UBLK_CMD_DEL_DEV:
	1469	ret = ublk_ctrl_del_dev(header->dev_id);
	1470	break;
	1471	case UBLK_CMD_GET_QUEUE_AFFINITY:
	1472	ret = ublk_ctrl_get_queue_affinity(cmd);
	1473	break;
	1474	default:
	1475	break;
	1476	}
	1477	out:
	1478	io_uring_cmd_done(cmd, ret, 0);
	1479	pr_devel("%s: cmd done ret %d cmd_op %x, dev id %d qid %d\n",
	1480	__func__, ret, cmd->cmd_op, header->dev_id, header->queue_id);
	1481	return -EIOCBQUEUED;
	1482	}
	1483
	1484	static const struct file_operations ublk_ctl_fops = {
	1485	.open = nonseekable_open,
	1486	.uring_cmd = ublk_ctrl_uring_cmd,
	1487	.owner = THIS_MODULE,
	1488	.llseek = noop_llseek,
	1489	};
	1490
	1491	static struct miscdevice ublk_misc = {
	1492	.minor = MISC_DYNAMIC_MINOR,
	1493	.name = "ublk-control",
	1494	.fops = &ublk_ctl_fops,
	1495	};
	1496
	1497	static int __init ublk_init(void)
	1498	{
	1499	int ret;
	1500
	1501	init_waitqueue_head(&ublk_idr_wq);
	1502
	1503	ret = misc_register(&ublk_misc);
	1504	if (ret)
	1505	return ret;
	1506
	1507	ret = alloc_chrdev_region(&ublk_chr_devt, 0, UBLK_MINORS, "ublk-char");
	1508	if (ret)
	1509	goto unregister_mis;
	1510
	1511	ublk_chr_class = class_create(THIS_MODULE, "ublk-char");
	1512	if (IS_ERR(ublk_chr_class)) {
	1513	ret = PTR_ERR(ublk_chr_class);
	1514	goto free_chrdev_region;
	1515	}
	1516	return 0;
	1517
	1518	free_chrdev_region:
	1519	unregister_chrdev_region(ublk_chr_devt, UBLK_MINORS);
	1520	unregister_mis:
	1521	misc_deregister(&ublk_misc);
	1522	return ret;
	1523	}
	1524
	1525	static void __exit ublk_exit(void)
	1526	{
	1527	struct ublk_device *ub;
	1528	int id;
	1529
	1530	class_destroy(ublk_chr_class);
	1531
	1532	misc_deregister(&ublk_misc);
	1533
	1534	idr_for_each_entry(&ublk_index_idr, ub, id)
	1535	ublk_remove(ub);
	1536
	1537	idr_destroy(&ublk_index_idr);
	1538	unregister_chrdev_region(ublk_chr_devt, UBLK_MINORS);
	1539	}
	1540
	1541	module_init(ublk_init);
	1542	module_exit(ublk_exit);
	1543
	1544	MODULE_AUTHOR("Ming Lei <ming.lei@redhat.com>");
	1545	MODULE_LICENSE("GPL");

drivers/block/virtio_blk.c+1−2

 	return 0;
 out_cleanup_disk:
-	blk_cleanup_disk(vblk->disk);
+	put_disk(vblk->disk);
 out_free_tags:
 	blk_mq_free_tag_set(&vblk->tag_set);
 out_free_vq:
 	flush_work(&vblk->config_work);
 	del_gendisk(vblk->disk);
-	blk_cleanup_queue(vblk->disk->queue);
 	blk_mq_free_tag_set(&vblk->tag_set);
 	mutex_lock(&vblk->vdev_mutex);

drivers/block/xen-blkback/blkback.c+3−3

@@ -442,7 +442,7 @@ static void free_req(struct xen_blkif_ring ring, struct pending_req req) · 441 unmodified lines
442	* Routines for managing virtual block devices (vbds).	442	* Routines for managing virtual block devices (vbds).
443	*/	443	*/
444	static int xen_vbd_translate(struct phys_req req, struct xen_blkif blkif,	444	static int xen_vbd_translate(struct phys_req req, struct xen_blkif blkif,
445	int operation)	445	enum req_op operation)
446	{	446	{
447	struct xen_vbd *vbd = &blkif->vbd;	447	struct xen_vbd *vbd = &blkif->vbd;
448	int rc = -EACCES;	448	int rc = -EACCES;
@@ -1193,8 +1193,8 @@ static int dispatch_rw_block_io(struct xen_blkif_ring *ring, · 744 unmodified lines
1193	struct bio *bio = NULL;	1193	struct bio *bio = NULL;
1194	struct bio **biolist = pending_req->biolist;	1194	struct bio **biolist = pending_req->biolist;
1195	int i, nbio = 0;	1195	int i, nbio = 0;
1196	int operation;	1196	enum req_op operation;
1197	int operation_flags = 0;	1197	blk_opf_t operation_flags = 0;
1198	struct blk_plug plug;	1198	struct blk_plug plug;
1199	bool drain = false;	1199	bool drain = false;
1200	struct grant_page **pages = pending_req->segments;	1200	struct grant_page **pages = pending_req->segments;

drivers/block/xen-blkfront.c+2−2

@@ -2397,7 +2397,7 @@ static void blkfront_connect(struct blkfront_info *info) · 2396 unmodified lines
2397		2397
2398	err = device_add_disk(&info->xbdev->dev, info->gd, NULL);	2398	err = device_add_disk(&info->xbdev->dev, info->gd, NULL);
2399	if (err) {	2399	if (err) {
2400	blk_cleanup_disk(info->gd);	2400	put_disk(info->gd);
2401	blk_mq_free_tag_set(&info->tag_set);	2401	blk_mq_free_tag_set(&info->tag_set);
2402	info->rq = NULL;	2402	info->rq = NULL;
2403	goto fail;	2403	goto fail;
@@ -2482,7 +2482,7 @@ static int blkfront_remove(struct xenbus_device *xbdev) · 78 unmodified lines
2482	blkif_free(info, 0);	2482	blkif_free(info, 0);
2483	if (info->gd) {	2483	if (info->gd) {
2484	xlbd_release_minors(info->gd->first_minor, info->gd->minors);	2484	xlbd_release_minors(info->gd->first_minor, info->gd->minors);
2485	blk_cleanup_disk(info->gd);	2485	put_disk(info->gd);
2486	blk_mq_free_tag_set(&info->tag_set);	2486	blk_mq_free_tag_set(&info->tag_set);
2487	}	2487	}
2488		2488

drivers/block/z2ram.c+1−2

 	z2ram_gendisk[minor] = disk;
 	err = add_disk(disk);
 	if (err)
-		blk_cleanup_disk(disk);
+		put_disk(disk);
 	return err;
 }
 	for (i = 0; i < Z2MINOR_COUNT; i++) {
 		del_gendisk(z2ram_gendisk[i]);
-		blk_cleanup_queue(z2ram_gendisk[i]->queue);
 		put_disk(z2ram_gendisk[i]);
 	}
 	blk_mq_free_tag_set(&tag_set);

drivers/block/zram/zram_drv.c+4−4

@@ -1523,7 +1523,7 @@ static void zram_bio_discard(struct zram *zram, u32 index, · 1522 unmodified lines
1523	* Returns 1 if IO request was successfully submitted.	1523	* Returns 1 if IO request was successfully submitted.
1524	*/	1524	*/
1525	static int zram_bvec_rw(struct zram zram, struct bio_vec bvec, u32 index,	1525	static int zram_bvec_rw(struct zram zram, struct bio_vec bvec, u32 index,
1526	int offset, unsigned int op, struct bio *bio)	1526	int offset, enum req_op op, struct bio *bio)
1527	{	1527	{
1528	int ret;	1528	int ret;
1529		1529
@@ -1631,7 +1631,7 @@ static void zram_slot_free_notify(struct block_device *bdev, · 101 unmodified lines
1631	}	1631	}
1632		1632
1633	static int zram_rw_page(struct block_device *bdev, sector_t sector,	1633	static int zram_rw_page(struct block_device *bdev, sector_t sector,
1634	struct page *page, unsigned int op)	1634	struct page *page, enum req_op op)
1635	{	1635	{
1636	int offset, ret;	1636	int offset, ret;
1637	u32 index;	1637	u32 index;
@@ -1957,7 +1957,7 @@ static int zram_add(void) · 319 unmodified lines
1957	return device_id;	1957	return device_id;
1958		1958
1959	out_cleanup_disk:	1959	out_cleanup_disk:
1960	blk_cleanup_disk(zram->disk);	1960	put_disk(zram->disk);
1961	out_free_idr:	1961	out_free_idr:
1962	idr_remove(&zram_index_idr, device_id);	1962	idr_remove(&zram_index_idr, device_id);
1963	out_free_dev:	1963	out_free_dev:
@@ -2008,7 +2008,7 @@ static int zram_remove(struct zram *zram) · 44 unmodified lines
2008	*/	2008	*/
2009	zram_reset_device(zram);	2009	zram_reset_device(zram);
2010		2010
2011	blk_cleanup_disk(zram->disk);	2011	put_disk(zram->disk);
2012	kfree(zram);	2012	kfree(zram);
2013	return 0;	2013	return 0;
2014	}	2014	}

drivers/cdrom/gdrom.c+1−2

 	free_irq(HW_EVENT_GDROM_DMA, &gd);
 	free_irq(HW_EVENT_GDROM_CMD, &gd);
 probe_fail_cleanup_disk:
-	blk_cleanup_disk(gd.disk);
+	put_disk(gd.disk);
 probe_fail_free_tag_set:
 	blk_mq_free_tag_set(&gd.tag_set);
 probe_fail_free_cd_info:
 static int remove_gdrom(struct platform_device *devptr)
 {
-	blk_cleanup_queue(gd.gdrom_rq);
 	blk_mq_free_tag_set(&gd.tag_set);
 	free_irq(HW_EVENT_GDROM_CMD, &gd);
 	free_irq(HW_EVENT_GDROM_DMA, &gd);

drivers/infiniband/ulp/srp/ib_srp.c+1−2

@@ -1282,8 +1282,7 @@ struct srp_terminate_context { · 1281 unmodified lines
1282	int scsi_result;	1282	int scsi_result;
1283	};	1283	};
1284		1284
1285	static bool srp_terminate_cmd(struct scsi_cmnd scmnd, void context_ptr,	1285	static bool srp_terminate_cmd(struct scsi_cmnd scmnd, void context_ptr)
1286	bool reserved)
1287	{	1286	{
1288	struct srp_terminate_context *context = context_ptr;	1287	struct srp_terminate_context *context = context_ptr;
1289	struct srp_target_port *target = context->srp_target;	1288	struct srp_target_port *target = context->srp_target;

drivers/md/bcache/super.c+13−14

 	up(&c->uuid_write_mutex);
 }
-static void uuid_io(struct cache_set *c, int op, unsigned long op_flags,
+static void uuid_io(struct cache_set *c, blk_opf_t opf, struct bkey *k,
-		    struct bkey *k, struct closure *parent)
+		    struct closure *parent)
 {
 	struct closure *cl = &c->uuid_write;
 	struct uuid_entry *u;
 	for (i = 0; i < KEY_PTRS(k); i++) {
 		struct bio *bio = bch_bbio_alloc(c);
-		bio->bi_opf = REQ_SYNC | REQ_META | op_flags;
+		bio->bi_opf = opf | REQ_SYNC | REQ_META;
 		bio->bi_iter.bi_size = KEY_SIZE(k) << 9;
 		bio->bi_end_io	= uuid_endio;
 		bio->bi_private = cl;
-		bio_set_op_attrs(bio, op, REQ_SYNC|REQ_META|op_flags);
 		bch_bio_map(bio, c->uuids);
 		bch_submit_bbio(bio, c, k, i);
-		if (op != REQ_OP_WRITE)
+		if ((opf & REQ_OP_MASK) != REQ_OP_WRITE)
 			break;
 	}
 	bch_extent_to_text(buf, sizeof(buf), k);
-	pr_debug("%s UUIDs at %s\n", op == REQ_OP_WRITE ? "wrote" : "read", buf);
+	pr_debug("%s UUIDs at %s\n", (opf & REQ_OP_MASK) == REQ_OP_WRITE ?
+		 "wrote" : "read", buf);
 	for (u = c->uuids; u < c->uuids + c->nr_uuids; u++)
 		if (!bch_is_zero(u->uuid, 16))
 		return "bad uuid pointer";
 	bkey_copy(&c->uuid_bucket, k);
-	uuid_io(c, REQ_OP_READ, 0, k, cl);
+	uuid_io(c, REQ_OP_READ, k, cl);
 	if (j->version < BCACHE_JSET_VERSION_UUIDv1) {
 		struct uuid_entry_v0	*u0 = (void *) c->uuids;
 	size =  meta_bucket_pages(&ca->sb) * PAGE_SECTORS;
 	SET_KEY_SIZE(&k.key, size);
-	uuid_io(c, REQ_OP_WRITE, 0, &k.key, &cl);
+	uuid_io(c, REQ_OP_WRITE, &k.key, &cl);
 	closure_sync(&cl);
 	/* Only one bucket used for uuid write */
 	closure_put(&ca->prio);
 }
-static void prio_io(struct cache *ca, uint64_t bucket, int op,
+static void prio_io(struct cache *ca, uint64_t bucket, blk_opf_t opf)
-		    unsigned long op_flags)
 {
 	struct closure *cl = &ca->prio;
 	struct bio *bio = bch_bbio_alloc(ca->set);
 	bio->bi_end_io	= prio_endio;
 	bio->bi_private = ca;
-	bio_set_op_attrs(bio, op, REQ_SYNC|REQ_META|op_flags);
+	bio->bi_opf = opf | REQ_SYNC | REQ_META;
 	bch_bio_map(bio, ca->disk_buckets);
 	closure_bio_submit(ca->set, bio, &ca->prio);
 		BUG_ON(bucket == -1);
 		mutex_unlock(&ca->set->bucket_lock);
-		prio_io(ca, bucket, REQ_OP_WRITE, 0);
+		prio_io(ca, bucket, REQ_OP_WRITE);
 		mutex_lock(&ca->set->bucket_lock);
 		ca->prio_buckets[i] = bucket;
 			ca->prio_last_buckets[bucket_nr] = bucket;
 			bucket_nr++;
-			prio_io(ca, bucket, REQ_OP_READ, 0);
+			prio_io(ca, bucket, REQ_OP_READ);
 			if (p->csum !=
 			    bch_crc64(&p->magic, meta_bucket_bytes(&ca->sb) - 8)) {
 	if (disk) {
 		ida_simple_remove(&bcache_device_idx,
 				  first_minor_to_idx(disk->first_minor));
-		blk_cleanup_disk(disk);
+		put_disk(disk);
 	}
 	bioset_exit(&d->bio_split);

drivers/md/dm-bufio.c+12−14

 	b->end_io(b, unlikely(error != 0) ? BLK_STS_IOERR : 0);
 }
-static void use_dmio(struct dm_buffer *b, int rw, sector_t sector,
+static void use_dmio(struct dm_buffer *b, enum req_op op, sector_t sector,
 		     unsigned n_sectors, unsigned offset)
 {
 	int r;
 	struct dm_io_request io_req = {
-		.bi_op = rw,
+		.bi_opf = op,
-		.bi_op_flags = 0,
 		.notify.fn = dmio_complete,
 		.notify.context = b,
 		.client = b->c->dm_io,
 	b->end_io(b, status);
 }
-static void use_bio(struct dm_buffer *b, int rw, sector_t sector,
+static void use_bio(struct dm_buffer *b, enum req_op op, sector_t sector,
 		    unsigned n_sectors, unsigned offset)
 {
 	struct bio *bio;
 	bio = bio_kmalloc(vec_size, GFP_NOWAIT | __GFP_NORETRY | __GFP_NOWARN);
 	if (!bio) {
 dmio:
-		use_dmio(b, rw, sector, n_sectors, offset);
+		use_dmio(b, op, sector, n_sectors, offset);
 		return;
 	}
-	bio_init(bio, b->c->bdev, bio->bi_inline_vecs, vec_size, rw);
+	bio_init(bio, b->c->bdev, bio->bi_inline_vecs, vec_size, op);
 	bio->bi_iter.bi_sector = sector;
 	bio->bi_end_io = bio_complete;
 	bio->bi_private = b;
 	return sector;
 }
-static void submit_io(struct dm_buffer *b, int rw, void (*end_io)(struct dm_buffer *, blk_status_t))
+static void submit_io(struct dm_buffer *b, enum req_op op,
+		      void (*end_io)(struct dm_buffer *, blk_status_t))
 {
 	unsigned n_sectors;
 	sector_t sector;
 	sector = block_to_sector(b->c, b->block);
-	if (rw != REQ_OP_WRITE) {
+	if (op != REQ_OP_WRITE) {
 		n_sectors = b->c->block_size >> SECTOR_SHIFT;
 		offset = 0;
 	} else {
 	}
 	if (b->data_mode != DATA_MODE_VMALLOC)
-		use_bio(b, rw, sector, n_sectors, offset);
+		use_bio(b, op, sector, n_sectors, offset);
 	else
-		use_dmio(b, rw, sector, n_sectors, offset);
+		use_dmio(b, op, sector, n_sectors, offset);
 }
 /*----------------------------------------------------------------
 int dm_bufio_issue_flush(struct dm_bufio_client *c)
 {
 	struct dm_io_request io_req = {
-		.bi_op = REQ_OP_WRITE,
+		.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH | REQ_SYNC,
-		.bi_op_flags = REQ_PREFLUSH | REQ_SYNC,
 		.mem.type = DM_IO_KMEM,
 		.mem.ptr.addr = NULL,
 		.client = c->dm_io,
 int dm_bufio_issue_discard(struct dm_bufio_client *c, sector_t block, sector_t count)
 {
 	struct dm_io_request io_req = {
-		.bi_op = REQ_OP_DISCARD,
+		.bi_opf = REQ_OP_DISCARD | REQ_SYNC,
-		.bi_op_flags = REQ_SYNC,
 		.mem.type = DM_IO_KMEM,
 		.mem.ptr.addr = NULL,
 		.client = c->dm_io,

drivers/md/dm-ebs-target.c+8−7

  *
  * copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
  */
-static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bvec_iter *iter)
+static int __ebs_rw_bvec(struct ebs_c *ec, enum req_op op, struct bio_vec *bv,
+			 struct bvec_iter *iter)
 {
 	int r = 0;
 	unsigned char *ba, *pa;
 		cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);
 		/* Avoid reading for writes in case bio vector's page overwrites block completely. */
-		if (rw == READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
+		if (op == REQ_OP_READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
 			ba = dm_bufio_read(ec->bufio, block, &b);
 		else
 			ba = dm_bufio_new(ec->bufio, block, &b);
 		} else {
 			/* Copy data to/from bio to buffer if read/new was successful above. */
 			ba += buf_off;
-			if (rw == READ) {
+			if (op == REQ_OP_READ) {
 				memcpy(pa, ba, cur_len);
 				flush_dcache_page(bv->bv_page);
 			} else {
 }
 /* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
-static int __ebs_rw_bio(struct ebs_c *ec, int rw, struct bio *bio)
+static int __ebs_rw_bio(struct ebs_c *ec, enum req_op op, struct bio *bio)
 {
 	int r = 0, rr;
 	struct bio_vec bv;
 	struct bvec_iter iter;
 	bio_for_each_bvec(bv, bio, iter) {
-		rr = __ebs_rw_bvec(ec, rw, &bv, &iter);
+		rr = __ebs_rw_bvec(ec, op, &bv, &iter);
 		if (rr)
 			r = rr;
 	}
 	bio_list_for_each(bio, &bios) {
 		r = -EIO;
 		if (bio_op(bio) == REQ_OP_READ)
-			r = __ebs_rw_bio(ec, READ, bio);
+			r = __ebs_rw_bio(ec, REQ_OP_READ, bio);
 		else if (bio_op(bio) == REQ_OP_WRITE) {
 			write = true;
-			r = __ebs_rw_bio(ec, WRITE, bio);
+			r = __ebs_rw_bio(ec, REQ_OP_WRITE, bio);
 		} else if (bio_op(bio) == REQ_OP_DISCARD) {
 			__ebs_forget_bio(ec, bio);
 			r = __ebs_discard_bio(ec, bio);

drivers/md/dm-flakey.c+6−2

 	unsigned corrupt_bio_byte;
 	unsigned corrupt_bio_rw;
 	unsigned corrupt_bio_value;
-	unsigned corrupt_bio_flags;
+	blk_opf_t corrupt_bio_flags;
 };
 enum feature_flag_bits {
 			/*
 			 * Only corrupt bios with these flags set.
 			 */
-			r = dm_read_arg(_args + 3, as, &fc->corrupt_bio_flags, &ti->error);
+			BUILD_BUG_ON(sizeof(fc->corrupt_bio_flags) !=
+				     sizeof(unsigned int));
+			r = dm_read_arg(_args + 3, as,
+				(__force unsigned *)&fc->corrupt_bio_flags,
+				&ti->error);
 			if (r)
 				return r;
 			argc--;

drivers/md/dm-integrity.c+38−38

 	struct work_struct work;
 	struct dm_integrity_c *ic;
-	enum req_opf op;
+	enum req_op op;
 	bool fua;
 	struct dm_integrity_range range;
 	return 0;
 }
-static int sync_rw_sb(struct dm_integrity_c *ic, int op, int op_flags)
+static int sync_rw_sb(struct dm_integrity_c *ic, blk_opf_t opf)
 {
 	struct dm_io_request io_req;
 	struct dm_io_region io_loc;
+	const enum req_op op = opf & REQ_OP_MASK;
 	int r;
-	io_req.bi_op = op;
+	io_req.bi_opf = opf;
-	io_req.bi_op_flags = op_flags;
 	io_req.mem.type = DM_IO_KMEM;
 	io_req.mem.ptr.addr = ic->sb;
 	io_req.notify.fn = NULL;
 	complete_journal_op(comp);
 }
-static void rw_journal_sectors(struct dm_integrity_c *ic, int op, int op_flags,
+static void rw_journal_sectors(struct dm_integrity_c *ic, blk_opf_t opf,
-			       unsigned sector, unsigned n_sectors, struct journal_completion *comp)
+			       unsigned sector, unsigned n_sectors,
+			       struct journal_completion *comp)
 {
 	struct dm_io_request io_req;
 	struct dm_io_region io_loc;
 	pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);
 	pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);
-	io_req.bi_op = op;
+	io_req.bi_opf = opf;
-	io_req.bi_op_flags = op_flags;
 	io_req.mem.type = DM_IO_PAGE_LIST;
 	if (ic->journal_io)
 		io_req.mem.ptr.pl = &ic->journal_io[pl_index];
 	r = dm_io(&io_req, 1, &io_loc, NULL);
 	if (unlikely(r)) {
-		dm_integrity_io_error(ic, op == REQ_OP_READ ? "reading journal" : "writing journal", r);
+		dm_integrity_io_error(ic, (opf & REQ_OP_MASK) == REQ_OP_READ ?
+				      "reading journal" : "writing journal", r);
 		if (comp) {
 			WARN_ONCE(1, "asynchronous dm_io failed: %d", r);
 			complete_journal_io(-1UL, comp);
 	}
 }
-static void rw_journal(struct dm_integrity_c *ic, int op, int op_flags, unsigned section,
+static void rw_journal(struct dm_integrity_c *ic, blk_opf_t opf,
-		       unsigned n_sections, struct journal_completion *comp)
+		       unsigned section, unsigned n_sections,
+		       struct journal_completion *comp)
 {
 	unsigned sector, n_sectors;
 	sector = section * ic->journal_section_sectors;
 	n_sectors = n_sections * ic->journal_section_sectors;
-	rw_journal_sectors(ic, op, op_flags, sector, n_sectors, comp);
+	rw_journal_sectors(ic, opf, sector, n_sectors, comp);
 }
 static void write_journal(struct dm_integrity_c *ic, unsigned commit_start, unsigned commit_sections)
 			for (i = 0; i < commit_sections; i++)
 				rw_section_mac(ic, commit_start + i, true);
 		}
-		rw_journal(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC, commit_start,
+		rw_journal(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC, commit_start,
 			   commit_sections, &io_comp);
 	} else {
 		unsigned to_end;
 			crypt_comp_1.in_flight = (atomic_t)ATOMIC_INIT(0);
 			encrypt_journal(ic, true, commit_start, to_end, &crypt_comp_1);
 			if (try_wait_for_completion(&crypt_comp_1.comp)) {
-				rw_journal(ic, REQ_OP_WRITE, REQ_FUA, commit_start, to_end, &io_comp);
+				rw_journal(ic, REQ_OP_WRITE | REQ_FUA,
+					   commit_start, to_end, &io_comp);
 				reinit_completion(&crypt_comp_1.comp);
 				crypt_comp_1.in_flight = (atomic_t)ATOMIC_INIT(0);
 				encrypt_journal(ic, true, 0, commit_sections - to_end, &crypt_comp_1);
 				crypt_comp_2.in_flight = (atomic_t)ATOMIC_INIT(0);
 				encrypt_journal(ic, true, 0, commit_sections - to_end, &crypt_comp_2);
 				wait_for_completion_io(&crypt_comp_1.comp);
-				rw_journal(ic, REQ_OP_WRITE, REQ_FUA, commit_start, to_end, &io_comp);
+				rw_journal(ic, REQ_OP_WRITE | REQ_FUA, commit_start, to_end, &io_comp);
 				wait_for_completion_io(&crypt_comp_2.comp);
 			}
 		} else {
 			for (i = 0; i < to_end; i++)
 				rw_section_mac(ic, commit_start + i, true);
-			rw_journal(ic, REQ_OP_WRITE, REQ_FUA, commit_start, to_end, &io_comp);
+			rw_journal(ic, REQ_OP_WRITE | REQ_FUA, commit_start, to_end, &io_comp);
 			for (i = 0; i < commit_sections - to_end; i++)
 				rw_section_mac(ic, i, true);
 		}
-		rw_journal(ic, REQ_OP_WRITE, REQ_FUA, 0, commit_sections - to_end, &io_comp);
+		rw_journal(ic, REQ_OP_WRITE | REQ_FUA, 0, commit_sections - to_end, &io_comp);
 	}
 	wait_for_completion_io(&io_comp.comp);
 	pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);
 	pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);
-	io_req.bi_op = REQ_OP_WRITE;
+	io_req.bi_opf = REQ_OP_WRITE;
-	io_req.bi_op_flags = 0;
 	io_req.mem.type = DM_IO_PAGE_LIST;
 	io_req.mem.ptr.pl = &ic->journal[pl_index];
 	io_req.mem.offset = pl_offset;
 	if (!ic->meta_dev)
 		flush_data = false;
 	if (flush_data) {
-		fr.io_req.bi_op = REQ_OP_WRITE,
+		fr.io_req.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH | REQ_SYNC,
-		fr.io_req.bi_op_flags = REQ_PREFLUSH | REQ_SYNC,
 		fr.io_req.mem.type = DM_IO_KMEM,
 		fr.io_req.mem.ptr.addr = NULL,
 		fr.io_req.notify.fn = flush_notify,
 	if (dm_integrity_failed(ic))
 		return;
-	r = sync_rw_sb(ic, REQ_OP_WRITE, 0);
+	r = sync_rw_sb(ic, REQ_OP_WRITE);
 	if (unlikely(r))
 		dm_integrity_io_error(ic, "writing superblock", r);
 }
 	if (unlikely(dm_integrity_failed(ic)))
 		goto err;
-	io_req.bi_op = REQ_OP_READ;
+	io_req.bi_opf = REQ_OP_READ;
-	io_req.bi_op_flags = 0;
 	io_req.mem.type = DM_IO_VMA;
 	io_req.mem.ptr.addr = ic->recalc_buffer;
 	io_req.notify.fn = NULL;
 	if (bio_list_empty(&waiting))
 		return;
-	rw_journal_sectors(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC,
+	rw_journal_sectors(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC,
 			   bbs->idx * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT),
 			   BITMAP_BLOCK_SIZE >> SECTOR_SHIFT, NULL);
 	block_bitmap_op(ic, ic->journal, 0, limit, BITMAP_OP_CLEAR);
 	block_bitmap_op(ic, ic->may_write_bitmap, 0, limit, BITMAP_OP_CLEAR);
-	rw_journal_sectors(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC, 0,
+	rw_journal_sectors(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC, 0,
 			   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 	spin_lock_irq(&ic->endio_wait.lock);
 	if (!ic->just_formatted) {
 		DEBUG_print("reading journal\n");
-		rw_journal(ic, REQ_OP_READ, 0, 0, ic->journal_sections, NULL);
+		rw_journal(ic, REQ_OP_READ, 0, ic->journal_sections, NULL);
 		if (ic->journal_io)
 			DEBUG_bytes(lowmem_page_address(ic->journal_io[0].page), 64, "read journal");
 		if (ic->journal_io) {
 		/* set to 0 to test bitmap replay code */
 		init_journal(ic, 0, ic->journal_sections, 0);
 		ic->sb->flags &= ~cpu_to_le32(SB_FLAG_DIRTY_BITMAP);
-		r = sync_rw_sb(ic, REQ_OP_WRITE, REQ_FUA);
+		r = sync_rw_sb(ic, REQ_OP_WRITE | REQ_FUA);
 		if (unlikely(r))
 			dm_integrity_io_error(ic, "writing superblock", r);
 #endif
 		if (ic->provided_data_sectors > old_provided_data_sectors &&
 		    ic->mode == 'B' &&
 		    ic->sb->log2_blocks_per_bitmap_bit == ic->log2_blocks_per_bitmap_bit) {
-			rw_journal_sectors(ic, REQ_OP_READ, 0, 0,
+			rw_journal_sectors(ic, REQ_OP_READ, 0,
 					   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 			block_bitmap_op(ic, ic->journal, old_provided_data_sectors,
 					ic->provided_data_sectors - old_provided_data_sectors, BITMAP_OP_SET);
-			rw_journal_sectors(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC, 0,
+			rw_journal_sectors(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC, 0,
 					   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 		}
 		ic->sb->provided_data_sectors = cpu_to_le64(ic->provided_data_sectors);
-		r = sync_rw_sb(ic, REQ_OP_WRITE, REQ_FUA);
+		r = sync_rw_sb(ic, REQ_OP_WRITE | REQ_FUA);
 		if (unlikely(r))
 			dm_integrity_io_error(ic, "writing superblock", r);
 	}
 	if (ic->sb->flags & cpu_to_le32(SB_FLAG_DIRTY_BITMAP)) {
 		DEBUG_print("resume dirty_bitmap\n");
-		rw_journal_sectors(ic, REQ_OP_READ, 0, 0,
+		rw_journal_sectors(ic, REQ_OP_READ, 0,
 				   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 		if (ic->mode == 'B') {
 			if (ic->sb->log2_blocks_per_bitmap_bit == ic->log2_blocks_per_bitmap_bit &&
 				block_bitmap_op(ic, ic->recalc_bitmap, 0, ic->provided_data_sectors, BITMAP_OP_SET);
 				block_bitmap_op(ic, ic->may_write_bitmap, 0, ic->provided_data_sectors, BITMAP_OP_SET);
 				block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_SET);
-				rw_journal_sectors(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC, 0,
+				rw_journal_sectors(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC, 0,
 						   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 				ic->sb->flags |= cpu_to_le32(SB_FLAG_RECALCULATING);
 				ic->sb->recalc_sector = cpu_to_le64(0);
 			replay_journal(ic);
 			ic->sb->flags &= ~cpu_to_le32(SB_FLAG_DIRTY_BITMAP);
 		}
-		r = sync_rw_sb(ic, REQ_OP_WRITE, REQ_FUA);
+		r = sync_rw_sb(ic, REQ_OP_WRITE | REQ_FUA);
 		if (unlikely(r))
 			dm_integrity_io_error(ic, "writing superblock", r);
 	} else {
 		if (ic->mode == 'B') {
 			ic->sb->flags |= cpu_to_le32(SB_FLAG_DIRTY_BITMAP);
 			ic->sb->log2_blocks_per_bitmap_bit = ic->log2_blocks_per_bitmap_bit;
-			r = sync_rw_sb(ic, REQ_OP_WRITE, REQ_FUA);
+			r = sync_rw_sb(ic, REQ_OP_WRITE | REQ_FUA);
 			if (unlikely(r))
 				dm_integrity_io_error(ic, "writing superblock", r);
 				block_bitmap_op(ic, ic->may_write_bitmap, le64_to_cpu(ic->sb->recalc_sector),
 						ic->provided_data_sectors - le64_to_cpu(ic->sb->recalc_sector), BITMAP_OP_SET);
 			}
-			rw_journal_sectors(ic, REQ_OP_WRITE, REQ_FUA | REQ_SYNC, 0,
+			rw_journal_sectors(ic, REQ_OP_WRITE | REQ_FUA | REQ_SYNC, 0,
 					   ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);
 		}
 	}
 		goto bad;
 	}
-	r = sync_rw_sb(ic, REQ_OP_READ, 0);
+	r = sync_rw_sb(ic, REQ_OP_READ);
 	if (r) {
 		ti->error = "Error reading superblock";
 		goto bad;
 			ti->error = "Error initializing journal";
 			goto bad;
 		}
-		r = sync_rw_sb(ic, REQ_OP_WRITE, REQ_FUA);
+		r = sync_rw_sb(ic, REQ_OP_WRITE | REQ_FUA);
 		if (r) {
 			ti->error = "Error initializing superblock";
 			goto bad;

drivers/md/dm-io.c+19−19

 /*-----------------------------------------------------------------
  * IO routines that accept a list of pages.
  *---------------------------------------------------------------*/
-static void do_region(int op, int op_flags, unsigned region,
+static void do_region(const blk_opf_t opf, unsigned region,
 		      struct dm_io_region *where, struct dpages *dp,
 		      struct io *io)
 {
 	struct request_queue *q = bdev_get_queue(where->bdev);
 	sector_t num_sectors;
 	unsigned int special_cmd_max_sectors;
+	const enum req_op op = opf & REQ_OP_MASK;
 	/*
 	 * Reject unsupported discard and write same requests.
 						(PAGE_SIZE >> SECTOR_SHIFT)));
 		}
-		bio = bio_alloc_bioset(where->bdev, num_bvecs, op | op_flags,
+		bio = bio_alloc_bioset(where->bdev, num_bvecs, opf, GFP_NOIO,
-				       GFP_NOIO, &io->client->bios);
+				       &io->client->bios);
 		bio->bi_iter.bi_sector = where->sector + (where->count - remaining);
 		bio->bi_end_io = endio;
 		store_io_and_region_in_bio(bio, io, region);
 	} while (remaining);
 }
-static void dispatch_io(int op, int op_flags, unsigned int num_regions,
+static void dispatch_io(blk_opf_t opf, unsigned int num_regions,
 			struct dm_io_region *where, struct dpages *dp,
 			struct io *io, int sync)
 {
 	BUG_ON(num_regions > DM_IO_MAX_REGIONS);
 	if (sync)
-		op_flags |= REQ_SYNC;
+		opf |= REQ_SYNC;
 	/*
 	 * For multiple regions we need to be careful to rewind
 	 */
 	for (i = 0; i < num_regions; i++) {
 		*dp = old_pages;
-		if (where[i].count || (op_flags & REQ_PREFLUSH))
+		if (where[i].count || (opf & REQ_PREFLUSH))
-			do_region(op, op_flags, i, where + i, dp, io);
+			do_region(opf, i, where + i, dp, io);
 	}
 	/*
 }
 static int sync_io(struct dm_io_client *client, unsigned int num_regions,
-		   struct dm_io_region *where, int op, int op_flags,
+		   struct dm_io_region *where, blk_opf_t opf, struct dpages *dp,
-		   struct dpages *dp, unsigned long *error_bits)
+		   unsigned long *error_bits)
 {
 	struct io *io;
 	struct sync_io sio;
-	if (num_regions > 1 && !op_is_write(op)) {
+	if (num_regions > 1 && !op_is_write(opf)) {
 		WARN_ON(1);
 		return -EIO;
 	}
 	io->vma_invalidate_address = dp->vma_invalidate_address;
 	io->vma_invalidate_size = dp->vma_invalidate_size;
-	dispatch_io(op, op_flags, num_regions, where, dp, io, 1);
+	dispatch_io(opf, num_regions, where, dp, io, 1);
 	wait_for_completion_io(&sio.wait);
 }
 static int async_io(struct dm_io_client *client, unsigned int num_regions,
-		    struct dm_io_region *where, int op, int op_flags,
+		    struct dm_io_region *where, blk_opf_t opf,
 		    struct dpages *dp, io_notify_fn fn, void *context)
 {
 	struct io *io;
-	if (num_regions > 1 && !op_is_write(op)) {
+	if (num_regions > 1 && !op_is_write(opf)) {
 		WARN_ON(1);
 		fn(1, context);
 		return -EIO;
 	io->vma_invalidate_address = dp->vma_invalidate_address;
 	io->vma_invalidate_size = dp->vma_invalidate_size;
-	dispatch_io(op, op_flags, num_regions, where, dp, io, 0);
+	dispatch_io(opf, num_regions, where, dp, io, 0);
 	return 0;
 }
 	case DM_IO_VMA:
 		flush_kernel_vmap_range(io_req->mem.ptr.vma, size);
-		if (io_req->bi_op == REQ_OP_READ) {
+		if ((io_req->bi_opf & REQ_OP_MASK) == REQ_OP_READ) {
 			dp->vma_invalidate_address = io_req->mem.ptr.vma;
 			dp->vma_invalidate_size = size;
 		}
 	if (!io_req->notify.fn)
 		return sync_io(io_req->client, num_regions, where,
-			       io_req->bi_op, io_req->bi_op_flags, &dp,
+			       io_req->bi_opf, &dp, sync_error_bits);
-			       sync_error_bits);
-	return async_io(io_req->client, num_regions, where, io_req->bi_op,
+	return async_io(io_req->client, num_regions, where,
-			io_req->bi_op_flags, &dp, io_req->notify.fn,
+			io_req->bi_opf, &dp, io_req->notify.fn,
 			io_req->notify.context);
 }
 EXPORT_SYMBOL(dm_io);

drivers/md/dm-kcopyd.c+13−13

 	unsigned long write_err;
 	/*
-	 * Either READ or WRITE
+	 * REQ_OP_READ, REQ_OP_WRITE or REQ_OP_WRITE_ZEROES.
 	 */
-	int rw;
+	enum req_op op;
 	struct dm_io_region source;
 	/*
 	 * constraint and sequential writes that are at the right position.
 	 */
 	list_for_each_entry(job, jobs, list) {
-		if (job->rw == READ || !(job->flags & BIT(DM_KCOPYD_WRITE_SEQ))) {
+		if (job->op == REQ_OP_READ ||
+		    !(job->flags & BIT(DM_KCOPYD_WRITE_SEQ))) {
 			list_del(&job->list);
 			return job;
 		}
 	io_job_finish(kc->throttle);
 	if (error) {
-		if (op_is_write(job->rw))
+		if (op_is_write(job->op))
 			job->write_err |= error;
 		else
 			job->read_err = 1;
 		}
 	}
-	if (op_is_write(job->rw))
+	if (op_is_write(job->op))
 		push(&kc->complete_jobs, job);
 	else {
-		job->rw = WRITE;
+		job->op = REQ_OP_WRITE;
 		push(&kc->io_jobs, job);
 	}
 {
 	int r;
 	struct dm_io_request io_req = {
-		.bi_op = job->rw,
+		.bi_opf = job->op,
-		.bi_op_flags = 0,
 		.mem.type = DM_IO_PAGE_LIST,
 		.mem.ptr.pl = job->pages,
 		.mem.offset = 0,
 	io_job_start(job->kc->throttle);
-	if (job->rw == READ)
+	if (job->op == REQ_OP_READ)
 		r = dm_io(&io_req, 1, &job->source, NULL);
 	else
 		r = dm_io(&io_req, job->num_dests, job->dests, NULL);
 		if (r < 0) {
 			/* error this rogue job */
-			if (op_is_write(job->rw))
+			if (op_is_write(job->op))
 				job->write_err = (unsigned long) -1L;
 			else
 				job->read_err = 1;
 	if (from) {
 		job->source = *from;
 		job->pages = NULL;
-		job->rw = READ;
+		job->op = REQ_OP_READ;
 	} else {
 		memset(&job->source, 0, sizeof job->source);
 		job->source.count = job->dests[0].count;
 		/*
 		 * Use WRITE ZEROES to optimize zeroing if all dests support it.
 		 */
-		job->rw = REQ_OP_WRITE_ZEROES;
+		job->op = REQ_OP_WRITE_ZEROES;
 		for (i = 0; i < job->num_dests; i++)
 			if (!bdev_write_zeroes_sectors(job->dests[i].bdev)) {
-				job->rw = WRITE;
+				job->op = REQ_OP_WRITE;
 				break;
 			}
 	}

drivers/md/dm-log.c+3−5

 	core->nr_regions = le64_to_cpu(disk->nr_regions);
 }
-static int rw_header(struct log_c *lc, int op)
+static int rw_header(struct log_c *lc, enum req_op op)
 {
-	lc->io_req.bi_op = op;
+	lc->io_req.bi_opf = op;
-	lc->io_req.bi_op_flags = 0;
 	return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
 }
 		.count = 0,
 	};
-	lc->io_req.bi_op = REQ_OP_WRITE;
+	lc->io_req.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
-	lc->io_req.bi_op_flags = REQ_PREFLUSH;
 	return dm_io(&lc->io_req, 1, &null_location, NULL);
 }

drivers/md/dm-raid.c+1−1

@@ -2038,7 +2038,7 @@ static int read_disk_sb(struct md_rdev *rdev, int size, bool force_reload) · 2037 unmodified lines
2038		2038
2039	rdev->sb_loaded = 0;	2039	rdev->sb_loaded = 0;
2040		2040
2041	if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true)) {	2041	if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, true)) {
2042	DMERR("Failed to read superblock of device at position %d",	2042	DMERR("Failed to read superblock of device at position %d",
2043	rdev->raid_disk);	2043	rdev->raid_disk);
2044	md_error(rdev->mddev, rdev);	2044	md_error(rdev->mddev, rdev);

drivers/md/dm-raid1.c+5−7

 	struct dm_io_region io[MAX_NR_MIRRORS];
 	struct mirror *m;
 	struct dm_io_request io_req = {
-		.bi_op = REQ_OP_WRITE,
+		.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH | REQ_SYNC,
-		.bi_op_flags = REQ_PREFLUSH | REQ_SYNC,
 		.mem.type = DM_IO_KMEM,
 		.mem.ptr.addr = NULL,
 		.client = ms->io_client,
 {
 	struct dm_io_region io;
 	struct dm_io_request io_req = {
-		.bi_op = REQ_OP_READ,
+		.bi_opf = REQ_OP_READ,
-		.bi_op_flags = 0,
 		.mem.type = DM_IO_BIO,
 		.mem.ptr.bio = bio,
 		.notify.fn = read_callback,
 	unsigned int i;
 	struct dm_io_region io[MAX_NR_MIRRORS], *dest = io;
 	struct mirror *m;
+	blk_opf_t op_flags = bio->bi_opf & (REQ_FUA | REQ_PREFLUSH);
 	struct dm_io_request io_req = {
-		.bi_op = REQ_OP_WRITE,
+		.bi_opf = REQ_OP_WRITE | op_flags,
-		.bi_op_flags = bio->bi_opf & (REQ_FUA | REQ_PREFLUSH),
 		.mem.type = DM_IO_BIO,
 		.mem.ptr.bio = bio,
 		.notify.fn = write_callback,
 	};
 	if (bio_op(bio) == REQ_OP_DISCARD) {
-		io_req.bi_op = REQ_OP_DISCARD;
+		io_req.bi_opf = REQ_OP_DISCARD | op_flags;
 		io_req.mem.type = DM_IO_KMEM;
 		io_req.mem.ptr.addr = NULL;
 	}

drivers/md/dm-snap-persistent.c+12−13

 /*
  * Read or write a chunk aligned and sized block of data from a device.
  */
-static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, int op,
+static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, blk_opf_t opf,
-		    int op_flags, int metadata)
+		    int metadata)
 {
 	struct dm_io_region where = {
 		.bdev = dm_snap_cow(ps->store->snap)->bdev,
 		.count = ps->store->chunk_size,
 	};
 	struct dm_io_request io_req = {
-		.bi_op = op,
+		.bi_opf = opf,
-		.bi_op_flags = op_flags,
 		.mem.type = DM_IO_VMA,
 		.mem.ptr.vma = area,
 		.client = ps->io_client,
  * Read or write a metadata area.  Remembering to skip the first
  * chunk which holds the header.
  */
-static int area_io(struct pstore *ps, int op, int op_flags)
+static int area_io(struct pstore *ps, blk_opf_t opf)
 {
 	chunk_t chunk = area_location(ps, ps->current_area);
-	return chunk_io(ps, ps->area, chunk, op, op_flags, 0);
+	return chunk_io(ps, ps->area, chunk, opf, 0);
 }
 static void zero_memory_area(struct pstore *ps)
 static int zero_disk_area(struct pstore *ps, chunk_t area)
 {
 	return chunk_io(ps, ps->zero_area, area_location(ps, area),
-			REQ_OP_WRITE, 0, 0);
+			REQ_OP_WRITE, 0);
 }
 static int read_header(struct pstore *ps, int *new_snapshot)
 	if (r)
 		return r;
-	r = chunk_io(ps, ps->header_area, 0, REQ_OP_READ, 0, 1);
+	r = chunk_io(ps, ps->header_area, 0, REQ_OP_READ, 1);
 	if (r)
 		goto bad;
 	dh->version = cpu_to_le32(ps->version);
 	dh->chunk_size = cpu_to_le32(ps->store->chunk_size);
-	return chunk_io(ps, ps->header_area, 0, REQ_OP_WRITE, 0, 1);
+	return chunk_io(ps, ps->header_area, 0, REQ_OP_WRITE, 1);
 }
 /*
 	/*
 	 * Commit exceptions to disk.
 	 */
-	if (ps->valid && area_io(ps, REQ_OP_WRITE,
+	if (ps->valid && area_io(ps, REQ_OP_WRITE | REQ_PREFLUSH | REQ_FUA |
-				 REQ_PREFLUSH | REQ_FUA | REQ_SYNC))
+				 REQ_SYNC))
 		ps->valid = 0;
 	/*
 			return 0;
 		ps->current_area--;
-		r = area_io(ps, REQ_OP_READ, 0);
+		r = area_io(ps, REQ_OP_READ);
 		if (r < 0)
 			return r;
 		ps->current_committed = ps->exceptions_per_area;
 	for (i = 0; i < nr_merged; i++)
 		clear_exception(ps, ps->current_committed - 1 - i);
-	r = area_io(ps, REQ_OP_WRITE, REQ_PREFLUSH | REQ_FUA);
+	r = area_io(ps, REQ_OP_WRITE | REQ_PREFLUSH | REQ_FUA);
 	if (r < 0)
 		return r;

drivers/md/dm-table.c+2−4

@@ -1620,13 +1620,11 @@ static bool dm_table_supports_zoned_model(struct dm_table *t, · 1619 unmodified lines
1620	static int device_not_matches_zone_sectors(struct dm_target ti, struct dm_dev dev,	1620	static int device_not_matches_zone_sectors(struct dm_target ti, struct dm_dev dev,
1621	sector_t start, sector_t len, void *data)	1621	sector_t start, sector_t len, void *data)
1622	{	1622	{
1623	struct request_queue *q = bdev_get_queue(dev->bdev);
1624	unsigned int *zone_sectors = data;	1623	unsigned int *zone_sectors = data;
1625		1624
1626	if (!blk_queue_is_zoned(q))	1625	if (!bdev_is_zoned(dev->bdev))
1627	return 0;	1626	return 0;
1628		1627	return bdev_zone_sectors(dev->bdev) != *zone_sectors;
1629	return blk_queue_zone_sectors(q) != *zone_sectors;
1630	}	1628	}
1631		1629
1632	/*	1630	/*

drivers/md/dm-writecache.c+4−8

 		region.sector += wc->start_sector;
 		atomic_inc(&endio.count);
-		req.bi_op = REQ_OP_WRITE;
+		req.bi_opf = REQ_OP_WRITE | REQ_SYNC;
-		req.bi_op_flags = REQ_SYNC;
 		req.mem.type = DM_IO_VMA;
 		req.mem.ptr.vma = (char *)wc->memory_map + (size_t)i * BITMAP_GRANULARITY;
 		req.client = wc->dm_io;
 	region.sector += wc->start_sector;
-	req.bi_op = REQ_OP_WRITE;
+	req.bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_FUA;
-	req.bi_op_flags = REQ_SYNC | REQ_FUA;
 	req.mem.type = DM_IO_VMA;
 	req.mem.ptr.vma = (char *)wc->memory_map;
 	req.client = wc->dm_io;
 	region.bdev = dev->bdev;
 	region.sector = 0;
 	region.count = 0;
-	req.bi_op = REQ_OP_WRITE;
+	req.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
-	req.bi_op_flags = REQ_PREFLUSH;
 	req.mem.type = DM_IO_KMEM;
 	req.mem.ptr.addr = NULL;
 	req.client = wc->dm_io;
 	region.bdev = wc->ssd_dev->bdev;
 	region.sector = wc->start_sector;
 	region.count = n_sectors;
-	req.bi_op = REQ_OP_READ;
+	req.bi_opf = REQ_OP_READ | REQ_SYNC;
-	req.bi_op_flags = REQ_SYNC;
 	req.mem.type = DM_IO_VMA;
 	req.mem.ptr.vma = (char *)wc->memory_map;
 	req.client = wc->dm_io;

drivers/md/dm-zone.c+43−45

@@ -139,13 +139,11 @@ bool dm_is_zone_write(struct mapped_device md, struct bio bio) · 138 unmodified lines
139		139
140	void dm_cleanup_zoned_dev(struct mapped_device *md)	140	void dm_cleanup_zoned_dev(struct mapped_device *md)
141	{	141	{
142	struct request_queue *q = md->queue;	142	if (md->disk) {
143		143	kfree(md->disk->conv_zones_bitmap);
144	if (q) {	144	md->disk->conv_zones_bitmap = NULL;
145	kfree(q->conv_zones_bitmap);	145	kfree(md->disk->seq_zones_wlock);
146	q->conv_zones_bitmap = NULL;	146	md->disk->seq_zones_wlock = NULL;
147	kfree(q->seq_zones_wlock);
148	q->seq_zones_wlock = NULL;
149	}	147	}
150		148
151	kvfree(md->zwp_offset);	149	kvfree(md->zwp_offset);
@@ -179,31 +177,31 @@ static int dm_zone_revalidate_cb(struct blk_zone *zone, unsigned int idx, · 27 unmodified lines
179	void *data)	177	void *data)
180	{	178	{
181	struct mapped_device *md = data;	179	struct mapped_device *md = data;
182	struct request_queue *q = md->queue;	180	struct gendisk *disk = md->disk;
183		181
184	switch (zone->type) {	182	switch (zone->type) {
185	case BLK_ZONE_TYPE_CONVENTIONAL:	183	case BLK_ZONE_TYPE_CONVENTIONAL:
186	if (!q->conv_zones_bitmap) {	184	if (!disk->conv_zones_bitmap) {
187	q->conv_zones_bitmap =	185	disk->conv_zones_bitmap =
188	kcalloc(BITS_TO_LONGS(q->nr_zones),	186	kcalloc(BITS_TO_LONGS(disk->nr_zones),
189	sizeof(unsigned long), GFP_NOIO);	187	sizeof(unsigned long), GFP_NOIO);
190	if (!q->conv_zones_bitmap)	188	if (!disk->conv_zones_bitmap)
191	return -ENOMEM;	189	return -ENOMEM;
192	}	190	}
193	set_bit(idx, q->conv_zones_bitmap);	191	set_bit(idx, disk->conv_zones_bitmap);
194	break;	192	break;
195	case BLK_ZONE_TYPE_SEQWRITE_REQ:	193	case BLK_ZONE_TYPE_SEQWRITE_REQ:
196	case BLK_ZONE_TYPE_SEQWRITE_PREF:	194	case BLK_ZONE_TYPE_SEQWRITE_PREF:
197	if (!q->seq_zones_wlock) {	195	if (!disk->seq_zones_wlock) {
198	q->seq_zones_wlock =	196	disk->seq_zones_wlock =
199	kcalloc(BITS_TO_LONGS(q->nr_zones),	197	kcalloc(BITS_TO_LONGS(disk->nr_zones),
200	sizeof(unsigned long), GFP_NOIO);	198	sizeof(unsigned long), GFP_NOIO);
201	if (!q->seq_zones_wlock)	199	if (!disk->seq_zones_wlock)
202	return -ENOMEM;	200	return -ENOMEM;
203	}	201	}
204	if (!md->zwp_offset) {	202	if (!md->zwp_offset) {
205	md->zwp_offset =	203	md->zwp_offset =
206	kvcalloc(q->nr_zones, sizeof(unsigned int),	204	kvcalloc(disk->nr_zones, sizeof(unsigned int),
207	GFP_KERNEL);	205	GFP_KERNEL);
208	if (!md->zwp_offset)	206	if (!md->zwp_offset)
209	return -ENOMEM;	207	return -ENOMEM;
@@ -228,7 +226,7 @@ static int dm_zone_revalidate_cb(struct blk_zone *zone, unsigned int idx, · 18 unmodified lines
228	*/	226	*/
229	static int dm_revalidate_zones(struct mapped_device md, struct dm_table t)	227	static int dm_revalidate_zones(struct mapped_device md, struct dm_table t)
230	{	228	{
231	struct request_queue *q = md->queue;	229	struct gendisk *disk = md->disk;
232	unsigned int noio_flag;	230	unsigned int noio_flag;
233	int ret;	231	int ret;
234		232
@@ -236,7 +234,7 @@ static int dm_revalidate_zones(struct mapped_device md, struct dm_table t) · 1 unmodified line
236	* Check if something changed. If yes, cleanup the current resources	234	* Check if something changed. If yes, cleanup the current resources
237	* and reallocate everything.	235	* and reallocate everything.
238	*/	236	*/
239	if (!q->nr_zones \|\| q->nr_zones != md->nr_zones)	237	if (!disk->nr_zones \|\| disk->nr_zones != md->nr_zones)
240	dm_cleanup_zoned_dev(md);	238	dm_cleanup_zoned_dev(md);
241	if (md->nr_zones)	239	if (md->nr_zones)
242	return 0;	240	return 0;
@@ -246,17 +244,17 @@ static int dm_revalidate_zones(struct mapped_device md, struct dm_table t) · 3 unmodified lines
246	* operations in this context are done as if GFP_NOIO was specified.	244	* operations in this context are done as if GFP_NOIO was specified.
247	*/	245	*/
248	noio_flag = memalloc_noio_save();	246	noio_flag = memalloc_noio_save();
249	ret = dm_blk_do_report_zones(md, t, 0, q->nr_zones,	247	ret = dm_blk_do_report_zones(md, t, 0, disk->nr_zones,
250	dm_zone_revalidate_cb, md);	248	dm_zone_revalidate_cb, md);
251	memalloc_noio_restore(noio_flag);	249	memalloc_noio_restore(noio_flag);
252	if (ret < 0)	250	if (ret < 0)
253	goto err;	251	goto err;
254	if (ret != q->nr_zones) {	252	if (ret != disk->nr_zones) {
255	ret = -EIO;	253	ret = -EIO;
256	goto err;	254	goto err;
257	}	255	}
258		256
259	md->nr_zones = q->nr_zones;	257	md->nr_zones = disk->nr_zones;
260		258
261	return 0;	259	return 0;
262		260
@@ -270,7 +268,7 @@ static int device_not_zone_append_capable(struct dm_target *ti, · 7 unmodified lines
270	struct dm_dev *dev, sector_t start,	268	struct dm_dev *dev, sector_t start,
271	sector_t len, void *data)	269	sector_t len, void *data)
272	{	270	{
273	return !blk_queue_is_zoned(bdev_get_queue(dev->bdev));	271	return !bdev_is_zoned(dev->bdev);
274	}	272	}
275		273
276	static bool dm_table_supports_zone_append(struct dm_table *t)	274	static bool dm_table_supports_zone_append(struct dm_table *t)
@@ -301,7 +299,7 @@ int dm_set_zones_restrictions(struct dm_table t, struct request_queue q) · 24 unmodified lines
301	* correct value to be exposed in sysfs queue/nr_zones.	299	* correct value to be exposed in sysfs queue/nr_zones.
302	*/	300	*/
303	WARN_ON_ONCE(queue_is_mq(q));	301	WARN_ON_ONCE(queue_is_mq(q));
304	q->nr_zones = blkdev_nr_zones(md->disk);	302	md->disk->nr_zones = bdev_nr_zones(md->disk->part0);
305		303
306	/* Check if zone append is natively supported */	304	/* Check if zone append is natively supported */
307	if (dm_table_supports_zone_append(t)) {	305	if (dm_table_supports_zone_append(t)) {
@@ -334,7 +332,7 @@ static int dm_update_zone_wp_offset_cb(struct blk_zone *zone, unsigned int idx, · 26 unmodified lines
334	static int dm_update_zone_wp_offset(struct mapped_device *md, unsigned int zno,	332	static int dm_update_zone_wp_offset(struct mapped_device *md, unsigned int zno,
335	unsigned int *wp_ofst)	333	unsigned int *wp_ofst)
336	{	334	{
337	sector_t sector = zno * blk_queue_zone_sectors(md->queue);	335	sector_t sector = zno * bdev_zone_sectors(md->disk->part0);
338	unsigned int noio_flag;	336	unsigned int noio_flag;
339	struct dm_table *t;	337	struct dm_table *t;
340	int srcu_idx, ret;	338	int srcu_idx, ret;
@@ -361,7 +359,7 @@ static int dm_update_zone_wp_offset(struct mapped_device *md, unsigned int zno, · 20 unmodified lines
361	}	359	}
362		360
363	struct orig_bio_details {	361	struct orig_bio_details {
364	unsigned int op;	362	enum req_op op;
365	unsigned int nr_sectors;	363	unsigned int nr_sectors;
366	};	364	};
367		365
@@ -373,7 +371,7 @@ struct orig_bio_details { · 5 unmodified lines
373	static bool dm_zone_map_bio_begin(struct mapped_device *md,	371	static bool dm_zone_map_bio_begin(struct mapped_device *md,
374	unsigned int zno, struct bio *clone)	372	unsigned int zno, struct bio *clone)
375	{	373	{
376	sector_t zsectors = blk_queue_zone_sectors(md->queue);	374	sector_t zsectors = bdev_zone_sectors(md->disk->part0);
377	unsigned int zwp_offset = READ_ONCE(md->zwp_offset[zno]);	375	unsigned int zwp_offset = READ_ONCE(md->zwp_offset[zno]);
378		376
379	/*	377	/*
@@ -443,7 +441,7 @@ static blk_status_t dm_zone_map_bio_end(struct mapped_device *md, unsigned int z · 63 unmodified lines
443	return BLK_STS_OK;	441	return BLK_STS_OK;
444	case REQ_OP_ZONE_FINISH:	442	case REQ_OP_ZONE_FINISH:
445	WRITE_ONCE(md->zwp_offset[zno],	443	WRITE_ONCE(md->zwp_offset[zno],
446	blk_queue_zone_sectors(md->queue));	444	bdev_zone_sectors(md->disk->part0));
447	return BLK_STS_OK;	445	return BLK_STS_OK;
448	case REQ_OP_WRITE_ZEROES:	446	case REQ_OP_WRITE_ZEROES:
449	case REQ_OP_WRITE:	447	case REQ_OP_WRITE:
@@ -466,26 +464,26 @@ static blk_status_t dm_zone_map_bio_end(struct mapped_device *md, unsigned int z · 16 unmodified lines
466	}	464	}
467	}	465	}
468		466
469	static inline void dm_zone_lock(struct request_queue *q,	467	static inline void dm_zone_lock(struct gendisk *disk, unsigned int zno,
470	unsigned int zno, struct bio *clone)	468	struct bio *clone)
471	{	469	{
472	if (WARN_ON_ONCE(bio_flagged(clone, BIO_ZONE_WRITE_LOCKED)))	470	if (WARN_ON_ONCE(bio_flagged(clone, BIO_ZONE_WRITE_LOCKED)))
473	return;	471	return;
474		472
475	wait_on_bit_lock_io(q->seq_zones_wlock, zno, TASK_UNINTERRUPTIBLE);	473	wait_on_bit_lock_io(disk->seq_zones_wlock, zno, TASK_UNINTERRUPTIBLE);
476	bio_set_flag(clone, BIO_ZONE_WRITE_LOCKED);	474	bio_set_flag(clone, BIO_ZONE_WRITE_LOCKED);
477	}	475	}
478		476
479	static inline void dm_zone_unlock(struct request_queue *q,	477	static inline void dm_zone_unlock(struct gendisk *disk, unsigned int zno,
480	unsigned int zno, struct bio *clone)	478	struct bio *clone)
481	{	479	{
482	if (!bio_flagged(clone, BIO_ZONE_WRITE_LOCKED))	480	if (!bio_flagged(clone, BIO_ZONE_WRITE_LOCKED))
483	return;	481	return;
484		482
485	WARN_ON_ONCE(!test_bit(zno, q->seq_zones_wlock));	483	WARN_ON_ONCE(!test_bit(zno, disk->seq_zones_wlock));
486	clear_bit_unlock(zno, q->seq_zones_wlock);	484	clear_bit_unlock(zno, disk->seq_zones_wlock);
487	smp_mb__after_atomic();	485	smp_mb__after_atomic();
488	wake_up_bit(q->seq_zones_wlock, zno);	486	wake_up_bit(disk->seq_zones_wlock, zno);
489		487
490	bio_clear_flag(clone, BIO_ZONE_WRITE_LOCKED);	488	bio_clear_flag(clone, BIO_ZONE_WRITE_LOCKED);
491	}	489	}
@@ -520,7 +518,6 @@ int dm_zone_map_bio(struct dm_target_io *tio) · 28 unmodified lines
520	struct dm_io *io = tio->io;	518	struct dm_io *io = tio->io;
521	struct dm_target *ti = tio->ti;	519	struct dm_target *ti = tio->ti;
522	struct mapped_device *md = io->md;	520	struct mapped_device *md = io->md;
523	struct request_queue *q = md->queue;
524	struct bio *clone = &tio->clone;	521	struct bio *clone = &tio->clone;
525	struct orig_bio_details orig_bio_details;	522	struct orig_bio_details orig_bio_details;
526	unsigned int zno;	523	unsigned int zno;
@@ -536,7 +533,7 @@ int dm_zone_map_bio(struct dm_target_io *tio) · 9 unmodified lines
536		533
537	/* Lock the target zone */	534	/* Lock the target zone */
538	zno = bio_zone_no(clone);	535	zno = bio_zone_no(clone);
539	dm_zone_lock(q, zno, clone);	536	dm_zone_lock(md->disk, zno, clone);
540		537
541	orig_bio_details.nr_sectors = bio_sectors(clone);	538	orig_bio_details.nr_sectors = bio_sectors(clone);
542	orig_bio_details.op = bio_op(clone);	539	orig_bio_details.op = bio_op(clone);
@@ -546,7 +543,7 @@ int dm_zone_map_bio(struct dm_target_io *tio) · 3 unmodified lines
546	* both valid, and if the bio is a zone append, remap it to a write.	543	* both valid, and if the bio is a zone append, remap it to a write.
547	*/	544	*/
548	if (!dm_zone_map_bio_begin(md, zno, clone)) {	545	if (!dm_zone_map_bio_begin(md, zno, clone)) {
549	dm_zone_unlock(q, zno, clone);	546	dm_zone_unlock(md->disk, zno, clone);
550	return DM_MAPIO_KILL;	547	return DM_MAPIO_KILL;
551	}	548	}
552		549
@@ -570,12 +567,12 @@ int dm_zone_map_bio(struct dm_target_io *tio) · 17 unmodified lines
570	sts = dm_zone_map_bio_end(md, zno, &orig_bio_details,	567	sts = dm_zone_map_bio_end(md, zno, &orig_bio_details,
571	*tio->len_ptr);	568	*tio->len_ptr);
572	if (sts != BLK_STS_OK)	569	if (sts != BLK_STS_OK)
573	dm_zone_unlock(q, zno, clone);	570	dm_zone_unlock(md->disk, zno, clone);
574	break;	571	break;
575	case DM_MAPIO_REQUEUE:	572	case DM_MAPIO_REQUEUE:
576	case DM_MAPIO_KILL:	573	case DM_MAPIO_KILL:
577	default:	574	default:
578	dm_zone_unlock(q, zno, clone);	575	dm_zone_unlock(md->disk, zno, clone);
579	sts = BLK_STS_IOERR;	576	sts = BLK_STS_IOERR;
580	break;	577	break;
581	}	578	}
@@ -592,7 +589,7 @@ int dm_zone_map_bio(struct dm_target_io *tio) · 10 unmodified lines
592	void dm_zone_endio(struct dm_io io, struct bio clone)	589	void dm_zone_endio(struct dm_io io, struct bio clone)
593	{	590	{
594	struct mapped_device *md = io->md;	591	struct mapped_device *md = io->md;
595	struct request_queue *q = md->queue;	592	struct gendisk *disk = md->disk;
596	struct bio *orig_bio = io->orig_bio;	593	struct bio *orig_bio = io->orig_bio;
597	unsigned int zwp_offset;	594	unsigned int zwp_offset;
598	unsigned int zno;	595	unsigned int zno;
@@ -608,7 +605,8 @@ void dm_zone_endio(struct dm_io io, struct bio clone) · 9 unmodified lines
608	*/	605	*/
609	if (clone->bi_status == BLK_STS_OK &&	606	if (clone->bi_status == BLK_STS_OK &&
610	bio_op(clone) == REQ_OP_ZONE_APPEND) {	607	bio_op(clone) == REQ_OP_ZONE_APPEND) {
611	sector_t mask = (sector_t)blk_queue_zone_sectors(q) - 1;	608	sector_t mask =
		609	(sector_t)bdev_zone_sectors(disk->part0) - 1;
612		610
613	orig_bio->bi_iter.bi_sector +=	611	orig_bio->bi_iter.bi_sector +=
614	clone->bi_iter.bi_sector & mask;	612	clone->bi_iter.bi_sector & mask;
@@ -649,5 +647,5 @@ void dm_zone_endio(struct dm_io io, struct bio clone) · 34 unmodified lines
649	zwp_offset - bio_sectors(orig_bio);	647	zwp_offset - bio_sectors(orig_bio);
650	}	648	}
651		649
652	dm_zone_unlock(q, zno, clone);	650	dm_zone_unlock(disk, zno, clone);
653	}	651	}

drivers/md/dm-zoned-metadata.c+3−2

 /*
  * Read/write a metadata block.
  */
-static int dmz_rdwr_block(struct dmz_dev *dev, int op,
+static int dmz_rdwr_block(struct dmz_dev *dev, enum req_op op,
 			  sector_t block, struct page *page)
 {
 	struct bio *bio;
  * allocated and used to map the chunk.
  * The zone returned will be set to the active state.
  */
-struct dm_zone *dmz_get_chunk_mapping(struct dmz_metadata *zmd, unsigned int chunk, int op)
+struct dm_zone *dmz_get_chunk_mapping(struct dmz_metadata *zmd,
+				      unsigned int chunk, enum req_op op)
 {
 	struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];
 	struct dmz_map *dmap = (struct dmz_map *) dmap_mblk->data;

drivers/md/dm-zoned-target.c+12−13

 static int dmz_fixup_devices(struct dm_target *ti)
 {
 	struct dmz_target *dmz = ti->private;
-	struct dmz_dev *reg_dev, *zoned_dev;
+	struct dmz_dev *reg_dev = NULL;
-	struct request_queue *q;
 	sector_t zone_nr_sectors = 0;
 	int i;
 			return -EINVAL;
 		}
 		for (i = 1; i < dmz->nr_ddevs; i++) {
-			zoned_dev = &dmz->dev[i];
+			struct dmz_dev *zoned_dev = &dmz->dev[i];
+			struct block_device *bdev = zoned_dev->bdev;
 			if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
 				ti->error = "Secondary disk is not a zoned device";
 				return -EINVAL;
 			}
-			q = bdev_get_queue(zoned_dev->bdev);
 			if (zone_nr_sectors &&
-			    zone_nr_sectors != blk_queue_zone_sectors(q)) {
+			    zone_nr_sectors != bdev_zone_sectors(bdev)) {
 				ti->error = "Zone nr sectors mismatch";
 				return -EINVAL;
 			}
-			zone_nr_sectors = blk_queue_zone_sectors(q);
+			zone_nr_sectors = bdev_zone_sectors(bdev);
 			zoned_dev->zone_nr_sectors = zone_nr_sectors;
-			zoned_dev->nr_zones =
+			zoned_dev->nr_zones = bdev_nr_zones(bdev);
-				blkdev_nr_zones(zoned_dev->bdev->bd_disk);
 		}
 	} else {
-		reg_dev = NULL;
+		struct dmz_dev *zoned_dev = &dmz->dev[0];
-		zoned_dev = &dmz->dev[0];
+		struct block_device *bdev = zoned_dev->bdev;
 		if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
 			ti->error = "Disk is not a zoned device";
 			return -EINVAL;
 		}
-		q = bdev_get_queue(zoned_dev->bdev);
+		zoned_dev->zone_nr_sectors = bdev_zone_sectors(bdev);
-		zoned_dev->zone_nr_sectors = blk_queue_zone_sectors(q);
+		zoned_dev->nr_zones = bdev_nr_zones(bdev);
-		zoned_dev->nr_zones = blkdev_nr_zones(zoned_dev->bdev->bd_disk);
 	}
 	if (reg_dev) {

drivers/md/dm-zoned.h+1−1

@@ -248,7 +248,7 @@ struct dm_zone dmz_get_zone_for_reclaim(struct dmz_metadata zmd, · 247 unmodified lines
248	unsigned int dev_idx, bool idle);	248	unsigned int dev_idx, bool idle);
249		249
250	struct dm_zone dmz_get_chunk_mapping(struct dmz_metadata zmd,	250	struct dm_zone dmz_get_chunk_mapping(struct dmz_metadata zmd,
251	unsigned int chunk, int op);	251	unsigned int chunk, enum req_op op);
252	void dmz_put_chunk_mapping(struct dmz_metadata zmd, struct dm_zone zone);	252	void dmz_put_chunk_mapping(struct dmz_metadata zmd, struct dm_zone zone);
253	struct dm_zone dmz_get_chunk_buffer(struct dmz_metadata zmd,	253	struct dm_zone dmz_get_chunk_buffer(struct dmz_metadata zmd,
254	struct dm_zone *dzone);	254	struct dm_zone *dzone);

drivers/md/dm.c+15−18

 }
 static inline struct dm_table *dm_get_live_table_bio(struct mapped_device *md,
-						     int *srcu_idx, unsigned bio_opf)
+					int *srcu_idx, blk_opf_t bio_opf)
 {
 	if (bio_opf & REQ_NOWAIT)
 		return dm_get_live_table_fast(md);
 }
 static inline void dm_put_live_table_bio(struct mapped_device *md, int srcu_idx,
-					 unsigned bio_opf)
+					 blk_opf_t bio_opf)
 {
 	if (bio_opf & REQ_NOWAIT)
 		dm_put_live_table_fast(md);
 	}
 	if (static_branch_unlikely(&zoned_enabled) &&
-	    unlikely(blk_queue_is_zoned(bdev_get_queue(bio->bi_bdev))))
+	    unlikely(bdev_is_zoned(bio->bi_bdev)))
 		dm_zone_endio(io, bio);
 	if (endio) {
 {
 	sector_t target_offset = dm_target_offset(ti, sector);
 	sector_t len = max_io_len_target_boundary(ti, target_offset);
-	sector_t max_len;
 	/*
 	 * Does the target need to split IO even further?
 	 * - varied (per target) IO splitting is a tenet of DM; this
 	 *   explains why stacked chunk_sectors based splitting via
-	 *   blk_max_size_offset() isn't possible here. So pass in
+	 *   blk_queue_split() isn't possible here.
-	 *   ti->max_io_len to override stacked chunk_sectors.
 	 */
-	if (ti->max_io_len) {
+	if (!ti->max_io_len)
-		max_len = blk_max_size_offset(ti->table->md->queue,
+		return len;
-					      target_offset, ti->max_io_len);
+	return min_t(sector_t, len,
-		if (len > max_len)
+		min(queue_max_sectors(ti->table->md->queue),
-			len = max_len;
+		    blk_chunk_sectors_left(target_offset, ti->max_io_len)));
-	}
-	return len;
 }
 int dm_set_target_max_io_len(struct dm_target *ti, sector_t len)
 static bool is_abnormal_io(struct bio *bio)
 {
-	unsigned int op = bio_op(bio);
+	enum req_op op = bio_op(bio);
 	if (op != REQ_OP_READ && op != REQ_OP_WRITE && op != REQ_OP_FLUSH) {
 		switch (op) {
 	case REQ_OP_WRITE_ZEROES:
 		num_bios = ti->num_write_zeroes_bios;
 		break;
+	default:
+		break;
 	}
 	/*
 	 * Only support bio polling for normal IO, and the target io is
 	 * exactly inside the dm_io instance (verified in dm_poll_dm_io)
 	 */
-	ci->submit_as_polled = ci->bio->bi_opf & REQ_POLLED;
+	ci->submit_as_polled = !!(ci->bio->bi_opf & REQ_POLLED);
 	len = min_t(sector_t, max_io_len(ti, ci->sector), ci->sector_count);
 	setup_split_accounting(ci, len);
 	struct mapped_device *md = bio->bi_bdev->bd_disk->private_data;
 	int srcu_idx;
 	struct dm_table *map;
-	unsigned bio_opf = bio->bi_opf;
+	blk_opf_t bio_opf = bio->bi_opf;
 	map = dm_get_live_table_bio(md, &srcu_idx, bio_opf);
 			del_gendisk(md->disk);
 		}
 		dm_queue_destroy_crypto_profile(md->queue);
-		blk_cleanup_disk(md->disk);
+		put_disk(md->disk);
 	}
 	if (md->pending_io) {

drivers/md/md-bitmap.c+3−3

@@ -165,7 +165,7 @@ static int read_sb_page(struct mddev *mddev, loff_t offset, · 164 unmodified lines
165		165
166	if (sync_page_io(rdev, target,	166	if (sync_page_io(rdev, target,
167	roundup(size, bdev_logical_block_size(rdev->bdev)),	167	roundup(size, bdev_logical_block_size(rdev->bdev)),
168	page, REQ_OP_READ, 0, true)) {	168	page, REQ_OP_READ, true)) {
169	page->index = index;	169	page->index = index;
170	return 0;	170	return 0;
171	}	171	}
@@ -302,7 +302,7 @@ static void write_page(struct bitmap bitmap, struct page page, int wait) · 130 unmodified lines
302	atomic_inc(&bitmap->pending_writes);	302	atomic_inc(&bitmap->pending_writes);
303	set_buffer_locked(bh);	303	set_buffer_locked(bh);
304	set_buffer_mapped(bh);	304	set_buffer_mapped(bh);
305	submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);	305	submit_bh(REQ_OP_WRITE \| REQ_SYNC, bh);
306	bh = bh->b_this_page;	306	bh = bh->b_this_page;
307	}	307	}
308		308
@@ -394,7 +394,7 @@ static int read_page(struct file *file, unsigned long index, · 85 unmodified lines
394	atomic_inc(&bitmap->pending_writes);	394	atomic_inc(&bitmap->pending_writes);
395	set_buffer_locked(bh);	395	set_buffer_locked(bh);
396	set_buffer_mapped(bh);	396	set_buffer_mapped(bh);
397	submit_bh(REQ_OP_READ, 0, bh);	397	submit_bh(REQ_OP_READ, bh);
398	}	398	}
399	blk_cur++;	399	blk_cur++;
400	bh = bh->b_this_page;	400	bh = bh->b_this_page;

drivers/md/md.c+8−8

@@ -993,15 +993,15 @@ int md_super_wait(struct mddev *mddev) · 992 unmodified lines
993	}	993	}
994		994
995	int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,	995	int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
996	struct page *page, int op, int op_flags, bool metadata_op)	996	struct page *page, blk_opf_t opf, bool metadata_op)
997	{	997	{
998	struct bio bio;	998	struct bio bio;
999	struct bio_vec bvec;	999	struct bio_vec bvec;
1000		1000
1001	if (metadata_op && rdev->meta_bdev)	1001	if (metadata_op && rdev->meta_bdev)
1002	bio_init(&bio, rdev->meta_bdev, &bvec, 1, op \| op_flags);	1002	bio_init(&bio, rdev->meta_bdev, &bvec, 1, opf);
1003	else	1003	else
1004	bio_init(&bio, rdev->bdev, &bvec, 1, op \| op_flags);	1004	bio_init(&bio, rdev->bdev, &bvec, 1, opf);
1005		1005
1006	if (metadata_op)	1006	if (metadata_op)
1007	bio.bi_iter.bi_sector = sector + rdev->sb_start;	1007	bio.bi_iter.bi_sector = sector + rdev->sb_start;
@@ -1024,7 +1024,7 @@ static int read_disk_sb(struct md_rdev *rdev, int size) · 16 unmodified lines
1024	if (rdev->sb_loaded)	1024	if (rdev->sb_loaded)
1025	return 0;	1025	return 0;
1026		1026
1027	if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))	1027	if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, true))
1028	goto fail;	1028	goto fail;
1029	rdev->sb_loaded = 1;	1029	rdev->sb_loaded = 1;
1030	return 0;	1030	return 0;
@@ -1722,7 +1722,7 @@ static int super_1_load(struct md_rdev rdev, struct md_rdev refdev, int minor_ · 691 unmodified lines
1722	return -EINVAL;	1722	return -EINVAL;
1723	bb_sector = (long long)offset;	1723	bb_sector = (long long)offset;
1724	if (!sync_page_io(rdev, bb_sector, sectors << 9,	1724	if (!sync_page_io(rdev, bb_sector, sectors << 9,
1725	rdev->bb_page, REQ_OP_READ, 0, true))	1725	rdev->bb_page, REQ_OP_READ, true))
1726	return -EIO;	1726	return -EIO;
1727	bbp = (__le64 *)page_address(rdev->bb_page);	1727	bbp = (__le64 *)page_address(rdev->bb_page);
1728	rdev->badblocks.shift = sb->bblog_shift;	1728	rdev->badblocks.shift = sb->bblog_shift;
@@ -2438,7 +2438,7 @@ static int bind_rdev_to_array(struct md_rdev rdev, struct mddev mddev) · 709 unmodified lines
2438	mdname(mddev), mddev->max_disks);	2438	mdname(mddev), mddev->max_disks);
2439	return -EBUSY;	2439	return -EBUSY;
2440	}	2440	}
2441	bdevname(rdev->bdev,b);	2441	snprintf(b, sizeof(b), "%pg", rdev->bdev);
2442	strreplace(b, '/', '!');	2442	strreplace(b, '/', '!');
2443		2443
2444	rdev->mddev = mddev;	2444	rdev->mddev = mddev;
@@ -5579,7 +5579,7 @@ static void md_free(struct kobject *ko) · 3134 unmodified lines
5579		5579
5580	if (mddev->gendisk) {	5580	if (mddev->gendisk) {
5581	del_gendisk(mddev->gendisk);	5581	del_gendisk(mddev->gendisk);
5582	blk_cleanup_disk(mddev->gendisk);	5582	put_disk(mddev->gendisk);
5583	}	5583	}
5584	percpu_ref_exit(&mddev->writes_pending);	5584	percpu_ref_exit(&mddev->writes_pending);
5585		5585
@@ -5718,7 +5718,7 @@ static int md_alloc(dev_t dev, char *name) · 132 unmodified lines
5718	out_del_gendisk:	5718	out_del_gendisk:
5719	del_gendisk(disk);	5719	del_gendisk(disk);
5720	out_cleanup_disk:	5720	out_cleanup_disk:
5721	blk_cleanup_disk(disk);	5721	put_disk(disk);
5722	out_unlock_disks_mutex:	5722	out_unlock_disks_mutex:
5723	mutex_unlock(&disks_mutex);	5723	mutex_unlock(&disks_mutex);
5724	mddev_put(mddev);	5724	mddev_put(mddev);

drivers/md/md.h+1−2

 			   sector_t sector, int size, struct page *page);
 extern int md_super_wait(struct mddev *mddev);
 extern int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
-			struct page *page, int op, int op_flags,
+		struct page *page, blk_opf_t opf, bool metadata_op);
-			bool metadata_op);
 extern void md_do_sync(struct md_thread *thread);
 extern void md_new_event(void);
 extern void md_allow_write(struct mddev *mddev);

drivers/md/raid1.c+7−7

@@ -1220,8 +1220,8 @@ static void raid1_read_request(struct mddev mddev, struct bio bio, · 1219 unmodified lines
1220	struct raid1_info *mirror;	1220	struct raid1_info *mirror;
1221	struct bio *read_bio;	1221	struct bio *read_bio;
1222	struct bitmap *bitmap = mddev->bitmap;	1222	struct bitmap *bitmap = mddev->bitmap;
1223	const int op = bio_op(bio);	1223	const enum req_op op = bio_op(bio);
1224	const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);	1224	const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
1225	int max_sectors;	1225	int max_sectors;
1226	int rdisk;	1226	int rdisk;
1227	bool r1bio_existed = !!r1_bio;	1227	bool r1bio_existed = !!r1_bio;
@@ -1240,7 +1240,7 @@ static void raid1_read_request(struct mddev mddev, struct bio bio, · 12 unmodified lines
1240	rcu_read_lock();	1240	rcu_read_lock();
1241	rdev = rcu_dereference(conf->mirrors[r1_bio->read_disk].rdev);	1241	rdev = rcu_dereference(conf->mirrors[r1_bio->read_disk].rdev);
1242	if (rdev)	1242	if (rdev)
1243	bdevname(rdev->bdev, b);	1243	snprintf(b, sizeof(b), "%pg", rdev->bdev);
1244	else	1244	else
1245	strcpy(b, "???");	1245	strcpy(b, "???");
1246	rcu_read_unlock();	1246	rcu_read_unlock();
@@ -1988,9 +1988,9 @@ static void end_sync_write(struct bio *bio) · 741 unmodified lines
1988	}	1988	}
1989		1989
1990	static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector,	1990	static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector,
1991	int sectors, struct page *page, int rw)	1991	int sectors, struct page *page, int rw)
1992	{	1992	{
1993	if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))	1993	if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
1994	/* success */	1994	/* success */
1995	return 1;	1995	return 1;
1996	if (rw == WRITE) {	1996	if (rw == WRITE) {
@@ -2057,7 +2057,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio) · 60 unmodified lines
2057	rdev = conf->mirrors[d].rdev;	2057	rdev = conf->mirrors[d].rdev;
2058	if (sync_page_io(rdev, sect, s<<9,	2058	if (sync_page_io(rdev, sect, s<<9,
2059	pages[idx],	2059	pages[idx],
2060	REQ_OP_READ, 0, false)) {	2060	REQ_OP_READ, false)) {
2061	success = 1;	2061	success = 1;
2062	break;	2062	break;
2063	}	2063	}
@@ -2305,7 +2305,7 @@ static void fix_read_error(struct r1conf *conf, int read_disk, · 241 unmodified lines
2305	atomic_inc(&rdev->nr_pending);	2305	atomic_inc(&rdev->nr_pending);
2306	rcu_read_unlock();	2306	rcu_read_unlock();
2307	if (sync_page_io(rdev, sect, s<<9,	2307	if (sync_page_io(rdev, sect, s<<9,
2308	conf->tmppage, REQ_OP_READ, 0, false))	2308	conf->tmppage, REQ_OP_READ, false))
2309	success = 1;	2309	success = 1;
2310	rdev_dec_pending(rdev, mddev);	2310	rdev_dec_pending(rdev, mddev);
2311	if (success)	2311	if (success)

drivers/md/raid10.c+11−11

@@ -1136,8 +1136,8 @@ static void raid10_read_request(struct mddev mddev, struct bio bio, · 1135 unmodified lines
1136	{	1136	{
1137	struct r10conf *conf = mddev->private;	1137	struct r10conf *conf = mddev->private;
1138	struct bio *read_bio;	1138	struct bio *read_bio;
1139	const int op = bio_op(bio);	1139	const enum req_op op = bio_op(bio);
1140	const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);	1140	const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
1141	int max_sectors;	1141	int max_sectors;
1142	struct md_rdev *rdev;	1142	struct md_rdev *rdev;
1143	char b[BDEVNAME_SIZE];	1143	char b[BDEVNAME_SIZE];
@@ -1164,7 +1164,7 @@ static void raid10_read_request(struct mddev mddev, struct bio bio, · 20 unmodified lines
1164	disk = r10_bio->devs[slot].devnum;	1164	disk = r10_bio->devs[slot].devnum;
1165	err_rdev = rcu_dereference(conf->mirrors[disk].rdev);	1165	err_rdev = rcu_dereference(conf->mirrors[disk].rdev);
1166	if (err_rdev)	1166	if (err_rdev)
1167	bdevname(err_rdev->bdev, b);	1167	snprintf(b, sizeof(b), "%pg", err_rdev->bdev);
1168	else {	1168	else {
1169	strcpy(b, "???");	1169	strcpy(b, "???");
1170	/* This never gets dereferenced */	1170	/* This never gets dereferenced */
@@ -1230,9 +1230,9 @@ static void raid10_write_one_disk(struct mddev mddev, struct r10bio r10_bio, · 59 unmodified lines
1230	struct bio *bio, bool replacement,	1230	struct bio *bio, bool replacement,
1231	int n_copy)	1231	int n_copy)
1232	{	1232	{
1233	const int op = bio_op(bio);	1233	const enum req_op op = bio_op(bio);
1234	const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);	1234	const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
1235	const unsigned long do_fua = (bio->bi_opf & REQ_FUA);	1235	const blk_opf_t do_fua = bio->bi_opf & REQ_FUA;
1236	unsigned long flags;	1236	unsigned long flags;
1237	struct blk_plug_cb *cb;	1237	struct blk_plug_cb *cb;
1238	struct raid1_plug_cb *plug = NULL;	1238	struct raid1_plug_cb *plug = NULL;
@@ -2512,7 +2512,7 @@ static void fix_recovery_read_error(struct r10bio *r10_bio) · 1273 unmodified lines
2512	addr,	2512	addr,
2513	s << 9,	2513	s << 9,
2514	pages[idx],	2514	pages[idx],
2515	REQ_OP_READ, 0, false);	2515	REQ_OP_READ, false);
2516	if (ok) {	2516	if (ok) {
2517	rdev = conf->mirrors[dw].rdev;	2517	rdev = conf->mirrors[dw].rdev;
2518	addr = r10_bio->devs[1].addr + sect;	2518	addr = r10_bio->devs[1].addr + sect;
@@ -2520,7 +2520,7 @@ static void fix_recovery_read_error(struct r10bio *r10_bio) · 1 unmodified line
2520	addr,	2520	addr,
2521	s << 9,	2521	s << 9,
2522	pages[idx],	2522	pages[idx],
2523	REQ_OP_WRITE, 0, false);	2523	REQ_OP_WRITE, false);
2524	if (!ok) {	2524	if (!ok) {
2525	set_bit(WriteErrorSeen, &rdev->flags);	2525	set_bit(WriteErrorSeen, &rdev->flags);
2526	if (!test_and_set_bit(WantReplacement,	2526	if (!test_and_set_bit(WantReplacement,
@@ -2644,7 +2644,7 @@ static int r10_sync_page_io(struct md_rdev *rdev, sector_t sector, · 117 unmodified lines
2644	if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)	2644	if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
2645	&& (rw == READ \|\| test_bit(WriteErrorSeen, &rdev->flags)))	2645	&& (rw == READ \|\| test_bit(WriteErrorSeen, &rdev->flags)))
2646	return -1;	2646	return -1;
2647	if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))	2647	if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
2648	/* success */	2648	/* success */
2649	return 1;	2649	return 1;
2650	if (rw == WRITE) {	2650	if (rw == WRITE) {
@@ -2726,7 +2726,7 @@ static void fix_read_error(struct r10conf conf, struct mddev mddev, struct r10 · 75 unmodified lines
2726	sect,	2726	sect,
2727	s<<9,	2727	s<<9,
2728	conf->tmppage,	2728	conf->tmppage,
2729	REQ_OP_READ, 0, false);	2729	REQ_OP_READ, false);
2730	rdev_dec_pending(rdev, mddev);	2730	rdev_dec_pending(rdev, mddev);
2731	rcu_read_lock();	2731	rcu_read_lock();
2732	if (success)	2732	if (success)
@@ -5107,7 +5107,7 @@ static int handle_reshape_read_error(struct mddev *mddev, · 2374 unmodified lines
5107	addr,	5107	addr,
5108	s << 9,	5108	s << 9,
5109	pages[idx],	5109	pages[idx],
5110	REQ_OP_READ, 0, false);	5110	REQ_OP_READ, false);
5111	rdev_dec_pending(rdev, mddev);	5111	rdev_dec_pending(rdev, mddev);
5112	rcu_read_lock();	5112	rcu_read_lock();
5113	if (success)	5113	if (success)

drivers/md/raid5-cache.c+6−6

@@ -1788,7 +1788,7 @@ static int r5l_log_write_empty_meta_block(struct r5l_log *log, sector_t pos, · 1787 unmodified lines
1788	mb = page_address(page);	1788	mb = page_address(page);
1789	mb->checksum = cpu_to_le32(crc32c_le(log->uuid_checksum,	1789	mb->checksum = cpu_to_le32(crc32c_le(log->uuid_checksum,
1790	mb, PAGE_SIZE));	1790	mb, PAGE_SIZE));
1791	if (!sync_page_io(log->rdev, pos, PAGE_SIZE, page, REQ_OP_WRITE,	1791	if (!sync_page_io(log->rdev, pos, PAGE_SIZE, page, REQ_OP_WRITE \|
1792	REQ_SYNC \| REQ_FUA, false)) {	1792	REQ_SYNC \| REQ_FUA, false)) {
1793	__free_page(page);	1793	__free_page(page);
1794	return -EIO;	1794	return -EIO;
@@ -1898,7 +1898,7 @@ r5l_recovery_replay_one_stripe(struct r5conf *conf, · 103 unmodified lines
1898	atomic_inc(&rdev->nr_pending);	1898	atomic_inc(&rdev->nr_pending);
1899	rcu_read_unlock();	1899	rcu_read_unlock();
1900	sync_page_io(rdev, sh->sector, PAGE_SIZE,	1900	sync_page_io(rdev, sh->sector, PAGE_SIZE,
1901	sh->dev[disk_index].page, REQ_OP_WRITE, 0,	1901	sh->dev[disk_index].page, REQ_OP_WRITE,
1902	false);	1902	false);
1903	rdev_dec_pending(rdev, rdev->mddev);	1903	rdev_dec_pending(rdev, rdev->mddev);
1904	rcu_read_lock();	1904	rcu_read_lock();
@@ -1908,7 +1908,7 @@ r5l_recovery_replay_one_stripe(struct r5conf *conf, · 3 unmodified lines
1908	atomic_inc(&rrdev->nr_pending);	1908	atomic_inc(&rrdev->nr_pending);
1909	rcu_read_unlock();	1909	rcu_read_unlock();
1910	sync_page_io(rrdev, sh->sector, PAGE_SIZE,	1910	sync_page_io(rrdev, sh->sector, PAGE_SIZE,
1911	sh->dev[disk_index].page, REQ_OP_WRITE, 0,	1911	sh->dev[disk_index].page, REQ_OP_WRITE,
1912	false);	1912	false);
1913	rdev_dec_pending(rrdev, rrdev->mddev);	1913	rdev_dec_pending(rrdev, rrdev->mddev);
1914	rcu_read_lock();	1914	rcu_read_lock();
@@ -2394,7 +2394,7 @@ r5c_recovery_rewrite_data_only_stripes(struct r5l_log *log, · 479 unmodified lines
2394	PAGE_SIZE));	2394	PAGE_SIZE));
2395	kunmap_atomic(addr);	2395	kunmap_atomic(addr);
2396	sync_page_io(log->rdev, write_pos, PAGE_SIZE,	2396	sync_page_io(log->rdev, write_pos, PAGE_SIZE,
2397	dev->page, REQ_OP_WRITE, 0, false);	2397	dev->page, REQ_OP_WRITE, false);
2398	write_pos = r5l_ring_add(log, write_pos,	2398	write_pos = r5l_ring_add(log, write_pos,
2399	BLOCK_SECTORS);	2399	BLOCK_SECTORS);
2400	offset += sizeof(__le32) +	2400	offset += sizeof(__le32) +
@@ -2406,7 +2406,7 @@ r5c_recovery_rewrite_data_only_stripes(struct r5l_log *log, · 5 unmodified lines
2406	mb->checksum = cpu_to_le32(crc32c_le(log->uuid_checksum,	2406	mb->checksum = cpu_to_le32(crc32c_le(log->uuid_checksum,
2407	mb, PAGE_SIZE));	2407	mb, PAGE_SIZE));
2408	sync_page_io(log->rdev, ctx->pos, PAGE_SIZE, page,	2408	sync_page_io(log->rdev, ctx->pos, PAGE_SIZE, page,
2409	REQ_OP_WRITE, REQ_SYNC \| REQ_FUA, false);	2409	REQ_OP_WRITE \| REQ_SYNC \| REQ_FUA, false);
2410	sh->log_start = ctx->pos;	2410	sh->log_start = ctx->pos;
2411	list_add_tail(&sh->r5c, &log->stripe_in_journal_list);	2411	list_add_tail(&sh->r5c, &log->stripe_in_journal_list);
2412	atomic_inc(&log->stripe_in_journal_count);	2412	atomic_inc(&log->stripe_in_journal_count);
@@ -2971,7 +2971,7 @@ static int r5l_load_log(struct r5l_log *log) · 558 unmodified lines
2971	if (!page)	2971	if (!page)
2972	return -ENOMEM;	2972	return -ENOMEM;
2973		2973
2974	if (!sync_page_io(rdev, cp, PAGE_SIZE, page, REQ_OP_READ, 0, false)) {	2974	if (!sync_page_io(rdev, cp, PAGE_SIZE, page, REQ_OP_READ, false)) {
2975	ret = -EIO;	2975	ret = -EIO;
2976	goto ioerr;	2976	goto ioerr;
2977	}	2977	}

drivers/md/raid5-ppl.c+6−6

@@ -897,7 +897,7 @@ static int ppl_recover_entry(struct ppl_log log, struct ppl_header_entry e, · 896 unmodified lines
897	__func__, indent, "", rdev->bdev,	897	__func__, indent, "", rdev->bdev,
898	(unsigned long long)sector);	898	(unsigned long long)sector);
899	if (!sync_page_io(rdev, sector, block_size, page2,	899	if (!sync_page_io(rdev, sector, block_size, page2,
900	REQ_OP_READ, 0, false)) {	900	REQ_OP_READ, false)) {
901	md_error(mddev, rdev);	901	md_error(mddev, rdev);
902	pr_debug("%s:%*s read failed!\n", __func__,	902	pr_debug("%s:%*s read failed!\n", __func__,
903	indent, "");	903	indent, "");
@@ -919,7 +919,7 @@ static int ppl_recover_entry(struct ppl_log log, struct ppl_header_entry e, · 15 unmodified lines
919	(unsigned long long)(ppl_sector + i));	919	(unsigned long long)(ppl_sector + i));
920	if (!sync_page_io(log->rdev,	920	if (!sync_page_io(log->rdev,
921	ppl_sector - log->rdev->data_offset + i,	921	ppl_sector - log->rdev->data_offset + i,
922	block_size, page2, REQ_OP_READ, 0,	922	block_size, page2, REQ_OP_READ,
923	false)) {	923	false)) {
924	pr_debug("%s:%*s read failed!\n", __func__,	924	pr_debug("%s:%*s read failed!\n", __func__,
925	indent, "");	925	indent, "");
@@ -946,7 +946,7 @@ static int ppl_recover_entry(struct ppl_log log, struct ppl_header_entry e, · 20 unmodified lines
946	(unsigned long long)parity_sector,	946	(unsigned long long)parity_sector,
947	parity_rdev->bdev);	947	parity_rdev->bdev);
948	if (!sync_page_io(parity_rdev, parity_sector, block_size,	948	if (!sync_page_io(parity_rdev, parity_sector, block_size,
949	page1, REQ_OP_WRITE, 0, false)) {	949	page1, REQ_OP_WRITE, false)) {
950	pr_debug("%s:%*s parity write error!\n", __func__,	950	pr_debug("%s:%*s parity write error!\n", __func__,
951	indent, "");	951	indent, "");
952	md_error(mddev, parity_rdev);	952	md_error(mddev, parity_rdev);
@@ -998,7 +998,7 @@ static int ppl_recover(struct ppl_log log, struct ppl_header pplhdr, · 45 unmodified lines
998	int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size;	998	int s = pp_size > PAGE_SIZE ? PAGE_SIZE : pp_size;
999		999
1000	if (!sync_page_io(rdev, sector - rdev->data_offset,	1000	if (!sync_page_io(rdev, sector - rdev->data_offset,
1001	s, page, REQ_OP_READ, 0, false)) {	1001	s, page, REQ_OP_READ, false)) {
1002	md_error(mddev, rdev);	1002	md_error(mddev, rdev);
1003	ret = -EIO;	1003	ret = -EIO;
1004	goto out;	1004	goto out;
@@ -1062,7 +1062,7 @@ static int ppl_write_empty_header(struct ppl_log *log) · 57 unmodified lines
1062		1062
1063	if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset,	1063	if (!sync_page_io(rdev, rdev->ppl.sector - rdev->data_offset,
1064	PPL_HEADER_SIZE, page, REQ_OP_WRITE \| REQ_SYNC \|	1064	PPL_HEADER_SIZE, page, REQ_OP_WRITE \| REQ_SYNC \|
1065	REQ_FUA, 0, false)) {	1065	REQ_FUA, false)) {
1066	md_error(rdev->mddev, rdev);	1066	md_error(rdev->mddev, rdev);
1067	ret = -EIO;	1067	ret = -EIO;
1068	}	1068	}
@@ -1100,7 +1100,7 @@ static int ppl_load_distributed(struct ppl_log *log) · 31 unmodified lines
1100	if (!sync_page_io(rdev,	1100	if (!sync_page_io(rdev,
1101	rdev->ppl.sector - rdev->data_offset +	1101	rdev->ppl.sector - rdev->data_offset +
1102	pplhdr_offset, PAGE_SIZE, page, REQ_OP_READ,	1102	pplhdr_offset, PAGE_SIZE, page, REQ_OP_READ,
1103	0, false)) {	1103	false)) {
1104	md_error(mddev, rdev);	1104	md_error(mddev, rdev);
1105	ret = -EIO;	1105	ret = -EIO;
1106	/* if not able to read - don't recover any PPL */	1106	/* if not able to read - don't recover any PPL */

drivers/md/raid5.c+2−1

@@ -1082,7 +1082,8 @@ static void ops_run_io(struct stripe_head sh, struct stripe_head_state s) · 1081 unmodified lines
1082	should_defer = conf->batch_bio_dispatch && conf->group_cnt;	1082	should_defer = conf->batch_bio_dispatch && conf->group_cnt;
1083		1083
1084	for (i = disks; i--; ) {	1084	for (i = disks; i--; ) {
1085	int op, op_flags = 0;	1085	enum req_op op;
		1086	blk_opf_t op_flags = 0;
1086	int replace_only = 0;	1087	int replace_only = 0;
1087	struct bio bi, rbi;	1088	struct bio bi, rbi;
1088	struct md_rdev rdev, rrdev = NULL;	1089	struct md_rdev rdev, rrdev = NULL;

drivers/memstick/core/ms_block.c+1−2

 	return 0;
 out_cleanup_disk:
-	blk_cleanup_disk(msb->disk);
+	put_disk(msb->disk);
 out_free_tag_set:
 	blk_mq_free_tag_set(&msb->tag_set);
 out_release_id:
 	/* Remove the disk */
 	del_gendisk(msb->disk);
-	blk_cleanup_queue(msb->queue);
 	blk_mq_free_tag_set(&msb->tag_set);
 	msb->queue = NULL;

drivers/memstick/core/mspro_block.c+1−2

 	return 0;
 out_cleanup_disk:
-	blk_cleanup_disk(msb->disk);
+	put_disk(msb->disk);
 out_free_tag_set:
 	blk_mq_free_tag_set(&msb->tag_set);
 out_release_id:
 	del_gendisk(msb->disk);
 	dev_dbg(&card->dev, "mspro block remove\n");
-	blk_cleanup_queue(msb->queue);
 	blk_mq_free_tag_set(&msb->tag_set);
 	msb->queue = NULL;

drivers/mmc/core/block.c+3−3

@@ -2505,11 +2505,11 @@ static struct mmc_blk_data mmc_blk_alloc_req(struct mmc_card card, · 2504 unmodified lines
2505	dev_set_drvdata(&card->dev, md);	2505	dev_set_drvdata(&card->dev, md);
2506	ret = device_add_disk(md->parent, md->disk, mmc_disk_attr_groups);	2506	ret = device_add_disk(md->parent, md->disk, mmc_disk_attr_groups);
2507	if (ret)	2507	if (ret)
2508	goto err_cleanup_queue;	2508	goto err_put_disk;
2509	return md;	2509	return md;
2510		2510
2511	err_cleanup_queue:	2511	err_put_disk:
2512	blk_cleanup_queue(md->disk->queue);	2512	put_disk(md->disk);
2513	blk_mq_free_tag_set(&md->queue.tag_set);	2513	blk_mq_free_tag_set(&md->queue.tag_set);
2514	err_kfree:	2514	err_kfree:
2515	kfree(md);	2515	kfree(md);

drivers/mmc/core/queue.c+1−3

 	}
 }
-static enum blk_eh_timer_return mmc_mq_timed_out(struct request *req,
+static enum blk_eh_timer_return mmc_mq_timed_out(struct request *req)
-						 bool reserved)
 {
 	struct request_queue *q = req->q;
 	struct mmc_queue *mq = q->queuedata;
 	if (blk_queue_quiesced(q))
 		blk_mq_unquiesce_queue(q);
-	blk_cleanup_queue(q);
 	blk_mq_free_tag_set(&mq->tag_set);
 	/*

drivers/mtd/mtd_blkdevs.c+2−2

@@ -29,7 +29,7 @@ static void blktrans_dev_release(struct kref *kref) · 28 unmodified lines
29	struct mtd_blktrans_dev *dev =	29	struct mtd_blktrans_dev *dev =
30	container_of(kref, struct mtd_blktrans_dev, ref);	30	container_of(kref, struct mtd_blktrans_dev, ref);
31		31
32	blk_cleanup_disk(dev->disk);	32	put_disk(dev->disk);
33	blk_mq_free_tag_set(dev->tag_set);	33	blk_mq_free_tag_set(dev->tag_set);
34	kfree(dev->tag_set);	34	kfree(dev->tag_set);
35	list_del(&dev->list);	35	list_del(&dev->list);
@@ -398,7 +398,7 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new) · 362 unmodified lines
398	return 0;	398	return 0;
399		399
400	out_cleanup_disk:	400	out_cleanup_disk:
401	blk_cleanup_disk(new->disk);	401	put_disk(new->disk);
402	out_free_tag_set:	402	out_free_tag_set:
403	blk_mq_free_tag_set(new->tag_set);	403	blk_mq_free_tag_set(new->tag_set);
404	out_kfree_tag_set:	404	out_kfree_tag_set:

drivers/mtd/ubi/block.c+2−2

@@ -467,7 +467,7 @@ out_destroy_wq: · 466 unmodified lines
467	out_remove_minor:	467	out_remove_minor:
468	idr_remove(&ubiblock_minor_idr, gd->first_minor);	468	idr_remove(&ubiblock_minor_idr, gd->first_minor);
469	out_cleanup_disk:	469	out_cleanup_disk:
470	blk_cleanup_disk(dev->gd);	470	put_disk(dev->gd);
471	out_free_tags:	471	out_free_tags:
472	blk_mq_free_tag_set(&dev->tag_set);	472	blk_mq_free_tag_set(&dev->tag_set);
473	out_free_dev:	473	out_free_dev:
@@ -486,7 +486,7 @@ static void ubiblock_cleanup(struct ubiblock *dev) · 12 unmodified lines
486	destroy_workqueue(dev->wq);	486	destroy_workqueue(dev->wq);
487	/* Finally destroy the blk queue */	487	/* Finally destroy the blk queue */
488	dev_info(disk_to_dev(dev->gd), "released");	488	dev_info(disk_to_dev(dev->gd), "released");
489	blk_cleanup_disk(dev->gd);	489	put_disk(dev->gd);
490	blk_mq_free_tag_set(&dev->tag_set);	490	blk_mq_free_tag_set(&dev->tag_set);
491	idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);	491	idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
492	}	492	}

drivers/nvdimm/btt.c+4−4

@@ -1422,7 +1422,7 @@ static int btt_write_pg(struct btt btt, struct bio_integrity_payload bip, · 1421 unmodified lines
1422		1422
1423	static int btt_do_bvec(struct btt btt, struct bio_integrity_payload bip,	1423	static int btt_do_bvec(struct btt btt, struct bio_integrity_payload bip,
1424	struct page *page, unsigned int len, unsigned int off,	1424	struct page *page, unsigned int len, unsigned int off,
1425	unsigned int op, sector_t sector)	1425	enum req_op op, sector_t sector)
1426	{	1426	{
1427	int ret;	1427	int ret;
1428		1428
@@ -1483,7 +1483,7 @@ static void btt_submit_bio(struct bio *bio) · 54 unmodified lines
1483	}	1483	}
1484		1484
1485	static int btt_rw_page(struct block_device *bdev, sector_t sector,	1485	static int btt_rw_page(struct block_device *bdev, sector_t sector,
1486	struct page *page, unsigned int op)	1486	struct page *page, enum req_op op)
1487	{	1487	{
1488	struct btt *btt = bdev->bd_disk->private_data;	1488	struct btt *btt = bdev->bd_disk->private_data;
1489	int rc;	1489	int rc;
@@ -1548,14 +1548,14 @@ static int btt_blk_init(struct btt *btt) · 58 unmodified lines
1548	return 0;	1548	return 0;
1549		1549
1550	out_cleanup_disk:	1550	out_cleanup_disk:
1551	blk_cleanup_disk(btt->btt_disk);	1551	put_disk(btt->btt_disk);
1552	return rc;	1552	return rc;
1553	}	1553	}
1554		1554
1555	static void btt_blk_cleanup(struct btt *btt)	1555	static void btt_blk_cleanup(struct btt *btt)
1556	{	1556	{
1557	del_gendisk(btt->btt_disk);	1557	del_gendisk(btt->btt_disk);
1558	blk_cleanup_disk(btt->btt_disk);	1558	put_disk(btt->btt_disk);
1559	}	1559	}
1560		1560
1561	/**	1561	/**

drivers/nvdimm/pmem.c+3−3

@@ -239,7 +239,7 @@ static void pmem_submit_bio(struct bio *bio) · 238 unmodified lines
239	}	239	}
240		240
241	static int pmem_rw_page(struct block_device *bdev, sector_t sector,	241	static int pmem_rw_page(struct block_device *bdev, sector_t sector,
242	struct page *page, unsigned int op)	242	struct page *page, enum req_op op)
243	{	243	{
244	struct pmem_device *pmem = bdev->bd_disk->private_data;	244	struct pmem_device *pmem = bdev->bd_disk->private_data;
245	blk_status_t rc;	245	blk_status_t rc;
@@ -450,7 +450,7 @@ static void pmem_release_disk(void *__pmem) · 204 unmodified lines
450	put_dax(pmem->dax_dev);	450	put_dax(pmem->dax_dev);
451	del_gendisk(pmem->disk);	451	del_gendisk(pmem->disk);
452		452
453	blk_cleanup_disk(pmem->disk);	453	put_disk(pmem->disk);
454	}	454	}
455		455
456	static int pmem_attach_disk(struct device *dev,	456	static int pmem_attach_disk(struct device *dev,
@@ -596,7 +596,7 @@ out_cleanup_dax: · 139 unmodified lines
596	kill_dax(pmem->dax_dev);	596	kill_dax(pmem->dax_dev);
597	put_dax(pmem->dax_dev);	597	put_dax(pmem->dax_dev);
598	out:	598	out:
599	blk_cleanup_disk(pmem->disk);	599	put_disk(pmem->disk);
600	return rc;	600	return rc;
601	}	601	}
602		602

drivers/nvme/host/apple.c+2−3

 	}
 }
-static enum blk_eh_timer_return apple_nvme_timeout(struct request *req,
+static enum blk_eh_timer_return apple_nvme_timeout(struct request *req)
-						   bool reserved)
 {
 	struct apple_nvme_iod *iod = blk_mq_rq_to_pdu(req);
 	struct apple_nvme_queue *q = iod->q;
 	if (!blk_get_queue(anv->ctrl.admin_q)) {
 		nvme_start_admin_queue(&anv->ctrl);
-		blk_cleanup_queue(anv->ctrl.admin_q);
+		blk_mq_destroy_queue(anv->ctrl.admin_q);
 		anv->ctrl.admin_q = NULL;
 		ret = -ENODEV;
 		goto put_dev;

drivers/nvme/host/core.c+2−3

 }
 EXPORT_SYMBOL_GPL(nvme_host_path_error);
-bool nvme_cancel_request(struct request *req, void *data, bool reserved)
+bool nvme_cancel_request(struct request *req, void *data)
 {
 	dev_dbg_ratelimited(((struct nvme_ctrl *) data)->device,
 				"Cancelling I/O %d", req->tag);
 	mutex_unlock(&ctrl->subsys->lock);
 	nvme_put_ns_head(ns->head);
  out_cleanup_disk:
-	blk_cleanup_disk(disk);
+	put_disk(disk);
  out_free_ns:
 	kfree(ns);
  out_free_id:
 	if (!nvme_ns_head_multipath(ns->head))
 		nvme_cdev_del(&ns->cdev, &ns->cdev_device);
 	del_gendisk(ns->disk);
-	blk_cleanup_queue(ns->queue);
 	down_write(&ns->ctrl->namespaces_rwsem);
 	list_del_init(&ns->list);

drivers/nvme/host/fc.c+8−10

 	unsigned long flags;
 	if (ctrl->ctrl.tagset) {
-		blk_cleanup_queue(ctrl->ctrl.connect_q);
+		blk_mq_destroy_queue(ctrl->ctrl.connect_q);
 		blk_mq_free_tag_set(&ctrl->tag_set);
 	}
 	spin_unlock_irqrestore(&ctrl->rport->lock, flags);
 	nvme_start_admin_queue(&ctrl->ctrl);
-	blk_cleanup_queue(ctrl->ctrl.admin_q);
+	blk_mq_destroy_queue(ctrl->ctrl.admin_q);
-	blk_cleanup_queue(ctrl->ctrl.fabrics_q);
+	blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
 	blk_mq_free_tag_set(&ctrl->admin_tag_set);
 	kfree(ctrl->queues);
  * status. The done path will return the io request back to the block
  * layer with an error status.
  */
-static bool
+static bool nvme_fc_terminate_exchange(struct request *req, void *data)
-nvme_fc_terminate_exchange(struct request *req, void *data, bool reserved)
 {
 	struct nvme_ctrl *nctrl = data;
 	struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);
 	nvme_reset_ctrl(&ctrl->ctrl);
 }
-static enum blk_eh_timer_return
+static enum blk_eh_timer_return nvme_fc_timeout(struct request *rq)
-nvme_fc_timeout(struct request *rq, bool reserved)
 {
 	struct nvme_fc_fcp_op *op = blk_mq_rq_to_pdu(rq);
 	struct nvme_fc_ctrl *ctrl = op->ctrl;
 out_delete_hw_queues:
 	nvme_fc_delete_hw_io_queues(ctrl);
 out_cleanup_blk_queue:
-	blk_cleanup_queue(ctrl->ctrl.connect_q);
+	blk_mq_destroy_queue(ctrl->ctrl.connect_q);
 out_free_tag_set:
 	blk_mq_free_tag_set(&ctrl->tag_set);
 	nvme_fc_free_io_queues(ctrl);
 	return ERR_PTR(-EIO);
 out_cleanup_admin_q:
-	blk_cleanup_queue(ctrl->ctrl.admin_q);
+	blk_mq_destroy_queue(ctrl->ctrl.admin_q);
 out_cleanup_fabrics_q:
-	blk_cleanup_queue(ctrl->ctrl.fabrics_q);
+	blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
 out_free_admin_tag_set:
 	blk_mq_free_tag_set(&ctrl->admin_tag_set);
 out_free_queues:

drivers/nvme/host/ioctl.c+2−2

@@ -68,7 +68,7 @@ static struct request nvme_alloc_user_request(struct request_queue q, · 67 unmodified lines
68	struct nvme_command cmd, void __user ubuffer,	68	struct nvme_command cmd, void __user ubuffer,
69	unsigned bufflen, void __user *meta_buffer, unsigned meta_len,	69	unsigned bufflen, void __user *meta_buffer, unsigned meta_len,
70	u32 meta_seed, void **metap, unsigned timeout, bool vec,	70	u32 meta_seed, void **metap, unsigned timeout, bool vec,
71	unsigned int rq_flags, blk_mq_req_flags_t blk_flags)	71	blk_opf_t rq_flags, blk_mq_req_flags_t blk_flags)
72	{	72	{
73	bool write = nvme_is_write(cmd);	73	bool write = nvme_is_write(cmd);
74	struct nvme_ns *ns = q->queuedata;	74	struct nvme_ns *ns = q->queuedata;
@@ -407,7 +407,7 @@ static int nvme_uring_cmd_io(struct nvme_ctrl ctrl, struct nvme_ns ns, · 332 unmodified lines
407	struct nvme_uring_data d;	407	struct nvme_uring_data d;
408	struct nvme_command c;	408	struct nvme_command c;
409	struct request *req;	409	struct request *req;
410	unsigned int rq_flags = 0;	410	blk_opf_t rq_flags = 0;
411	blk_mq_req_flags_t blk_flags = 0;	411	blk_mq_req_flags_t blk_flags = 0;
412	void *meta = NULL;	412	void *meta = NULL;
413		413

drivers/nvme/host/multipath.c+2−2

@@ -830,7 +830,7 @@ void nvme_mpath_add_disk(struct nvme_ns ns, struct nvme_id_ns id) · 829 unmodified lines
830	ns->head->disk->queue);	830	ns->head->disk->queue);
831	#ifdef CONFIG_BLK_DEV_ZONED	831	#ifdef CONFIG_BLK_DEV_ZONED
832	if (blk_queue_is_zoned(ns->queue) && ns->head->disk)	832	if (blk_queue_is_zoned(ns->queue) && ns->head->disk)
833	ns->head->disk->queue->nr_zones = ns->queue->nr_zones;	833	ns->head->disk->nr_zones = ns->disk->nr_zones;
834	#endif	834	#endif
835	}	835	}
836		836
@@ -853,7 +853,7 @@ void nvme_mpath_remove_disk(struct nvme_ns_head *head) · 16 unmodified lines
853	/* make sure all pending bios are cleaned up */	853	/* make sure all pending bios are cleaned up */
854	kblockd_schedule_work(&head->requeue_work);	854	kblockd_schedule_work(&head->requeue_work);
855	flush_work(&head->requeue_work);	855	flush_work(&head->requeue_work);
856	blk_cleanup_disk(head->disk);	856	put_disk(head->disk);
857	}	857	}
858		858
859	void nvme_mpath_init_ctrl(struct nvme_ctrl *ctrl)	859	void nvme_mpath_init_ctrl(struct nvme_ctrl *ctrl)

drivers/nvme/host/nvme.h+2−2

@@ -698,7 +698,7 @@ static __always_inline void nvme_complete_batch(struct io_comp_batch *iob, · 697 unmodified lines
698	}	698	}
699		699
700	blk_status_t nvme_host_path_error(struct request *req);	700	blk_status_t nvme_host_path_error(struct request *req);
701	bool nvme_cancel_request(struct request req, void data, bool reserved);	701	bool nvme_cancel_request(struct request req, void data);
702	void nvme_cancel_tagset(struct nvme_ctrl *ctrl);	702	void nvme_cancel_tagset(struct nvme_ctrl *ctrl);
703	void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl);	703	void nvme_cancel_admin_tagset(struct nvme_ctrl *ctrl);
704	bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,	704	bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,
@@ -734,7 +734,7 @@ void nvme_wait_freeze(struct nvme_ctrl *ctrl); · 29 unmodified lines
734	int nvme_wait_freeze_timeout(struct nvme_ctrl *ctrl, long timeout);	734	int nvme_wait_freeze_timeout(struct nvme_ctrl *ctrl, long timeout);
735	void nvme_start_freeze(struct nvme_ctrl *ctrl);	735	void nvme_start_freeze(struct nvme_ctrl *ctrl);
736		736
737	static inline unsigned int nvme_req_op(struct nvme_command *cmd)	737	static inline enum req_op nvme_req_op(struct nvme_command *cmd)
738	{	738	{
739	return nvme_is_write(cmd) ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN;	739	return nvme_is_write(cmd) ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN;
740	}	740	}

drivers/nvme/host/pci.c+2−2

@@ -1344,7 +1344,7 @@ static void nvme_warn_reset(struct nvme_dev *dev, u32 csts) · 1343 unmodified lines
1344	"Try \"nvme_core.default_ps_max_latency_us=0 pcie_aspm=off\" and report a bug\n");	1344	"Try \"nvme_core.default_ps_max_latency_us=0 pcie_aspm=off\" and report a bug\n");
1345	}	1345	}
1346		1346
1347	static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved)	1347	static enum blk_eh_timer_return nvme_timeout(struct request *req)
1348	{	1348	{
1349	struct nvme_iod *iod = blk_mq_rq_to_pdu(req);	1349	struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
1350	struct nvme_queue *nvmeq = iod->nvmeq;	1350	struct nvme_queue *nvmeq = iod->nvmeq;
@@ -1760,7 +1760,7 @@ static void nvme_dev_remove_admin(struct nvme_dev *dev) · 409 unmodified lines
1760	* queue to flush these to completion.	1760	* queue to flush these to completion.
1761	*/	1761	*/
1762	nvme_start_admin_queue(&dev->ctrl);	1762	nvme_start_admin_queue(&dev->ctrl);
1763	blk_cleanup_queue(dev->ctrl.admin_q);	1763	blk_mq_destroy_queue(dev->ctrl.admin_q);
1764	blk_mq_free_tag_set(&dev->admin_tagset);	1764	blk_mq_free_tag_set(&dev->admin_tagset);
1765	}	1765	}
1766	}	1766	}

drivers/nvme/host/rdma.c+7−8

 		bool remove)
 {
 	if (remove) {
-		blk_cleanup_queue(ctrl->ctrl.admin_q);
+		blk_mq_destroy_queue(ctrl->ctrl.admin_q);
-		blk_cleanup_queue(ctrl->ctrl.fabrics_q);
+		blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
 		blk_mq_free_tag_set(ctrl->ctrl.admin_tagset);
 	}
 	if (ctrl->async_event_sqe.data) {
 	nvme_cancel_admin_tagset(&ctrl->ctrl);
 out_cleanup_queue:
 	if (new)
-		blk_cleanup_queue(ctrl->ctrl.admin_q);
+		blk_mq_destroy_queue(ctrl->ctrl.admin_q);
 out_cleanup_fabrics_q:
 	if (new)
-		blk_cleanup_queue(ctrl->ctrl.fabrics_q);
+		blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
 out_free_tagset:
 	if (new)
 		blk_mq_free_tag_set(ctrl->ctrl.admin_tagset);
 		bool remove)
 {
 	if (remove) {
-		blk_cleanup_queue(ctrl->ctrl.connect_q);
+		blk_mq_destroy_queue(ctrl->ctrl.connect_q);
 		blk_mq_free_tag_set(ctrl->ctrl.tagset);
 	}
 	nvme_rdma_free_io_queues(ctrl);
 out_cleanup_connect_q:
 	nvme_cancel_tagset(&ctrl->ctrl);
 	if (new)
-		blk_cleanup_queue(ctrl->ctrl.connect_q);
+		blk_mq_destroy_queue(ctrl->ctrl.connect_q);
 out_free_tag_set:
 	if (new)
 		blk_mq_free_tag_set(ctrl->ctrl.tagset);
 	nvmf_complete_timed_out_request(rq);
 }
-static enum blk_eh_timer_return
+static enum blk_eh_timer_return nvme_rdma_timeout(struct request *rq)
-nvme_rdma_timeout(struct request *rq, bool reserved)
 {
 	struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
 	struct nvme_rdma_queue *queue = req->queue;

drivers/nvme/host/tcp.c+7−8

 {
 	nvme_tcp_stop_io_queues(ctrl);
 	if (remove) {
-		blk_cleanup_queue(ctrl->connect_q);
+		blk_mq_destroy_queue(ctrl->connect_q);
 		blk_mq_free_tag_set(ctrl->tagset);
 	}
 	nvme_tcp_free_io_queues(ctrl);
 out_cleanup_connect_q:
 	nvme_cancel_tagset(ctrl);
 	if (new)
-		blk_cleanup_queue(ctrl->connect_q);
+		blk_mq_destroy_queue(ctrl->connect_q);
 out_free_tag_set:
 	if (new)
 		blk_mq_free_tag_set(ctrl->tagset);
 {
 	nvme_tcp_stop_queue(ctrl, 0);
 	if (remove) {
-		blk_cleanup_queue(ctrl->admin_q);
+		blk_mq_destroy_queue(ctrl->admin_q);
-		blk_cleanup_queue(ctrl->fabrics_q);
+		blk_mq_destroy_queue(ctrl->fabrics_q);
 		blk_mq_free_tag_set(ctrl->admin_tagset);
 	}
 	nvme_tcp_free_admin_queue(ctrl);
 	nvme_cancel_admin_tagset(ctrl);
 out_cleanup_queue:
 	if (new)
-		blk_cleanup_queue(ctrl->admin_q);
+		blk_mq_destroy_queue(ctrl->admin_q);
 out_cleanup_fabrics_q:
 	if (new)
-		blk_cleanup_queue(ctrl->fabrics_q);
+		blk_mq_destroy_queue(ctrl->fabrics_q);
 out_free_tagset:
 	if (new)
 		blk_mq_free_tag_set(ctrl->admin_tagset);
 	nvmf_complete_timed_out_request(rq);
 }
-static enum blk_eh_timer_return
+static enum blk_eh_timer_return nvme_tcp_timeout(struct request *rq)
-nvme_tcp_timeout(struct request *rq, bool reserved)
 {
 	struct nvme_tcp_request *req = blk_mq_rq_to_pdu(rq);
 	struct nvme_ctrl *ctrl = &req->queue->ctrl->ctrl;

drivers/nvme/host/zns.c+3−3

@@ -109,10 +109,10 @@ int nvme_update_zone_info(struct nvme_ns *ns, unsigned lbaf) · 108 unmodified lines
109	goto free_data;	109	goto free_data;
110	}	110	}
111		111
112	blk_queue_set_zoned(ns->disk, BLK_ZONED_HM);	112	disk_set_zoned(ns->disk, BLK_ZONED_HM);
113	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);	113	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
114	blk_queue_max_open_zones(q, le32_to_cpu(id->mor) + 1);	114	disk_set_max_open_zones(ns->disk, le32_to_cpu(id->mor) + 1);
115	blk_queue_max_active_zones(q, le32_to_cpu(id->mar) + 1);	115	disk_set_max_active_zones(ns->disk, le32_to_cpu(id->mar) + 1);
116	free_data:	116	free_data:
117	kfree(id);	117	kfree(id);
118	return status;	118	return status;

drivers/nvme/target/io-cmd-bdev.c+9−8

 	struct scatterlist *sg;
 	struct blk_plug plug;
 	sector_t sector;
-	int op, i, rc;
+	blk_opf_t opf;
+	int i, rc;
 	struct sg_mapping_iter prot_miter;
 	unsigned int iter_flags;
 	unsigned int total_len = nvmet_rw_data_len(req) + req->metadata_len;
 	}
 	if (req->cmd->rw.opcode == nvme_cmd_write) {
-		op = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
+		opf = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
 		if (req->cmd->rw.control & cpu_to_le16(NVME_RW_FUA))
-			op |= REQ_FUA;
+			opf |= REQ_FUA;
 		iter_flags = SG_MITER_TO_SG;
 	} else {
-		op = REQ_OP_READ;
+		opf = REQ_OP_READ;
 		iter_flags = SG_MITER_FROM_SG;
 	}
 	if (is_pci_p2pdma_page(sg_page(req->sg)))
-		op |= REQ_NOMERGE;
+		opf |= REQ_NOMERGE;
 	sector = nvmet_lba_to_sect(req->ns, req->cmd->rw.slba);
 	if (nvmet_use_inline_bvec(req)) {
 		bio = &req->b.inline_bio;
 		bio_init(bio, req->ns->bdev, req->inline_bvec,
-			 ARRAY_SIZE(req->inline_bvec), op);
+			 ARRAY_SIZE(req->inline_bvec), opf);
 	} else {
-		bio = bio_alloc(req->ns->bdev, bio_max_segs(sg_cnt), op,
+		bio = bio_alloc(req->ns->bdev, bio_max_segs(sg_cnt), opf,
 				GFP_KERNEL);
 	}
 	bio->bi_iter.bi_sector = sector;
 			}
 			bio = bio_alloc(req->ns->bdev, bio_max_segs(sg_cnt),
-					op, GFP_KERNEL);
+					opf, GFP_KERNEL);
 			bio->bi_iter.bi_sector = sector;
 			bio_chain(bio, prev);

drivers/nvme/target/loop.c+6−6

@@ -266,8 +266,8 @@ static void nvme_loop_destroy_admin_queue(struct nvme_loop_ctrl *ctrl) · 265 unmodified lines
266	if (!test_and_clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags))	266	if (!test_and_clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags))
267	return;	267	return;
268	nvmet_sq_destroy(&ctrl->queues[0].nvme_sq);	268	nvmet_sq_destroy(&ctrl->queues[0].nvme_sq);
269	blk_cleanup_queue(ctrl->ctrl.admin_q);	269	blk_mq_destroy_queue(ctrl->ctrl.admin_q);
270	blk_cleanup_queue(ctrl->ctrl.fabrics_q);	270	blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
271	blk_mq_free_tag_set(&ctrl->admin_tag_set);	271	blk_mq_free_tag_set(&ctrl->admin_tag_set);
272	}	272	}
273		273
@@ -283,7 +283,7 @@ static void nvme_loop_free_ctrl(struct nvme_ctrl *nctrl) · 9 unmodified lines
283	mutex_unlock(&nvme_loop_ctrl_mutex);	283	mutex_unlock(&nvme_loop_ctrl_mutex);
284		284
285	if (nctrl->tagset) {	285	if (nctrl->tagset) {
286	blk_cleanup_queue(ctrl->ctrl.connect_q);	286	blk_mq_destroy_queue(ctrl->ctrl.connect_q);
287	blk_mq_free_tag_set(&ctrl->tag_set);	287	blk_mq_free_tag_set(&ctrl->tag_set);
288	}	288	}
289	kfree(ctrl->queues);	289	kfree(ctrl->queues);
@@ -410,9 +410,9 @@ static int nvme_loop_configure_admin_queue(struct nvme_loop_ctrl *ctrl) · 120 unmodified lines
410		410
411	out_cleanup_queue:	411	out_cleanup_queue:
412	clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags);	412	clear_bit(NVME_LOOP_Q_LIVE, &ctrl->queues[0].flags);
413	blk_cleanup_queue(ctrl->ctrl.admin_q);	413	blk_mq_destroy_queue(ctrl->ctrl.admin_q);
414	out_cleanup_fabrics_q:	414	out_cleanup_fabrics_q:
415	blk_cleanup_queue(ctrl->ctrl.fabrics_q);	415	blk_mq_destroy_queue(ctrl->ctrl.fabrics_q);
416	out_free_tagset:	416	out_free_tagset:
417	blk_mq_free_tag_set(&ctrl->admin_tag_set);	417	blk_mq_free_tag_set(&ctrl->admin_tag_set);
418	out_free_sq:	418	out_free_sq:
@@ -554,7 +554,7 @@ static int nvme_loop_create_io_queues(struct nvme_loop_ctrl *ctrl) · 135 unmodified lines
554	return 0;	554	return 0;
555		555
556	out_cleanup_connect_q:	556	out_cleanup_connect_q:
557	blk_cleanup_queue(ctrl->ctrl.connect_q);	557	blk_mq_destroy_queue(ctrl->ctrl.connect_q);
558	out_free_tagset:	558	out_free_tagset:
559	blk_mq_free_tag_set(&ctrl->tag_set);	559	blk_mq_free_tag_set(&ctrl->tag_set);
560	out_destroy_queues:	560	out_destroy_queues:

drivers/nvme/target/zns.c+12−12

@@ -57,10 +57,10 @@ bool nvmet_bdev_zns_enable(struct nvmet_ns *ns) · 56 unmodified lines
57	* zones, reject the device. Otherwise, use report zones to detect if	57	* zones, reject the device. Otherwise, use report zones to detect if
58	* the device has conventional zones.	58	* the device has conventional zones.
59	*/	59	*/
60	if (ns->bdev->bd_disk->queue->conv_zones_bitmap)	60	if (ns->bdev->bd_disk->conv_zones_bitmap)
61	return false;	61	return false;
62		62
63	ret = blkdev_report_zones(ns->bdev, 0, blkdev_nr_zones(bd_disk),	63	ret = blkdev_report_zones(ns->bdev, 0, bdev_nr_zones(ns->bdev),
64	validate_conv_zones_cb, NULL);	64	validate_conv_zones_cb, NULL);
65	if (ret < 0)	65	if (ret < 0)
66	return false;	66	return false;
@@ -241,7 +241,7 @@ static unsigned long nvmet_req_nr_zones_from_slba(struct nvmet_req *req) · 174 unmodified lines
241	{	241	{
242	unsigned int sect = nvmet_lba_to_sect(req->ns, req->cmd->zmr.slba);	242	unsigned int sect = nvmet_lba_to_sect(req->ns, req->cmd->zmr.slba);
243		243
244	return blkdev_nr_zones(req->ns->bdev->bd_disk) -	244	return bdev_nr_zones(req->ns->bdev) -
245	(sect >> ilog2(bdev_zone_sectors(req->ns->bdev)));	245	(sect >> ilog2(bdev_zone_sectors(req->ns->bdev)));
246	}	246	}
247		247
@@ -308,7 +308,7 @@ void nvmet_bdev_execute_zone_mgmt_recv(struct nvmet_req *req) · 60 unmodified lines
308	queue_work(zbd_wq, &req->z.zmgmt_work);	308	queue_work(zbd_wq, &req->z.zmgmt_work);
309	}	309	}
310		310
311	static inline enum req_opf zsa_req_op(u8 zsa)	311	static inline enum req_op zsa_req_op(u8 zsa)
312	{	312	{
313	switch (zsa) {	313	switch (zsa) {
314	case NVME_ZONE_OPEN:	314	case NVME_ZONE_OPEN:
@@ -386,7 +386,7 @@ static int zmgmt_send_scan_cb(struct blk_zone z, unsigned i, void d) · 71 unmodified lines
386	static u16 nvmet_bdev_zone_mgmt_emulate_all(struct nvmet_req *req)	386	static u16 nvmet_bdev_zone_mgmt_emulate_all(struct nvmet_req *req)
387	{	387	{
388	struct block_device *bdev = req->ns->bdev;	388	struct block_device *bdev = req->ns->bdev;
389	unsigned int nr_zones = blkdev_nr_zones(bdev->bd_disk);	389	unsigned int nr_zones = bdev_nr_zones(bdev);
390	struct request_queue *q = bdev_get_queue(bdev);	390	struct request_queue *q = bdev_get_queue(bdev);
391	struct bio *bio = NULL;	391	struct bio *bio = NULL;
392	sector_t sector = 0;	392	sector_t sector = 0;
@@ -413,8 +413,8 @@ static u16 nvmet_bdev_zone_mgmt_emulate_all(struct nvmet_req *req) · 20 unmodified lines
413	ret = 0;	413	ret = 0;
414	}	414	}
415		415
416	while (sector < get_capacity(bdev->bd_disk)) {	416	while (sector < bdev_nr_sectors(bdev)) {
417	if (test_bit(blk_queue_zone_no(q, sector), d.zbitmap)) {	417	if (test_bit(disk_zone_no(bdev->bd_disk, sector), d.zbitmap)) {
418	bio = blk_next_bio(bio, bdev, 0,	418	bio = blk_next_bio(bio, bdev, 0,
419	zsa_req_op(req->cmd->zms.zsa) \| REQ_SYNC,	419	zsa_req_op(req->cmd->zms.zsa) \| REQ_SYNC,
420	GFP_KERNEL);	420	GFP_KERNEL);
@@ -422,7 +422,7 @@ static u16 nvmet_bdev_zone_mgmt_emulate_all(struct nvmet_req *req) · 1 unmodified line
422	/* This may take a while, so be nice to others */	422	/* This may take a while, so be nice to others */
423	cond_resched();	423	cond_resched();
424	}	424	}
425	sector += blk_queue_zone_sectors(q);	425	sector += bdev_zone_sectors(bdev);
426	}	426	}
427		427
428	if (bio) {	428	if (bio) {
@@ -465,7 +465,7 @@ static void nvmet_bdev_zmgmt_send_work(struct work_struct *w) · 36 unmodified lines
465	{	465	{
466	struct nvmet_req *req = container_of(w, struct nvmet_req, z.zmgmt_work);	466	struct nvmet_req *req = container_of(w, struct nvmet_req, z.zmgmt_work);
467	sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->zms.slba);	467	sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->zms.slba);
468	enum req_opf op = zsa_req_op(req->cmd->zms.zsa);	468	enum req_op op = zsa_req_op(req->cmd->zms.zsa);
469	struct block_device *bdev = req->ns->bdev;	469	struct block_device *bdev = req->ns->bdev;
470	sector_t zone_sectors = bdev_zone_sectors(bdev);	470	sector_t zone_sectors = bdev_zone_sectors(bdev);
471	u16 status = NVME_SC_SUCCESS;	471	u16 status = NVME_SC_SUCCESS;
@@ -525,7 +525,7 @@ static void nvmet_bdev_zone_append_bio_done(struct bio *bio) · 53 unmodified lines
525	void nvmet_bdev_execute_zone_append(struct nvmet_req *req)	525	void nvmet_bdev_execute_zone_append(struct nvmet_req *req)
526	{	526	{
527	sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->rw.slba);	527	sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->rw.slba);
528	const unsigned int op = REQ_OP_ZONE_APPEND \| REQ_SYNC \| REQ_IDLE;	528	const blk_opf_t opf = REQ_OP_ZONE_APPEND \| REQ_SYNC \| REQ_IDLE;
529	u16 status = NVME_SC_SUCCESS;	529	u16 status = NVME_SC_SUCCESS;
530	unsigned int total_len = 0;	530	unsigned int total_len = 0;
531	struct scatterlist *sg;	531	struct scatterlist *sg;
@@ -556,9 +556,9 @@ void nvmet_bdev_execute_zone_append(struct nvmet_req *req) · 24 unmodified lines
556	if (nvmet_use_inline_bvec(req)) {	556	if (nvmet_use_inline_bvec(req)) {
557	bio = &req->z.inline_bio;	557	bio = &req->z.inline_bio;
558	bio_init(bio, req->ns->bdev, req->inline_bvec,	558	bio_init(bio, req->ns->bdev, req->inline_bvec,
559	ARRAY_SIZE(req->inline_bvec), op);	559	ARRAY_SIZE(req->inline_bvec), opf);
560	} else {	560	} else {
561	bio = bio_alloc(req->ns->bdev, req->sg_cnt, op, GFP_KERNEL);	561	bio = bio_alloc(req->ns->bdev, req->sg_cnt, opf, GFP_KERNEL);
562	}	562	}
563		563
564	bio->bi_end_io = nvmet_bdev_zone_append_bio_done;	564	bio->bi_end_io = nvmet_bdev_zone_append_bio_done;

drivers/s390/block/dasd.c+2−2

@@ -3145,7 +3145,7 @@ out: · 3144 unmodified lines
3145	* BLK_EH_DONE if the request is handled or terminated	3145	* BLK_EH_DONE if the request is handled or terminated
3146	* by the driver.	3146	* by the driver.
3147	*/	3147	*/
3148	enum blk_eh_timer_return dasd_times_out(struct request *req, bool reserved)	3148	enum blk_eh_timer_return dasd_times_out(struct request *req)
3149	{	3149	{
3150	struct dasd_block *block = req->q->queuedata;	3150	struct dasd_block *block = req->q->queuedata;
3151	struct dasd_device *device;	3151	struct dasd_device *device;
@@ -3280,7 +3280,7 @@ static int dasd_alloc_queue(struct dasd_block *block) · 128 unmodified lines
3280	static void dasd_free_queue(struct dasd_block *block)	3280	static void dasd_free_queue(struct dasd_block *block)
3281	{	3281	{
3282	if (block->request_queue) {	3282	if (block->request_queue) {
3283	blk_cleanup_queue(block->request_queue);	3283	blk_mq_destroy_queue(block->request_queue);
3284	blk_mq_free_tag_set(&block->tag_set);	3284	blk_mq_free_tag_set(&block->tag_set);
3285	block->request_queue = NULL;	3285	block->request_queue = NULL;
3286	}	3286	}

drivers/s390/block/dasd_genhd.c+2−2

@@ -41,8 +41,8 @@ int dasd_gendisk_alloc(struct dasd_block *block) · 40 unmodified lines
41	if (base->devindex >= DASD_PER_MAJOR)	41	if (base->devindex >= DASD_PER_MAJOR)
42	return -EBUSY;	42	return -EBUSY;
43		43
44	gdp = __alloc_disk_node(block->request_queue, NUMA_NO_NODE,	44	gdp = blk_mq_alloc_disk_for_queue(block->request_queue,
45	&dasd_bio_compl_lkclass);	45	&dasd_bio_compl_lkclass);
46	if (!gdp)	46	if (!gdp)
47	return -ENOMEM;	47	return -ENOMEM;
48		48

drivers/s390/block/dasd_int.h+1−1

@@ -795,7 +795,7 @@ void dasd_free_device(struct dasd_device *); · 794 unmodified lines
795	struct dasd_block *dasd_alloc_block(void);	795	struct dasd_block *dasd_alloc_block(void);
796	void dasd_free_block(struct dasd_block *);	796	void dasd_free_block(struct dasd_block *);
797		797
798	enum blk_eh_timer_return dasd_times_out(struct request *req, bool reserved);	798	enum blk_eh_timer_return dasd_times_out(struct request *req);
799		799
800	void dasd_enable_device(struct dasd_device *);	800	void dasd_enable_device(struct dasd_device *);
801	void dasd_set_target_state(struct dasd_device *, int);	801	void dasd_set_target_state(struct dasd_device *, int);

drivers/s390/block/dcssblk.c+4−4

@@ -414,7 +414,7 @@ removeseg: · 413 unmodified lines
414	kill_dax(dev_info->dax_dev);	414	kill_dax(dev_info->dax_dev);
415	put_dax(dev_info->dax_dev);	415	put_dax(dev_info->dax_dev);
416	del_gendisk(dev_info->gd);	416	del_gendisk(dev_info->gd);
417	blk_cleanup_disk(dev_info->gd);	417	put_disk(dev_info->gd);
418	up_write(&dcssblk_devices_sem);	418	up_write(&dcssblk_devices_sem);
419		419
420	if (device_remove_file_self(dev, attr)) {	420	if (device_remove_file_self(dev, attr)) {
@@ -712,7 +712,7 @@ out_dax: · 291 unmodified lines
712	put_dax(dev_info->dax_dev);	712	put_dax(dev_info->dax_dev);
713	put_dev:	713	put_dev:
714	list_del(&dev_info->lh);	714	list_del(&dev_info->lh);
715	blk_cleanup_disk(dev_info->gd);	715	put_disk(dev_info->gd);
716	list_for_each_entry(seg_info, &dev_info->seg_list, lh) {	716	list_for_each_entry(seg_info, &dev_info->seg_list, lh) {
717	segment_unload(seg_info->segment_name);	717	segment_unload(seg_info->segment_name);
718	}	718	}
@@ -722,7 +722,7 @@ put_dev: · 3 unmodified lines
722	dev_list_del:	722	dev_list_del:
723	list_del(&dev_info->lh);	723	list_del(&dev_info->lh);
724	release_gd:	724	release_gd:
725	blk_cleanup_disk(dev_info->gd);	725	put_disk(dev_info->gd);
726	up_write(&dcssblk_devices_sem);	726	up_write(&dcssblk_devices_sem);
727	seg_list_del:	727	seg_list_del:
728	if (dev_info == NULL)	728	if (dev_info == NULL)
@@ -790,7 +790,7 @@ dcssblk_remove_store(struct device dev, struct device_attribute attr, const ch · 61 unmodified lines
790	kill_dax(dev_info->dax_dev);	790	kill_dax(dev_info->dax_dev);
791	put_dax(dev_info->dax_dev);	791	put_dax(dev_info->dax_dev);
792	del_gendisk(dev_info->gd);	792	del_gendisk(dev_info->gd);
793	blk_cleanup_disk(dev_info->gd);	793	put_disk(dev_info->gd);
794		794
795	/* unload all related segments */	795	/* unload all related segments */
796	list_for_each_entry(entry, &dev_info->seg_list, lh)	796	list_for_each_entry(entry, &dev_info->seg_list, lh)

drivers/s390/block/scm_blk.c+2−2

@@ -501,7 +501,7 @@ int scm_blk_dev_setup(struct scm_blk_dev bdev, struct scm_device scmdev) · 500 unmodified lines
501	return 0;	501	return 0;
502		502
503	out_cleanup_disk:	503	out_cleanup_disk:
504	blk_cleanup_disk(bdev->gendisk);	504	put_disk(bdev->gendisk);
505	out_tag:	505	out_tag:
506	blk_mq_free_tag_set(&bdev->tag_set);	506	blk_mq_free_tag_set(&bdev->tag_set);
507	out:	507	out:
@@ -512,7 +512,7 @@ out: · 4 unmodified lines
512	void scm_blk_dev_cleanup(struct scm_blk_dev *bdev)	512	void scm_blk_dev_cleanup(struct scm_blk_dev *bdev)
513	{	513	{
514	del_gendisk(bdev->gendisk);	514	del_gendisk(bdev->gendisk);
515	blk_cleanup_disk(bdev->gendisk);	515	put_disk(bdev->gendisk);
516	blk_mq_free_tag_set(&bdev->tag_set);	516	blk_mq_free_tag_set(&bdev->tag_set);
517	}	517	}
518		518

drivers/scsi/aacraid/comminit.c+1−1

@@ -272,7 +272,7 @@ static void aac_queue_init(struct aac_dev * dev, struct aac_queue * q, u32 *mem, · 271 unmodified lines
272	q->entries = qsize;	272	q->entries = qsize;
273	}	273	}
274		274
275	static bool wait_for_io_iter(struct scsi_cmnd cmd, void data, bool rsvd)	275	static bool wait_for_io_iter(struct scsi_cmnd cmd, void data)
276	{	276	{
277	int *active = data;	277	int *active = data;
278		278

drivers/scsi/aacraid/linit.c+1−1

@@ -633,7 +633,7 @@ struct fib_count_data { · 632 unmodified lines
633	int krlcnt;	633	int krlcnt;
634	};	634	};
635		635
636	static bool fib_count_iter(struct scsi_cmnd scmnd, void data, bool reserved)	636	static bool fib_count_iter(struct scsi_cmnd scmnd, void data)
637	{	637	{
638	struct fib_count_data *fib_count = data;	638	struct fib_count_data *fib_count = data;
639		639

drivers/scsi/device_handler/scsi_dh_alua.c+2−2

@@ -127,7 +127,7 @@ static int submit_rtpg(struct scsi_device sdev, unsigned char buff, · 126 unmodified lines
127	int bufflen, struct scsi_sense_hdr *sshdr, int flags)	127	int bufflen, struct scsi_sense_hdr *sshdr, int flags)
128	{	128	{
129	u8 cdb[MAX_COMMAND_SIZE];	129	u8 cdb[MAX_COMMAND_SIZE];
130	int req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	130	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
131	REQ_FAILFAST_DRIVER;	131	REQ_FAILFAST_DRIVER;
132		132
133	/* Prepare the command. */	133	/* Prepare the command. */
@@ -157,7 +157,7 @@ static int submit_stpg(struct scsi_device *sdev, int group_id, · 23 unmodified lines
157	u8 cdb[MAX_COMMAND_SIZE];	157	u8 cdb[MAX_COMMAND_SIZE];
158	unsigned char stpg_data[8];	158	unsigned char stpg_data[8];
159	int stpg_len = 8;	159	int stpg_len = 8;
160	int req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	160	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
161	REQ_FAILFAST_DRIVER;	161	REQ_FAILFAST_DRIVER;
162		162
163	/* Prepare the data buffer */	163	/* Prepare the data buffer */

drivers/scsi/device_handler/scsi_dh_emc.c+1−1

@@ -239,7 +239,7 @@ static int send_trespass_cmd(struct scsi_device *sdev, · 238 unmodified lines
239	unsigned char cdb[MAX_COMMAND_SIZE];	239	unsigned char cdb[MAX_COMMAND_SIZE];
240	int err, res = SCSI_DH_OK, len;	240	int err, res = SCSI_DH_OK, len;
241	struct scsi_sense_hdr sshdr;	241	struct scsi_sense_hdr sshdr;
242	u64 req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	242	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
243	REQ_FAILFAST_DRIVER;	243	REQ_FAILFAST_DRIVER;
244		244
245	if (csdev->flags & CLARIION_SHORT_TRESPASS) {	245	if (csdev->flags & CLARIION_SHORT_TRESPASS) {

drivers/scsi/device_handler/scsi_dh_hp_sw.c+2−2

@@ -83,7 +83,7 @@ static int hp_sw_tur(struct scsi_device sdev, struct hp_sw_dh_data h) · 82 unmodified lines
83	unsigned char cmd[6] = { TEST_UNIT_READY };	83	unsigned char cmd[6] = { TEST_UNIT_READY };
84	struct scsi_sense_hdr sshdr;	84	struct scsi_sense_hdr sshdr;
85	int ret = SCSI_DH_OK, res;	85	int ret = SCSI_DH_OK, res;
86	u64 req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	86	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
87	REQ_FAILFAST_DRIVER;	87	REQ_FAILFAST_DRIVER;
88		88
89	retry:	89	retry:
@@ -121,7 +121,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h) · 31 unmodified lines
121	struct scsi_device *sdev = h->sdev;	121	struct scsi_device *sdev = h->sdev;
122	int res, rc = SCSI_DH_OK;	122	int res, rc = SCSI_DH_OK;
123	int retry_cnt = HP_SW_RETRIES;	123	int retry_cnt = HP_SW_RETRIES;
124	u64 req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	124	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
125	REQ_FAILFAST_DRIVER;	125	REQ_FAILFAST_DRIVER;
126		126
127	retry:	127	retry:

drivers/scsi/device_handler/scsi_dh_rdac.c+1−1

@@ -536,7 +536,7 @@ static void send_mode_select(struct work_struct *work) · 535 unmodified lines
536	unsigned char cdb[MAX_COMMAND_SIZE];	536	unsigned char cdb[MAX_COMMAND_SIZE];
537	struct scsi_sense_hdr sshdr;	537	struct scsi_sense_hdr sshdr;
538	unsigned int data_size;	538	unsigned int data_size;
539	u64 req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|	539	blk_opf_t req_flags = REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \|
540	REQ_FAILFAST_DRIVER;	540	REQ_FAILFAST_DRIVER;
541		541
542	spin_lock(&ctlr->ms_lock);	542	spin_lock(&ctlr->ms_lock);

drivers/scsi/fnic/fnic_scsi.c+4−10

 	return wq_work_done;
 }
-static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
+static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data)
-				 bool reserved)
 {
 	const int tag = scsi_cmd_to_rq(sc)->tag;
 	struct fnic *fnic = data;
 	int term_cnt;
 };
-static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
+static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data)
-				     bool reserved)
 {
 	struct fnic_rport_abort_io_iter_data *iter_data = data;
 	struct fnic *fnic = iter_data->fnic;
 	int ret;
 };
-static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
+static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc, void *data)
-				     void *data, bool reserved)
 {
 	struct fnic_pending_aborts_iter_data *iter_data = data;
 	struct fnic *fnic = iter_data->fnic;
 	if (sc == iter_data->lr_sc || sc->device != lun_dev)
 		return true;
-	if (reserved)
-		return true;
 	io_lock = fnic_io_lock_tag(fnic, abt_tag);
 	spin_lock_irqsave(io_lock, flags);
 }
-static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
+static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data)
-				   bool reserved)
 {
 	struct fnic_pending_aborts_iter_data *iter_data = data;
 	struct fnic *fnic = iter_data->fnic;

drivers/scsi/hosts.c+6−8

 }
 EXPORT_SYMBOL(scsi_host_get);
-static bool scsi_host_check_in_flight(struct request *rq, void *data,
+static bool scsi_host_check_in_flight(struct request *rq, void *data)
-				      bool reserved)
 {
 	int *count = data;
 	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
 }
 EXPORT_SYMBOL_GPL(scsi_flush_work);
-static bool complete_all_cmds_iter(struct request *rq, void *data, bool rsvd)
+static bool complete_all_cmds_iter(struct request *rq, void *data)
 {
 	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
 	enum scsi_host_status status = *(enum scsi_host_status *)data;
 EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands);
 struct scsi_host_busy_iter_data {
-	bool (*fn)(struct scsi_cmnd *, void *, bool);
+	bool (*fn)(struct scsi_cmnd *, void *);
 	void *priv;
 };
-static bool __scsi_host_busy_iter_fn(struct request *req, void *priv,
+static bool __scsi_host_busy_iter_fn(struct request *req, void *priv)
-				   bool reserved)
 {
 	struct scsi_host_busy_iter_data *iter_data = priv;
 	struct scsi_cmnd *sc = blk_mq_rq_to_pdu(req);
-	return iter_data->fn(sc, iter_data->priv, reserved);
+	return iter_data->fn(sc, iter_data->priv);
 }
 /**
  * ithas to be provided by the caller
  **/
 void scsi_host_busy_iter(struct Scsi_Host *shost,
-			 bool (*fn)(struct scsi_cmnd *, void *, bool),
+			 bool (*fn)(struct scsi_cmnd *, void *),
 			 void *priv)
 {
 	struct scsi_host_busy_iter_data iter_data = {

drivers/scsi/mpi3mr/mpi3mr_os.c+4−12

  * mpi3mr_print_scmd - print individual SCSI command
  * @rq: Block request
  * @data: Adapter instance reference
- * @reserved: N/A. Currently not used
  *
  * Print the SCSI command details if it is in LLD scope.
  *
  * Return: true always.
  */
-static bool mpi3mr_print_scmd(struct request *rq,
+static bool mpi3mr_print_scmd(struct request *rq, void *data)
-	void *data, bool reserved)
 {
 	struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
 	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  * mpi3mr_flush_scmd - Flush individual SCSI command
  * @rq: Block request
  * @data: Adapter instance reference
- * @reserved: N/A. Currently not used
  *
  * Return the SCSI command to the upper layers if it is in LLD
  * scope.
  * Return: true always.
  */
-static bool mpi3mr_flush_scmd(struct request *rq,
+static bool mpi3mr_flush_scmd(struct request *rq, void *data)
-	void *data, bool reserved)
 {
 	struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data;
 	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
  * mpi3mr_count_dev_pending - Count commands pending for a lun
  * @rq: Block request
  * @data: SCSI device reference
- * @reserved: Unused
  *
  * This is an iterator function called for each SCSI command in
  * a host and if the command is pending in the LLD for the
  * Return: true always.
  */
-static bool mpi3mr_count_dev_pending(struct request *rq,
+static bool mpi3mr_count_dev_pending(struct request *rq, void *data)
-	void *data, bool reserved)
 {
 	struct scsi_device *sdev = (struct scsi_device *)data;
 	struct mpi3mr_sdev_priv_data *sdev_priv_data = sdev->hostdata;
  * mpi3mr_count_tgt_pending - Count commands pending for target
  * @rq: Block request
  * @data: SCSI target reference
- * @reserved: Unused
  *
  * This is an iterator function called for each SCSI command in
  * a host and if the command is pending in the LLD for the
  * Return: true always.
  */
-static bool mpi3mr_count_tgt_pending(struct request *rq,
+static bool mpi3mr_count_tgt_pending(struct request *rq, void *data)
-	void *data, bool reserved)
 {
 	struct scsi_target *starget = (struct scsi_target *)data;
 	struct mpi3mr_stgt_priv_data *stgt_priv_data = starget->hostdata;

drivers/scsi/scsi_error.c+11−11

@@ -139,7 +139,7 @@ static bool scsi_eh_should_retry_cmd(struct scsi_cmnd *cmd) · 138 unmodified lines
139	*	139	*
140	* Note: this function must be called only for a command that has timed out.	140	* Note: this function must be called only for a command that has timed out.
141	* Because the block layer marks a request as complete before it calls	141	* Because the block layer marks a request as complete before it calls
142	* scsi_times_out(), a .scsi_done() call from the LLD for a command that has	142	* scsi_timeout(), a .scsi_done() call from the LLD for a command that has
143	* timed out do not have any effect. Hence it is safe to call	143	* timed out do not have any effect. Hence it is safe to call
144	* scsi_finish_command() from this function.	144	* scsi_finish_command() from this function.
145	*/	145	*/
@@ -316,7 +316,7 @@ void scsi_eh_scmd_add(struct scsi_cmnd *scmd) · 170 unmodified lines
316	}	316	}
317		317
318	/**	318	/**
319	* scsi_times_out - Timeout function for normal scsi commands.	319	* scsi_timeout - Timeout function for normal scsi commands.
320	* @req: request that is timing out.	320	* @req: request that is timing out.
321	*	321	*
322	* Notes:	322	* Notes:
@@ -325,7 +325,7 @@ void scsi_eh_scmd_add(struct scsi_cmnd *scmd) · 2 unmodified lines
325	* normal completion function determines that the timer has already	325	* normal completion function determines that the timer has already
326	* fired, then it mustn't do anything.	326	* fired, then it mustn't do anything.
327	*/	327	*/
328	enum blk_eh_timer_return scsi_times_out(struct request *req)	328	enum blk_eh_timer_return scsi_timeout(struct request *req)
329	{	329	{
330	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);	330	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
331	enum blk_eh_timer_return rtn = BLK_EH_DONE;	331	enum blk_eh_timer_return rtn = BLK_EH_DONE;
@@ -1779,7 +1779,7 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q, · 1447 unmodified lines
1779	* scsi_noretry_cmd - determine if command should be failed fast	1779	* scsi_noretry_cmd - determine if command should be failed fast
1780	* @scmd: SCSI cmd to examine.	1780	* @scmd: SCSI cmd to examine.
1781	*/	1781	*/
1782	int scsi_noretry_cmd(struct scsi_cmnd *scmd)	1782	bool scsi_noretry_cmd(struct scsi_cmnd *scmd)
1783	{	1783	{
1784	struct request *req = scsi_cmd_to_rq(scmd);	1784	struct request *req = scsi_cmd_to_rq(scmd);
1785		1785
@@ -1789,19 +1789,19 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd) · 3 unmodified lines
1789	case DID_TIME_OUT:	1789	case DID_TIME_OUT:
1790	goto check_type;	1790	goto check_type;
1791	case DID_BUS_BUSY:	1791	case DID_BUS_BUSY:
1792	return req->cmd_flags & REQ_FAILFAST_TRANSPORT;	1792	return !!(req->cmd_flags & REQ_FAILFAST_TRANSPORT);
1793	case DID_PARITY:	1793	case DID_PARITY:
1794	return req->cmd_flags & REQ_FAILFAST_DEV;	1794	return !!(req->cmd_flags & REQ_FAILFAST_DEV);
1795	case DID_ERROR:	1795	case DID_ERROR:
1796	if (get_status_byte(scmd) == SAM_STAT_RESERVATION_CONFLICT)	1796	if (get_status_byte(scmd) == SAM_STAT_RESERVATION_CONFLICT)
1797	return 0;	1797	return false;
1798	fallthrough;	1798	fallthrough;
1799	case DID_SOFT_ERROR:	1799	case DID_SOFT_ERROR:
1800	return req->cmd_flags & REQ_FAILFAST_DRIVER;	1800	return !!(req->cmd_flags & REQ_FAILFAST_DRIVER);
1801	}	1801	}
1802		1802
1803	if (!scsi_status_is_check_condition(scmd->result))	1803	if (!scsi_status_is_check_condition(scmd->result))
1804	return 0;	1804	return false;
1805		1805
1806	check_type:	1806	check_type:
1807	/*	1807	/*
@@ -1809,9 +1809,9 @@ check_type: · 1 unmodified line
1809	* the check condition was retryable.	1809	* the check condition was retryable.
1810	*/	1810	*/
1811	if (req->cmd_flags & REQ_FAILFAST_DEV \|\| blk_rq_is_passthrough(req))	1811	if (req->cmd_flags & REQ_FAILFAST_DEV \|\| blk_rq_is_passthrough(req))
1812	return 1;	1812	return true;
1813		1813
1814	return 0;	1814	return false;
1815	}	1815	}
1816		1816
1817	/**	1817	/**

drivers/scsi/scsi_lib.c+9−17

 	 * Requeue this command.  It will go before all other commands
 	 * that are already in the queue. Schedule requeue work under
 	 * lock such that the kblockd_schedule_work() call happens
-	 * before blk_cleanup_queue() finishes.
+	 * before blk_mq_destroy_queue() finishes.
 	 */
 	cmd->result = 0;
 int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 		 int data_direction, void *buffer, unsigned bufflen,
 		 unsigned char *sense, struct scsi_sense_hdr *sshdr,
-		 int timeout, int retries, u64 flags, req_flags_t rq_flags,
+		 int timeout, int retries, blk_opf_t flags,
-		 int *resid)
+		 req_flags_t rq_flags, int *resid)
 {
 	struct request *req;
 	struct scsi_cmnd *scmd;
 		 * it and the queue.  Mitigate by taking a reference to the
 		 * queue and never touching the sdev again after we drop the
 		 * host lock.  Note: if __scsi_remove_device() invokes
-		 * blk_cleanup_queue() before the queue is run from this
+		 * blk_mq_destroy_queue() before the queue is run from this
 		 * function then blk_run_queue() will return immediately since
-		 * blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
+		 * blk_mq_destroy_queue() marks the queue with QUEUE_FLAG_DYING.
 		 */
 		slq = sdev->request_queue;
 		if (!blk_get_queue(slq))
  */
 static unsigned int scsi_rq_err_bytes(const struct request *rq)
 {
-	unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
+	blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;
 	unsigned int bytes = 0;
 	struct bio *bio;
 	cmd->retries = 0;
 }
-struct request *scsi_alloc_request(struct request_queue *q,
+struct request *scsi_alloc_request(struct request_queue *q, blk_opf_t opf,
-		unsigned int op, blk_mq_req_flags_t flags)
+				   blk_mq_req_flags_t flags)
 {
 	struct request *rq;
-	rq = blk_mq_alloc_request(q, op, flags);
+	rq = blk_mq_alloc_request(q, opf, flags);
 	if (!IS_ERR(rq))
 		scsi_initialize_rq(rq);
 	return rq;
 	return ret;
 }
-static enum blk_eh_timer_return scsi_timeout(struct request *req,
-		bool reserved)
-{
-	if (reserved)
-		return BLK_EH_RESET_TIMER;
-	return scsi_times_out(req);
-}
 static int scsi_mq_init_request(struct blk_mq_tag_set *set, struct request *rq,
 				unsigned int hctx_idx, unsigned int numa_node)
 {

drivers/scsi/scsi_priv.h+2−2

@@ -72,7 +72,7 @@ extern void scsi_exit_devinfo(void); · 71 unmodified lines
72		72
73	/* scsi_error.c */	73	/* scsi_error.c */
74	extern void scmd_eh_abort_handler(struct work_struct *work);	74	extern void scmd_eh_abort_handler(struct work_struct *work);
75	extern enum blk_eh_timer_return scsi_times_out(struct request *req);	75	extern enum blk_eh_timer_return scsi_timeout(struct request *req);
76	extern int scsi_error_handler(void *host);	76	extern int scsi_error_handler(void *host);
77	extern enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *cmd);	77	extern enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *cmd);
78	extern void scsi_eh_wakeup(struct Scsi_Host *shost);	78	extern void scsi_eh_wakeup(struct Scsi_Host *shost);
@@ -82,7 +82,7 @@ void scsi_eh_ready_devs(struct Scsi_Host *shost, · 3 unmodified lines
82	struct list_head *done_q);	82	struct list_head *done_q);
83	int scsi_eh_get_sense(struct list_head *work_q,	83	int scsi_eh_get_sense(struct list_head *work_q,
84	struct list_head *done_q);	84	struct list_head *done_q);
85	int scsi_noretry_cmd(struct scsi_cmnd *scmd);	85	bool scsi_noretry_cmd(struct scsi_cmnd *scmd);
86	void scsi_eh_done(struct scsi_cmnd *scmd);	86	void scsi_eh_done(struct scsi_cmnd *scmd);
87		87
88	/* scsi_lib.c */	88	/* scsi_lib.c */

drivers/scsi/scsi_sysfs.c+1−1

@@ -1475,7 +1475,7 @@ void __scsi_remove_device(struct scsi_device *sdev) · 1474 unmodified lines
1475	scsi_device_set_state(sdev, SDEV_DEL);	1475	scsi_device_set_state(sdev, SDEV_DEL);
1476	mutex_unlock(&sdev->state_mutex);	1476	mutex_unlock(&sdev->state_mutex);
1477		1477
1478	blk_cleanup_queue(sdev->request_queue);	1478	blk_mq_destroy_queue(sdev->request_queue);
1479	cancel_work_sync(&sdev->requeue_work);	1479	cancel_work_sync(&sdev->requeue_work);
1480		1480
1481	if (sdev->host->hostt->slave_destroy)	1481	if (sdev->host->hostt->slave_destroy)

drivers/scsi/sd.c+5−5

@@ -2934,15 +2934,15 @@ static void sd_read_block_characteristics(struct scsi_disk *sdkp) · 2933 unmodified lines
2934		2934
2935	if (sdkp->device->type == TYPE_ZBC) {	2935	if (sdkp->device->type == TYPE_ZBC) {
2936	/* Host-managed */	2936	/* Host-managed */
2937	blk_queue_set_zoned(sdkp->disk, BLK_ZONED_HM);	2937	disk_set_zoned(sdkp->disk, BLK_ZONED_HM);
2938	} else {	2938	} else {
2939	sdkp->zoned = zoned;	2939	sdkp->zoned = zoned;
2940	if (sdkp->zoned == 1) {	2940	if (sdkp->zoned == 1) {
2941	/* Host-aware */	2941	/* Host-aware */
2942	blk_queue_set_zoned(sdkp->disk, BLK_ZONED_HA);	2942	disk_set_zoned(sdkp->disk, BLK_ZONED_HA);
2943	} else {	2943	} else {
2944	/* Regular disk or drive managed disk */	2944	/* Regular disk or drive managed disk */
2945	blk_queue_set_zoned(sdkp->disk, BLK_ZONED_NONE);	2945	disk_set_zoned(sdkp->disk, BLK_ZONED_NONE);
2946	}	2946	}
2947	}	2947	}
2948		2948
@@ -3440,8 +3440,8 @@ static int sd_probe(struct device *dev) · 491 unmodified lines
3440	if (!sdkp)	3440	if (!sdkp)
3441	goto out;	3441	goto out;
3442		3442
3443	gd = __alloc_disk_node(sdp->request_queue, NUMA_NO_NODE,	3443	gd = blk_mq_alloc_disk_for_queue(sdp->request_queue,
3444	&sd_bio_compl_lkclass);	3444	&sd_bio_compl_lkclass);
3445	if (!gd)	3445	if (!gd)
3446	goto out_free;	3446	goto out_free;
3447		3447

drivers/scsi/sd_zbc.c+6−6

@@ -529,7 +529,7 @@ static unsigned int sd_zbc_zone_wp_update(struct scsi_cmnd *cmd, · 528 unmodified lines
529	struct request *rq = scsi_cmd_to_rq(cmd);	529	struct request *rq = scsi_cmd_to_rq(cmd);
530	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);	530	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
531	unsigned int zno = blk_rq_zone_no(rq);	531	unsigned int zno = blk_rq_zone_no(rq);
532	enum req_opf op = req_op(rq);	532	enum req_op op = req_op(rq);
533	unsigned long flags;	533	unsigned long flags;
534		534
535	/*	535	/*
@@ -855,7 +855,7 @@ int sd_zbc_revalidate_zones(struct scsi_disk *sdkp) · 319 unmodified lines
855		855
856	if (sdkp->zone_info.zone_blocks == zone_blocks &&	856	if (sdkp->zone_info.zone_blocks == zone_blocks &&
857	sdkp->zone_info.nr_zones == nr_zones &&	857	sdkp->zone_info.nr_zones == nr_zones &&
858	disk->queue->nr_zones == nr_zones)	858	disk->nr_zones == nr_zones)
859	goto unlock;	859	goto unlock;
860		860
861	flags = memalloc_noio_save();	861	flags = memalloc_noio_save();
@@ -929,7 +929,7 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]) · 67 unmodified lines
929	/*	929	/*
930	* This can happen for a host aware disk with partitions.	930	* This can happen for a host aware disk with partitions.
931	* The block device zone model was already cleared by	931	* The block device zone model was already cleared by
932	* blk_queue_set_zoned(). Only free the scsi disk zone	932	* disk_set_zoned(). Only free the scsi disk zone
933	* information and exit early.	933	* information and exit early.
934	*/	934	*/
935	sd_zbc_free_zone_info(sdkp);	935	sd_zbc_free_zone_info(sdkp);
@@ -950,10 +950,10 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]) · 14 unmodified lines
950	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);	950	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
951	blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE);	951	blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE);
952	if (sdkp->zones_max_open == U32_MAX)	952	if (sdkp->zones_max_open == U32_MAX)
953	blk_queue_max_open_zones(q, 0);	953	disk_set_max_open_zones(disk, 0);
954	else	954	else
955	blk_queue_max_open_zones(q, sdkp->zones_max_open);	955	disk_set_max_open_zones(disk, sdkp->zones_max_open);
956	blk_queue_max_active_zones(q, 0);	956	disk_set_max_active_zones(disk, 0);
957	nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);	957	nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);
958		958
959	/*	959	/*

drivers/scsi/sr.c+2−2

@@ -624,8 +624,8 @@ static int sr_probe(struct device *dev) · 623 unmodified lines
624	if (!cd)	624	if (!cd)
625	goto fail;	625	goto fail;
626		626
627	disk = __alloc_disk_node(sdev->request_queue, NUMA_NO_NODE,	627	disk = blk_mq_alloc_disk_for_queue(sdev->request_queue,
628	&sr_bio_compl_lkclass);	628	&sr_bio_compl_lkclass);
629	if (!disk)	629	if (!disk)
630	goto fail_free;	630	goto fail_free;
631	mutex_init(&cd->lock);	631	mutex_init(&cd->lock);

drivers/target/target_core_iblock.c+2−2

@@ -343,7 +343,7 @@ static void iblock_bio_done(struct bio *bio) · 342 unmodified lines
343	}	343	}
344		344
345	static struct bio iblock_get_bio(struct se_cmd cmd, sector_t lba, u32 sg_num,	345	static struct bio iblock_get_bio(struct se_cmd cmd, sector_t lba, u32 sg_num,
346	unsigned int opf)	346	blk_opf_t opf)
347	{	347	{
348	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);	348	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
349	struct bio *bio;	349	struct bio *bio;
@@ -723,7 +723,7 @@ iblock_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents, · 373 unmodified lines
723	struct bio_list list;	723	struct bio_list list;
724	struct scatterlist *sg;	724	struct scatterlist *sg;
725	u32 sg_num = sgl_nents;	725	u32 sg_num = sgl_nents;
726	unsigned int opf;	726	blk_opf_t opf;
727	unsigned bio_cnt;	727	unsigned bio_cnt;
728	int i, rc;	728	int i, rc;
729	struct sg_mapping_iter prot_miter;	729	struct sg_mapping_iter prot_miter;

drivers/ufs/core/ufshcd.c+2−2

@@ -9509,7 +9509,7 @@ void ufshcd_remove(struct ufs_hba *hba) · 9508 unmodified lines
9509	ufs_bsg_remove(hba);	9509	ufs_bsg_remove(hba);
9510	ufshpb_remove(hba);	9510	ufshpb_remove(hba);
9511	ufs_sysfs_remove_nodes(hba->dev);	9511	ufs_sysfs_remove_nodes(hba->dev);
9512	blk_cleanup_queue(hba->tmf_queue);	9512	blk_mq_destroy_queue(hba->tmf_queue);
9513	blk_mq_free_tag_set(&hba->tmf_tag_set);	9513	blk_mq_free_tag_set(&hba->tmf_tag_set);
9514	scsi_remove_host(hba->host);	9514	scsi_remove_host(hba->host);
9515	/* disable interrupts */	9515	/* disable interrupts */
@@ -9805,7 +9805,7 @@ int ufshcd_init(struct ufs_hba hba, void __iomem mmio_base, unsigned int irq) · 289 unmodified lines
9805	return 0;	9805	return 0;
9806		9806
9807	free_tmf_queue:	9807	free_tmf_queue:
9808	blk_cleanup_queue(hba->tmf_queue);	9808	blk_mq_destroy_queue(hba->tmf_queue);
9809	free_tmf_tag_set:	9809	free_tmf_tag_set:
9810	blk_mq_free_tag_set(&hba->tmf_tag_set);	9810	blk_mq_free_tag_set(&hba->tmf_tag_set);
9811	out_remove_scsi_host:	9811	out_remove_scsi_host:

drivers/ufs/core/ufshpb.c+3−4

 	return 0;
 }
-static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
+static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb, int rgn_idx,
-					 int rgn_idx, enum req_opf dir,
+					 enum req_op op, bool atomic)
-					 bool atomic)
 {
 	struct ufshpb_req *rq;
 	struct request *req;
 		return NULL;
 retry:
-	req = blk_mq_alloc_request(hpb->sdev_ufs_lu->request_queue, dir,
+	req = blk_mq_alloc_request(hpb->sdev_ufs_lu->request_queue, op,
 			      BLK_MQ_REQ_NOWAIT);
 	if (!atomic && (PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) {

fs/btrfs/check-integrity.c+2−2

@@ -152,7 +152,7 @@ struct btrfsic_block { · 151 unmodified lines
152	struct btrfsic_block *next_in_same_bio;	152	struct btrfsic_block *next_in_same_bio;
153	void *orig_bio_private;	153	void *orig_bio_private;
154	bio_end_io_t *orig_bio_end_io;	154	bio_end_io_t *orig_bio_end_io;
155	int submit_bio_bh_rw;	155	blk_opf_t submit_bio_bh_rw;
156	u64 flush_gen; /* only valid if !never_written */	156	u64 flush_gen; /* only valid if !never_written */
157	};	157	};
158		158
@@ -1681,7 +1681,7 @@ static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state, · 1522 unmodified lines
1681	u64 dev_bytenr, char **mapped_datav,	1681	u64 dev_bytenr, char **mapped_datav,
1682	unsigned int num_pages,	1682	unsigned int num_pages,
1683	struct bio bio, int bio_is_patched,	1683	struct bio bio, int bio_is_patched,
1684	int submit_bio_bh_rw)	1684	blk_opf_t submit_bio_bh_rw)
1685	{	1685	{
1686	int is_metadata;	1686	int is_metadata;
1687	struct btrfsic_block *block;	1687	struct btrfsic_block *block;

fs/btrfs/compression.c+3−3

@@ -455,7 +455,7 @@ static blk_status_t submit_compressed_bio(struct btrfs_fs_info *fs_info, · 454 unmodified lines
455		455
456		456
457	static struct bio alloc_compressed_bio(struct compressed_bio cb, u64 disk_bytenr,	457	static struct bio alloc_compressed_bio(struct compressed_bio cb, u64 disk_bytenr,
458	unsigned int opf, bio_end_io_t endio_func,	458	blk_opf_t opf, bio_end_io_t endio_func,
459	u64 *next_stripe_start)	459	u64 *next_stripe_start)
460	{	460	{
461	struct btrfs_fs_info *fs_info = btrfs_sb(cb->inode->i_sb);	461	struct btrfs_fs_info *fs_info = btrfs_sb(cb->inode->i_sb);
@@ -505,7 +505,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start, · 43 unmodified lines
505	unsigned int compressed_len,	505	unsigned int compressed_len,
506	struct page **compressed_pages,	506	struct page **compressed_pages,
507	unsigned int nr_pages,	507	unsigned int nr_pages,
508	unsigned int write_flags,	508	blk_opf_t write_flags,
509	struct cgroup_subsys_state *blkcg_css,	509	struct cgroup_subsys_state *blkcg_css,
510	bool writeback)	510	bool writeback)
511	{	511	{
@@ -517,7 +517,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start, · 5 unmodified lines
517	blk_status_t ret;	517	blk_status_t ret;
518	int skip_sum = inode->flags & BTRFS_INODE_NODATASUM;	518	int skip_sum = inode->flags & BTRFS_INODE_NODATASUM;
519	const bool use_append = btrfs_use_zone_append(inode, disk_start);	519	const bool use_append = btrfs_use_zone_append(inode, disk_start);
520	const unsigned int bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;	520	const enum req_op bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;
521		521
522	ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&	522	ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
523	IS_ALIGNED(len, fs_info->sectorsize));	523	IS_ALIGNED(len, fs_info->sectorsize));

fs/btrfs/compression.h+1−1

@@ -99,7 +99,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start, · 98 unmodified lines
99	unsigned int compressed_len,	99	unsigned int compressed_len,
100	struct page **compressed_pages,	100	struct page **compressed_pages,
101	unsigned int nr_pages,	101	unsigned int nr_pages,
102	unsigned int write_flags,	102	blk_opf_t write_flags,
103	struct cgroup_subsys_state *blkcg_css,	103	struct cgroup_subsys_state *blkcg_css,
104	bool writeback);	104	bool writeback);
105	void btrfs_submit_compressed_read(struct inode inode, struct bio bio,	105	void btrfs_submit_compressed_read(struct inode inode, struct bio bio,

fs/btrfs/extent_io.c+9−9

@@ -3359,7 +3359,7 @@ static int calc_bio_boundaries(struct btrfs_bio_ctrl *bio_ctrl, · 3358 unmodified lines
3359	static int alloc_new_bio(struct btrfs_inode *inode,	3359	static int alloc_new_bio(struct btrfs_inode *inode,
3360	struct btrfs_bio_ctrl *bio_ctrl,	3360	struct btrfs_bio_ctrl *bio_ctrl,
3361	struct writeback_control *wbc,	3361	struct writeback_control *wbc,
3362	unsigned int opf,	3362	blk_opf_t opf,
3363	bio_end_io_t end_io_func,	3363	bio_end_io_t end_io_func,
3364	u64 disk_bytenr, u32 offset, u64 file_offset,	3364	u64 disk_bytenr, u32 offset, u64 file_offset,
3365	enum btrfs_compression_type compress_type)	3365	enum btrfs_compression_type compress_type)
@@ -3439,7 +3439,7 @@ error: · 73 unmodified lines
3439	* @prev_bio_flags: flags of previous bio to see if we can merge the current one	3439	* @prev_bio_flags: flags of previous bio to see if we can merge the current one
3440	* @compress_type: compress type for current bio	3440	* @compress_type: compress type for current bio
3441	*/	3441	*/
3442	static int submit_extent_page(unsigned int opf,	3442	static int submit_extent_page(blk_opf_t opf,
3443	struct writeback_control *wbc,	3443	struct writeback_control *wbc,
3444	struct btrfs_bio_ctrl *bio_ctrl,	3444	struct btrfs_bio_ctrl *bio_ctrl,
3445	struct page *page, u64 disk_bytenr,	3445	struct page *page, u64 disk_bytenr,
@@ -3617,7 +3617,7 @@ __get_extent_map(struct inode inode, struct page page, size_t pg_offset, · 171 unmodified lines
3617	*/	3617	*/
3618	static int btrfs_do_readpage(struct page page, struct extent_map *em_cached,	3618	static int btrfs_do_readpage(struct page page, struct extent_map *em_cached,
3619	struct btrfs_bio_ctrl *bio_ctrl,	3619	struct btrfs_bio_ctrl *bio_ctrl,
3620	unsigned int read_flags, u64 *prev_em_start)	3620	blk_opf_t read_flags, u64 *prev_em_start)
3621	{	3621	{
3622	struct inode *inode = page->mapping->host;	3622	struct inode *inode = page->mapping->host;
3623	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	3623	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -3985,8 +3985,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode, · 361 unmodified lines
3985	int saved_ret = 0;	3985	int saved_ret = 0;
3986	int ret = 0;	3986	int ret = 0;
3987	int nr = 0;	3987	int nr = 0;
3988	u32 opf = REQ_OP_WRITE;	3988	enum req_op op = REQ_OP_WRITE;
3989	const unsigned int write_flags = wbc_to_write_flags(wbc);	3989	const blk_opf_t write_flags = wbc_to_write_flags(wbc);
3990	bool has_error = false;	3990	bool has_error = false;
3991	bool compressed;	3991	bool compressed;
3992		3992
@@ -4060,7 +4060,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode, · 67 unmodified lines
4060	iosize = min(min(em_end, end + 1), dirty_range_end) - cur;	4060	iosize = min(min(em_end, end + 1), dirty_range_end) - cur;
4061		4061
4062	if (btrfs_use_zone_append(inode, em->block_start))	4062	if (btrfs_use_zone_append(inode, em->block_start))
4063	opf = REQ_OP_ZONE_APPEND;	4063	op = REQ_OP_ZONE_APPEND;
4064		4064
4065	free_extent_map(em);	4065	free_extent_map(em);
4066	em = NULL;	4066	em = NULL;
@@ -4096,7 +4096,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode, · 29 unmodified lines
4096	*/	4096	*/
4097	btrfs_page_clear_dirty(fs_info, page, cur, iosize);	4097	btrfs_page_clear_dirty(fs_info, page, cur, iosize);
4098		4098
4099	ret = submit_extent_page(opf \| write_flags, wbc,	4099	ret = submit_extent_page(op \| write_flags, wbc,
4100	&epd->bio_ctrl, page,	4100	&epd->bio_ctrl, page,
4101	disk_bytenr, iosize,	4101	disk_bytenr, iosize,
4102	cur - page_offset(page),	4102	cur - page_offset(page),
@@ -4577,7 +4577,7 @@ static int write_one_subpage_eb(struct extent_buffer *eb, · 474 unmodified lines
4577	{	4577	{
4578	struct btrfs_fs_info *fs_info = eb->fs_info;	4578	struct btrfs_fs_info *fs_info = eb->fs_info;
4579	struct page *page = eb->pages[0];	4579	struct page *page = eb->pages[0];
4580	unsigned int write_flags = wbc_to_write_flags(wbc) \| REQ_META;	4580	blk_opf_t write_flags = wbc_to_write_flags(wbc) \| REQ_META;
4581	bool no_dirty_ebs = false;	4581	bool no_dirty_ebs = false;
4582	int ret;	4582	int ret;
4583		4583
@@ -4622,7 +4622,7 @@ static noinline_for_stack int write_one_eb(struct extent_buffer *eb, · 38 unmodified lines
4622	{	4622	{
4623	u64 disk_bytenr = eb->start;	4623	u64 disk_bytenr = eb->start;
4624	int i, num_pages;	4624	int i, num_pages;
4625	unsigned int write_flags = wbc_to_write_flags(wbc) \| REQ_META;	4625	blk_opf_t write_flags = wbc_to_write_flags(wbc) \| REQ_META;
4626	int ret = 0;	4626	int ret = 0;
4627		4627
4628	prepare_eb_write(eb);	4628	prepare_eb_write(eb);

fs/btrfs/inode.c+2−2

@@ -485,7 +485,7 @@ struct async_chunk { · 484 unmodified lines
485	struct page *locked_page;	485	struct page *locked_page;
486	u64 start;	486	u64 start;
487	u64 end;	487	u64 end;
488	unsigned int write_flags;	488	blk_opf_t write_flags;
489	struct list_head extents;	489	struct list_head extents;
490	struct cgroup_subsys_state *blkcg_css;	490	struct cgroup_subsys_state *blkcg_css;
491	struct btrfs_work work;	491	struct btrfs_work work;
@@ -1435,7 +1435,7 @@ static int cow_file_range_async(struct btrfs_inode *inode, · 943 unmodified lines
1435	int i;	1435	int i;
1436	bool should_compress;	1436	bool should_compress;
1437	unsigned nofs_flag;	1437	unsigned nofs_flag;
1438	const unsigned int write_flags = wbc_to_write_flags(wbc);	1438	const blk_opf_t write_flags = wbc_to_write_flags(wbc);
1439		1439
1440	unlock_extent(&inode->io_tree, start, end);	1440	unlock_extent(&inode->io_tree, start, end);
1441		1441

fs/btrfs/raid56.c+2−2

@@ -1136,7 +1136,7 @@ static int rbio_add_io_sector(struct btrfs_raid_bio *rbio, · 1135 unmodified lines
1136	unsigned int stripe_nr,	1136	unsigned int stripe_nr,
1137	unsigned int sector_nr,	1137	unsigned int sector_nr,
1138	unsigned long bio_max_len,	1138	unsigned long bio_max_len,
1139	unsigned int opf)	1139	enum req_op op)
1140	{	1140	{
1141	const u32 sectorsize = rbio->bioc->fs_info->sectorsize;	1141	const u32 sectorsize = rbio->bioc->fs_info->sectorsize;
1142	struct bio *last = bio_list->tail;	1142	struct bio *last = bio_list->tail;
@@ -1181,7 +1181,7 @@ static int rbio_add_io_sector(struct btrfs_raid_bio *rbio, · 38 unmodified lines
1181		1181
1182	/* put a new bio on the list */	1182	/* put a new bio on the list */
1183	bio = bio_alloc(stripe->dev->bdev, max(bio_max_len >> PAGE_SHIFT, 1UL),	1183	bio = bio_alloc(stripe->dev->bdev, max(bio_max_len >> PAGE_SHIFT, 1UL),
1184	opf, GFP_NOFS);	1184	op, GFP_NOFS);
1185	bio->bi_iter.bi_sector = disk_start >> 9;	1185	bio->bi_iter.bi_sector = disk_start >> 9;
1186	bio->bi_private = rbio;	1186	bio->bi_private = rbio;
1187		1187

fs/buffer.c+31−30

 #include "internal.h"
 static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);
-static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
+static int submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
 			 struct writeback_control *wbc);
 #define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
 	struct buffer_head *bh = __find_get_block(bdev, bblock + 1, blocksize);
 	if (bh) {
 		if (buffer_dirty(bh))
-			ll_rw_block(REQ_OP_WRITE, 0, 1, &bh);
+			ll_rw_block(REQ_OP_WRITE, 1, &bh);
 		put_bh(bh);
 	}
 }
 	} else {
 		get_bh(bh);
 		bh->b_end_io = end_buffer_read_sync;
-		submit_bh(REQ_OP_READ, 0, bh);
+		submit_bh(REQ_OP_READ, bh);
 		wait_on_buffer(bh);
 		if (buffer_uptodate(bh))
 			return bh;
 {
 	struct buffer_head *bh = __getblk(bdev, block, size);
 	if (likely(bh)) {
-		ll_rw_block(REQ_OP_READ, REQ_RAHEAD, 1, &bh);
+		ll_rw_block(REQ_OP_READ | REQ_RAHEAD, 1, &bh);
 		brelse(bh);
 	}
 }
 {
 	struct buffer_head *bh = __getblk_gfp(bdev, block, size, gfp);
 	if (likely(bh)) {
-		ll_rw_block(REQ_OP_READ, REQ_RAHEAD, 1, &bh);
+		ll_rw_block(REQ_OP_READ | REQ_RAHEAD, 1, &bh);
 		brelse(bh);
 	}
 }
 	struct buffer_head *bh, *head;
 	unsigned int blocksize, bbits;
 	int nr_underway = 0;
-	int write_flags = wbc_to_write_flags(wbc);
+	blk_opf_t write_flags = wbc_to_write_flags(wbc);
 	head = create_page_buffers(page, inode,
 					(1 << BH_Dirty)|(1 << BH_Uptodate));
 	do {
 		struct buffer_head *next = bh->b_this_page;
 		if (buffer_async_write(bh)) {
-			submit_bh_wbc(REQ_OP_WRITE, write_flags, bh, wbc);
+			submit_bh_wbc(REQ_OP_WRITE | write_flags, bh, wbc);
 			nr_underway++;
 		}
 		bh = next;
 		struct buffer_head *next = bh->b_this_page;
 		if (buffer_async_write(bh)) {
 			clear_buffer_dirty(bh);
-			submit_bh_wbc(REQ_OP_WRITE, write_flags, bh, wbc);
+			submit_bh_wbc(REQ_OP_WRITE | write_flags, bh, wbc);
 			nr_underway++;
 		}
 		bh = next;
 		if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
 		    !buffer_unwritten(bh) &&
 		     (block_start < from || block_end > to)) {
-			ll_rw_block(REQ_OP_READ, 0, 1, &bh);
+			ll_rw_block(REQ_OP_READ, 1, &bh);
 			*wait_bh++=bh;
 		}
 	}
 		if (buffer_uptodate(bh))
 			end_buffer_async_read(bh, 1);
 		else
-			submit_bh(REQ_OP_READ, 0, bh);
+			submit_bh(REQ_OP_READ, bh);
 	}
 	return 0;
 }
 		if (block_start < from || block_end > to) {
 			lock_buffer(bh);
 			bh->b_end_io = end_buffer_read_nobh;
-			submit_bh(REQ_OP_READ, 0, bh);
+			submit_bh(REQ_OP_READ, bh);
 			nr_reads++;
 		}
 	}
 	if (!buffer_uptodate(bh) && !buffer_delay(bh) && !buffer_unwritten(bh)) {
 		err = -EIO;
-		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
+		ll_rw_block(REQ_OP_READ, 1, &bh);
 		wait_on_buffer(bh);
 		/* Uhhuh. Read error. Complain and punt. */
 		if (!buffer_uptodate(bh))
 	bio_put(bio);
 }
-static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
+static int submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
 			 struct writeback_control *wbc)
 {
+	const enum req_op op = opf & REQ_OP_MASK;
 	struct bio *bio;
 	BUG_ON(!buffer_locked(bh));
 		clear_buffer_write_io_error(bh);
 	if (buffer_meta(bh))
-		op_flags |= REQ_META;
+		opf |= REQ_META;
 	if (buffer_prio(bh))
-		op_flags |= REQ_PRIO;
+		opf |= REQ_PRIO;
-	bio = bio_alloc(bh->b_bdev, 1, op | op_flags, GFP_NOIO);
+	bio = bio_alloc(bh->b_bdev, 1, opf, GFP_NOIO);
 	fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);
 	return 0;
 }
-int submit_bh(int op, int op_flags, struct buffer_head *bh)
+int submit_bh(blk_opf_t opf, struct buffer_head *bh)
 {
-	return submit_bh_wbc(op, op_flags, bh, NULL);
+	return submit_bh_wbc(opf, bh, NULL);
 }
 EXPORT_SYMBOL(submit_bh);
 /**
  * ll_rw_block: low-level access to block devices (DEPRECATED)
- * @op: whether to %READ or %WRITE
+ * @opf: block layer request operation and flags.
- * @op_flags: req_flag_bits
  * @nr: number of &struct buffer_heads in the array
  * @bhs: array of pointers to &struct buffer_head
  *
  * ll_rw_block() takes an array of pointers to &struct buffer_heads, and
  * requests an I/O operation on them, either a %REQ_OP_READ or a %REQ_OP_WRITE.
- * @op_flags contains flags modifying the detailed I/O behavior, most notably
+ * @opf contains flags modifying the detailed I/O behavior, most notably
  * %REQ_RAHEAD.
  *
  * This function drops any buffer that it cannot get a lock on (with the
  * All of the buffers must be for the same device, and must also be a
  * multiple of the current approved size for the device.
  */
-void ll_rw_block(int op, int op_flags,  int nr, struct buffer_head *bhs[])
+void ll_rw_block(const blk_opf_t opf, int nr, struct buffer_head *bhs[])
 {
+	const enum req_op op = opf & REQ_OP_MASK;
 	int i;
 	for (i = 0; i < nr; i++) {
 		if (!trylock_buffer(bh))
 			continue;
-		if (op == WRITE) {
+		if (op == REQ_OP_WRITE) {
 			if (test_clear_buffer_dirty(bh)) {
 				bh->b_end_io = end_buffer_write_sync;
 				get_bh(bh);
-				submit_bh(op, op_flags, bh);
+				submit_bh(opf, bh);
 				continue;
 			}
 		} else {
 			if (!buffer_uptodate(bh)) {
 				bh->b_end_io = end_buffer_read_sync;
 				get_bh(bh);
-				submit_bh(op, op_flags, bh);
+				submit_bh(opf, bh);
 				continue;
 			}
 		}
 }
 EXPORT_SYMBOL(ll_rw_block);
-void write_dirty_buffer(struct buffer_head *bh, int op_flags)
+void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags)
 {
 	lock_buffer(bh);
 	if (!test_clear_buffer_dirty(bh)) {
 	}
 	bh->b_end_io = end_buffer_write_sync;
 	get_bh(bh);
-	submit_bh(REQ_OP_WRITE, op_flags, bh);
+	submit_bh(REQ_OP_WRITE | op_flags, bh);
 }
 EXPORT_SYMBOL(write_dirty_buffer);
  * and then start new I/O and then wait upon it.  The caller must have a ref on
  * the buffer_head.
  */
-int __sync_dirty_buffer(struct buffer_head *bh, int op_flags)
+int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags)
 {
 	int ret = 0;
 		get_bh(bh);
 		bh->b_end_io = end_buffer_write_sync;
-		ret = submit_bh(REQ_OP_WRITE, op_flags, bh);
+		ret = submit_bh(REQ_OP_WRITE | op_flags, bh);
 		wait_on_buffer(bh);
 		if (!ret && !buffer_uptodate(bh))
 			ret = -EIO;
 	get_bh(bh);
 	bh->b_end_io = end_buffer_read_sync;
-	submit_bh(REQ_OP_READ, 0, bh);
+	submit_bh(REQ_OP_READ, bh);
 	wait_on_buffer(bh);
 	if (buffer_uptodate(bh))
 		return 0;

fs/direct-io.c+23−17

 /* dio_state communicated between submission path and end_io */
 struct dio {
 	int flags;			/* doesn't change */
-	int op;
+	blk_opf_t opf;			/* request operation type and flags */
-	int op_flags;
 	struct gendisk *bio_disk;
 	struct inode *inode;
 	loff_t i_size;			/* i_size when submitted */
  */
 static inline int dio_refill_pages(struct dio *dio, struct dio_submit *sdio)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	ssize_t ret;
 	ret = iov_iter_get_pages(sdio->iter, dio->pages, LONG_MAX, DIO_PAGES,
 				&sdio->from);
-	if (ret < 0 && sdio->blocks_available && (dio->op == REQ_OP_WRITE)) {
+	if (ret < 0 && sdio->blocks_available && dio_op == REQ_OP_WRITE) {
 		struct page *page = ZERO_PAGE(0);
 		/*
 		 * A memory fault, but the filesystem has some outstanding
  */
 static ssize_t dio_complete(struct dio *dio, ssize_t ret, unsigned int flags)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	loff_t offset = dio->iocb->ki_pos;
 	ssize_t transferred = 0;
 	int err;
 		transferred = dio->result;
 		/* Check for short read case */
-		if ((dio->op == REQ_OP_READ) &&
+		if (dio_op == REQ_OP_READ &&
 		    ((offset + transferred) > dio->i_size))
 			transferred = dio->i_size - offset;
 		/* ignore EFAULT if some IO has been done */
 	 * zeros from unwritten extents.
 	 */
 	if (flags & DIO_COMPLETE_INVALIDATE &&
-	    ret > 0 && dio->op == REQ_OP_WRITE &&
+	    ret > 0 && dio_op == REQ_OP_WRITE &&
 	    dio->inode->i_mapping->nrpages) {
 		err = invalidate_inode_pages2_range(dio->inode->i_mapping,
 					offset >> PAGE_SHIFT,
 		 */
 		dio->iocb->ki_pos += transferred;
-		if (ret > 0 && dio->op == REQ_OP_WRITE)
+		if (ret > 0 && dio_op == REQ_OP_WRITE)
 			ret = generic_write_sync(dio->iocb, ret);
 		dio->iocb->ki_complete(dio->iocb, ret);
 	}
 static void dio_bio_end_aio(struct bio *bio)
 {
 	struct dio *dio = bio->bi_private;
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	unsigned long remaining;
 	unsigned long flags;
 	bool defer_completion = false;
 		 */
 		if (dio->result)
 			defer_completion = dio->defer_completion ||
-					   (dio->op == REQ_OP_WRITE &&
+					   (dio_op == REQ_OP_WRITE &&
 					    dio->inode->i_mapping->nrpages);
 		if (defer_completion) {
 			INIT_WORK(&dio->complete_work, dio_aio_complete_work);
 	 * bio_alloc() is guaranteed to return a bio when allowed to sleep and
 	 * we request a valid number of vectors.
 	 */
-	bio = bio_alloc(bdev, nr_vecs, dio->op | dio->op_flags, GFP_KERNEL);
+	bio = bio_alloc(bdev, nr_vecs, dio->opf, GFP_KERNEL);
 	bio->bi_iter.bi_sector = first_sector;
 	if (dio->is_async)
 		bio->bi_end_io = dio_bio_end_aio;
  */
 static inline void dio_bio_submit(struct dio *dio, struct dio_submit *sdio)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	struct bio *bio = sdio->bio;
 	unsigned long flags;
 	dio->refcount++;
 	spin_unlock_irqrestore(&dio->bio_lock, flags);
-	if (dio->is_async && dio->op == REQ_OP_READ && dio->should_dirty)
+	if (dio->is_async && dio_op == REQ_OP_READ && dio->should_dirty)
 		bio_set_pages_dirty(bio);
 	dio->bio_disk = bio->bi_bdev->bd_disk;
 static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio)
 {
 	blk_status_t err = bio->bi_status;
-	bool should_dirty = dio->op == REQ_OP_READ && dio->should_dirty;
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
+	bool should_dirty = dio_op == REQ_OP_READ && dio->should_dirty;
 	if (err) {
 		if (err == BLK_STS_AGAIN && (bio->bi_opf & REQ_NOWAIT))
 static int get_more_blocks(struct dio *dio, struct dio_submit *sdio,
 			   struct buffer_head *map_bh)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	int ret;
 	sector_t fs_startblk;	/* Into file, in filesystem-sized blocks */
 	sector_t fs_endblk;	/* Into file, in filesystem-sized blocks */
 		 * which may decide to handle it or also return an unmapped
 		 * buffer head.
 		 */
-		create = dio->op == REQ_OP_WRITE;
+		create = dio_op == REQ_OP_WRITE;
 		if (dio->flags & DIO_SKIP_HOLES) {
 			i_size = i_size_read(dio->inode);
 			if (i_size && fs_startblk <= (i_size - 1) >> i_blkbits)
 		    unsigned offset, unsigned len, sector_t blocknr,
 		    struct buffer_head *map_bh)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	int ret = 0;
 	int boundary = sdio->boundary;	/* dio_send_cur_page may clear it */
-	if (dio->op == REQ_OP_WRITE) {
+	if (dio_op == REQ_OP_WRITE) {
 		/*
 		 * Read accounting is performed in submit_bio()
 		 */
 static int do_direct_IO(struct dio *dio, struct dio_submit *sdio,
 			struct buffer_head *map_bh)
 {
+	const enum req_op dio_op = dio->opf & REQ_OP_MASK;
 	const unsigned blkbits = sdio->blkbits;
 	const unsigned i_blkbits = blkbits + sdio->blkfactor;
 	int ret = 0;
 				loff_t i_size_aligned;
 				/* AKPM: eargh, -ENOTBLK is a hack */
-				if (dio->op == REQ_OP_WRITE) {
+				if (dio_op == REQ_OP_WRITE) {
 					put_page(page);
 					return -ENOTBLK;
 				}
 	dio->inode = inode;
 	if (iov_iter_rw(iter) == WRITE) {
-		dio->op = REQ_OP_WRITE;
+		dio->opf = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
-		dio->op_flags = REQ_SYNC | REQ_IDLE;
 		if (iocb->ki_flags & IOCB_NOWAIT)
-			dio->op_flags |= REQ_NOWAIT;
+			dio->opf |= REQ_NOWAIT;
 	} else {
-		dio->op = REQ_OP_READ;
+		dio->opf = REQ_OP_READ;
 	}
 	/*

fs/ext4/ext4.h+4−4

@@ -3058,14 +3058,14 @@ extern unsigned int ext4_list_backups(struct super_block *sb, · 3057 unmodified lines
3058		3058
3059	/* super.c */	3059	/* super.c */
3060	extern struct buffer_head ext4_sb_bread(struct super_block sb,	3060	extern struct buffer_head ext4_sb_bread(struct super_block sb,
3061	sector_t block, int op_flags);	3061	sector_t block, blk_opf_t op_flags);
3062	extern struct buffer_head ext4_sb_bread_unmovable(struct super_block sb,	3062	extern struct buffer_head ext4_sb_bread_unmovable(struct super_block sb,
3063	sector_t block);	3063	sector_t block);
3064	extern void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,	3064	extern void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
3065	bh_end_io_t *end_io);	3065	bh_end_io_t *end_io);
3066	extern int ext4_read_bh(struct buffer_head *bh, int op_flags,	3066	extern int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
3067	bh_end_io_t *end_io);	3067	bh_end_io_t *end_io);
3068	extern int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait);	3068	extern int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait);
3069	extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);	3069	extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);
3070	extern int ext4_seq_options_show(struct seq_file seq, void offset);	3070	extern int ext4_seq_options_show(struct seq_file seq, void offset);
3071	extern int ext4_calculate_overhead(struct super_block *sb);	3071	extern int ext4_calculate_overhead(struct super_block *sb);

fs/ext4/fast_commit.c+2−2

@@ -658,7 +658,7 @@ void ext4_fc_track_range(handle_t handle, struct inode inode, ext4_lblk_t star · 657 unmodified lines
658		658
659	static void ext4_fc_submit_bh(struct super_block *sb, bool is_tail)	659	static void ext4_fc_submit_bh(struct super_block *sb, bool is_tail)
660	{	660	{
661	int write_flags = REQ_SYNC;	661	blk_opf_t write_flags = REQ_SYNC;
662	struct buffer_head *bh = EXT4_SB(sb)->s_fc_bh;	662	struct buffer_head *bh = EXT4_SB(sb)->s_fc_bh;
663		663
664	/* Add REQ_FUA \| REQ_PREFLUSH only its tail */	664	/* Add REQ_FUA \| REQ_PREFLUSH only its tail */
@@ -668,7 +668,7 @@ static void ext4_fc_submit_bh(struct super_block *sb, bool is_tail) · 3 unmodified lines
668	set_buffer_dirty(bh);	668	set_buffer_dirty(bh);
669	set_buffer_uptodate(bh);	669	set_buffer_uptodate(bh);
670	bh->b_end_io = ext4_end_buffer_io_sync;	670	bh->b_end_io = ext4_end_buffer_io_sync;
671	submit_bh(REQ_OP_WRITE, write_flags, bh);	671	submit_bh(REQ_OP_WRITE \| write_flags, bh);
672	EXT4_SB(sb)->s_fc_bh = NULL;	672	EXT4_SB(sb)->s_fc_bh = NULL;
673	}	673	}
674		674

fs/ext4/mmp.c+6−5

 	lock_buffer(bh);
 	bh->b_end_io = end_buffer_write_sync;
 	get_bh(bh);
-	submit_bh(REQ_OP_WRITE, REQ_SYNC | REQ_META | REQ_PRIO, bh);
+	submit_bh(REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO, bh);
 	wait_on_buffer(bh);
 	sb_end_write(sb);
 	if (unlikely(!buffer_uptodate(bh)))
 	mmp_check_interval = max(EXT4_MMP_CHECK_MULT * mmp_update_interval,
 				 EXT4_MMP_MIN_CHECK_INTERVAL);
 	mmp->mmp_check_interval = cpu_to_le16(mmp_check_interval);
-	BUILD_BUG_ON(sizeof(mmp->mmp_bdevname) < BDEVNAME_SIZE);
-	bdevname(bh->b_bdev, mmp->mmp_bdevname);
 	memcpy(mmp->mmp_nodename, init_utsname()->nodename,
 	       sizeof(mmp->mmp_nodename));
 	EXT4_SB(sb)->s_mmp_bh = bh;
+	BUILD_BUG_ON(sizeof(mmp->mmp_bdevname) < BDEVNAME_SIZE);
+	snprintf(mmp->mmp_bdevname, sizeof(mmp->mmp_bdevname),
+		 "%pg", bh->b_bdev);
 	/*
 	 * Start a kernel thread to update the MMP block periodically.
 	 */
 	EXT4_SB(sb)->s_mmp_tsk = kthread_run(kmmpd, sb, "kmmpd-%.*s",
 					     (int)sizeof(mmp->mmp_bdevname),
-					     bdevname(bh->b_bdev,
+					     mmp->mmp_bdevname);
-						      mmp->mmp_bdevname));
 	if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) {
 		EXT4_SB(sb)->s_mmp_tsk = NULL;
 		ext4_warning(sb, "Unable to create kmmpd thread for %s.",

fs/ext4/super.c+10−10

@@ -159,7 +159,7 @@ MODULE_ALIAS("ext3"); · 158 unmodified lines
159	#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)	159	#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
160		160
161		161
162	static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,	162	static inline void __ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
163	bh_end_io_t *end_io)	163	bh_end_io_t *end_io)
164	{	164	{
165	/*	165	/*
@@ -171,10 +171,10 @@ static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags, · 5 unmodified lines
171		171
172	bh->b_end_io = end_io ? end_io : end_buffer_read_sync;	172	bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
173	get_bh(bh);	173	get_bh(bh);
174	submit_bh(REQ_OP_READ, op_flags, bh);	174	submit_bh(REQ_OP_READ \| op_flags, bh);
175	}	175	}
176		176
177	void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,	177	void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
178	bh_end_io_t *end_io)	178	bh_end_io_t *end_io)
179	{	179	{
180	BUG_ON(!buffer_locked(bh));	180	BUG_ON(!buffer_locked(bh));
@@ -186,7 +186,7 @@ void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags, · 5 unmodified lines
186	__ext4_read_bh(bh, op_flags, end_io);	186	__ext4_read_bh(bh, op_flags, end_io);
187	}	187	}
188		188
189	int ext4_read_bh(struct buffer_head bh, int op_flags, bh_end_io_t end_io)	189	int ext4_read_bh(struct buffer_head bh, blk_opf_t op_flags, bh_end_io_t end_io)
190	{	190	{
191	BUG_ON(!buffer_locked(bh));	191	BUG_ON(!buffer_locked(bh));
192		192
@@ -203,7 +203,7 @@ int ext4_read_bh(struct buffer_head bh, int op_flags, bh_end_io_t end_io) · 10 unmodified lines
203	return -EIO;	203	return -EIO;
204	}	204	}
205		205
206	int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)	206	int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait)
207	{	207	{
208	if (trylock_buffer(bh)) {	208	if (trylock_buffer(bh)) {
209	if (wait)	209	if (wait)
@@ -227,8 +227,8 @@ int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait) · 17 unmodified lines
227	* return.	227	* return.
228	*/	228	*/
229	static struct buffer_head __ext4_sb_bread_gfp(struct super_block sb,	229	static struct buffer_head __ext4_sb_bread_gfp(struct super_block sb,
230	sector_t block, int op_flags,	230	sector_t block,
231	gfp_t gfp)	231	blk_opf_t op_flags, gfp_t gfp)
232	{	232	{
233	struct buffer_head *bh;	233	struct buffer_head *bh;
234	int ret;	234	int ret;
@@ -248,7 +248,7 @@ static struct buffer_head __ext4_sb_bread_gfp(struct super_block sb, · 13 unmodified lines
248	}	248	}
249		249
250	struct buffer_head ext4_sb_bread(struct super_block sb, sector_t block,	250	struct buffer_head ext4_sb_bread(struct super_block sb, sector_t block,
251	int op_flags)	251	blk_opf_t op_flags)
252	{	252	{
253	return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);	253	return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
254	}	254	}
@@ -5939,8 +5939,8 @@ static int ext4_commit_super(struct super_block *sb) · 5684 unmodified lines
5939	/* Clear potential dirty bit if it was journalled update */	5939	/* Clear potential dirty bit if it was journalled update */
5940	clear_buffer_dirty(sbh);	5940	clear_buffer_dirty(sbh);
5941	sbh->b_end_io = end_buffer_write_sync;	5941	sbh->b_end_io = end_buffer_write_sync;
5942	submit_bh(REQ_OP_WRITE,	5942	submit_bh(REQ_OP_WRITE \| REQ_SYNC \|
5943	REQ_SYNC \| (test_opt(sb, BARRIER) ? REQ_FUA : 0), sbh);	5943	(test_opt(sb, BARRIER) ? REQ_FUA : 0), sbh);
5944	wait_on_buffer(sbh);	5944	wait_on_buffer(sbh);
5945	if (buffer_write_io_error(sbh)) {	5945	if (buffer_write_io_error(sbh)) {
5946	ext4_msg(sb, KERN_ERR, "I/O error while writing "	5946	ext4_msg(sb, KERN_ERR, "I/O error while writing "

fs/f2fs/data.c+6−5

 	return 0;
 }
-static unsigned int f2fs_io_flags(struct f2fs_io_info *fio)
+static blk_opf_t f2fs_io_flags(struct f2fs_io_info *fio)
 {
 	unsigned int temp_mask = (1 << NR_TEMP_TYPE) - 1;
 	unsigned int fua_flag, meta_flag, io_flag;
-	unsigned int op_flags = 0;
+	blk_opf_t op_flags = 0;
 	if (fio->op != REQ_OP_WRITE)
 		return 0;
 }
 static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
-				      unsigned nr_pages, unsigned op_flag,
+				      unsigned nr_pages, blk_opf_t op_flag,
 				      pgoff_t first_idx, bool for_write)
 {
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 /* This can handle encryption stuffs */
 static int f2fs_submit_page_read(struct inode *inode, struct page *page,
-				 block_t blkaddr, int op_flags, bool for_write)
+				 block_t blkaddr, blk_opf_t op_flags,
+				 bool for_write)
 {
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	struct bio *bio;
 }
 struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
-						int op_flags, bool for_write)
+				     blk_opf_t op_flags, bool for_write)
 {
 	struct address_space *mapping = inode->i_mapping;
 	struct dnode_of_data dn;

fs/f2fs/f2fs.h+3−3

@@ -1183,8 +1183,8 @@ struct f2fs_io_info { · 1182 unmodified lines
1183	nid_t ino; /* inode number */	1183	nid_t ino; /* inode number */
1184	enum page_type type; /* contains DATA/NODE/META/META_FLUSH */	1184	enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
1185	enum temp_type temp; /* contains HOT/WARM/COLD */	1185	enum temp_type temp; /* contains HOT/WARM/COLD */
1186	int op; /* contains REQ_OP_ */	1186	enum req_op op; /* contains REQ_OP_ */
1187	int op_flags; /* req_flag_bits */	1187	blk_opf_t op_flags; /* req_flag_bits */
1188	block_t new_blkaddr; /* new block address to be written */	1188	block_t new_blkaddr; /* new block address to be written */
1189	block_t old_blkaddr; /* old block address before Cow */	1189	block_t old_blkaddr; /* old block address before Cow */
1190	struct page page; / page to be written */	1190	struct page page; / page to be written */
@@ -3741,7 +3741,7 @@ int f2fs_reserve_new_block(struct dnode_of_data *dn); · 2550 unmodified lines
3741	int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);	3741	int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
3742	int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);	3742	int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
3743	struct page f2fs_get_read_data_page(struct inode inode, pgoff_t index,	3743	struct page f2fs_get_read_data_page(struct inode inode, pgoff_t index,
3744	int op_flags, bool for_write);	3744	blk_opf_t op_flags, bool for_write);
3745	struct page f2fs_find_data_page(struct inode inode, pgoff_t index);	3745	struct page f2fs_find_data_page(struct inode inode, pgoff_t index);
3746	struct page f2fs_get_lock_data_page(struct inode inode, pgoff_t index,	3746	struct page f2fs_get_lock_data_page(struct inode inode, pgoff_t index,
3747	bool for_write);	3747	bool for_write);

fs/f2fs/node.c+1−1

@@ -1327,7 +1327,7 @@ fail: · 1326 unmodified lines
1327	* 0: f2fs_put_page(page, 0)	1327	* 0: f2fs_put_page(page, 0)
1328	* LOCKED_PAGE or error: f2fs_put_page(page, 1)	1328	* LOCKED_PAGE or error: f2fs_put_page(page, 1)
1329	*/	1329	*/
1330	static int read_node_page(struct page *page, int op_flags)	1330	static int read_node_page(struct page *page, blk_opf_t op_flags)
1331	{	1331	{
1332	struct f2fs_sb_info *sbi = F2FS_P_SB(page);	1332	struct f2fs_sb_info *sbi = F2FS_P_SB(page);
1333	struct node_info ni;	1333	struct node_info ni;

fs/f2fs/segment.c+1−1

@@ -1082,7 +1082,7 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · 1081 unmodified lines
1082	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;	1082	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
1083	struct list_head *wait_list = (dpolicy->type == DPOLICY_FSTRIM) ?	1083	struct list_head *wait_list = (dpolicy->type == DPOLICY_FSTRIM) ?
1084	&(dcc->fstrim_list) : &(dcc->wait_list);	1084	&(dcc->fstrim_list) : &(dcc->wait_list);
1085	int flag = dpolicy->sync ? REQ_SYNC : 0;	1085	blk_opf_t flag = dpolicy->sync ? REQ_SYNC : 0;
1086	block_t lstart, start, len, total_len;	1086	block_t lstart, start, len, total_len;
1087	int err = 0;	1087	int err = 0;
1088		1088

fs/gfs2/bmap.c+2−3

 		if (trylock_buffer(rabh)) {
 			if (!buffer_uptodate(rabh)) {
 				rabh->b_end_io = end_buffer_read_sync;
-				submit_bh(REQ_OP_READ,
+				submit_bh(REQ_OP_READ | REQ_RAHEAD | REQ_META |
-					  REQ_RAHEAD | REQ_META | REQ_PRIO,
+					  REQ_PRIO, rabh);
-					  rabh);
 				continue;
 			}
 			unlock_buffer(rabh);

fs/gfs2/dir.c+2−3

 				continue;
 			}
 			bh->b_end_io = end_buffer_read_sync;
-			submit_bh(REQ_OP_READ,
+			submit_bh(REQ_OP_READ | REQ_RAHEAD | REQ_META |
-				  REQ_RAHEAD | REQ_META | REQ_PRIO,
+				  REQ_PRIO, bh);
-				  bh);
 			continue;
 		}
 		brelse(bh);

fs/gfs2/log.c+2−2

@@ -823,7 +823,7 @@ void gfs2_flush_revokes(struct gfs2_sbd *sdp) · 822 unmodified lines
823		823
824	void gfs2_write_log_header(struct gfs2_sbd sdp, struct gfs2_jdesc jd,	824	void gfs2_write_log_header(struct gfs2_sbd sdp, struct gfs2_jdesc jd,
825	u64 seq, u32 tail, u32 lblock, u32 flags,	825	u64 seq, u32 tail, u32 lblock, u32 flags,
826	int op_flags)	826	blk_opf_t op_flags)
827	{	827	{
828	struct gfs2_log_header *lh;	828	struct gfs2_log_header *lh;
829	u32 hash, crc;	829	u32 hash, crc;
@@ -905,7 +905,7 @@ void gfs2_write_log_header(struct gfs2_sbd sdp, struct gfs2_jdesc jd, · 75 unmodified lines
905		905
906	static void log_write_header(struct gfs2_sbd *sdp, u32 flags)	906	static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
907	{	907	{
908	int op_flags = REQ_PREFLUSH \| REQ_FUA \| REQ_META \| REQ_SYNC;	908	blk_opf_t op_flags = REQ_PREFLUSH \| REQ_FUA \| REQ_META \| REQ_SYNC;
909	enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);	909	enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
910		910
911	gfs2_assert_withdraw(sdp, (state != SFS_FROZEN));	911	gfs2_assert_withdraw(sdp, (state != SFS_FROZEN));

fs/gfs2/log.h+1−1

@@ -82,7 +82,7 @@ extern void gfs2_log_reserve(struct gfs2_sbd sdp, struct gfs2_trans tr, · 81 unmodified lines
82	unsigned int *extra_revokes);	82	unsigned int *extra_revokes);
83	extern void gfs2_write_log_header(struct gfs2_sbd sdp, struct gfs2_jdesc jd,	83	extern void gfs2_write_log_header(struct gfs2_sbd sdp, struct gfs2_jdesc jd,
84	u64 seq, u32 tail, u32 lblock, u32 flags,	84	u64 seq, u32 tail, u32 lblock, u32 flags,
85	int op_flags);	85	blk_opf_t op_flags);
86	extern void gfs2_log_flush(struct gfs2_sbd sdp, struct gfs2_glock gl,	86	extern void gfs2_log_flush(struct gfs2_sbd sdp, struct gfs2_glock gl,
87	u32 type);	87	u32 type);
88	extern void gfs2_log_commit(struct gfs2_sbd sdp, struct gfs2_trans trans);	88	extern void gfs2_log_commit(struct gfs2_sbd sdp, struct gfs2_trans trans);

fs/gfs2/lops.c+2−2

@@ -238,7 +238,7 @@ static void gfs2_end_log_write(struct bio *bio) · 237 unmodified lines
238	* there is no pending bio, then this is a no-op.	238	* there is no pending bio, then this is a no-op.
239	*/	239	*/
240		240
241	void gfs2_log_submit_bio(struct bio **biop, int opf)	241	void gfs2_log_submit_bio(struct bio **biop, blk_opf_t opf)
242	{	242	{
243	struct bio bio = biop;	243	struct bio bio = biop;
244	if (bio) {	244	if (bio) {
@@ -292,7 +292,7 @@ static struct bio gfs2_log_alloc_bio(struct gfs2_sbd sdp, u64 blkno, · 47 unmodified lines
292	*/	292	*/
293		293
294	static struct bio gfs2_log_get_bio(struct gfs2_sbd sdp, u64 blkno,	294	static struct bio gfs2_log_get_bio(struct gfs2_sbd sdp, u64 blkno,
295	struct bio **biop, int op,	295	struct bio **biop, enum req_op op,
296	bio_end_io_t *end_io, bool flush)	296	bio_end_io_t *end_io, bool flush)
297	{	297	{
298	struct bio bio = biop;	298	struct bio bio = biop;

fs/gfs2/lops.h+1−1

@@ -16,7 +16,7 @@ extern u64 gfs2_log_bmap(struct gfs2_jdesc *jd, unsigned int lbn); · 15 unmodified lines
16	extern void gfs2_log_write(struct gfs2_sbd sdp, struct gfs2_jdesc jd,	16	extern void gfs2_log_write(struct gfs2_sbd sdp, struct gfs2_jdesc jd,
17	struct page *page, unsigned size, unsigned offset,	17	struct page *page, unsigned size, unsigned offset,
18	u64 blkno);	18	u64 blkno);
19	extern void gfs2_log_submit_bio(struct bio **biop, int opf);	19	extern void gfs2_log_submit_bio(struct bio **biop, blk_opf_t opf);
20	extern void gfs2_pin(struct gfs2_sbd sdp, struct buffer_head bh);	20	extern void gfs2_pin(struct gfs2_sbd sdp, struct buffer_head bh);
21	extern int gfs2_find_jhead(struct gfs2_jdesc *jd,	21	extern int gfs2_find_jhead(struct gfs2_jdesc *jd,
22	struct gfs2_log_header_host *head, bool keep_cache);	22	struct gfs2_log_header_host *head, bool keep_cache);

fs/gfs2/meta_io.c+8−10

 {
 	struct buffer_head *bh, *head;
 	int nr_underway = 0;
-	int write_flags = REQ_META | REQ_PRIO | wbc_to_write_flags(wbc);
+	blk_opf_t write_flags = REQ_META | REQ_PRIO | wbc_to_write_flags(wbc);
 	BUG_ON(!PageLocked(page));
 	BUG_ON(!page_has_buffers(page));
 	do {
 		struct buffer_head *next = bh->b_this_page;
 		if (buffer_async_write(bh)) {
-			submit_bh(REQ_OP_WRITE, write_flags, bh);
+			submit_bh(REQ_OP_WRITE | write_flags, bh);
 			nr_underway++;
 		}
 		bh = next;
  * Submit several consecutive buffer head I/O requests as a single bio I/O
  * request.  (See submit_bh_wbc.)
  */
-static void gfs2_submit_bhs(int op, int op_flags, struct buffer_head *bhs[],
+static void gfs2_submit_bhs(blk_opf_t opf, struct buffer_head *bhs[], int num)
-			    int num)
 {
 	while (num > 0) {
 		struct buffer_head *bh = *bhs;
 		struct bio *bio;
-		bio = bio_alloc(bh->b_bdev, num, op | op_flags, GFP_NOIO);
+		bio = bio_alloc(bh->b_bdev, num, opf, GFP_NOIO);
 		bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
 		while (num > 0) {
 			bh = *bhs;
 		}
 	}
-	gfs2_submit_bhs(REQ_OP_READ, REQ_META | REQ_PRIO, bhs, num);
+	gfs2_submit_bhs(REQ_OP_READ | REQ_META | REQ_PRIO, bhs, num);
 	if (!(flags & DIO_WAIT))
 		return 0;
 	if (buffer_uptodate(first_bh))
 		goto out;
 	if (!buffer_locked(first_bh))
-		ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &first_bh);
+		ll_rw_block(REQ_OP_READ | REQ_META | REQ_PRIO, 1, &first_bh);
 	dblock++;
 	extlen--;
 		bh = gfs2_getbuf(gl, dblock, CREATE);
 		if (!buffer_uptodate(bh) && !buffer_locked(bh))
-			ll_rw_block(REQ_OP_READ,
+			ll_rw_block(REQ_OP_READ | REQ_RAHEAD | REQ_META |
-				    REQ_RAHEAD | REQ_META | REQ_PRIO,
+				    REQ_PRIO, 1, &bh);
-				    1, &bh);
 		brelse(bh);
 		dblock++;
 		extlen--;

fs/gfs2/quota.c+1−1

@@ -746,7 +746,7 @@ static int gfs2_write_buf_to_page(struct gfs2_inode *ip, unsigned long index, · 745 unmodified lines
746	if (PageUptodate(page))	746	if (PageUptodate(page))
747	set_buffer_uptodate(bh);	747	set_buffer_uptodate(bh);
748	if (!buffer_uptodate(bh)) {	748	if (!buffer_uptodate(bh)) {
749	ll_rw_block(REQ_OP_READ, REQ_META \| REQ_PRIO, 1, &bh);	749	ll_rw_block(REQ_OP_READ \| REQ_META \| REQ_PRIO, 1, &bh);
750	wait_on_buffer(bh);	750	wait_on_buffer(bh);
751	if (!buffer_uptodate(bh))	751	if (!buffer_uptodate(bh))
752	goto unlock_out;	752	goto unlock_out;

fs/hfsplus/hfsplus_fs.h+1−1

@@ -525,7 +525,7 @@ int hfsplus_compare_dentry(const struct dentry *dentry, unsigned int len, · 524 unmodified lines
525		525
526	/* wrapper.c */	526	/* wrapper.c */
527	int hfsplus_submit_bio(struct super_block sb, sector_t sector, void buf,	527	int hfsplus_submit_bio(struct super_block sb, sector_t sector, void buf,
528	void **data, int op, int op_flags);	528	void **data, blk_opf_t opf);
529	int hfsplus_read_wrapper(struct super_block *sb);	529	int hfsplus_read_wrapper(struct super_block *sb);
530		530
531	/*	531	/*

fs/hfsplus/part_tbl.c+2−3

 		if ((u8 *)pm - (u8 *)buf >= buf_size) {
 			res = hfsplus_submit_bio(sb,
 						 *part_start + HFS_PMAP_BLK + i,
-						 buf, (void **)&pm, REQ_OP_READ,
+						 buf, (void **)&pm, REQ_OP_READ);
-						 0);
 			if (res)
 				return res;
 		}
 		return -ENOMEM;
 	res = hfsplus_submit_bio(sb, *part_start + HFS_PMAP_BLK,
-				 buf, &data, REQ_OP_READ, 0);
+				 buf, &data, REQ_OP_READ);
 	if (res)
 		goto out;

fs/hfsplus/super.c+2−2

@@ -221,7 +221,7 @@ static int hfsplus_sync_fs(struct super_block *sb, int wait) · 220 unmodified lines
221		221
222	error2 = hfsplus_submit_bio(sb,	222	error2 = hfsplus_submit_bio(sb,
223	sbi->part_start + HFSPLUS_VOLHEAD_SECTOR,	223	sbi->part_start + HFSPLUS_VOLHEAD_SECTOR,
224	sbi->s_vhdr_buf, NULL, REQ_OP_WRITE,	224	sbi->s_vhdr_buf, NULL, REQ_OP_WRITE \|
225	REQ_SYNC);	225	REQ_SYNC);
226	if (!error)	226	if (!error)
227	error = error2;	227	error = error2;
@@ -230,7 +230,7 @@ static int hfsplus_sync_fs(struct super_block *sb, int wait) · 2 unmodified lines
230		230
231	error2 = hfsplus_submit_bio(sb,	231	error2 = hfsplus_submit_bio(sb,
232	sbi->part_start + sbi->sect_count - 2,	232	sbi->part_start + sbi->sect_count - 2,
233	sbi->s_backup_vhdr_buf, NULL, REQ_OP_WRITE,	233	sbi->s_backup_vhdr_buf, NULL, REQ_OP_WRITE \|
234	REQ_SYNC);	234	REQ_SYNC);
235	if (!error)	235	if (!error)
236	error2 = error;	236	error2 = error;

fs/hfsplus/wrapper.c+6−6

  * will work correctly.
  */
 int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
-		       void *buf, void **data, int op, int op_flags)
+		       void *buf, void **data, blk_opf_t opf)
 {
+	const enum req_op op = opf & REQ_OP_MASK;
 	struct bio *bio;
 	int ret = 0;
 	u64 io_size;
 	offset = start & (io_size - 1);
 	sector &= ~((io_size >> HFSPLUS_SECTOR_SHIFT) - 1);
-	bio = bio_alloc(sb->s_bdev, 1, op | op_flags, GFP_NOIO);
+	bio = bio_alloc(sb->s_bdev, 1, opf, GFP_NOIO);
 	bio->bi_iter.bi_sector = sector;
-	if (op != WRITE && data)
+	if (op != REQ_OP_WRITE && data)
 		*data = (u8 *)buf + offset;
 	while (io_size > 0) {
 reread:
 	error = hfsplus_submit_bio(sb, part_start + HFSPLUS_VOLHEAD_SECTOR,
 				   sbi->s_vhdr_buf, (void **)&sbi->s_vhdr,
-				   REQ_OP_READ, 0);
+				   REQ_OP_READ);
 	if (error)
 		goto out_free_backup_vhdr;
 	error = hfsplus_submit_bio(sb, part_start + part_size - 2,
 				   sbi->s_backup_vhdr_buf,
-				   (void **)&sbi->s_backup_vhdr, REQ_OP_READ,
+				   (void **)&sbi->s_backup_vhdr, REQ_OP_READ);
-				   0);
 	if (error)
 		goto out_free_backup_vhdr;

fs/iomap/direct-io.c+6−6

 };
 static struct bio *iomap_dio_alloc_bio(const struct iomap_iter *iter,
-		struct iomap_dio *dio, unsigned short nr_vecs, unsigned int opf)
+		struct iomap_dio *dio, unsigned short nr_vecs, blk_opf_t opf)
 {
 	if (dio->dops && dio->dops->bio_set)
 		return bio_alloc_bioset(iter->iomap.bdev, nr_vecs, opf,
  * mapping, and whether or not we want FUA.  Note that we can end up
  * clearing the WRITE_FUA flag in the dio request.
  */
-static inline unsigned int iomap_dio_bio_opflags(struct iomap_dio *dio,
+static inline blk_opf_t iomap_dio_bio_opflags(struct iomap_dio *dio,
 		const struct iomap *iomap, bool use_fua)
 {
-	unsigned int opflags = REQ_SYNC | REQ_IDLE;
+	blk_opf_t opflags = REQ_SYNC | REQ_IDLE;
 	if (!(dio->flags & IOMAP_DIO_WRITE)) {
 		WARN_ON_ONCE(iomap->flags & IOMAP_F_ZONE_APPEND);
 	struct inode *inode = iter->inode;
 	unsigned int blkbits = blksize_bits(bdev_logical_block_size(iomap->bdev));
 	unsigned int fs_block_size = i_blocksize(inode), pad;
-	unsigned int align = iov_iter_alignment(dio->submit.iter);
 	loff_t length = iomap_length(iter);
 	loff_t pos = iter->pos;
-	unsigned int bio_opf;
+	blk_opf_t bio_opf;
 	struct bio *bio;
 	bool need_zeroout = false;
 	bool use_fua = false;
 	size_t copied = 0;
 	size_t orig_count;
-	if ((pos | length | align) & ((1 << blkbits) - 1))
+	if ((pos | length) & ((1 << blkbits) - 1) ||
+	    !bdev_iter_is_aligned(iomap->bdev, dio->submit.iter))
 		return -EINVAL;
 	if (iomap->type == IOMAP_UNWRITTEN) {

fs/isofs/compress.c+1−1

@@ -82,7 +82,7 @@ static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start, · 81 unmodified lines
82	return 0;	82	return 0;
83	}	83	}
84	haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks);	84	haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks);
85	ll_rw_block(REQ_OP_READ, 0, haveblocks, bhs);	85	ll_rw_block(REQ_OP_READ, haveblocks, bhs);
86		86
87	curbh = 0;	87	curbh = 0;
88	curpage = 0;	88	curpage = 0;

fs/jbd2/commit.c+4−4

@@ -155,10 +155,10 @@ static int journal_submit_commit_record(journal_t *journal, · 154 unmodified lines
155		155
156	if (journal->j_flags & JBD2_BARRIER &&	156	if (journal->j_flags & JBD2_BARRIER &&
157	!jbd2_has_feature_async_commit(journal))	157	!jbd2_has_feature_async_commit(journal))
158	ret = submit_bh(REQ_OP_WRITE,	158	ret = submit_bh(REQ_OP_WRITE \| REQ_SYNC \| REQ_PREFLUSH \|
159	REQ_SYNC \| REQ_PREFLUSH \| REQ_FUA, bh);	159	REQ_FUA, bh);
160	else	160	else
161	ret = submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);	161	ret = submit_bh(REQ_OP_WRITE \| REQ_SYNC, bh);
162		162
163	*cbh = bh;	163	*cbh = bh;
164	return ret;	164	return ret;
@@ -763,7 +763,7 @@ start_journal_io: · 598 unmodified lines
763	clear_buffer_dirty(bh);	763	clear_buffer_dirty(bh);
764	set_buffer_uptodate(bh);	764	set_buffer_uptodate(bh);
765	bh->b_end_io = journal_end_buffer_io_sync;	765	bh->b_end_io = journal_end_buffer_io_sync;
766	submit_bh(REQ_OP_WRITE, REQ_SYNC, bh);	766	submit_bh(REQ_OP_WRITE \| REQ_SYNC, bh);
767	}	767	}
768	cond_resched();	768	cond_resched();
769		769

fs/jbd2/journal.c+14−11

 	if (!journal)
 		return NULL;
-	bdevname(journal->j_dev, journal->j_devname);
+	snprintf(journal->j_devname, sizeof(journal->j_devname),
+		 "%pg", journal->j_dev);
 	strreplace(journal->j_devname, '/', '!');
 	jbd2_stats_proc_init(journal);
 		return NULL;
 	journal->j_inode = inode;
-	bdevname(journal->j_dev, journal->j_devname);
+	snprintf(journal->j_devname, sizeof(journal->j_devname),
+		 "%pg", journal->j_dev);
 	p = strreplace(journal->j_devname, '/', '!');
 	sprintf(p, "-%lu", journal->j_inode->i_ino);
 	jbd2_stats_proc_init(journal);
  * This function expects that the caller will have locked the journal
  * buffer head, and will return with it unlocked
  */
-static int jbd2_write_superblock(journal_t *journal, int write_flags)
+static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags)
 {
 	struct buffer_head *bh = journal->j_sb_buffer;
 	journal_superblock_t *sb = journal->j_superblock;
 		sb->s_checksum = jbd2_superblock_csum(journal, sb);
 	get_bh(bh);
 	bh->b_end_io = end_buffer_write_sync;
-	ret = submit_bh(REQ_OP_WRITE, write_flags, bh);
+	ret = submit_bh(REQ_OP_WRITE | write_flags, bh);
 	wait_on_buffer(bh);
 	if (buffer_write_io_error(bh)) {
 		clear_buffer_write_io_error(bh);
  * @journal: The journal to update.
  * @tail_tid: TID of the new transaction at the tail of the log
  * @tail_block: The first block of the transaction at the tail of the log
- * @write_op: With which operation should we write the journal sb
+ * @write_flags: Flags for the journal sb write operation
  *
  * Update a journal's superblock information about log tail and write it to
  * disk, waiting for the IO to complete.
  */
 int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
-				     unsigned long tail_block, int write_op)
+				    unsigned long tail_block,
+				    blk_opf_t write_flags)
 {
 	journal_superblock_t *sb = journal->j_superblock;
 	int ret;
 	sb->s_sequence = cpu_to_be32(tail_tid);
 	sb->s_start    = cpu_to_be32(tail_block);
-	ret = jbd2_write_superblock(journal, write_op);
+	ret = jbd2_write_superblock(journal, write_flags);
 	if (ret)
 		goto out;
 /**
  * jbd2_mark_journal_empty() - Mark on disk journal as empty.
  * @journal: The journal to update.
- * @write_op: With which operation should we write the journal sb
+ * @write_flags: Flags for the journal sb write operation
  *
  * Update a journal's dynamic superblock fields to show that journal is empty.
  * Write updated superblock to disk waiting for IO to complete.
  */
-static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
+static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags)
 {
 	journal_superblock_t *sb = journal->j_superblock;
 	bool had_fast_commit = false;
 		had_fast_commit = true;
 	}
-	jbd2_write_superblock(journal, write_op);
+	jbd2_write_superblock(journal, write_flags);
 	if (had_fast_commit)
 		jbd2_set_feature_fast_commit(journal);
 	J_ASSERT(bh != NULL);
 	if (!buffer_uptodate(bh)) {
-		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
+		ll_rw_block(REQ_OP_READ, 1, &bh);
 		wait_on_buffer(bh);
 		if (!buffer_uptodate(bh)) {
 			printk(KERN_ERR

fs/jbd2/recovery.c+2−2

@@ -100,7 +100,7 @@ static int do_readahead(journal_t *journal, unsigned int start) · 99 unmodified lines
100	if (!buffer_uptodate(bh) && !buffer_locked(bh)) {	100	if (!buffer_uptodate(bh) && !buffer_locked(bh)) {
101	bufs[nbufs++] = bh;	101	bufs[nbufs++] = bh;
102	if (nbufs == MAXBUF) {	102	if (nbufs == MAXBUF) {
103	ll_rw_block(REQ_OP_READ, 0, nbufs, bufs);	103	ll_rw_block(REQ_OP_READ, nbufs, bufs);
104	journal_brelse_array(bufs, nbufs);	104	journal_brelse_array(bufs, nbufs);
105	nbufs = 0;	105	nbufs = 0;
106	}	106	}
@@ -109,7 +109,7 @@ static int do_readahead(journal_t *journal, unsigned int start) · 2 unmodified lines
109	}	109	}
110		110
111	if (nbufs)	111	if (nbufs)
112	ll_rw_block(REQ_OP_READ, 0, nbufs, bufs);	112	ll_rw_block(REQ_OP_READ, nbufs, bufs);
113	err = 0;	113	err = 0;
114		114
115	failed:	115	failed:

fs/mpage.c+3−3

@@ -145,13 +145,13 @@ static struct bio do_mpage_readpage(struct mpage_readpage_args args) · 144 unmodified lines
145	struct block_device *bdev = NULL;	145	struct block_device *bdev = NULL;
146	int length;	146	int length;
147	int fully_mapped = 1;	147	int fully_mapped = 1;
148	int op = REQ_OP_READ;	148	blk_opf_t opf = REQ_OP_READ;
149	unsigned nblocks;	149	unsigned nblocks;
150	unsigned relative_block;	150	unsigned relative_block;
151	gfp_t gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);	151	gfp_t gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
152		152
153	if (args->is_readahead) {	153	if (args->is_readahead) {
154	op \|= REQ_RAHEAD;	154	opf \|= REQ_RAHEAD;
155	gfp \|= __GFP_NORETRY \| __GFP_NOWARN;	155	gfp \|= __GFP_NORETRY \| __GFP_NOWARN;
156	}	156	}
157		157
@@ -269,7 +269,7 @@ alloc_new: · 111 unmodified lines
269	page))	269	page))
270	goto out;	270	goto out;
271	}	271	}
272	args->bio = bio_alloc(bdev, bio_max_segs(args->nr_pages), op,	272	args->bio = bio_alloc(bdev, bio_max_segs(args->nr_pages), opf,
273	gfp);	273	gfp);
274	if (args->bio == NULL)	274	if (args->bio == NULL)
275	goto confused;	275	goto confused;

fs/nfs/blocklayout/blocklayout.c+6−7

 }
 static struct bio *
-do_add_page_to_bio(struct bio *bio, int npg, int rw, sector_t isect,
+do_add_page_to_bio(struct bio *bio, int npg, enum req_op op, sector_t isect,
 		struct page *page, struct pnfs_block_dev_map *map,
 		struct pnfs_block_extent *be, bio_end_io_t end_io,
 		struct parallel_io *par, unsigned int offset, int *len)
 	u64 disk_addr, end;
 	dprintk("%s: npg %d rw %d isect %llu offset %u len %d\n", __func__,
-		npg, rw, (unsigned long long)isect, offset, *len);
+		npg, (__force u32)op, (unsigned long long)isect, offset, *len);
 	/* translate to device offset */
 	isect += be->be_v_offset;
 retry:
 	if (!bio) {
-		bio = bio_alloc(map->bdev, bio_max_segs(npg), rw, GFP_NOIO);
+		bio = bio_alloc(map->bdev, bio_max_segs(npg), op, GFP_NOIO);
 		bio->bi_iter.bi_sector = disk_addr >> SECTOR_SHIFT;
 		bio->bi_end_io = end_io;
 		bio->bi_private = par;
 		} else {
 			bio = do_add_page_to_bio(bio,
 						 header->page_array.npages - i,
-						 READ,
+						 REQ_OP_READ,
 						 isect, pages[i], &map, &be,
 						 bl_end_io_read, par,
 						 pg_offset, &pg_len);
 		pg_len = PAGE_SIZE;
 		bio = do_add_page_to_bio(bio, header->page_array.npages - i,
-					 WRITE, isect, pages[i], &map, &be,
+					 REQ_OP_WRITE, isect, pages[i], &map,
-					 bl_end_io_write, par,
+					 &be, bl_end_io_write, par, 0, &pg_len);
-					 0, &pg_len);
 		if (IS_ERR(bio)) {
 			header->pnfs_error = PTR_ERR(bio);
 			bio = NULL;

fs/nilfs2/btnode.c+4−4

@@ -70,7 +70,7 @@ nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr) · 69 unmodified lines
70	}	70	}
71		71
72	int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,	72	int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
73	sector_t pblocknr, int mode, int mode_flags,	73	sector_t pblocknr, blk_opf_t opf,
74	struct buffer_head *pbh, sector_t submit_ptr)	74	struct buffer_head *pbh, sector_t submit_ptr)
75	{	75	{
76	struct buffer_head *bh;	76	struct buffer_head *bh;
@@ -103,13 +103,13 @@ int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr, · 26 unmodified lines
103	}	103	}
104	}	104	}
105		105
106	if (mode_flags & REQ_RAHEAD) {	106	if (opf & REQ_RAHEAD) {
107	if (pblocknr != *submit_ptr + 1 \|\| !trylock_buffer(bh)) {	107	if (pblocknr != *submit_ptr + 1 \|\| !trylock_buffer(bh)) {
108	err = -EBUSY; /* internal code */	108	err = -EBUSY; /* internal code */
109	brelse(bh);	109	brelse(bh);
110	goto out_locked;	110	goto out_locked;
111	}	111	}
112	} else { /* mode == READ */	112	} else { /* opf == REQ_OP_READ */
113	lock_buffer(bh);	113	lock_buffer(bh);
114	}	114	}
115	if (buffer_uptodate(bh)) {	115	if (buffer_uptodate(bh)) {
@@ -122,7 +122,7 @@ int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr, · 6 unmodified lines
122	bh->b_blocknr = pblocknr; /* set block address for read */	122	bh->b_blocknr = pblocknr; /* set block address for read */
123	bh->b_end_io = end_buffer_read_sync;	123	bh->b_end_io = end_buffer_read_sync;
124	get_bh(bh);	124	get_bh(bh);
125	submit_bh(mode, mode_flags, bh);	125	submit_bh(opf, bh);
126	bh->b_blocknr = blocknr; /* set back to the given block address */	126	bh->b_blocknr = blocknr; /* set back to the given block address */
127	*submit_ptr = pblocknr;	127	*submit_ptr = pblocknr;
128	err = 0;	128	err = 0;

fs/nilfs2/btnode.h+2−2

@@ -34,8 +34,8 @@ void nilfs_init_btnc_inode(struct inode *btnc_inode); · 33 unmodified lines
34	void nilfs_btnode_cache_clear(struct address_space *);	34	void nilfs_btnode_cache_clear(struct address_space *);
35	struct buffer_head nilfs_btnode_create_block(struct address_space btnc,	35	struct buffer_head nilfs_btnode_create_block(struct address_space btnc,
36	__u64 blocknr);	36	__u64 blocknr);
37	int nilfs_btnode_submit_block(struct address_space *, __u64, sector_t, int,	37	int nilfs_btnode_submit_block(struct address_space *, __u64, sector_t,
38	int, struct buffer_head *, sector_t );	38	blk_opf_t, struct buffer_head *, sector_t );
39	void nilfs_btnode_delete(struct buffer_head *);	39	void nilfs_btnode_delete(struct buffer_head *);
40	int nilfs_btnode_prepare_change_key(struct address_space *,	40	int nilfs_btnode_prepare_change_key(struct address_space *,
41	struct nilfs_btnode_chkey_ctxt *);	41	struct nilfs_btnode_chkey_ctxt *);

fs/nilfs2/btree.c+3−3

@@ -477,7 +477,7 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr, · 476 unmodified lines
477	sector_t submit_ptr = 0;	477	sector_t submit_ptr = 0;
478	int ret;	478	int ret;
479		479
480	ret = nilfs_btnode_submit_block(btnc, ptr, 0, REQ_OP_READ, 0, &bh,	480	ret = nilfs_btnode_submit_block(btnc, ptr, 0, REQ_OP_READ, &bh,
481	&submit_ptr);	481	&submit_ptr);
482	if (ret) {	482	if (ret) {
483	if (ret != -EEXIST)	483	if (ret != -EEXIST)
@@ -495,8 +495,8 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr, · 11 unmodified lines
495	ptr2 = nilfs_btree_node_get_ptr(ra->node, i, ra->ncmax);	495	ptr2 = nilfs_btree_node_get_ptr(ra->node, i, ra->ncmax);
496		496
497	ret = nilfs_btnode_submit_block(btnc, ptr2, 0,	497	ret = nilfs_btnode_submit_block(btnc, ptr2, 0,
498	REQ_OP_READ, REQ_RAHEAD,	498	REQ_OP_READ \| REQ_RAHEAD,
499	&ra_bh, &submit_ptr);	499	&ra_bh, &submit_ptr);
500	if (likely(!ret \|\| ret == -EEXIST))	500	if (likely(!ret \|\| ret == -EEXIST))
501	brelse(ra_bh);	501	brelse(ra_bh);
502	else if (ret != -EBUSY)	502	else if (ret != -EBUSY)

fs/nilfs2/gcinode.c+3−4

 	bh->b_blocknr = pbn;
 	bh->b_end_io = end_buffer_read_sync;
 	get_bh(bh);
-	submit_bh(REQ_OP_READ, 0, bh);
+	submit_bh(REQ_OP_READ, bh);
 	if (vbn)
 		bh->b_blocknr = vbn;
  out:
 	struct inode *btnc_inode = NILFS_I(inode)->i_assoc_inode;
 	int ret;
-	ret = nilfs_btnode_submit_block(btnc_inode->i_mapping,
+	ret = nilfs_btnode_submit_block(btnc_inode->i_mapping, vbn ? : pbn, pbn,
-					vbn ? : pbn, pbn, REQ_OP_READ, 0,
+					REQ_OP_READ, out_bh, &pbn);
-					out_bh, &pbn);
 	if (ret == -EEXIST) /* internal code (cache hit) */
 		ret = 0;
 	return ret;

fs/nilfs2/mdt.c+10−9

 }
 static int
-nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,
+nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff, blk_opf_t opf,
-		       int mode, int mode_flags, struct buffer_head **out_bh)
+		       struct buffer_head **out_bh)
 {
 	struct buffer_head *bh;
 	__u64 blknum = 0;
 	if (buffer_uptodate(bh))
 		goto out;
-	if (mode_flags & REQ_RAHEAD) {
+	if (opf & REQ_RAHEAD) {
 		if (!trylock_buffer(bh)) {
 			ret = -EBUSY;
 			goto failed_bh;
 		}
-	} else /* mode == READ */
+	} else /* opf == REQ_OP_READ */
 		lock_buffer(bh);
 	if (buffer_uptodate(bh)) {
 	bh->b_end_io = end_buffer_read_sync;
 	get_bh(bh);
-	submit_bh(mode, mode_flags, bh);
+	submit_bh(opf, bh);
 	ret = 0;
-	trace_nilfs2_mdt_submit_block(inode, inode->i_ino, blkoff, mode);
+	trace_nilfs2_mdt_submit_block(inode, inode->i_ino, blkoff,
+				      opf & REQ_OP_MASK);
  out:
 	get_bh(bh);
 	*out_bh = bh;
 	int i, nr_ra_blocks = NILFS_MDT_MAX_RA_BLOCKS;
 	int err;
-	err = nilfs_mdt_submit_block(inode, block, REQ_OP_READ, 0, &first_bh);
+	err = nilfs_mdt_submit_block(inode, block, REQ_OP_READ, &first_bh);
 	if (err == -EEXIST) /* internal code */
 		goto out;
 	if (readahead) {
 		blkoff = block + 1;
 		for (i = 0; i < nr_ra_blocks; i++, blkoff++) {
-			err = nilfs_mdt_submit_block(inode, blkoff, REQ_OP_READ,
+			err = nilfs_mdt_submit_block(inode, blkoff,
-						     REQ_RAHEAD, &bh);
+						REQ_OP_READ | REQ_RAHEAD, &bh);
 			if (likely(!err || err == -EEXIST))
 				brelse(bh);
 			else if (err != -EBUSY)

fs/ntfs/aops.c+3−3

@@ -342,7 +342,7 @@ handle_zblock: · 341 unmodified lines
342	for (i = 0; i < nr; i++) {	342	for (i = 0; i < nr; i++) {
343	tbh = arr[i];	343	tbh = arr[i];
344	if (likely(!buffer_uptodate(tbh)))	344	if (likely(!buffer_uptodate(tbh)))
345	submit_bh(REQ_OP_READ, 0, tbh);	345	submit_bh(REQ_OP_READ, tbh);
346	else	346	else
347	ntfs_end_buffer_async_read(tbh, 1);	347	ntfs_end_buffer_async_read(tbh, 1);
348	}	348	}
@@ -859,7 +859,7 @@ lock_retry_remap: · 510 unmodified lines
859	do {	859	do {
860	struct buffer_head *next = bh->b_this_page;	860	struct buffer_head *next = bh->b_this_page;
861	if (buffer_async_write(bh)) {	861	if (buffer_async_write(bh)) {
862	submit_bh(REQ_OP_WRITE, 0, bh);	862	submit_bh(REQ_OP_WRITE, bh);
863	need_end_writeback = false;	863	need_end_writeback = false;
864	}	864	}
865	bh = next;	865	bh = next;
@@ -1187,7 +1187,7 @@ lock_retry_remap: · 321 unmodified lines
1187	BUG_ON(!buffer_mapped(tbh));	1187	BUG_ON(!buffer_mapped(tbh));
1188	get_bh(tbh);	1188	get_bh(tbh);
1189	tbh->b_end_io = end_buffer_write_sync;	1189	tbh->b_end_io = end_buffer_write_sync;
1190	submit_bh(REQ_OP_WRITE, 0, tbh);	1190	submit_bh(REQ_OP_WRITE, tbh);
1191	}	1191	}
1192	/* Synchronize the mft mirror now if not @sync. */	1192	/* Synchronize the mft mirror now if not @sync. */
1193	if (is_mft && !sync)	1193	if (is_mft && !sync)

fs/ntfs/compress.c+1−1

@@ -658,7 +658,7 @@ lock_retry_remap: · 657 unmodified lines
658	}	658	}
659	get_bh(tbh);	659	get_bh(tbh);
660	tbh->b_end_io = end_buffer_read_sync;	660	tbh->b_end_io = end_buffer_read_sync;
661	submit_bh(REQ_OP_READ, 0, tbh);	661	submit_bh(REQ_OP_READ, tbh);
662	}	662	}
663		663
664	/* Wait for io completion on all buffer heads. */	664	/* Wait for io completion on all buffer heads. */

fs/ntfs/file.c+1−1

@@ -537,7 +537,7 @@ static inline int ntfs_submit_bh_for_read(struct buffer_head *bh) · 536 unmodified lines
537	lock_buffer(bh);	537	lock_buffer(bh);
538	get_bh(bh);	538	get_bh(bh);
539	bh->b_end_io = end_buffer_read_sync;	539	bh->b_end_io = end_buffer_read_sync;
540	return submit_bh(REQ_OP_READ, 0, bh);	540	return submit_bh(REQ_OP_READ, bh);
541	}	541	}
542		542
543	/**	543	/**

fs/ntfs/logfile.c+1−1

@@ -807,7 +807,7 @@ map_vcn: · 806 unmodified lines
807	* completed ignore errors afterwards as we can assume	807	* completed ignore errors afterwards as we can assume
808	* that if one buffer worked all of them will work.	808	* that if one buffer worked all of them will work.
809	*/	809	*/
810	submit_bh(REQ_OP_WRITE, 0, bh);	810	submit_bh(REQ_OP_WRITE, bh);
811	if (should_wait) {	811	if (should_wait) {
812	should_wait = false;	812	should_wait = false;
813	wait_on_buffer(bh);	813	wait_on_buffer(bh);

fs/ntfs/mft.c+2−2

@@ -583,7 +583,7 @@ int ntfs_sync_mft_mirror(ntfs_volume *vol, const unsigned long mft_no, · 582 unmodified lines
583	clear_buffer_dirty(tbh);	583	clear_buffer_dirty(tbh);
584	get_bh(tbh);	584	get_bh(tbh);
585	tbh->b_end_io = end_buffer_write_sync;	585	tbh->b_end_io = end_buffer_write_sync;
586	submit_bh(REQ_OP_WRITE, 0, tbh);	586	submit_bh(REQ_OP_WRITE, tbh);
587	}	587	}
588	/* Wait on i/o completion of buffers. */	588	/* Wait on i/o completion of buffers. */
589	for (i_bhs = 0; i_bhs < nr_bhs; i_bhs++) {	589	for (i_bhs = 0; i_bhs < nr_bhs; i_bhs++) {
@@ -780,7 +780,7 @@ int write_mft_record_nolock(ntfs_inode ni, MFT_RECORD m, int sync) · 190 unmodified lines
780	clear_buffer_dirty(tbh);	780	clear_buffer_dirty(tbh);
781	get_bh(tbh);	781	get_bh(tbh);
782	tbh->b_end_io = end_buffer_write_sync;	782	tbh->b_end_io = end_buffer_write_sync;
783	submit_bh(REQ_OP_WRITE, 0, tbh);	783	submit_bh(REQ_OP_WRITE, tbh);
784	}	784	}
785	/* Synchronize the mft mirror now if not @sync. */	785	/* Synchronize the mft mirror now if not @sync. */
786	if (!sync && ni->mft_no < vol->mftmirr_size)	786	if (!sync && ni->mft_no < vol->mftmirr_size)

fs/ntfs3/file.c+1−1

@@ -242,7 +242,7 @@ static int ntfs_zero_range(struct inode *inode, u64 vbo, u64 vbo_to) · 241 unmodified lines
242	lock_buffer(bh);	242	lock_buffer(bh);
243	bh->b_end_io = end_buffer_read_sync;	243	bh->b_end_io = end_buffer_read_sync;
244	get_bh(bh);	244	get_bh(bh);
245	submit_bh(REQ_OP_READ, 0, bh);	245	submit_bh(REQ_OP_READ, bh);
246		246
247	wait_on_buffer(bh);	247	wait_on_buffer(bh);
248	if (!buffer_uptodate(bh)) {	248	if (!buffer_uptodate(bh)) {

fs/ntfs3/fsntfs.c+1−1

@@ -1448,7 +1448,7 @@ int ntfs_write_bh(struct ntfs_sb_info sbi, struct NTFS_RECORD_HEADER rhdr, · 1447 unmodified lines
1448	*/	1448	*/
1449	int ntfs_bio_pages(struct ntfs_sb_info sbi, const struct runs_tree run,	1449	int ntfs_bio_pages(struct ntfs_sb_info sbi, const struct runs_tree run,
1450	struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,	1450	struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
1451	u32 op)	1451	enum req_op op)
1452	{	1452	{
1453	int err = 0;	1453	int err = 0;
1454	struct bio new, bio = NULL;	1454	struct bio new, bio = NULL;

fs/ntfs3/inode.c+1−1

@@ -629,7 +629,7 @@ static noinline int ntfs_get_block_vbo(struct inode *inode, u64 vbo, · 628 unmodified lines
629	bh->b_size = block_size;	629	bh->b_size = block_size;
630	off = vbo & (PAGE_SIZE - 1);	630	off = vbo & (PAGE_SIZE - 1);
631	set_bh_page(bh, page, off);	631	set_bh_page(bh, page, off);
632	ll_rw_block(REQ_OP_READ, 0, 1, &bh);	632	ll_rw_block(REQ_OP_READ, 1, &bh);
633	wait_on_buffer(bh);	633	wait_on_buffer(bh);
634	if (!buffer_uptodate(bh)) {	634	if (!buffer_uptodate(bh)) {
635	err = -EIO;	635	err = -EIO;

fs/ntfs3/ntfs_fs.h+1−1

@@ -617,7 +617,7 @@ int ntfs_write_bh(struct ntfs_sb_info sbi, struct NTFS_RECORD_HEADER rhdr, · 616 unmodified lines
617	struct ntfs_buffers *nb, int sync);	617	struct ntfs_buffers *nb, int sync);
618	int ntfs_bio_pages(struct ntfs_sb_info sbi, const struct runs_tree run,	618	int ntfs_bio_pages(struct ntfs_sb_info sbi, const struct runs_tree run,
619	struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,	619	struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
620	u32 op);	620	enum req_op op);
621	int ntfs_bio_fill_1(struct ntfs_sb_info sbi, const struct runs_tree run);	621	int ntfs_bio_fill_1(struct ntfs_sb_info sbi, const struct runs_tree run);
622	int ntfs_vbo_to_lbo(struct ntfs_sb_info sbi, const struct runs_tree run,	622	int ntfs_vbo_to_lbo(struct ntfs_sb_info sbi, const struct runs_tree run,
623	u64 vbo, u64 lbo, u64 bytes);	623	u64 vbo, u64 lbo, u64 bytes);

fs/ocfs2/aops.c+1−1

@@ -638,7 +638,7 @@ int ocfs2_map_page_blocks(struct page page, u64 p_blkno, · 637 unmodified lines
638	!buffer_new(bh) &&	638	!buffer_new(bh) &&
639	ocfs2_should_read_blk(inode, page, block_start) &&	639	ocfs2_should_read_blk(inode, page, block_start) &&
640	(block_start < from \|\| block_end > to)) {	640	(block_start < from \|\| block_end > to)) {
641	ll_rw_block(REQ_OP_READ, 0, 1, &bh);	641	ll_rw_block(REQ_OP_READ, 1, &bh);
642	*wait_bh++=bh;	642	*wait_bh++=bh;
643	}	643	}
644		644

fs/ocfs2/buffer_head_io.c+4−4

@@ -64,7 +64,7 @@ int ocfs2_write_block(struct ocfs2_super osb, struct buffer_head bh, · 63 unmodified lines
64		64
65	get_bh(bh); /* for end_buffer_write_sync() */	65	get_bh(bh); /* for end_buffer_write_sync() */
66	bh->b_end_io = end_buffer_write_sync;	66	bh->b_end_io = end_buffer_write_sync;
67	submit_bh(REQ_OP_WRITE, 0, bh);	67	submit_bh(REQ_OP_WRITE, bh);
68		68
69	wait_on_buffer(bh);	69	wait_on_buffer(bh);
70		70
@@ -147,7 +147,7 @@ int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block, · 76 unmodified lines
147		147
148	get_bh(bh); /* for end_buffer_read_sync() */	148	get_bh(bh); /* for end_buffer_read_sync() */
149	bh->b_end_io = end_buffer_read_sync;	149	bh->b_end_io = end_buffer_read_sync;
150	submit_bh(REQ_OP_READ, 0, bh);	150	submit_bh(REQ_OP_READ, bh);
151	}	151	}
152		152
153	read_failure:	153	read_failure:
@@ -328,7 +328,7 @@ int ocfs2_read_blocks(struct ocfs2_caching_info *ci, u64 block, int nr, · 174 unmodified lines
328	if (validate)	328	if (validate)
329	set_buffer_needs_validate(bh);	329	set_buffer_needs_validate(bh);
330	bh->b_end_io = end_buffer_read_sync;	330	bh->b_end_io = end_buffer_read_sync;
331	submit_bh(REQ_OP_READ, 0, bh);	331	submit_bh(REQ_OP_READ, bh);
332	continue;	332	continue;
333	}	333	}
334	}	334	}
@@ -449,7 +449,7 @@ int ocfs2_write_super_or_backup(struct ocfs2_super *osb, · 114 unmodified lines
449	get_bh(bh); /* for end_buffer_write_sync() */	449	get_bh(bh); /* for end_buffer_write_sync() */
450	bh->b_end_io = end_buffer_write_sync;	450	bh->b_end_io = end_buffer_write_sync;
451	ocfs2_compute_meta_ecc(osb->sb, bh->b_data, &di->i_check);	451	ocfs2_compute_meta_ecc(osb->sb, bh->b_data, &di->i_check);
452	submit_bh(REQ_OP_WRITE, 0, bh);	452	submit_bh(REQ_OP_WRITE, bh);
453		453
454	wait_on_buffer(bh);	454	wait_on_buffer(bh);
455		455

fs/ocfs2/cluster/heartbeat.c+35−40

 	 * (hr_steady_iterations == 0) within hr_unsteady_iterations */
 	atomic_t		hr_unsteady_iterations;
-	char			hr_dev_name[BDEVNAME_SIZE];
 	unsigned int		hr_timeout_ms;
 	/* randomized as the region goes up and down so that a node
 		container_of(work, struct o2hb_region,
 			     hr_write_timeout_work.work);
-	mlog(ML_ERROR, "Heartbeat write timeout to device %s after %u "
+	mlog(ML_ERROR, "Heartbeat write timeout to device %pg after %u "
-	     "milliseconds\n", reg->hr_dev_name,
+	     "milliseconds\n", reg->hr_bdev,
 	     jiffies_to_msecs(jiffies - reg->hr_last_timeout_start));
 	if (o2hb_global_heartbeat_active()) {
 	if (master_node == o2nm_this_node()) {
 		if (!test_bit(master_node, reg->hr_nego_node_bitmap)) {
-			printk(KERN_NOTICE "o2hb: node %d hb write hung for %ds on region %s (%s).\n",
+			printk(KERN_NOTICE "o2hb: node %d hb write hung for %ds on region %s (%pg).\n",
 				o2nm_this_node(), O2HB_NEGO_TIMEOUT_MS/1000,
-				config_item_name(&reg->hr_item), reg->hr_dev_name);
+				config_item_name(&reg->hr_item), reg->hr_bdev);
 			set_bit(master_node, reg->hr_nego_node_bitmap);
 		}
 		if (memcmp(reg->hr_nego_node_bitmap, live_node_bitmap,
 			return;
 		}
-		printk(KERN_NOTICE "o2hb: all nodes hb write hung, maybe region %s (%s) is down.\n",
+		printk(KERN_NOTICE "o2hb: all nodes hb write hung, maybe region %s (%pg) is down.\n",
-			config_item_name(&reg->hr_item), reg->hr_dev_name);
+			config_item_name(&reg->hr_item), reg->hr_bdev);
 		/* approve negotiate timeout request. */
 		o2hb_arm_timeout(reg);
 		}
 	} else {
 		/* negotiate timeout with master node. */
-		printk(KERN_NOTICE "o2hb: node %d hb write hung for %ds on region %s (%s), negotiate timeout with node %d.\n",
+		printk(KERN_NOTICE "o2hb: node %d hb write hung for %ds on region %s (%pg), negotiate timeout with node %d.\n",
 			o2nm_this_node(), O2HB_NEGO_TIMEOUT_MS/1000, config_item_name(&reg->hr_item),
-			reg->hr_dev_name, master_node);
+			reg->hr_bdev, master_node);
 		ret = o2hb_send_nego_msg(reg->hr_key, O2HB_NEGO_TIMEOUT_MSG,
 				master_node);
 		if (ret)
 	struct o2hb_nego_msg *nego_msg;
 	nego_msg = (struct o2hb_nego_msg *)msg->buf;
-	printk(KERN_NOTICE "o2hb: receive negotiate timeout message from node %d on region %s (%s).\n",
+	printk(KERN_NOTICE "o2hb: receive negotiate timeout message from node %d on region %s (%pg).\n",
-		nego_msg->node_num, config_item_name(&reg->hr_item), reg->hr_dev_name);
+		nego_msg->node_num, config_item_name(&reg->hr_item), reg->hr_bdev);
 	if (nego_msg->node_num < O2NM_MAX_NODES)
 		set_bit(nego_msg->node_num, reg->hr_nego_node_bitmap);
 	else
 {
 	struct o2hb_region *reg = data;
-	printk(KERN_NOTICE "o2hb: negotiate timeout approved by master node on region %s (%s).\n",
+	printk(KERN_NOTICE "o2hb: negotiate timeout approved by master node on region %s (%pg).\n",
-		config_item_name(&reg->hr_item), reg->hr_dev_name);
+		config_item_name(&reg->hr_item), reg->hr_bdev);
 	o2hb_arm_timeout(reg);
 	return 0;
 }
 static struct bio *o2hb_setup_one_bio(struct o2hb_region *reg,
 				      struct o2hb_bio_wait_ctxt *wc,
 				      unsigned int *current_slot,
-				      unsigned int max_slots, int op,
+				      unsigned int max_slots, blk_opf_t opf)
-				      int op_flags)
 {
 	int len, current_page;
 	unsigned int vec_len, vec_start;
 	 * GFP_KERNEL that the local node can get fenced. It would be
 	 * nicest if we could pre-allocate these bios and avoid this
 	 * all together. */
-	bio = bio_alloc(reg->hr_bdev, 16, op | op_flags, GFP_ATOMIC);
+	bio = bio_alloc(reg->hr_bdev, 16, opf, GFP_ATOMIC);
 	if (!bio) {
 		mlog(ML_ERROR, "Could not alloc slots BIO!\n");
 		bio = ERR_PTR(-ENOMEM);
 	while(current_slot < max_slots) {
 		bio = o2hb_setup_one_bio(reg, &wc, &current_slot, max_slots,
-					 REQ_OP_READ, 0);
+					 REQ_OP_READ);
 		if (IS_ERR(bio)) {
 			status = PTR_ERR(bio);
 			mlog_errno(status);
 	slot = o2nm_this_node();
-	bio = o2hb_setup_one_bio(reg, write_wc, &slot, slot+1, REQ_OP_WRITE,
+	bio = o2hb_setup_one_bio(reg, write_wc, &slot, slot+1,
-				 REQ_SYNC);
+				 REQ_OP_WRITE | REQ_SYNC);
 	if (IS_ERR(bio)) {
 		status = PTR_ERR(bio);
 		mlog_errno(status);
 	else
 		errstr = ERRSTR3;
-	mlog(ML_ERROR, "%s (%s): expected(%u:0x%llx, 0x%llx), "
+	mlog(ML_ERROR, "%s (%pg): expected(%u:0x%llx, 0x%llx), "
-	     "ondisk(%u:0x%llx, 0x%llx)\n", errstr, reg->hr_dev_name,
+	     "ondisk(%u:0x%llx, 0x%llx)\n", errstr, reg->hr_bdev,
 	     slot->ds_node_num, (unsigned long long)slot->ds_last_generation,
 	     (unsigned long long)slot->ds_last_time, hb_block->hb_node,
 	     (unsigned long long)le64_to_cpu(hb_block->hb_generation),
 		   sizeof(o2hb_live_node_bitmap)))
 		goto unlock;
-	printk(KERN_NOTICE "o2hb: Region %s (%s) is now a quorum device\n",
+	printk(KERN_NOTICE "o2hb: Region %s (%pg) is now a quorum device\n",
-	       config_item_name(&reg->hr_item), reg->hr_dev_name);
+	       config_item_name(&reg->hr_item), reg->hr_bdev);
 	set_bit(reg->hr_region_num, o2hb_quorum_region_bitmap);
 		/* The node is live but pushed out a bad crc. We
 		 * consider it a transient miss but don't populate any
 		 * other values as they may be junk. */
-		mlog(ML_ERROR, "Node %d has written a bad crc to %s\n",
+		mlog(ML_ERROR, "Node %d has written a bad crc to %pg\n",
-		     slot->ds_node_num, reg->hr_dev_name);
+		     slot->ds_node_num, reg->hr_bdev);
 		o2hb_dump_slot(hb_block);
 		slot->ds_equal_samples++;
 		slot_dead_ms = le32_to_cpu(hb_block->hb_dead_ms);
 		if (slot_dead_ms && slot_dead_ms != dead_ms) {
 			/* TODO: Perhaps we can fail the region here. */
-			mlog(ML_ERROR, "Node %d on device %s has a dead count "
+			mlog(ML_ERROR, "Node %d on device %pg has a dead count "
 			     "of %u ms, but our count is %u ms.\n"
 			     "Please double check your configuration values "
 			     "for 'O2CB_HEARTBEAT_THRESHOLD'\n",
-			     slot->ds_node_num, reg->hr_dev_name, slot_dead_ms,
+			     slot->ds_node_num, reg->hr_bdev, slot_dead_ms,
 			     dead_ms);
 		}
 		goto out;
 		/* Do not re-arm the write timeout on I/O error - we
 		 * can't be sure that the new block ever made it to
 		 * disk */
-		mlog(ML_ERROR, "Write error %d on device \"%s\"\n",
+		mlog(ML_ERROR, "Write error %d on device \"%pg\"\n",
-		     write_wc.wc_error, reg->hr_dev_name);
+		     write_wc.wc_error, reg->hr_bdev);
 		ret = write_wc.wc_error;
 		goto bail;
 	}
 	if (atomic_read(&reg->hr_steady_iterations) != 0) {
 		if (atomic_dec_and_test(&reg->hr_unsteady_iterations)) {
 			printk(KERN_NOTICE "o2hb: Unable to stabilize "
-			       "heartbeat on region %s (%s)\n",
+			       "heartbeat on region %s (%pg)\n",
 			       config_item_name(&reg->hr_item),
-			       reg->hr_dev_name);
+			       reg->hr_bdev);
 			atomic_set(&reg->hr_steady_iterations, 0);
 			reg->hr_aborted_start = 1;
 			wake_up(&o2hb_steady_queue);
 	struct page *page;
 	struct o2hb_region *reg = to_o2hb_region(item);
-	mlog(ML_HEARTBEAT, "hb region release (%s)\n", reg->hr_dev_name);
+	mlog(ML_HEARTBEAT, "hb region release (%pg)\n", reg->hr_bdev);
 	kfree(reg->hr_tmp_block);
 	unsigned int ret = 0;
 	if (to_o2hb_region(item)->hr_bdev)
-		ret = sprintf(page, "%s\n", to_o2hb_region(item)->hr_dev_name);
+		ret = sprintf(page, "%pg\n", to_o2hb_region(item)->hr_bdev);
 	return ret;
 }
 		goto out2;
 	}
-	bdevname(reg->hr_bdev, reg->hr_dev_name);
 	sectsize = bdev_logical_block_size(reg->hr_bdev);
 	if (sectsize != reg->hr_block_bytes) {
 		mlog(ML_ERROR,
 		ret = -EIO;
 	if (hb_task && o2hb_global_heartbeat_active())
-		printk(KERN_NOTICE "o2hb: Heartbeat started on region %s (%s)\n",
+		printk(KERN_NOTICE "o2hb: Heartbeat started on region %s (%pg)\n",
-		       config_item_name(&reg->hr_item), reg->hr_dev_name);
+		       config_item_name(&reg->hr_item), reg->hr_bdev);
 out3:
 	if (ret < 0) {
 			quorum_region = 1;
 		clear_bit(reg->hr_region_num, o2hb_quorum_region_bitmap);
 		spin_unlock(&o2hb_live_lock);
-		printk(KERN_NOTICE "o2hb: Heartbeat %s on region %s (%s)\n",
+		printk(KERN_NOTICE "o2hb: Heartbeat %s on region %s (%pg)\n",
 		       ((atomic_read(&reg->hr_steady_iterations) == 0) ?
 			"stopped" : "start aborted"), config_item_name(item),
-		       reg->hr_dev_name);
+		       reg->hr_bdev);
 	}
 	/*

fs/ocfs2/super.c+1−1

@@ -1764,7 +1764,7 @@ static int ocfs2_get_sector(struct super_block *sb, · 1763 unmodified lines
1764	if (!buffer_dirty(*bh))	1764	if (!buffer_dirty(*bh))
1765	clear_buffer_uptodate(*bh);	1765	clear_buffer_uptodate(*bh);
1766	unlock_buffer(*bh);	1766	unlock_buffer(*bh);
1767	ll_rw_block(REQ_OP_READ, 0, 1, bh);	1767	ll_rw_block(REQ_OP_READ, 1, bh);
1768	wait_on_buffer(*bh);	1768	wait_on_buffer(*bh);
1769	if (!buffer_uptodate(*bh)) {	1769	if (!buffer_uptodate(*bh)) {
1770	mlog_errno(-EIO);	1770	mlog_errno(-EIO);

fs/reiserfs/inode.c+2−2

@@ -2656,7 +2656,7 @@ static int reiserfs_write_full_page(struct page *page, · 2655 unmodified lines
2656	do {	2656	do {
2657	struct buffer_head *next = bh->b_this_page;	2657	struct buffer_head *next = bh->b_this_page;
2658	if (buffer_async_write(bh)) {	2658	if (buffer_async_write(bh)) {
2659	submit_bh(REQ_OP_WRITE, 0, bh);	2659	submit_bh(REQ_OP_WRITE, bh);
2660	nr++;	2660	nr++;
2661	}	2661	}
2662	put_bh(bh);	2662	put_bh(bh);
@@ -2716,7 +2716,7 @@ fail: · 53 unmodified lines
2716	struct buffer_head *next = bh->b_this_page;	2716	struct buffer_head *next = bh->b_this_page;
2717	if (buffer_async_write(bh)) {	2717	if (buffer_async_write(bh)) {
2718	clear_buffer_dirty(bh);	2718	clear_buffer_dirty(bh);
2719	submit_bh(REQ_OP_WRITE, 0, bh);	2719	submit_bh(REQ_OP_WRITE, bh);
2720	nr++;	2720	nr++;
2721	}	2721	}
2722	put_bh(bh);	2722	put_bh(bh);

fs/reiserfs/journal.c+6−6

@@ -650,7 +650,7 @@ static void submit_logged_buffer(struct buffer_head *bh) · 649 unmodified lines
650	BUG();	650	BUG();
651	if (!buffer_uptodate(bh))	651	if (!buffer_uptodate(bh))
652	BUG();	652	BUG();
653	submit_bh(REQ_OP_WRITE, 0, bh);	653	submit_bh(REQ_OP_WRITE, bh);
654	}	654	}
655		655
656	static void submit_ordered_buffer(struct buffer_head *bh)	656	static void submit_ordered_buffer(struct buffer_head *bh)
@@ -660,7 +660,7 @@ static void submit_ordered_buffer(struct buffer_head *bh) · 3 unmodified lines
660	clear_buffer_dirty(bh);	660	clear_buffer_dirty(bh);
661	if (!buffer_uptodate(bh))	661	if (!buffer_uptodate(bh))
662	BUG();	662	BUG();
663	submit_bh(REQ_OP_WRITE, 0, bh);	663	submit_bh(REQ_OP_WRITE, bh);
664	}	664	}
665		665
666	#define CHUNK_SIZE 32	666	#define CHUNK_SIZE 32
@@ -868,7 +868,7 @@ loop_next: · 201 unmodified lines
868	*/	868	*/
869	if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) {	869	if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) {
870	spin_unlock(lock);	870	spin_unlock(lock);
871	ll_rw_block(REQ_OP_WRITE, 0, 1, &bh);	871	ll_rw_block(REQ_OP_WRITE, 1, &bh);
872	spin_lock(lock);	872	spin_lock(lock);
873	}	873	}
874	put_bh(bh);	874	put_bh(bh);
@@ -1054,7 +1054,7 @@ static int flush_commit_list(struct super_block *s, · 179 unmodified lines
1054	if (tbh) {	1054	if (tbh) {
1055	if (buffer_dirty(tbh)) {	1055	if (buffer_dirty(tbh)) {
1056	depth = reiserfs_write_unlock_nested(s);	1056	depth = reiserfs_write_unlock_nested(s);
1057	ll_rw_block(REQ_OP_WRITE, 0, 1, &tbh);	1057	ll_rw_block(REQ_OP_WRITE, 1, &tbh);
1058	reiserfs_write_lock_nested(s, depth);	1058	reiserfs_write_lock_nested(s, depth);
1059	}	1059	}
1060	put_bh(tbh) ;	1060	put_bh(tbh) ;
@@ -2240,7 +2240,7 @@ abort_replay: · 1179 unmodified lines
2240	}	2240	}
2241	}	2241	}
2242	/* read in the log blocks, memcpy to the corresponding real block */	2242	/* read in the log blocks, memcpy to the corresponding real block */
2243	ll_rw_block(REQ_OP_READ, 0, get_desc_trans_len(desc), log_blocks);	2243	ll_rw_block(REQ_OP_READ, get_desc_trans_len(desc), log_blocks);
2244	for (i = 0; i < get_desc_trans_len(desc); i++) {	2244	for (i = 0; i < get_desc_trans_len(desc); i++) {
2245		2245
2246	wait_on_buffer(log_blocks[i]);	2246	wait_on_buffer(log_blocks[i]);
@@ -2342,7 +2342,7 @@ static struct buffer_head reiserfs_breada(struct block_device dev, · 95 unmodified lines
2342	} else	2342	} else
2343	bhlist[j++] = bh;	2343	bhlist[j++] = bh;
2344	}	2344	}
2345	ll_rw_block(REQ_OP_READ, 0, j, bhlist);	2345	ll_rw_block(REQ_OP_READ, j, bhlist);
2346	for (i = 1; i < j; i++)	2346	for (i = 1; i < j; i++)
2347	brelse(bhlist[i]);	2347	brelse(bhlist[i]);
2348	bh = bhlist[0];	2348	bh = bhlist[0];

fs/reiserfs/stree.c+2−2

@@ -579,7 +579,7 @@ static int search_by_key_reada(struct super_block *s, · 578 unmodified lines
579	if (!buffer_uptodate(bh[j])) {	579	if (!buffer_uptodate(bh[j])) {
580	if (depth == -1)	580	if (depth == -1)
581	depth = reiserfs_write_unlock_nested(s);	581	depth = reiserfs_write_unlock_nested(s);
582	ll_rw_block(REQ_OP_READ, REQ_RAHEAD, 1, bh + j);	582	ll_rw_block(REQ_OP_READ \| REQ_RAHEAD, 1, bh + j);
583	}	583	}
584	brelse(bh[j]);	584	brelse(bh[j]);
585	}	585	}
@@ -685,7 +685,7 @@ int search_by_key(struct super_block sb, const struct cpu_key key, · 99 unmodified lines
685	if (!buffer_uptodate(bh) && depth == -1)	685	if (!buffer_uptodate(bh) && depth == -1)
686	depth = reiserfs_write_unlock_nested(sb);	686	depth = reiserfs_write_unlock_nested(sb);
687		687
688	ll_rw_block(REQ_OP_READ, 0, 1, &bh);	688	ll_rw_block(REQ_OP_READ, 1, &bh);
689	wait_on_buffer(bh);	689	wait_on_buffer(bh);
690		690
691	if (depth != -1)	691	if (depth != -1)

fs/reiserfs/super.c+1−1

@@ -1702,7 +1702,7 @@ static int read_super_block(struct super_block *s, int offset) · 1701 unmodified lines
1702	/* after journal replay, reread all bitmap and super blocks */	1702	/* after journal replay, reread all bitmap and super blocks */
1703	static int reread_meta_blocks(struct super_block *s)	1703	static int reread_meta_blocks(struct super_block *s)
1704	{	1704	{
1705	ll_rw_block(REQ_OP_READ, 0, 1, &SB_BUFFER_WITH_SB(s));	1705	ll_rw_block(REQ_OP_READ, 1, &SB_BUFFER_WITH_SB(s));
1706	wait_on_buffer(SB_BUFFER_WITH_SB(s));	1706	wait_on_buffer(SB_BUFFER_WITH_SB(s));
1707	if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {	1707	if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1708	reiserfs_warning(s, "reiserfs-2504", "error reading the super");	1708	reiserfs_warning(s, "reiserfs-2504", "error reading the super");

fs/udf/dir.c+1−1

@@ -130,7 +130,7 @@ static int udf_readdir(struct file file, struct dir_context ctx) · 129 unmodified lines
130	brelse(tmp);	130	brelse(tmp);
131	}	131	}
132	if (num) {	132	if (num) {
133	ll_rw_block(REQ_OP_READ, REQ_RAHEAD, num, bha);	133	ll_rw_block(REQ_OP_READ \| REQ_RAHEAD, num, bha);
134	for (i = 0; i < num; i++)	134	for (i = 0; i < num; i++)
135	brelse(bha[i]);	135	brelse(bha[i]);
136	}	136	}

fs/udf/directory.c+1−1

@@ -89,7 +89,7 @@ struct fileIdentDesc udf_fileident_read(struct inode dir, loff_t *nf_pos, · 88 unmodified lines
89	brelse(tmp);	89	brelse(tmp);
90	}	90	}
91	if (num) {	91	if (num) {
92	ll_rw_block(REQ_OP_READ, REQ_RAHEAD, num, bha);	92	ll_rw_block(REQ_OP_READ \| REQ_RAHEAD, num, bha);
93	for (i = 0; i < num; i++)	93	for (i = 0; i < num; i++)
94	brelse(bha[i]);	94	brelse(bha[i]);
95	}	95	}

fs/udf/inode.c+1−1

@@ -1214,7 +1214,7 @@ struct buffer_head udf_bread(struct inode inode, udf_pblk_t block, · 1213 unmodified lines
1214	if (buffer_uptodate(bh))	1214	if (buffer_uptodate(bh))
1215	return bh;	1215	return bh;
1216		1216
1217	ll_rw_block(REQ_OP_READ, 0, 1, &bh);	1217	ll_rw_block(REQ_OP_READ, 1, &bh);
1218		1218
1219	wait_on_buffer(bh);	1219	wait_on_buffer(bh);
1220	if (buffer_uptodate(bh))	1220	if (buffer_uptodate(bh))

fs/ufs/balloc.c+1−1

@@ -296,7 +296,7 @@ static void ufs_change_blocknr(struct inode *inode, sector_t beg, · 295 unmodified lines
296	if (!buffer_mapped(bh))	296	if (!buffer_mapped(bh))
297	map_bh(bh, inode->i_sb, oldb + pos);	297	map_bh(bh, inode->i_sb, oldb + pos);
298	if (!buffer_uptodate(bh)) {	298	if (!buffer_uptodate(bh)) {
299	ll_rw_block(REQ_OP_READ, 0, 1, &bh);	299	ll_rw_block(REQ_OP_READ, 1, &bh);
300	wait_on_buffer(bh);	300	wait_on_buffer(bh);
301	if (!buffer_uptodate(bh)) {	301	if (!buffer_uptodate(bh)) {
302	ufs_error(inode->i_sb, __func__,	302	ufs_error(inode->i_sb, __func__,

fs/xfs/xfs_bio_io.c+1−1

@@ -15,7 +15,7 @@ xfs_rw_bdev( · 14 unmodified lines
15	sector_t sector,	15	sector_t sector,
16	unsigned int count,	16	unsigned int count,
17	char *data,	17	char *data,
18	unsigned int op)	18	enum req_op op)
19		19
20	{	20	{
21	unsigned int is_vmalloc = is_vmalloc_addr(data);	21	unsigned int is_vmalloc = is_vmalloc_addr(data);

fs/xfs/xfs_buf.c+2−2

@@ -1416,7 +1416,7 @@ xfs_buf_ioapply_map( · 1415 unmodified lines
1416	int map,	1416	int map,
1417	int *buf_offset,	1417	int *buf_offset,
1418	int *count,	1418	int *count,
1419	int op)	1419	blk_opf_t op)
1420	{	1420	{
1421	int page_index;	1421	int page_index;
1422	unsigned int total_nr_pages = bp->b_page_count;	1422	unsigned int total_nr_pages = bp->b_page_count;
@@ -1493,7 +1493,7 @@ _xfs_buf_ioapply( · 70 unmodified lines
1493	struct xfs_buf *bp)	1493	struct xfs_buf *bp)
1494	{	1494	{
1495	struct blk_plug plug;	1495	struct blk_plug plug;
1496	int op;	1496	blk_opf_t op;
1497	int offset;	1497	int offset;
1498	int size;	1498	int size;
1499	int i;	1499	int i;

fs/xfs/xfs_linux.h+1−1

@@ -196,7 +196,7 @@ static inline uint64_t howmany_64(uint64_t x, uint32_t y) · 195 unmodified lines
196	}	196	}
197		197
198	int xfs_rw_bdev(struct block_device *bdev, sector_t sector, unsigned int count,	198	int xfs_rw_bdev(struct block_device *bdev, sector_t sector, unsigned int count,
199	char *data, unsigned int op);	199	char *data, enum req_op op);
200		200
201	#define ASSERT_ALWAYS(expr) \	201	#define ASSERT_ALWAYS(expr) \
202	(likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))	202	(likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))

fs/xfs/xfs_log_recover.c+1−1

@@ -122,7 +122,7 @@ xlog_do_io( · 121 unmodified lines
122	xfs_daddr_t blk_no,	122	xfs_daddr_t blk_no,
123	unsigned int nbblks,	123	unsigned int nbblks,
124	char *data,	124	char *data,
125	unsigned int op)	125	enum req_op op)
126	{	126	{
127	int error;	127	int error;
128		128

fs/zonefs/super.c+10−12

 	}
 }
-static inline int zonefs_zone_mgmt(struct inode *inode,
+static inline int zonefs_zone_mgmt(struct inode *inode, enum req_op op)
-				   enum req_opf op)
 {
 	struct zonefs_inode_info *zi = ZONEFS_I(inode);
 	int ret;
 {
 	struct zonefs_inode_info *zi = ZONEFS_I(inode);
 	loff_t old_isize;
-	enum req_opf op;
+	enum req_op op;
 	int ret = 0;
 	/*
 {
 	struct super_block *sb = parent->i_sb;
-	inode->i_ino = blkdev_nr_zones(sb->s_bdev->bd_disk) + type + 1;
+	inode->i_ino = bdev_nr_zones(sb->s_bdev) + type + 1;
 	inode_init_owner(&init_user_ns, inode, parent, S_IFDIR | 0555);
 	inode->i_op = &zonefs_dir_inode_operations;
 	inode->i_fop = &simple_dir_operations;
 	/*
 	 * The first zone contains the super block: skip it.
 	 */
-	end = zd->zones + blkdev_nr_zones(sb->s_bdev->bd_disk);
+	end = zd->zones + bdev_nr_zones(sb->s_bdev);
 	for (zone = &zd->zones[1]; zone < end; zone = next) {
 		next = zone + 1;
 	struct block_device *bdev = zd->sb->s_bdev;
 	int ret;
-	zd->zones = kvcalloc(blkdev_nr_zones(bdev->bd_disk),
+	zd->zones = kvcalloc(bdev_nr_zones(bdev), sizeof(struct blk_zone),
-			     sizeof(struct blk_zone), GFP_KERNEL);
+			     GFP_KERNEL);
 	if (!zd->zones)
 		return -ENOMEM;
 		return ret;
 	}
-	if (ret != blkdev_nr_zones(bdev->bd_disk)) {
+	if (ret != bdev_nr_zones(bdev)) {
 		zonefs_err(zd->sb, "Invalid zone report (%d/%u zones)\n",
-			   ret, blkdev_nr_zones(bdev->bd_disk));
+			   ret, bdev_nr_zones(bdev));
 		return -EIO;
 	}
 	if (ret)
 		goto cleanup;
-	zonefs_info(sb, "Mounting %u zones",
+	zonefs_info(sb, "Mounting %u zones", bdev_nr_zones(sb->s_bdev));
-		    blkdev_nr_zones(sb->s_bdev->bd_disk));
 	if (!sbi->s_max_wro_seq_files &&
 	    !sbi->s_max_active_seq_files &&
 	if (!inode)
 		goto cleanup;
-	inode->i_ino = blkdev_nr_zones(sb->s_bdev->bd_disk);
+	inode->i_ino = bdev_nr_zones(sb->s_bdev);
 	inode->i_mode = S_IFDIR | 0555;
 	inode->i_ctime = inode->i_mtime = inode->i_atime = current_time(inode);
 	inode->i_op = &zonefs_dir_inode_operations;

fs/zonefs/trace.h+2−2

@@ -20,12 +20,12 @@ · 19 unmodified lines
20	#define show_dev(dev) MAJOR(dev), MINOR(dev)	20	#define show_dev(dev) MAJOR(dev), MINOR(dev)
21		21
22	TRACE_EVENT(zonefs_zone_mgmt,	22	TRACE_EVENT(zonefs_zone_mgmt,
23	TP_PROTO(struct inode *inode, enum req_opf op),	23	TP_PROTO(struct inode *inode, enum req_op op),
24	TP_ARGS(inode, op),	24	TP_ARGS(inode, op),
25	TP_STRUCT__entry(	25	TP_STRUCT__entry(
26	__field(dev_t, dev)	26	__field(dev_t, dev)
27	__field(ino_t, ino)	27	__field(ino_t, ino)
28	__field(int, op)	28	__field(enum req_op, op)
29	__field(sector_t, sector)	29	__field(sector_t, sector)
30	__field(sector_t, nr_sectors)	30	__field(sector_t, nr_sectors)
31	),	31	),

include/linux/bio.h+5−5

@@ -405,7 +405,7 @@ extern void bioset_exit(struct bio_set *); · 404 unmodified lines
405	extern int biovec_init_pool(mempool_t *pool, int pool_entries);	405	extern int biovec_init_pool(mempool_t *pool, int pool_entries);
406		406
407	struct bio bio_alloc_bioset(struct block_device bdev, unsigned short nr_vecs,	407	struct bio bio_alloc_bioset(struct block_device bdev, unsigned short nr_vecs,
408	unsigned int opf, gfp_t gfp_mask,	408	blk_opf_t opf, gfp_t gfp_mask,
409	struct bio_set *bs);	409	struct bio_set *bs);
410	struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask);	410	struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask);
411	extern void bio_put(struct bio *);	411	extern void bio_put(struct bio *);
@@ -418,7 +418,7 @@ int bio_init_clone(struct block_device bdev, struct bio bio, · 6 unmodified lines
418	extern struct bio_set fs_bio_set;	418	extern struct bio_set fs_bio_set;
419		419
420	static inline struct bio bio_alloc(struct block_device bdev,	420	static inline struct bio bio_alloc(struct block_device bdev,
421	unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask)	421	unsigned short nr_vecs, blk_opf_t opf, gfp_t gfp_mask)
422	{	422	{
423	return bio_alloc_bioset(bdev, nr_vecs, opf, gfp_mask, &fs_bio_set);	423	return bio_alloc_bioset(bdev, nr_vecs, opf, gfp_mask, &fs_bio_set);
424	}	424	}
@@ -456,9 +456,9 @@ struct request_queue; · 31 unmodified lines
456		456
457	extern int submit_bio_wait(struct bio *bio);	457	extern int submit_bio_wait(struct bio *bio);
458	void bio_init(struct bio bio, struct block_device bdev, struct bio_vec *table,	458	void bio_init(struct bio bio, struct block_device bdev, struct bio_vec *table,
459	unsigned short max_vecs, unsigned int opf);	459	unsigned short max_vecs, blk_opf_t opf);
460	extern void bio_uninit(struct bio *);	460	extern void bio_uninit(struct bio *);
461	void bio_reset(struct bio bio, struct block_device bdev, unsigned int opf);	461	void bio_reset(struct bio bio, struct block_device bdev, blk_opf_t opf);
462	void bio_chain(struct bio , struct bio );	462	void bio_chain(struct bio , struct bio );
463		463
464	int bio_add_page(struct bio , struct page , unsigned len, unsigned off);	464	int bio_add_page(struct bio , struct page , unsigned len, unsigned off);
@@ -789,6 +789,6 @@ static inline void bio_clear_polled(struct bio *bio) · 324 unmodified lines
789	}	789	}
790		790
791	struct bio blk_next_bio(struct bio bio, struct block_device *bdev,	791	struct bio blk_next_bio(struct bio bio, struct block_device *bdev,
792	unsigned int nr_pages, unsigned int opf, gfp_t gfp);	792	unsigned int nr_pages, blk_opf_t opf, gfp_t gfp);
793		793
794	#endif /* __LINUX_BIO_H */	794	#endif /* __LINUX_BIO_H */

include/linux/blk-mq.h+22−12

 #define RQF_TIMED_OUT		((__force req_flags_t)(1 << 21))
 /* queue has elevator attached */
 #define RQF_ELV			((__force req_flags_t)(1 << 22))
+#define RQF_RESV			((__force req_flags_t)(1 << 23))
 /* flags that prevent us from merging requests: */
 #define RQF_NOMERGE_FLAGS \
 	struct blk_mq_ctx *mq_ctx;
 	struct blk_mq_hw_ctx *mq_hctx;
-	unsigned int cmd_flags;		/* op and common flags */
+	blk_opf_t cmd_flags;		/* op and common flags */
 	req_flags_t rq_flags;
 	int tag;
 	void *end_io_data;
 };
-#define req_op(req) \
+static inline enum req_op req_op(const struct request *req)
-	((req)->cmd_flags & REQ_OP_MASK)
+{
+	return req->cmd_flags & REQ_OP_MASK;
+}
 static inline bool blk_rq_is_passthrough(struct request *rq)
 {
 	bool last;
 };
-typedef bool (busy_tag_iter_fn)(struct request *, void *, bool);
+typedef bool (busy_tag_iter_fn)(struct request *, void *);
 /**
  * struct blk_mq_ops - Callback functions that implements block driver
 	/**
 	 * @timeout: Called on request timeout.
 	 */
-	enum blk_eh_timer_return (*timeout)(struct request *, bool);
+	enum blk_eh_timer_return (*timeout)(struct request *);
 	/**
 	 * @poll: Called to poll for completion of a specific tag.
 									\
 	__blk_mq_alloc_disk(set, queuedata, &__key);			\
 })
+struct gendisk *blk_mq_alloc_disk_for_queue(struct request_queue *q,
+		struct lock_class_key *lkclass);
 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *);
 int blk_mq_init_allocated_queue(struct blk_mq_tag_set *set,
 		struct request_queue *q);
-void blk_mq_unregister_dev(struct device *, struct request_queue *);
+void blk_mq_destroy_queue(struct request_queue *);
 int blk_mq_alloc_tag_set(struct blk_mq_tag_set *set);
 int blk_mq_alloc_sq_tag_set(struct blk_mq_tag_set *set,
 	BLK_MQ_REQ_PM		= (__force blk_mq_req_flags_t)(1 << 2),
 };
-struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
+struct request *blk_mq_alloc_request(struct request_queue *q, blk_opf_t opf,
 		blk_mq_req_flags_t flags);
 struct request *blk_mq_alloc_request_hctx(struct request_queue *q,
-		unsigned int op, blk_mq_req_flags_t flags,
+		blk_opf_t opf, blk_mq_req_flags_t flags,
 		unsigned int hctx_idx);
 /*
 	return (rq->rq_flags & (RQF_IO_STAT | RQF_STATS | RQF_ELV));
 }
+static inline bool blk_mq_is_reserved_rq(struct request *rq)
+{
+	return rq->rq_flags & RQF_RESV;
+}
 /*
  * Batched completions only work when there is no I/O error and no special
  * ->end_io handler.
 #ifdef CONFIG_BLK_DEV_ZONED
 static inline unsigned int blk_rq_zone_no(struct request *rq)
 {
-	return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
+	return disk_zone_no(rq->q->disk, blk_rq_pos(rq));
 }
 static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
 {
-	return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
+	return disk_zone_is_seq(rq->q->disk, blk_rq_pos(rq));
 }
 bool blk_req_needs_zone_write_lock(struct request *rq);
 static inline bool blk_req_zone_is_write_locked(struct request *rq)
 {
-	return rq->q->seq_zones_wlock &&
+	return rq->q->disk->seq_zones_wlock &&
-		test_bit(blk_rq_zone_no(rq), rq->q->seq_zones_wlock);
+		test_bit(blk_rq_zone_no(rq), rq->q->disk->seq_zones_wlock);
 }
 static inline bool blk_req_can_dispatch_to_zone(struct request *rq)

include/linux/blk_types.h+63−56

@@ -240,6 +240,8 @@ static inline void bio_issue_init(struct bio_issue *issue, · 239 unmodified lines
240	((u64)size << BIO_ISSUE_SIZE_SHIFT));	240	((u64)size << BIO_ISSUE_SIZE_SHIFT));
241	}	241	}
242		242
		243	typedef __u32 __bitwise blk_opf_t;
		244
243	typedef unsigned int blk_qc_t;	245	typedef unsigned int blk_qc_t;
244	#define BLK_QC_T_NONE -1U	246	#define BLK_QC_T_NONE -1U
245		247
@@ -250,7 +252,7 @@ typedef unsigned int blk_qc_t; · 4 unmodified lines
250	struct bio {	252	struct bio {
251	struct bio bi_next; / request queue link */	253	struct bio bi_next; / request queue link */
252	struct block_device *bi_bdev;	254	struct block_device *bi_bdev;
253	unsigned int bi_opf; /* bottom bits REQ_OP, top bits	255	blk_opf_t bi_opf; /* bottom bits REQ_OP, top bits
254	* req_flags.	256	* req_flags.
255	*/	257	*/
256	unsigned short bi_flags; /* BIO_* below */	258	unsigned short bi_flags; /* BIO_* below */
@@ -337,8 +339,12 @@ enum { · 80 unmodified lines
337		339
338	typedef __u32 __bitwise blk_mq_req_flags_t;	340	typedef __u32 __bitwise blk_mq_req_flags_t;
339		341
340	/*	342	#define REQ_OP_BITS 8
341	* Operations and flags common to the bio and request structures.	343	#define REQ_OP_MASK (__force blk_opf_t)((1 << REQ_OP_BITS) - 1)
		344	#define REQ_FLAG_BITS 24
		345
		346	/**
		347	* enum req_op - Operations common to the bio and request structures.
342	* We use 8 bits for encoding the operation, and the remaining 24 for flags.	348	* We use 8 bits for encoding the operation, and the remaining 24 for flags.
343	*	349	*
344	* The least significant bit of the operation number indicates the data	350	* The least significant bit of the operation number indicates the data
@@ -350,41 +356,37 @@ typedef __u32 __bitwise blk_mq_req_flags_t; · 5 unmodified lines
350	* If a operation does not transfer data the least significant bit has no	356	* If a operation does not transfer data the least significant bit has no
351	* meaning.	357	* meaning.
352	*/	358	*/
353	#define REQ_OP_BITS 8	359	enum req_op {
354	#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1)
355	#define REQ_FLAG_BITS 24
356
357	enum req_opf {
358	/* read sectors from the device */	360	/* read sectors from the device */
359	REQ_OP_READ = 0,	361	REQ_OP_READ = (__force blk_opf_t)0,
360	/* write sectors to the device */	362	/* write sectors to the device */
361	REQ_OP_WRITE = 1,	363	REQ_OP_WRITE = (__force blk_opf_t)1,
362	/* flush the volatile write cache */	364	/* flush the volatile write cache */
363	REQ_OP_FLUSH = 2,	365	REQ_OP_FLUSH = (__force blk_opf_t)2,
364	/* discard sectors */	366	/* discard sectors */
365	REQ_OP_DISCARD = 3,	367	REQ_OP_DISCARD = (__force blk_opf_t)3,
366	/* securely erase sectors */	368	/* securely erase sectors */
367	REQ_OP_SECURE_ERASE = 5,	369	REQ_OP_SECURE_ERASE = (__force blk_opf_t)5,
368	/* write the zero filled sector many times */	370	/* write the zero filled sector many times */
369	REQ_OP_WRITE_ZEROES = 9,	371	REQ_OP_WRITE_ZEROES = (__force blk_opf_t)9,
370	/* Open a zone */	372	/* Open a zone */
371	REQ_OP_ZONE_OPEN = 10,	373	REQ_OP_ZONE_OPEN = (__force blk_opf_t)10,
372	/* Close a zone */	374	/* Close a zone */
373	REQ_OP_ZONE_CLOSE = 11,	375	REQ_OP_ZONE_CLOSE = (__force blk_opf_t)11,
374	/* Transition a zone to full */	376	/* Transition a zone to full */
375	REQ_OP_ZONE_FINISH = 12,	377	REQ_OP_ZONE_FINISH = (__force blk_opf_t)12,
376	/* write data at the current zone write pointer */	378	/* write data at the current zone write pointer */
377	REQ_OP_ZONE_APPEND = 13,	379	REQ_OP_ZONE_APPEND = (__force blk_opf_t)13,
378	/* reset a zone write pointer */	380	/* reset a zone write pointer */
379	REQ_OP_ZONE_RESET = 15,	381	REQ_OP_ZONE_RESET = (__force blk_opf_t)15,
380	/* reset all the zone present on the device */	382	/* reset all the zone present on the device */
381	REQ_OP_ZONE_RESET_ALL = 17,	383	REQ_OP_ZONE_RESET_ALL = (__force blk_opf_t)17,
382		384
383	/* Driver private requests */	385	/* Driver private requests */
384	REQ_OP_DRV_IN = 34,	386	REQ_OP_DRV_IN = (__force blk_opf_t)34,
385	REQ_OP_DRV_OUT = 35,	387	REQ_OP_DRV_OUT = (__force blk_opf_t)35,
386		388
387	REQ_OP_LAST,	389	REQ_OP_LAST = (__force blk_opf_t)36,
388	};	390	};
389		391
390	enum req_flag_bits {	392	enum req_flag_bits {
@@ -425,28 +427,31 @@ enum req_flag_bits { · 34 unmodified lines
425	__REQ_NR_BITS, /* stops here */	427	__REQ_NR_BITS, /* stops here */
426	};	428	};
427		429
428	#define REQ_FAILFAST_DEV (1ULL << __REQ_FAILFAST_DEV)	430	#define REQ_FAILFAST_DEV \
429	#define REQ_FAILFAST_TRANSPORT (1ULL << __REQ_FAILFAST_TRANSPORT)	431	(__force blk_opf_t)(1ULL << __REQ_FAILFAST_DEV)
430	#define REQ_FAILFAST_DRIVER (1ULL << __REQ_FAILFAST_DRIVER)	432	#define REQ_FAILFAST_TRANSPORT \
431	#define REQ_SYNC (1ULL << __REQ_SYNC)	433	(__force blk_opf_t)(1ULL << __REQ_FAILFAST_TRANSPORT)
432	#define REQ_META (1ULL << __REQ_META)	434	#define REQ_FAILFAST_DRIVER \
433	#define REQ_PRIO (1ULL << __REQ_PRIO)	435	(__force blk_opf_t)(1ULL << __REQ_FAILFAST_DRIVER)
434	#define REQ_NOMERGE (1ULL << __REQ_NOMERGE)	436	#define REQ_SYNC (__force blk_opf_t)(1ULL << __REQ_SYNC)
435	#define REQ_IDLE (1ULL << __REQ_IDLE)	437	#define REQ_META (__force blk_opf_t)(1ULL << __REQ_META)
436	#define REQ_INTEGRITY (1ULL << __REQ_INTEGRITY)	438	#define REQ_PRIO (__force blk_opf_t)(1ULL << __REQ_PRIO)
437	#define REQ_FUA (1ULL << __REQ_FUA)	439	#define REQ_NOMERGE (__force blk_opf_t)(1ULL << __REQ_NOMERGE)
438	#define REQ_PREFLUSH (1ULL << __REQ_PREFLUSH)	440	#define REQ_IDLE (__force blk_opf_t)(1ULL << __REQ_IDLE)
439	#define REQ_RAHEAD (1ULL << __REQ_RAHEAD)	441	#define REQ_INTEGRITY (__force blk_opf_t)(1ULL << __REQ_INTEGRITY)
440	#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND)	442	#define REQ_FUA (__force blk_opf_t)(1ULL << __REQ_FUA)
441	#define REQ_NOWAIT (1ULL << __REQ_NOWAIT)	443	#define REQ_PREFLUSH (__force blk_opf_t)(1ULL << __REQ_PREFLUSH)
442	#define REQ_CGROUP_PUNT (1ULL << __REQ_CGROUP_PUNT)	444	#define REQ_RAHEAD (__force blk_opf_t)(1ULL << __REQ_RAHEAD)
443		445	#define REQ_BACKGROUND (__force blk_opf_t)(1ULL << __REQ_BACKGROUND)
444	#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP)	446	#define REQ_NOWAIT (__force blk_opf_t)(1ULL << __REQ_NOWAIT)
445	#define REQ_POLLED (1ULL << __REQ_POLLED)	447	#define REQ_CGROUP_PUNT (__force blk_opf_t)(1ULL << __REQ_CGROUP_PUNT)
446	#define REQ_ALLOC_CACHE (1ULL << __REQ_ALLOC_CACHE)	448
447		449	#define REQ_NOUNMAP (__force blk_opf_t)(1ULL << __REQ_NOUNMAP)
448	#define REQ_DRV (1ULL << __REQ_DRV)	450	#define REQ_POLLED (__force blk_opf_t)(1ULL << __REQ_POLLED)
449	#define REQ_SWAP (1ULL << __REQ_SWAP)	451	#define REQ_ALLOC_CACHE (__force blk_opf_t)(1ULL << __REQ_ALLOC_CACHE)
		452
		453	#define REQ_DRV (__force blk_opf_t)(1ULL << __REQ_DRV)
		454	#define REQ_SWAP (__force blk_opf_t)(1ULL << __REQ_SWAP)
450		455
451	#define REQ_FAILFAST_MASK \	456	#define REQ_FAILFAST_MASK \
452	(REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \| REQ_FAILFAST_DRIVER)	457	(REQ_FAILFAST_DEV \| REQ_FAILFAST_TRANSPORT \| REQ_FAILFAST_DRIVER)
@@ -463,26 +468,28 @@ enum stat_group { · 10 unmodified lines
463	NR_STAT_GROUPS	468	NR_STAT_GROUPS
464	};	469	};
465		470
466	#define bio_op(bio) \	471	static inline enum req_op bio_op(const struct bio *bio)
467	((bio)->bi_opf & REQ_OP_MASK)	472	{
		473	return bio->bi_opf & REQ_OP_MASK;
		474	}
468		475
469	/* obsolete, don't use in new code */	476	/* obsolete, don't use in new code */
470	static inline void bio_set_op_attrs(struct bio *bio, unsigned op,	477	static inline void bio_set_op_attrs(struct bio *bio, enum req_op op,
471	unsigned op_flags)	478	blk_opf_t op_flags)
472	{	479	{
473	bio->bi_opf = op \| op_flags;	480	bio->bi_opf = op \| op_flags;
474	}	481	}
475		482
476	static inline bool op_is_write(unsigned int op)	483	static inline bool op_is_write(blk_opf_t op)
477	{	484	{
478	return (op & 1);	485	return !!(op & (__force blk_opf_t)1);
479	}	486	}
480		487
481	/*	488	/*
482	* Check if the bio or request is one that needs special treatment in the	489	* Check if the bio or request is one that needs special treatment in the
483	* flush state machine.	490	* flush state machine.
484	*/	491	*/
485	static inline bool op_is_flush(unsigned int op)	492	static inline bool op_is_flush(blk_opf_t op)
486	{	493	{
487	return op & (REQ_FUA \| REQ_PREFLUSH);	494	return op & (REQ_FUA \| REQ_PREFLUSH);
488	}	495	}
@@ -492,13 +499,13 @@ static inline bool op_is_flush(unsigned int op) · 3 unmodified lines
492	* PREFLUSH flag. Other operations may be marked as synchronous using the	499	* PREFLUSH flag. Other operations may be marked as synchronous using the
493	* REQ_SYNC flag.	500	* REQ_SYNC flag.
494	*/	501	*/
495	static inline bool op_is_sync(unsigned int op)	502	static inline bool op_is_sync(blk_opf_t op)
496	{	503	{
497	return (op & REQ_OP_MASK) == REQ_OP_READ \|\|	504	return (op & REQ_OP_MASK) == REQ_OP_READ \|\|
498	(op & (REQ_SYNC \| REQ_FUA \| REQ_PREFLUSH));	505	(op & (REQ_SYNC \| REQ_FUA \| REQ_PREFLUSH));
499	}	506	}
500		507
501	static inline bool op_is_discard(unsigned int op)	508	static inline bool op_is_discard(blk_opf_t op)
502	{	509	{
503	return (op & REQ_OP_MASK) == REQ_OP_DISCARD;	510	return (op & REQ_OP_MASK) == REQ_OP_DISCARD;
504	}	511	}
@@ -509,7 +516,7 @@ static inline bool op_is_discard(unsigned int op) · 4 unmodified lines
509	* due to its different handling in the block layer and device response in	516	* due to its different handling in the block layer and device response in
510	* case of command failure.	517	* case of command failure.
511	*/	518	*/
512	static inline bool op_is_zone_mgmt(enum req_opf op)	519	static inline bool op_is_zone_mgmt(enum req_op op)
513	{	520	{
514	switch (op & REQ_OP_MASK) {	521	switch (op & REQ_OP_MASK) {
515	case REQ_OP_ZONE_RESET:	522	case REQ_OP_ZONE_RESET:
@@ -522,7 +529,7 @@ static inline bool op_is_zone_mgmt(enum req_opf op) · 6 unmodified lines
522	}	529	}
523	}	530	}
524		531
525	static inline int op_stat_group(unsigned int op)	532	static inline int op_stat_group(enum req_op op)
526	{	533	{
527	if (op_is_discard(op))	534	if (op_is_discard(op))
528	return STAT_DISCARD;	535	return STAT_DISCARD;

include/linux/blkdev.h+89−135

@@ -148,6 +148,7 @@ struct gendisk { · 147 unmodified lines
148	#define GD_NATIVE_CAPACITY 3	148	#define GD_NATIVE_CAPACITY 3
149	#define GD_ADDED 4	149	#define GD_ADDED 4
150	#define GD_SUPPRESS_PART_SCAN 5	150	#define GD_SUPPRESS_PART_SCAN 5
		151	#define GD_OWNS_QUEUE 6
151		152
152	struct mutex open_mutex; /* open/close mutex */	153	struct mutex open_mutex; /* open/close mutex */
153	unsigned open_partitions; /* number of open partitions */	154	unsigned open_partitions; /* number of open partitions */
@@ -163,6 +164,29 @@ struct gendisk { · 9 unmodified lines
163	#ifdef CONFIG_BLK_DEV_INTEGRITY	164	#ifdef CONFIG_BLK_DEV_INTEGRITY
164	struct kobject integrity_kobj;	165	struct kobject integrity_kobj;
165	#endif /* CONFIG_BLK_DEV_INTEGRITY */	166	#endif /* CONFIG_BLK_DEV_INTEGRITY */
		167
		168	#ifdef CONFIG_BLK_DEV_ZONED
		169	/*
		170	* Zoned block device information for request dispatch control.
		171	* nr_zones is the total number of zones of the device. This is always
		172	* 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones
		173	* bits which indicates if a zone is conventional (bit set) or
		174	* sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones
		175	* bits which indicates if a zone is write locked, that is, if a write
		176	* request targeting the zone was dispatched.
		177	*
		178	* Reads of this information must be protected with blk_queue_enter() /
		179	* blk_queue_exit(). Modifying this information is only allowed while
		180	* no requests are being processed. See also blk_mq_freeze_queue() and
		181	* blk_mq_unfreeze_queue().
		182	*/
		183	unsigned int nr_zones;
		184	unsigned int max_open_zones;
		185	unsigned int max_active_zones;
		186	unsigned long *conv_zones_bitmap;
		187	unsigned long *seq_zones_wlock;
		188	#endif /* CONFIG_BLK_DEV_ZONED */
		189
166	#if IS_ENABLED(CONFIG_CDROM)	190	#if IS_ENABLED(CONFIG_CDROM)
167	struct cdrom_device_info *cdi;	191	struct cdrom_device_info *cdi;
168	#endif	192	#endif
@@ -170,6 +194,12 @@ struct gendisk { · 1 unmodified line
170	struct badblocks *bb;	194	struct badblocks *bb;
171	struct lockdep_map lockdep_map;	195	struct lockdep_map lockdep_map;
172	u64 diskseq;	196	u64 diskseq;
		197
		198	/*
		199	* Independent sector access ranges. This is always NULL for
		200	* devices that do not have multiple independent access ranges.
		201	*/
		202	struct blk_independent_access_ranges *ia_ranges;
173	};	203	};
174		204
175	static inline bool disk_live(struct gendisk *disk)	205	static inline bool disk_live(struct gendisk *disk)
@@ -220,7 +250,7 @@ static inline int blk_validate_block_size(unsigned long bsize) · 44 unmodified lines
220	return 0;	250	return 0;
221	}	251	}
222		252
223	static inline bool blk_op_is_passthrough(unsigned int op)	253	static inline bool blk_op_is_passthrough(blk_opf_t op)
224	{	254	{
225	op &= REQ_OP_MASK;	255	op &= REQ_OP_MASK;
226	return op == REQ_OP_DRV_IN \|\| op == REQ_OP_DRV_OUT;	256	return op == REQ_OP_DRV_IN \|\| op == REQ_OP_DRV_OUT;
@@ -284,15 +314,15 @@ struct queue_limits { · 57 unmodified lines
284	typedef int (report_zones_cb)(struct blk_zone zone, unsigned int idx,	314	typedef int (report_zones_cb)(struct blk_zone zone, unsigned int idx,
285	void *data);	315	void *data);
286		316
287	void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model);	317	void disk_set_zoned(struct gendisk *disk, enum blk_zoned_model model);
288		318
289	#ifdef CONFIG_BLK_DEV_ZONED	319	#ifdef CONFIG_BLK_DEV_ZONED
290		320
291	#define BLK_ALL_ZONES ((unsigned int)-1)	321	#define BLK_ALL_ZONES ((unsigned int)-1)
292	int blkdev_report_zones(struct block_device *bdev, sector_t sector,	322	int blkdev_report_zones(struct block_device *bdev, sector_t sector,
293	unsigned int nr_zones, report_zones_cb cb, void *data);	323	unsigned int nr_zones, report_zones_cb cb, void *data);
294	unsigned int blkdev_nr_zones(struct gendisk *disk);	324	unsigned int bdev_nr_zones(struct block_device *bdev);
295	extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,	325	extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
296	sector_t sectors, sector_t nr_sectors,	326	sector_t sectors, sector_t nr_sectors,
297	gfp_t gfp_mask);	327	gfp_t gfp_mask);
298	int blk_revalidate_disk_zones(struct gendisk *disk,	328	int blk_revalidate_disk_zones(struct gendisk *disk,
@@ -305,7 +335,7 @@ extern int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, · 6 unmodified lines
305		335
306	#else /* CONFIG_BLK_DEV_ZONED */	336	#else /* CONFIG_BLK_DEV_ZONED */
307		337
308	static inline unsigned int blkdev_nr_zones(struct gendisk *disk)	338	static inline unsigned int bdev_nr_zones(struct block_device *bdev)
309	{	339	{
310	return 0;	340	return 0;
311	}	341	}
@@ -424,6 +454,11 @@ struct request_queue { · 112 unmodified lines
424	unsigned long nr_requests; /* Max # of requests */	454	unsigned long nr_requests; /* Max # of requests */
425		455
426	unsigned int dma_pad_mask;	456	unsigned int dma_pad_mask;
		457	/*
		458	* Drivers that set dma_alignment to less than 511 must be prepared to
		459	* handle individual bvec's that are not a multiple of a SECTOR_SIZE
		460	* due to possible offsets.
		461	*/
427	unsigned int dma_alignment;	462	unsigned int dma_alignment;
428		463
429	#ifdef CONFIG_BLK_INLINE_ENCRYPTION	464	#ifdef CONFIG_BLK_INLINE_ENCRYPTION
@@ -455,31 +490,6 @@ struct request_queue { · 25 unmodified lines
455		490
456	unsigned int required_elevator_features;	491	unsigned int required_elevator_features;
457		492
458	#ifdef CONFIG_BLK_DEV_ZONED
459	/*
460	* Zoned block device information for request dispatch control.
461	* nr_zones is the total number of zones of the device. This is always
462	* 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones
463	* bits which indicates if a zone is conventional (bit set) or
464	* sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones
465	* bits which indicates if a zone is write locked, that is, if a write
466	* request targeting the zone was dispatched. All three fields are
467	* initialized by the low level device driver (e.g. scsi/sd.c).
468	* Stacking drivers (device mappers) may or may not initialize
469	* these fields.
470	*
471	* Reads of this information must be protected with blk_queue_enter() /
472	* blk_queue_exit(). Modifying this information is only allowed while
473	* no requests are being processed. See also blk_mq_freeze_queue() and
474	* blk_mq_unfreeze_queue().
475	*/
476	unsigned int nr_zones;
477	unsigned long *conv_zones_bitmap;
478	unsigned long *seq_zones_wlock;
479	unsigned int max_open_zones;
480	unsigned int max_active_zones;
481	#endif /* CONFIG_BLK_DEV_ZONED */
482
483	int node;	493	int node;
484	#ifdef CONFIG_BLK_DEV_IO_TRACE	494	#ifdef CONFIG_BLK_DEV_IO_TRACE
485	struct blk_trace __rcu *blk_trace;	495	struct blk_trace __rcu *blk_trace;
@@ -533,12 +543,6 @@ struct request_queue { · 47 unmodified lines
533		543
534	bool mq_sysfs_init_done;	544	bool mq_sysfs_init_done;
535		545
536	/*
537	* Independent sector access ranges. This is always NULL for
538	* devices that do not have multiple independent access ranges.
539	*/
540	struct blk_independent_access_ranges *ia_ranges;
541
542	/**	546	/**
543	* @srcu: Sleepable RCU. Use as lock when type of the request queue	547	* @srcu: Sleepable RCU. Use as lock when type of the request queue
544	* is blocking (BLK_MQ_F_BLOCKING). Must be the last member	548	* is blocking (BLK_MQ_F_BLOCKING). Must be the last member
@@ -559,7 +563,6 @@ struct request_queue { · 14 unmodified lines
559	#define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */	563	#define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */
560	#define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */	564	#define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */
561	#define QUEUE_FLAG_SAME_FORCE 12 /* force complete on same CPU */	565	#define QUEUE_FLAG_SAME_FORCE 12 /* force complete on same CPU */
562	#define QUEUE_FLAG_DEAD 13 /* queue tear-down finished */
563	#define QUEUE_FLAG_INIT_DONE 14 /* queue is initialized */	566	#define QUEUE_FLAG_INIT_DONE 14 /* queue is initialized */
564	#define QUEUE_FLAG_STABLE_WRITES 15 /* don't modify blks until WB is done */	567	#define QUEUE_FLAG_STABLE_WRITES 15 /* don't modify blks until WB is done */
565	#define QUEUE_FLAG_POLL 16 /* IO polling enabled if set */	568	#define QUEUE_FLAG_POLL 16 /* IO polling enabled if set */
@@ -587,7 +590,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); · 21 unmodified lines
587	#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)	590	#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
588	#define blk_queue_dying(q) test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)	591	#define blk_queue_dying(q) test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
589	#define blk_queue_has_srcu(q) test_bit(QUEUE_FLAG_HAS_SRCU, &(q)->queue_flags)	592	#define blk_queue_has_srcu(q) test_bit(QUEUE_FLAG_HAS_SRCU, &(q)->queue_flags)
590	#define blk_queue_dead(q) test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
591	#define blk_queue_init_done(q) test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)	593	#define blk_queue_init_done(q) test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
592	#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)	594	#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
593	#define blk_queue_noxmerges(q) \	595	#define blk_queue_noxmerges(q) \
@@ -663,76 +665,69 @@ static inline bool blk_queue_is_zoned(struct request_queue *q) · 69 unmodified lines
663	}	665	}
664	}	666	}
665		667
666	static inline sector_t blk_queue_zone_sectors(struct request_queue *q)
667	{
668	return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
669	}
670
671	#ifdef CONFIG_BLK_DEV_ZONED	668	#ifdef CONFIG_BLK_DEV_ZONED
672	static inline unsigned int blk_queue_nr_zones(struct request_queue *q)	669	static inline unsigned int disk_nr_zones(struct gendisk *disk)
673	{	670	{
674	return blk_queue_is_zoned(q) ? q->nr_zones : 0;	671	return blk_queue_is_zoned(disk->queue) ? disk->nr_zones : 0;
675	}	672	}
676		673
677	static inline unsigned int blk_queue_zone_no(struct request_queue *q,	674	static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
678	sector_t sector)
679	{	675	{
680	if (!blk_queue_is_zoned(q))	676	if (!blk_queue_is_zoned(disk->queue))
681	return 0;	677	return 0;
682	return sector >> ilog2(q->limits.chunk_sectors);	678	return sector >> ilog2(disk->queue->limits.chunk_sectors);
683	}	679	}
684		680
685	static inline bool blk_queue_zone_is_seq(struct request_queue *q,	681	static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
686	sector_t sector)
687	{	682	{
688	if (!blk_queue_is_zoned(q))	683	if (!blk_queue_is_zoned(disk->queue))
689	return false;	684	return false;
690	if (!q->conv_zones_bitmap)	685	if (!disk->conv_zones_bitmap)
691	return true;	686	return true;
692	return !test_bit(blk_queue_zone_no(q, sector), q->conv_zones_bitmap);	687	return !test_bit(disk_zone_no(disk, sector), disk->conv_zones_bitmap);
693	}	688	}
694		689
695	static inline void blk_queue_max_open_zones(struct request_queue *q,	690	static inline void disk_set_max_open_zones(struct gendisk *disk,
696	unsigned int max_open_zones)	691	unsigned int max_open_zones)
697	{	692	{
698	q->max_open_zones = max_open_zones;	693	disk->max_open_zones = max_open_zones;
699	}	694	}
700		695
701	static inline unsigned int queue_max_open_zones(const struct request_queue *q)	696	static inline void disk_set_max_active_zones(struct gendisk *disk,
		697	unsigned int max_active_zones)
702	{	698	{
703	return q->max_open_zones;	699	disk->max_active_zones = max_active_zones;
704	}	700	}
705		701
706	static inline void blk_queue_max_active_zones(struct request_queue *q,	702	static inline unsigned int bdev_max_open_zones(struct block_device *bdev)
707	unsigned int max_active_zones)
708	{	703	{
709	q->max_active_zones = max_active_zones;	704	return bdev->bd_disk->max_open_zones;
710	}	705	}
711		706
712	static inline unsigned int queue_max_active_zones(const struct request_queue *q)	707	static inline unsigned int bdev_max_active_zones(struct block_device *bdev)
713	{	708	{
714	return q->max_active_zones;	709	return bdev->bd_disk->max_active_zones;
715	}	710	}
		711
716	#else /* CONFIG_BLK_DEV_ZONED */	712	#else /* CONFIG_BLK_DEV_ZONED */
717	static inline unsigned int blk_queue_nr_zones(struct request_queue *q)	713	static inline unsigned int disk_nr_zones(struct gendisk *disk)
718	{	714	{
719	return 0;	715	return 0;
720	}	716	}
721	static inline bool blk_queue_zone_is_seq(struct request_queue *q,	717	static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
722	sector_t sector)
723	{	718	{
724	return false;	719	return false;
725	}	720	}
726	static inline unsigned int blk_queue_zone_no(struct request_queue *q,	721	static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
727	sector_t sector)
728	{	722	{
729	return 0;	723	return 0;
730	}	724	}
731	static inline unsigned int queue_max_open_zones(const struct request_queue *q)	725	static inline unsigned int bdev_max_open_zones(struct block_device *bdev)
732	{	726	{
733	return 0;	727	return 0;
734	}	728	}
735	static inline unsigned int queue_max_active_zones(const struct request_queue *q)	729
		730	static inline unsigned int bdev_max_active_zones(struct block_device *bdev)
736	{	731	{
737	return 0;	732	return 0;
738	}	733	}
@@ -812,8 +807,6 @@ static inline u64 sb_bdev_nr_blocks(struct super_block *sb) · 73 unmodified lines
812		807
813	int bdev_disk_changed(struct gendisk *disk, bool invalidate);	808	int bdev_disk_changed(struct gendisk *disk, bool invalidate);
814		809
815	struct gendisk __alloc_disk_node(struct request_queue q, int node_id,
816	struct lock_class_key *lkclass);
817	void put_disk(struct gendisk *disk);	810	void put_disk(struct gendisk *disk);
818	struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass);	811	struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass);
819		812
@@ -832,7 +825,6 @@ struct gendisk __blk_alloc_disk(int node, struct lock_class_key lkclass); · 12 unmodified lines
832	\	825	\
833	__blk_alloc_disk(node_id, &__key); \	826	__blk_alloc_disk(node_id, &__key); \
834	})	827	})
835	void blk_cleanup_disk(struct gendisk *disk);
836		828
837	int __register_blkdev(unsigned int major, const char *name,	829	int __register_blkdev(unsigned int major, const char *name,
838	void (*probe)(dev_t devt));	830	void (*probe)(dev_t devt));
@@ -880,7 +872,7 @@ extern void blk_queue_exit(struct request_queue *q); · 41 unmodified lines
880	extern void blk_sync_queue(struct request_queue *q);	872	extern void blk_sync_queue(struct request_queue *q);
881		873
882	/* Helper to convert REQ_OP_XXX to its string format XXX */	874	/* Helper to convert REQ_OP_XXX to its string format XXX */
883	extern const char *blk_op_str(unsigned int op);	875	extern const char *blk_op_str(enum req_op op);
884		876
885	int blk_status_to_errno(blk_status_t status);	877	int blk_status_to_errno(blk_status_t status);
886	blk_status_t errno_to_blk_status(int errno);	878	blk_status_t errno_to_blk_status(int errno);
@@ -898,64 +890,33 @@ static inline struct request_queue bdev_get_queue(struct block_device bdev) · 11 unmodified lines
898	return bdev->bd_queue; /* this is never NULL */	890	return bdev->bd_queue; /* this is never NULL */
899	}	891	}
900		892
901	#ifdef CONFIG_BLK_DEV_ZONED
902
903	/* Helper to convert BLK_ZONE_ZONE_XXX to its string format XXX */	893	/* Helper to convert BLK_ZONE_ZONE_XXX to its string format XXX */
904	const char *blk_zone_cond_str(enum blk_zone_cond zone_cond);	894	const char *blk_zone_cond_str(enum blk_zone_cond zone_cond);
905		895
906	static inline unsigned int bio_zone_no(struct bio *bio)	896	static inline unsigned int bio_zone_no(struct bio *bio)
907	{	897	{
908	return blk_queue_zone_no(bdev_get_queue(bio->bi_bdev),	898	return disk_zone_no(bio->bi_bdev->bd_disk, bio->bi_iter.bi_sector);
909	bio->bi_iter.bi_sector);
910	}	899	}
911		900
912	static inline unsigned int bio_zone_is_seq(struct bio *bio)	901	static inline unsigned int bio_zone_is_seq(struct bio *bio)
913	{	902	{
914	return blk_queue_zone_is_seq(bdev_get_queue(bio->bi_bdev),	903	return disk_zone_is_seq(bio->bi_bdev->bd_disk, bio->bi_iter.bi_sector);
915	bio->bi_iter.bi_sector);
916	}
917	#endif /* CONFIG_BLK_DEV_ZONED */
918
919	static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
920	int op)
921	{
922	if (unlikely(op == REQ_OP_DISCARD \|\| op == REQ_OP_SECURE_ERASE))
923	return min(q->limits.max_discard_sectors,
924	UINT_MAX >> SECTOR_SHIFT);
925
926	if (unlikely(op == REQ_OP_WRITE_ZEROES))
927	return q->limits.max_write_zeroes_sectors;
928
929	return q->limits.max_sectors;
930	}	904	}
931		905
932	/*	906	/*
933	* Return maximum size of a request at given offset. Only valid for	907	* Return how much of the chunk is left to be used for I/O at a given offset.
934	* file system requests.
935	*/	908	*/
936	static inline unsigned int blk_max_size_offset(struct request_queue *q,	909	static inline unsigned int blk_chunk_sectors_left(sector_t offset,
937	sector_t offset,	910	unsigned int chunk_sectors)
938	unsigned int chunk_sectors)	911	{
939	{	912	if (unlikely(!is_power_of_2(chunk_sectors)))
940	if (!chunk_sectors) {	913	return chunk_sectors - sector_div(offset, chunk_sectors);
941	if (q->limits.chunk_sectors)	914	return chunk_sectors - (offset & (chunk_sectors - 1));
942	chunk_sectors = q->limits.chunk_sectors;
943	else
944	return q->limits.max_sectors;
945	}
946
947	if (likely(is_power_of_2(chunk_sectors)))
948	chunk_sectors -= offset & (chunk_sectors - 1);
949	else
950	chunk_sectors -= sector_div(offset, chunk_sectors);
951
952	return min(q->limits.max_sectors, chunk_sectors);
953	}	915	}
954		916
955	/*	917	/*
956	* Access functions for manipulating queue properties	918	* Access functions for manipulating queue properties
957	*/	919	*/
958	extern void blk_cleanup_queue(struct request_queue *);
959	void blk_queue_bounce_limit(struct request_queue *q, enum blk_bounce limit);	920	void blk_queue_bounce_limit(struct request_queue *q, enum blk_bounce limit);
960	extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);	921	extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
961	extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);	922	extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
@@ -1337,32 +1298,26 @@ static inline sector_t bdev_zone_sectors(struct block_device *bdev) · 375 unmodified lines
1337	{	1298	{
1338	struct request_queue *q = bdev_get_queue(bdev);	1299	struct request_queue *q = bdev_get_queue(bdev);
1339		1300
1340	if (q)	1301	if (!blk_queue_is_zoned(q))
1341	return blk_queue_zone_sectors(q);	1302	return 0;
1342	return 0;	1303	return q->limits.chunk_sectors;
1343	}	1304	}
1344		1305
1345	static inline unsigned int bdev_max_open_zones(struct block_device *bdev)	1306	static inline int queue_dma_alignment(const struct request_queue *q)
1346	{	1307	{
1347	struct request_queue *q = bdev_get_queue(bdev);	1308	return q ? q->dma_alignment : 511;
1348
1349	if (q)
1350	return queue_max_open_zones(q);
1351	return 0;
1352	}	1309	}
1353		1310
1354	static inline unsigned int bdev_max_active_zones(struct block_device *bdev)	1311	static inline unsigned int bdev_dma_alignment(struct block_device *bdev)
1355	{	1312	{
1356	struct request_queue *q = bdev_get_queue(bdev);	1313	return queue_dma_alignment(bdev_get_queue(bdev));
1357
1358	if (q)
1359	return queue_max_active_zones(q);
1360	return 0;
1361	}	1314	}
1362		1315
1363	static inline int queue_dma_alignment(const struct request_queue *q)	1316	static inline bool bdev_iter_is_aligned(struct block_device *bdev,
		1317	struct iov_iter *iter)
1364	{	1318	{
1365	return q ? q->dma_alignment : 511;	1319	return iov_iter_is_aligned(iter, bdev_dma_alignment(bdev),
		1320	bdev_logical_block_size(bdev) - 1);
1366	}	1321	}
1367		1322
1368	static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,	1323	static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
@@ -1426,7 +1381,7 @@ struct block_device_operations { · 57 unmodified lines
1426	unsigned int flags);	1381	unsigned int flags);
1427	int (open) (struct block_device , fmode_t);	1382	int (open) (struct block_device , fmode_t);
1428	void (release) (struct gendisk , fmode_t);	1383	void (release) (struct gendisk , fmode_t);
1429	int (rw_page)(struct block_device , sector_t, struct page *, unsigned int);	1384	int (rw_page)(struct block_device , sector_t, struct page *, enum req_op);
1430	int (ioctl) (struct block_device , fmode_t, unsigned, unsigned long);	1385	int (ioctl) (struct block_device , fmode_t, unsigned, unsigned long);
1431	int (compat_ioctl) (struct block_device , fmode_t, unsigned, unsigned long);	1386	int (compat_ioctl) (struct block_device , fmode_t, unsigned, unsigned long);
1432	unsigned int (check_events) (struct gendisk disk,	1387	unsigned int (check_events) (struct gendisk disk,
@@ -1479,9 +1434,9 @@ static inline void blk_wake_io_task(struct task_struct *waiter) · 46 unmodified lines
1479	}	1434	}
1480		1435
1481	unsigned long bdev_start_io_acct(struct block_device *bdev,	1436	unsigned long bdev_start_io_acct(struct block_device *bdev,
1482	unsigned int sectors, unsigned int op,	1437	unsigned int sectors, enum req_op op,
1483	unsigned long start_time);	1438	unsigned long start_time);
1484	void bdev_end_io_acct(struct block_device *bdev, unsigned int op,	1439	void bdev_end_io_acct(struct block_device *bdev, enum req_op op,
1485	unsigned long start_time);	1440	unsigned long start_time);
1486		1441
1487	void bio_start_io_acct_time(struct bio *bio, unsigned long start_time);	1442	void bio_start_io_acct_time(struct bio *bio, unsigned long start_time);
@@ -1502,7 +1457,6 @@ static inline void bio_end_io_acct(struct bio *bio, unsigned long start_time) · 14 unmodified lines
1502	int bdev_read_only(struct block_device *bdev);	1457	int bdev_read_only(struct block_device *bdev);
1503	int set_blocksize(struct block_device *bdev, int size);	1458	int set_blocksize(struct block_device *bdev, int size);
1504		1459
1505	const char bdevname(struct block_device bdev, char *buffer);
1506	int lookup_bdev(const char pathname, dev_t dev);	1460	int lookup_bdev(const char pathname, dev_t dev);
1507		1461
1508	void blkdev_show(struct seq_file *seqf, off_t offset);	1462	void blkdev_show(struct seq_file *seqf, off_t offset);

include/linux/blktrace_api.h+2−11

 #include <linux/compat.h>
 #include <uapi/linux/blktrace_api.h>
 #include <linux/list.h>
+#include <linux/blk_types.h>
 #if defined(CONFIG_BLK_DEV_IO_TRACE)
 			   char __user *arg);
 extern int blk_trace_startstop(struct request_queue *q, int start);
 extern int blk_trace_remove(struct request_queue *q);
-extern void blk_trace_remove_sysfs(struct device *dev);
-extern int blk_trace_init_sysfs(struct device *dev);
-extern struct attribute_group blk_trace_attr_group;
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
 # define blk_trace_ioctl(bdev, cmd, arg)		(-ENOTTY)
 # define blk_trace_remove(q)				(-ENOTTY)
 # define blk_add_trace_msg(q, fmt, ...)			do { } while (0)
 # define blk_add_cgroup_trace_msg(q, cg, fmt, ...)	do { } while (0)
-# define blk_trace_remove_sysfs(dev)			do { } while (0)
 # define blk_trace_note_message_enabled(q)		(false)
-static inline int blk_trace_init_sysfs(struct device *dev)
-{
-	return 0;
-}
 #endif /* CONFIG_BLK_DEV_IO_TRACE */
 #ifdef CONFIG_COMPAT
 #endif
-void blk_fill_rwbs(char *rwbs, unsigned int op);
+void blk_fill_rwbs(char *rwbs, blk_opf_t opf);
 static inline sector_t blk_rq_trace_sector(struct request *rq)
 {

include/linux/buffer_head.h+5−4

 #define _LINUX_BUFFER_HEAD_H
 #include <linux/types.h>
+#include <linux/blk_types.h>
 #include <linux/fs.h>
 #include <linux/linkage.h>
 #include <linux/pagemap.h>
 void free_buffer_head(struct buffer_head * bh);
 void unlock_buffer(struct buffer_head *bh);
 void __lock_buffer(struct buffer_head *bh);
-void ll_rw_block(int, int, int, struct buffer_head * bh[]);
+void ll_rw_block(blk_opf_t, int, struct buffer_head * bh[]);
 int sync_dirty_buffer(struct buffer_head *bh);
-int __sync_dirty_buffer(struct buffer_head *bh, int op_flags);
+int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
-void write_dirty_buffer(struct buffer_head *bh, int op_flags);
+void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
-int submit_bh(int, int, struct buffer_head *);
+int submit_bh(blk_opf_t, struct buffer_head *);
 void write_boundary_block(struct block_device *bdev,
 			sector_t bblock, unsigned blocksize);
 int bh_uptodate_or_lock(struct buffer_head *bh);

include/linux/dm-io.h+2−2

 #ifdef __KERNEL__
 #include <linux/types.h>
+#include <linux/blk_types.h>
 struct dm_io_region {
 	struct block_device *bdev;
  */
 struct dm_io_client;
 struct dm_io_request {
-	int bi_op;			/* REQ_OP */
+	blk_opf_t	    bi_opf;	/* Request type and flags */
-	int bi_op_flags;		/* req_flag_bits */
 	struct dm_io_memory mem;	/* Memory to use for io */
 	struct dm_io_notify notify;	/* Synchronous if notify.fn is NULL */
 	struct dm_io_client *client;	/* Client memory handler */

include/linux/ioprio.h+10−14

 /*
  * Default IO priority.
  */
-#define IOPRIO_DEFAULT	IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, IOPRIO_BE_NORM)
+#define IOPRIO_DEFAULT	IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0)
 /*
  * Check that a priority value has a valid class.
 		return IOPRIO_CLASS_BE;
 }
-/*
+#ifdef CONFIG_BLOCK
- * If the calling process has set an I/O priority, use that. Otherwise, return
+int __get_task_ioprio(struct task_struct *p);
- * the default I/O priority.
+#else
- */
+static inline int __get_task_ioprio(struct task_struct *p)
-static inline int get_current_ioprio(void)
 {
-	struct io_context *ioc = current->io_context;
-	if (ioc)
-		return ioc->ioprio;
 	return IOPRIO_DEFAULT;
 }
+#endif /* CONFIG_BLOCK */
-/*
+static inline int get_current_ioprio(void)
- * For inheritance, return the highest of the two given priorities
+{
- */
+	return __get_task_ioprio(current);
-extern int ioprio_best(unsigned short aprio, unsigned short bprio);
+}
 extern int set_task_ioprio(struct task_struct *task, int ioprio);

include/linux/jbd2.h+1−1

@@ -1557,7 +1557,7 @@ extern int jbd2_journal_wipe (journal_t *, int); · 1556 unmodified lines
1557	extern int jbd2_journal_skip_recovery (journal_t *);	1557	extern int jbd2_journal_skip_recovery (journal_t *);
1558	extern void jbd2_journal_update_sb_errno(journal_t *);	1558	extern void jbd2_journal_update_sb_errno(journal_t *);
1559	extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,	1559	extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1560	unsigned long, int);	1560	unsigned long, blk_opf_t);
1561	extern void jbd2_journal_abort (journal_t *, int);	1561	extern void jbd2_journal_abort (journal_t *, int);
1562	extern int jbd2_journal_errno (journal_t *);	1562	extern int jbd2_journal_errno (journal_t *);
1563	extern void jbd2_journal_ack_err (journal_t *);	1563	extern void jbd2_journal_ack_err (journal_t *);

include/linux/uio.h+2−0

@@ -219,6 +219,8 @@ size_t _copy_mc_to_iter(const void addr, size_t bytes, struct iov_iter i); · 218 unmodified lines
219	#endif	219	#endif
220		220
221	size_t iov_iter_zero(size_t bytes, struct iov_iter *);	221	size_t iov_iter_zero(size_t bytes, struct iov_iter *);
		222	bool iov_iter_is_aligned(const struct iov_iter *i, unsigned addr_mask,
		223	unsigned len_mask);
222	unsigned long iov_iter_alignment(const struct iov_iter *i);	224	unsigned long iov_iter_alignment(const struct iov_iter *i);
223	unsigned long iov_iter_gap_alignment(const struct iov_iter *i);	225	unsigned long iov_iter_gap_alignment(const struct iov_iter *i);
224	void iov_iter_init(struct iov_iter i, unsigned int direction, const struct iovec iov,	226	void iov_iter_init(struct iov_iter i, unsigned int direction, const struct iovec iov,

include/linux/writeback.h+2−2

@@ -101,9 +101,9 @@ struct writeback_control { · 100 unmodified lines
101	#endif	101	#endif
102	};	102	};
103		103
104	static inline int wbc_to_write_flags(struct writeback_control *wbc)	104	static inline blk_opf_t wbc_to_write_flags(struct writeback_control *wbc)
105	{	105	{
106	int flags = 0;	106	blk_opf_t flags = 0;
107		107
108	if (wbc->punt_to_cgroup)	108	if (wbc->punt_to_cgroup)
109	flags = REQ_CGROUP_PUNT;	109	flags = REQ_CGROUP_PUNT;

include/scsi/scsi_cmnd.h+2−2

@@ -386,7 +386,7 @@ static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd) · 385 unmodified lines
386	extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,	386	extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
387	u8 key, u8 asc, u8 ascq);	387	u8 key, u8 asc, u8 ascq);
388		388
389	struct request scsi_alloc_request(struct request_queue q,	389	struct request scsi_alloc_request(struct request_queue q, blk_opf_t opf,
390	unsigned int op, blk_mq_req_flags_t flags);	390	blk_mq_req_flags_t flags);
391		391
392	#endif /* _SCSI_SCSI_CMND_H */	392	#endif /* _SCSI_SCSI_CMND_H */

include/scsi/scsi_device.h+1−1

@@ -457,7 +457,7 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len); · 456 unmodified lines
457	extern int __scsi_execute(struct scsi_device sdev, const unsigned char cmd,	457	extern int __scsi_execute(struct scsi_device sdev, const unsigned char cmd,
458	int data_direction, void *buffer, unsigned bufflen,	458	int data_direction, void *buffer, unsigned bufflen,
459	unsigned char sense, struct scsi_sense_hdr sshdr,	459	unsigned char sense, struct scsi_sense_hdr sshdr,
460	int timeout, int retries, u64 flags,	460	int timeout, int retries, blk_opf_t flags,
461	req_flags_t rq_flags, int *resid);	461	req_flags_t rq_flags, int *resid);
462	/* Make sure any sense buffer is the correct size. */	462	/* Make sure any sense buffer is the correct size. */
463	#define scsi_execute(sdev, cmd, data_direction, buffer, bufflen, sense, \	463	#define scsi_execute(sdev, cmd, data_direction, buffer, bufflen, sense, \

include/scsi/scsi_host.h+1−1

@@ -786,7 +786,7 @@ extern int scsi_host_block(struct Scsi_Host *shost); · 785 unmodified lines
786	extern int scsi_host_unblock(struct Scsi_Host *shost, int new_state);	786	extern int scsi_host_unblock(struct Scsi_Host *shost, int new_state);
787		787
788	void scsi_host_busy_iter(struct Scsi_Host *,	788	void scsi_host_busy_iter(struct Scsi_Host *,
789	bool (fn)(struct scsi_cmnd , void , bool), void priv);	789	bool (fn)(struct scsi_cmnd , void ), void priv);
790		790
791	struct class_container;	791	struct class_container;
792		792

include/trace/events/f2fs.h+11−11

@@ -66,7 +66,7 @@ TRACE_DEFINE_ENUM(CP_RESIZE); · 65 unmodified lines
66		66
67	#define F2FS_OP_FLAGS (REQ_RAHEAD \| REQ_SYNC \| REQ_META \| REQ_PRIO \| \	67	#define F2FS_OP_FLAGS (REQ_RAHEAD \| REQ_SYNC \| REQ_META \| REQ_PRIO \| \
68	REQ_PREFLUSH \| REQ_FUA)	68	REQ_PREFLUSH \| REQ_FUA)
69	#define F2FS_BIO_FLAG_MASK(t) (t & F2FS_OP_FLAGS)	69	#define F2FS_BIO_FLAG_MASK(t) (__force u32)((t) & F2FS_OP_FLAGS)
70		70
71	#define show_bio_type(op,op_flags) show_bio_op(op), \	71	#define show_bio_type(op,op_flags) show_bio_op(op), \
72	show_bio_op_flags(op_flags)	72	show_bio_op_flags(op_flags)
@@ -75,12 +75,12 @@ TRACE_DEFINE_ENUM(CP_RESIZE); · 2 unmodified lines
75		75
76	#define show_bio_op_flags(flags) \	76	#define show_bio_op_flags(flags) \
77	__print_flags(F2FS_BIO_FLAG_MASK(flags), "\|", \	77	__print_flags(F2FS_BIO_FLAG_MASK(flags), "\|", \
78	{ REQ_RAHEAD, "R" }, \	78	{ (__force u32)REQ_RAHEAD, "R" }, \
79	{ REQ_SYNC, "S" }, \	79	{ (__force u32)REQ_SYNC, "S" }, \
80	{ REQ_META, "M" }, \	80	{ (__force u32)REQ_META, "M" }, \
81	{ REQ_PRIO, "P" }, \	81	{ (__force u32)REQ_PRIO, "P" }, \
82	{ REQ_PREFLUSH, "PF" }, \	82	{ (__force u32)REQ_PREFLUSH, "PF" }, \
83	{ REQ_FUA, "FUA" })	83	{ (__force u32)REQ_FUA, "FUA" })
84		84
85	#define show_data_type(type) \	85	#define show_data_type(type) \
86	__print_symbolic(type, \	86	__print_symbolic(type, \
@@ -1036,8 +1036,8 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio, · 949 unmodified lines
1036	__field(pgoff_t, index)	1036	__field(pgoff_t, index)
1037	__field(block_t, old_blkaddr)	1037	__field(block_t, old_blkaddr)
1038	__field(block_t, new_blkaddr)	1038	__field(block_t, new_blkaddr)
1039	__field(int, op)	1039	__field(enum req_op, op)
1040	__field(int, op_flags)	1040	__field(blk_opf_t, op_flags)
1041	__field(int, temp)	1041	__field(int, temp)
1042	__field(int, type)	1042	__field(int, type)
1043	),	1043	),
@@ -1092,8 +1092,8 @@ DECLARE_EVENT_CLASS(f2fs__bio, · 48 unmodified lines
1092	TP_STRUCT__entry(	1092	TP_STRUCT__entry(
1093	__field(dev_t, dev)	1093	__field(dev_t, dev)
1094	__field(dev_t, target)	1094	__field(dev_t, target)
1095	__field(int, op)	1095	__field(enum req_op, op)
1096	__field(int, op_flags)	1096	__field(blk_opf_t, op_flags)
1097	__field(int, type)	1097	__field(int, type)
1098	__field(sector_t, sector)	1098	__field(sector_t, sector)
1099	__field(unsigned int, size)	1099	__field(unsigned int, size)

include/trace/events/jbd2.h+6−6

@@ -355,22 +355,22 @@ TRACE_EVENT(jbd2_update_log_tail, · 354 unmodified lines
355		355
356	TRACE_EVENT(jbd2_write_superblock,	356	TRACE_EVENT(jbd2_write_superblock,
357		357
358	TP_PROTO(journal_t *journal, int write_op),	358	TP_PROTO(journal_t *journal, blk_opf_t write_flags),
359		359
360	TP_ARGS(journal, write_op),	360	TP_ARGS(journal, write_flags),
361		361
362	TP_STRUCT__entry(	362	TP_STRUCT__entry(
363	__field( dev_t, dev )	363	__field( dev_t, dev )
364	__field( int, write_op )	364	__field( blk_opf_t, write_flags )
365	),	365	),
366		366
367	TP_fast_assign(	367	TP_fast_assign(
368	__entry->dev = journal->j_fs_dev->bd_dev;	368	__entry->dev = journal->j_fs_dev->bd_dev;
369	__entry->write_op = write_op;	369	__entry->write_flags = write_flags;
370	),	370	),
371		371
372	TP_printk("dev %d,%d write_op %x", MAJOR(__entry->dev),	372	TP_printk("dev %d,%d write_flags %x", MAJOR(__entry->dev),
373	MINOR(__entry->dev), __entry->write_op)	373	MINOR(__entry->dev), (__force u32)__entry->write_flags)
374	);	374	);
375		375
376	TRACE_EVENT(jbd2_lock_buffer_stall,	376	TRACE_EVENT(jbd2_lock_buffer_stall,

include/trace/events/nilfs2.h+2−2

@@ -192,7 +192,7 @@ TRACE_EVENT(nilfs2_mdt_submit_block, · 191 unmodified lines
192	TP_PROTO(struct inode *inode,	192	TP_PROTO(struct inode *inode,
193	unsigned long ino,	193	unsigned long ino,
194	unsigned long blkoff,	194	unsigned long blkoff,
195	int mode),	195	enum req_op mode),
196		196
197	TP_ARGS(inode, ino, blkoff, mode),	197	TP_ARGS(inode, ino, blkoff, mode),
198		198
@@ -200,7 +200,7 @@ TRACE_EVENT(nilfs2_mdt_submit_block, · 1 unmodified line
200	__field(struct inode *, inode)	200	__field(struct inode *, inode)
201	__field(unsigned long, ino)	201	__field(unsigned long, ino)
202	__field(unsigned long, blkoff)	202	__field(unsigned long, blkoff)
203	__field(int, mode)	203	__field(enum req_op, mode)
204	),	204	),
205		205
206	TP_fast_assign(	206	TP_fast_assign(

include/uapi/linux/ublk_cmd.h+161−0

@@ -0,0 +1,161 @@
	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	2	#ifndef USER_BLK_DRV_CMD_INC_H
	3	#define USER_BLK_DRV_CMD_INC_H
	4
	5	#include <linux/types.h>
	6
	7	/* ublk server command definition */
	8
	9	/*
	10	* Admin commands, issued by ublk server, and handled by ublk driver.
	11	*/
	12	#define UBLK_CMD_GET_QUEUE_AFFINITY 0x01
	13	#define UBLK_CMD_GET_DEV_INFO 0x02
	14	#define UBLK_CMD_ADD_DEV 0x04
	15	#define UBLK_CMD_DEL_DEV 0x05
	16	#define UBLK_CMD_START_DEV 0x06
	17	#define UBLK_CMD_STOP_DEV 0x07
	18
	19	/*
	20	* IO commands, issued by ublk server, and handled by ublk driver.
	21	*
	22	* FETCH_REQ: issued via sqe(URING_CMD) beforehand for fetching IO request
	23	* from ublk driver, should be issued only when starting device. After
	24	* the associated cqe is returned, request's tag can be retrieved via
	25	* cqe->userdata.
	26	*
	27	* COMMIT_AND_FETCH_REQ: issued via sqe(URING_CMD) after ublkserver handled
	28	* this IO request, request's handling result is committed to ublk
	29	* driver, meantime FETCH_REQ is piggyback, and FETCH_REQ has to be
	30	* handled before completing io request.
	31	*/
	32	#define UBLK_IO_FETCH_REQ 0x20
	33	#define UBLK_IO_COMMIT_AND_FETCH_REQ 0x21
	34
	35	/* only ABORT means that no re-fetch */
	36	#define UBLK_IO_RES_OK 0
	37	#define UBLK_IO_RES_ABORT (-ENODEV)
	38
	39	#define UBLKSRV_CMD_BUF_OFFSET 0
	40	#define UBLKSRV_IO_BUF_OFFSET 0x80000000
	41
	42	/* tag bit is 12bit, so at most 4096 IOs for each queue */
	43	#define UBLK_MAX_QUEUE_DEPTH 4096
	44
	45	/*
	46	* zero copy requires 4k block size, and can remap ublk driver's io
	47	* request into ublksrv's vm space
	48	*/
	49	#define UBLK_F_SUPPORT_ZERO_COPY (1ULL << 0)
	50
	51	/*
	52	* Force to complete io cmd via io_uring_cmd_complete_in_task so that
	53	* performance comparison is done easily with using task_work_add
	54	*/
	55	#define UBLK_F_URING_CMD_COMP_IN_TASK (1ULL << 1)
	56
	57	/* device state */
	58	#define UBLK_S_DEV_DEAD 0
	59	#define UBLK_S_DEV_LIVE 1
	60
	61	/* shipped via sqe->cmd of io_uring command */
	62	struct ublksrv_ctrl_cmd {
	63	/* sent to which device, must be valid */
	64	__u32 dev_id;
	65
	66	/* sent to which queue, must be -1 if the cmd isn't for queue */
	67	__u16 queue_id;
	68	/*
	69	* cmd specific buffer, can be IN or OUT.
	70	*/
	71	__u16 len;
	72	__u64 addr;
	73
	74	/* inline data */
	75	__u64 data[2];
	76	};
	77
	78	struct ublksrv_ctrl_dev_info {
	79	__u16 nr_hw_queues;
	80	__u16 queue_depth;
	81	__u16 block_size;
	82	__u16 state;
	83
	84	__u32 rq_max_blocks;
	85	__u32 dev_id;
	86
	87	__u64 dev_blocks;
	88
	89	__s32 ublksrv_pid;
	90	__s32 reserved0;
	91	__u64 flags;
	92	__u64 flags_reserved;
	93
	94	/* For ublksrv internal use, invisible to ublk driver */
	95	__u64 ublksrv_flags;
	96	__u64 reserved1[9];
	97	};
	98
	99	#define UBLK_IO_OP_READ 0
	100	#define UBLK_IO_OP_WRITE 1
	101	#define UBLK_IO_OP_FLUSH 2
	102	#define UBLK_IO_OP_DISCARD 3
	103	#define UBLK_IO_OP_WRITE_SAME 4
	104	#define UBLK_IO_OP_WRITE_ZEROES 5
	105
	106	#define UBLK_IO_F_FAILFAST_DEV (1U << 8)
	107	#define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9)
	108	#define UBLK_IO_F_FAILFAST_DRIVER (1U << 10)
	109	#define UBLK_IO_F_META (1U << 11)
	110	#define UBLK_IO_F_FUA (1U << 13)
	111	#define UBLK_IO_F_NOUNMAP (1U << 15)
	112	#define UBLK_IO_F_SWAP (1U << 16)
	113
	114	/*
	115	* io cmd is described by this structure, and stored in share memory, indexed
	116	* by request tag.
	117	*
	118	* The data is stored by ublk driver, and read by ublksrv after one fetch command
	119	* returns.
	120	*/
	121	struct ublksrv_io_desc {
	122	/* op: bit 0-7, flags: bit 8-31 */
	123	__u32 op_flags;
	124
	125	__u32 nr_sectors;
	126
	127	/* start sector for this io */
	128	__u64 start_sector;
	129
	130	/* buffer address in ublksrv daemon vm space, from ublk driver */
	131	__u64 addr;
	132	};
	133
	134	static inline __u8 ublksrv_get_op(const struct ublksrv_io_desc *iod)
	135	{
	136	return iod->op_flags & 0xff;
	137	}
	138
	139	static inline __u32 ublksrv_get_flags(const struct ublksrv_io_desc *iod)
	140	{
	141	return iod->op_flags >> 8;
	142	}
	143
	144	/* issued to ublk driver via /dev/ublkcN */
	145	struct ublksrv_io_cmd {
	146	__u16 q_id;
	147
	148	/* for fetch/commit which result */
	149	__u16 tag;
	150
	151	/* io result, it is valid for COMMIT* command only */
	152	__s32 result;
	153
	154	/*
	155	* userspace buffer address in ublksrv daemon process, valid for
	156	* FETCH* command only
	157	*/
	158	__u64 addr;
	159	};
	160
	161	#endif

kernel/power/swap.c+13−16

 	bio_put(bio);
 }
-static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr,
+static int hib_submit_io(blk_opf_t opf, pgoff_t page_off, void *addr,
-		struct hib_bio_batch *hb)
+			 struct hib_bio_batch *hb)
 {
 	struct page *page = virt_to_page(addr);
 	struct bio *bio;
 	int error = 0;
-	bio = bio_alloc(hib_resume_bdev, 1, op | op_flags,
+	bio = bio_alloc(hib_resume_bdev, 1, opf, GFP_NOIO | __GFP_HIGH);
-			GFP_NOIO | __GFP_HIGH);
 	bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9);
 	if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
 {
 	int error;
-	hib_submit_io(REQ_OP_READ, 0, swsusp_resume_block,
+	hib_submit_io(REQ_OP_READ, swsusp_resume_block, swsusp_header, NULL);
-		      swsusp_header, NULL);
 	if (!memcmp("SWAP-SPACE",swsusp_header->sig, 10) ||
 	    !memcmp("SWAPSPACE2",swsusp_header->sig, 10)) {
 		memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
 		swsusp_header->flags = flags;
 		if (flags & SF_CRC32_MODE)
 			swsusp_header->crc32 = handle->crc32;
-		error = hib_submit_io(REQ_OP_WRITE, REQ_SYNC,
+		error = hib_submit_io(REQ_OP_WRITE | REQ_SYNC,
 				      swsusp_resume_block, swsusp_header, NULL);
 	} else {
 		pr_err("Swap header not found!\n");
 	} else {
 		src = buf;
 	}
-	return hib_submit_io(REQ_OP_WRITE, REQ_SYNC, offset, src, hb);
+	return hib_submit_io(REQ_OP_WRITE | REQ_SYNC, offset, src, hb);
 }
 static void release_swap_writer(struct swap_map_handle *handle)
 			return -ENOMEM;
 		}
-		error = hib_submit_io(REQ_OP_READ, 0, offset, tmp->map, NULL);
+		error = hib_submit_io(REQ_OP_READ, offset, tmp->map, NULL);
 		if (error) {
 			release_swap_reader(handle);
 			return error;
 	offset = handle->cur->entries[handle->k];
 	if (!offset)
 		return -EFAULT;
-	error = hib_submit_io(REQ_OP_READ, 0, offset, buf, hb);
+	error = hib_submit_io(REQ_OP_READ, offset, buf, hb);
 	if (error)
 		return error;
 	if (++handle->k >= MAP_PAGE_ENTRIES) {
 	if (!IS_ERR(hib_resume_bdev)) {
 		set_blocksize(hib_resume_bdev, PAGE_SIZE);
 		clear_page(swsusp_header);
-		error = hib_submit_io(REQ_OP_READ, 0,
+		error = hib_submit_io(REQ_OP_READ, swsusp_resume_block,
-					swsusp_resume_block,
 					swsusp_header, NULL);
 		if (error)
 			goto put;
 		if (!memcmp(HIBERNATE_SIG, swsusp_header->sig, 10)) {
 			memcpy(swsusp_header->sig, swsusp_header->orig_sig, 10);
 			/* Reset swap signature now */
-			error = hib_submit_io(REQ_OP_WRITE, REQ_SYNC,
+			error = hib_submit_io(REQ_OP_WRITE | REQ_SYNC,
 						swsusp_resume_block,
 						swsusp_header, NULL);
 		} else {
 {
 	int error;
-	hib_submit_io(REQ_OP_READ, 0, swsusp_resume_block,
+	hib_submit_io(REQ_OP_READ, swsusp_resume_block,
-		      swsusp_header, NULL);
+			swsusp_header, NULL);
 	if (!memcmp(HIBERNATE_SIG,swsusp_header->sig, 10)) {
 		memcpy(swsusp_header->sig,swsusp_header->orig_sig, 10);
-		error = hib_submit_io(REQ_OP_WRITE, REQ_SYNC,
+		error = hib_submit_io(REQ_OP_WRITE | REQ_SYNC,
 					swsusp_resume_block,
 					swsusp_header, NULL);
 	} else {

kernel/trace/blktrace.c+30−42

 #define BLK_TC_PREFLUSH		BLK_TC_FLUSH
 /* The ilog2() calls fall out because they're constant */
-#define MASK_TC_BIT(rw, __name) ((rw & REQ_ ## __name) << \
+#define MASK_TC_BIT(rw, __name) ((__force u32)(rw & REQ_ ## __name) <<	\
 	  (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - __REQ_ ## __name))
 /*
  * blk_io_trace structure and places it in a per-cpu subbuffer.
  */
 static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
-		     int op, int op_flags, u32 what, int error, int pdu_len,
+			    const blk_opf_t opf, u32 what, int error,
-		     void *pdu_data, u64 cgid)
+			    int pdu_len, void *pdu_data, u64 cgid)
 {
 	struct task_struct *tsk = current;
 	struct ring_buffer_event *event = NULL;
 	int cpu;
 	bool blk_tracer = blk_tracer_enabled;
 	ssize_t cgid_len = cgid ? sizeof(cgid) : 0;
+	const enum req_op op = opf & REQ_OP_MASK;
 	if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))
 		return;
 	what |= ddir_act[op_is_write(op) ? WRITE : READ];
-	what |= MASK_TC_BIT(op_flags, SYNC);
+	what |= MASK_TC_BIT(opf, SYNC);
-	what |= MASK_TC_BIT(op_flags, RAHEAD);
+	what |= MASK_TC_BIT(opf, RAHEAD);
-	what |= MASK_TC_BIT(op_flags, META);
+	what |= MASK_TC_BIT(opf, META);
-	what |= MASK_TC_BIT(op_flags, PREFLUSH);
+	what |= MASK_TC_BIT(opf, PREFLUSH);
-	what |= MASK_TC_BIT(op_flags, FUA);
+	what |= MASK_TC_BIT(opf, FUA);
 	if (op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE)
 		what |= BLK_TC_ACT(BLK_TC_DISCARD);
 	if (op == REQ_OP_FLUSH)
 	switch (cmd) {
 	case BLKTRACESETUP:
-		bdevname(bdev, b);
+		snprintf(b, sizeof(b), "%pg", bdev);
 		ret = __blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
 		break;
 #if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
 	case BLKTRACESETUP32:
-		bdevname(bdev, b);
+		snprintf(b, sizeof(b), "%pg", bdev);
 		ret = compat_blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
 		break;
 #endif
 	else
 		what |= BLK_TC_ACT(BLK_TC_FS);
-	__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes, req_op(rq),
+	__blk_add_trace(bt, blk_rq_trace_sector(rq), nr_bytes, rq->cmd_flags,
-			rq->cmd_flags, what, blk_status_to_errno(error), 0,
+			what, blk_status_to_errno(error), 0, NULL, cgid);
-			NULL, cgid);
 	rcu_read_unlock();
 }
 	}
 	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-			bio_op(bio), bio->bi_opf, what, error, 0, NULL,
+			bio->bi_opf, what, error, 0, NULL,
 			blk_trace_bio_get_cgid(q, bio));
 	rcu_read_unlock();
 }
 	rcu_read_lock();
 	bt = rcu_dereference(q->blk_trace);
 	if (bt)
-		__blk_add_trace(bt, 0, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0);
+		__blk_add_trace(bt, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL, 0);
 	rcu_read_unlock();
 }
 		else
 			what = BLK_TA_UNPLUG_TIMER;
-		__blk_add_trace(bt, 0, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu, 0);
+		__blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu, 0);
 	}
 	rcu_read_unlock();
 }
 		__be64 rpdu = cpu_to_be64(pdu);
 		__blk_add_trace(bt, bio->bi_iter.bi_sector,
-				bio->bi_iter.bi_size, bio_op(bio), bio->bi_opf,
+				bio->bi_iter.bi_size, bio->bi_opf, BLK_TA_SPLIT,
-				BLK_TA_SPLIT,
 				blk_status_to_errno(bio->bi_status),
 				sizeof(rpdu), &rpdu,
 				blk_trace_bio_get_cgid(q, bio));
 	r.sector_from = cpu_to_be64(from);
 	__blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
-			bio_op(bio), bio->bi_opf, BLK_TA_REMAP,
+			bio->bi_opf, BLK_TA_REMAP,
 			blk_status_to_errno(bio->bi_status),
 			sizeof(r), &r, blk_trace_bio_get_cgid(q, bio));
 	rcu_read_unlock();
 	r.sector_from = cpu_to_be64(from);
 	__blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq),
-			rq_data_dir(rq), 0, BLK_TA_REMAP, 0,
+			rq->cmd_flags, BLK_TA_REMAP, 0,
 			sizeof(r), &r, blk_trace_request_get_cgid(rq));
 	rcu_read_unlock();
 }
 		return;
 	}
-	__blk_add_trace(bt, blk_rq_trace_sector(rq), blk_rq_bytes(rq), 0, 0,
+	__blk_add_trace(bt, blk_rq_trace_sector(rq), blk_rq_bytes(rq), 0,
 				BLK_TA_DRV_DATA, 0, len, data,
 				blk_trace_request_get_cgid(rq));
 	rcu_read_unlock();
 out:
 	return ret ? ret : count;
 }
-int blk_trace_init_sysfs(struct device *dev)
-{
-	return sysfs_create_group(&dev->kobj, &blk_trace_attr_group);
-}
-void blk_trace_remove_sysfs(struct device *dev)
-{
-	sysfs_remove_group(&dev->kobj, &blk_trace_attr_group);
-}
 #endif /* CONFIG_BLK_DEV_IO_TRACE */
 #ifdef CONFIG_EVENT_TRACING
 /**
  * blk_fill_rwbs - Fill the buffer rwbs by mapping op to character string.
  * @rwbs:	buffer to be filled
- * @op:		REQ_OP_XXX for the tracepoint
+ * @opf:	request operation type (REQ_OP_XXX) and flags for the tracepoint
  *
  * Description:
- *     Maps the REQ_OP_XXX to character and fills the buffer provided by the
+ *     Maps each request operation and flag to a single character and fills the
- *     caller with resulting string.
+ *     buffer provided by the caller with resulting string.
  *
  **/
-void blk_fill_rwbs(char *rwbs, unsigned int op)
+void blk_fill_rwbs(char *rwbs, blk_opf_t opf)
 {
 	int i = 0;
-	if (op & REQ_PREFLUSH)
+	if (opf & REQ_PREFLUSH)
 		rwbs[i++] = 'F';
-	switch (op & REQ_OP_MASK) {
+	switch (opf & REQ_OP_MASK) {
 	case REQ_OP_WRITE:
 		rwbs[i++] = 'W';
 		break;
 		rwbs[i++] = 'N';
 	}
-	if (op & REQ_FUA)
+	if (opf & REQ_FUA)
 		rwbs[i++] = 'F';
-	if (op & REQ_RAHEAD)
+	if (opf & REQ_RAHEAD)
 		rwbs[i++] = 'A';
-	if (op & REQ_SYNC)
+	if (opf & REQ_SYNC)
 		rwbs[i++] = 'S';
-	if (op & REQ_META)
+	if (opf & REQ_META)
 		rwbs[i++] = 'M';
 	rwbs[i] = '\0';

lib/iov_iter.c+92−0

@@ -1268,6 +1268,98 @@ void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count) · 1267 unmodified lines
1268	}	1268	}
1269	EXPORT_SYMBOL(iov_iter_discard);	1269	EXPORT_SYMBOL(iov_iter_discard);
1270		1270
		1271	static bool iov_iter_aligned_iovec(const struct iov_iter *i, unsigned addr_mask,
		1272	unsigned len_mask)
		1273	{
		1274	size_t size = i->count;
		1275	size_t skip = i->iov_offset;
		1276	unsigned k;
		1277
		1278	for (k = 0; k < i->nr_segs; k++, skip = 0) {
		1279	size_t len = i->iov[k].iov_len - skip;
		1280
		1281	if (len > size)
		1282	len = size;
		1283	if (len & len_mask)
		1284	return false;
		1285	if ((unsigned long)(i->iov[k].iov_base + skip) & addr_mask)
		1286	return false;
		1287
		1288	size -= len;
		1289	if (!size)
		1290	break;
		1291	}
		1292	return true;
		1293	}
		1294
		1295	static bool iov_iter_aligned_bvec(const struct iov_iter *i, unsigned addr_mask,
		1296	unsigned len_mask)
		1297	{
		1298	size_t size = i->count;
		1299	unsigned skip = i->iov_offset;
		1300	unsigned k;
		1301
		1302	for (k = 0; k < i->nr_segs; k++, skip = 0) {
		1303	size_t len = i->bvec[k].bv_len - skip;
		1304
		1305	if (len > size)
		1306	len = size;
		1307	if (len & len_mask)
		1308	return false;
		1309	if ((unsigned long)(i->bvec[k].bv_offset + skip) & addr_mask)
		1310	return false;
		1311
		1312	size -= len;
		1313	if (!size)
		1314	break;
		1315	}
		1316	return true;
		1317	}
		1318
		1319	/**
		1320	* iov_iter_is_aligned() - Check if the addresses and lengths of each segments
		1321	* are aligned to the parameters.
		1322	*
		1323	* @i: &struct iov_iter to restore
		1324	* @addr_mask: bit mask to check against the iov element's addresses
		1325	* @len_mask: bit mask to check against the iov element's lengths
		1326	*
		1327	* Return: false if any addresses or lengths intersect with the provided masks
		1328	*/
		1329	bool iov_iter_is_aligned(const struct iov_iter *i, unsigned addr_mask,
		1330	unsigned len_mask)
		1331	{
		1332	if (likely(iter_is_iovec(i) \|\| iov_iter_is_kvec(i)))
		1333	return iov_iter_aligned_iovec(i, addr_mask, len_mask);
		1334
		1335	if (iov_iter_is_bvec(i))
		1336	return iov_iter_aligned_bvec(i, addr_mask, len_mask);
		1337
		1338	if (iov_iter_is_pipe(i)) {
		1339	unsigned int p_mask = i->pipe->ring_size - 1;
		1340	size_t size = i->count;
		1341
		1342	if (size & len_mask)
		1343	return false;
		1344	if (size && allocated(&i->pipe->bufs[i->head & p_mask])) {
		1345	if (i->iov_offset & addr_mask)
		1346	return false;
		1347	}
		1348
		1349	return true;
		1350	}
		1351
		1352	if (iov_iter_is_xarray(i)) {
		1353	if (i->count & len_mask)
		1354	return false;
		1355	if ((i->xarray_start + i->iov_offset) & addr_mask)
		1356	return false;
		1357	}
		1358
		1359	return true;
		1360	}
		1361	EXPORT_SYMBOL_GPL(iov_iter_is_aligned);
		1362
1271	static unsigned long iov_iter_alignment_iovec(const struct iov_iter *i)	1363	static unsigned long iov_iter_alignment_iovec(const struct iov_iter *i)
1272	{	1364	{
1273	unsigned long res = 0;	1365	unsigned long res = 0;