* [PATCH 01/51] treewide: Rename enum req_opf into enum req_op
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 02/51] block: Use enum req_op where appropriate Bart Van Assche
` (50 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
The type name enum req_opf is misleading since it suggests that values of
this type include both an operation type and flags. Since values of this
type represent an operation only, change the type name into enum req_op.
Convert the enum req_op documentation into kernel-doc format. Move a few
definitions such that the enum req_op documentation occurs just above
the enum req_op definition.
The name "req_opf" was introduced by commit ef295ecf090d ("block: better op
and flags encoding").
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
block/blk-zoned.c | 7 +++----
drivers/block/null_blk/main.c | 9 ++++-----
drivers/block/null_blk/null_blk.h | 12 +++++-------
drivers/block/null_blk/trace.h | 2 +-
drivers/block/null_blk/zoned.c | 4 ++--
drivers/md/dm-integrity.c | 2 +-
drivers/nvme/target/zns.c | 4 ++--
drivers/scsi/sd_zbc.c | 2 +-
drivers/ufs/core/ufshpb.c | 5 ++---
fs/zonefs/super.c | 5 ++---
fs/zonefs/trace.h | 2 +-
include/linux/blk_types.h | 16 ++++++++--------
include/linux/blkdev.h | 2 +-
13 files changed, 33 insertions(+), 39 deletions(-)
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index 38cd840d8838..ac0b9dfd2321 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -257,9 +257,8 @@ static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
* 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,
- sector_t sector, sector_t nr_sectors,
- gfp_t gfp_mask)
+int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
+ sector_t sector, sector_t nr_sectors, gfp_t gfp_mask)
{
struct request_queue *q = bdev_get_queue(bdev);
sector_t zone_sectors = blk_queue_zone_sectors(q);
@@ -398,7 +397,7 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
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)
diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
index 6b67088f4ea7..d5b0412830e0 100644
--- a/drivers/block/null_blk/main.c
+++ b/drivers/block/null_blk/main.c
@@ -1310,7 +1310,7 @@ static inline blk_status_t null_handle_badblocks(struct nullb_cmd *cmd,
}
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)
{
@@ -1381,9 +1381,8 @@ static inline void nullb_complete_cmd(struct nullb_cmd *cmd)
}
}
-blk_status_t null_process_cmd(struct nullb_cmd *cmd,
- enum req_opf op, sector_t sector,
- unsigned int nr_sectors)
+blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
+ sector_t sector, unsigned int nr_sectors)
{
struct nullb_device *dev = cmd->nq->dev;
blk_status_t ret;
@@ -1401,7 +1400,7 @@ blk_status_t null_process_cmd(struct nullb_cmd *cmd,
}
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;
diff --git a/drivers/block/null_blk/null_blk.h b/drivers/block/null_blk/null_blk.h
index 8359b43842f2..6fbf0a1b2622 100644
--- a/drivers/block/null_blk/null_blk.h
+++ b/drivers/block/null_blk/null_blk.h
@@ -136,9 +136,8 @@ struct nullb {
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,
- enum req_opf op, sector_t sector,
- unsigned int nr_sectors);
+blk_status_t null_process_cmd(struct nullb_cmd *cmd, enum req_op op,
+ sector_t sector, unsigned int nr_sectors);
#ifdef CONFIG_BLK_DEV_ZONED
int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q);
@@ -146,9 +145,8 @@ int null_register_zoned_dev(struct nullb *nullb);
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,
- enum req_opf op, sector_t sector,
- sector_t nr_sectors);
+blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
+ sector_t sector, sector_t nr_sectors);
size_t null_zone_valid_read_len(struct nullb *nullb,
sector_t sector, unsigned int len);
#else
@@ -164,7 +162,7 @@ static inline int null_register_zoned_dev(struct nullb *nullb)
}
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;
}
diff --git a/drivers/block/null_blk/trace.h b/drivers/block/null_blk/trace.h
index 86d6c12c603c..6b2b370e786f 100644
--- a/drivers/block/null_blk/trace.h
+++ b/drivers/block/null_blk/trace.h
@@ -36,7 +36,7 @@ TRACE_EVENT(nullb_zone_op,
TP_ARGS(cmd, zone_no, zone_cond),
TP_STRUCT__entry(
__array(char, disk, DISK_NAME_LEN)
- __field(enum req_opf, op)
+ __field(enum req_op, op)
__field(unsigned int, zone_no)
__field(unsigned int, zone_cond)
),
diff --git a/drivers/block/null_blk/zoned.c b/drivers/block/null_blk/zoned.c
index 2fdd7b20c224..99f45bb85080 100644
--- a/drivers/block/null_blk/zoned.c
+++ b/drivers/block/null_blk/zoned.c
@@ -600,7 +600,7 @@ static blk_status_t null_reset_zone(struct nullb_device *dev,
return BLK_STS_OK;
}
-static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_opf op,
+static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op,
sector_t sector)
{
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,
return ret;
}
-blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_opf op,
+blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op,
sector_t sector, sector_t nr_sectors)
{
struct nullb_device *dev;
diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index 3d5a0ce123c9..148978ad03a8 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -298,7 +298,7 @@ struct dm_integrity_io {
struct work_struct work;
struct dm_integrity_c *ic;
- enum req_opf op;
+ enum req_op op;
bool fua;
struct dm_integrity_range range;
diff --git a/drivers/nvme/target/zns.c b/drivers/nvme/target/zns.c
index 82b61acf7a72..62afb7936132 100644
--- a/drivers/nvme/target/zns.c
+++ b/drivers/nvme/target/zns.c
@@ -308,7 +308,7 @@ void nvmet_bdev_execute_zone_mgmt_recv(struct nvmet_req *req)
queue_work(zbd_wq, &req->z.zmgmt_work);
}
-static inline enum req_opf zsa_req_op(u8 zsa)
+static inline enum req_op zsa_req_op(u8 zsa)
{
switch (zsa) {
case NVME_ZONE_OPEN:
@@ -465,7 +465,7 @@ static void nvmet_bdev_zmgmt_send_work(struct work_struct *w)
{
struct nvmet_req *req = container_of(w, struct nvmet_req, z.zmgmt_work);
sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->zms.slba);
- enum req_opf op = zsa_req_op(req->cmd->zms.zsa);
+ enum req_op op = zsa_req_op(req->cmd->zms.zsa);
struct block_device *bdev = req->ns->bdev;
sector_t zone_sectors = bdev_zone_sectors(bdev);
u16 status = NVME_SC_SUCCESS;
diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index 6acc4f406eb8..6d3658e36c84 100644
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -529,7 +529,7 @@ static unsigned int sd_zbc_zone_wp_update(struct scsi_cmnd *cmd,
struct request *rq = scsi_cmd_to_rq(cmd);
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
unsigned int zno = blk_rq_zone_no(rq);
- enum req_opf op = req_op(rq);
+ enum req_op op = req_op(rq);
unsigned long flags;
/*
diff --git a/drivers/ufs/core/ufshpb.c b/drivers/ufs/core/ufshpb.c
index de2bb8401bc4..24f1ee82c215 100644
--- a/drivers/ufs/core/ufshpb.c
+++ b/drivers/ufs/core/ufshpb.c
@@ -433,9 +433,8 @@ int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
return 0;
}
-static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb,
- int rgn_idx, enum req_opf dir,
- bool atomic)
+static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb, int rgn_idx,
+ enum req_op dir, bool atomic)
{
struct ufshpb_req *rq;
struct request *req;
diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
index 053299758deb..59e77992443c 100644
--- a/fs/zonefs/super.c
+++ b/fs/zonefs/super.c
@@ -60,8 +60,7 @@ static void zonefs_account_active(struct inode *inode)
}
}
-static inline int zonefs_zone_mgmt(struct inode *inode,
- enum req_opf op)
+static inline int zonefs_zone_mgmt(struct inode *inode, enum req_op op)
{
struct zonefs_inode_info *zi = ZONEFS_I(inode);
int ret;
@@ -525,7 +524,7 @@ static int zonefs_file_truncate(struct inode *inode, loff_t isize)
{
struct zonefs_inode_info *zi = ZONEFS_I(inode);
loff_t old_isize;
- enum req_opf op;
+ enum req_op op;
int ret = 0;
/*
diff --git a/fs/zonefs/trace.h b/fs/zonefs/trace.h
index f369d7d50303..21501da764bd 100644
--- a/fs/zonefs/trace.h
+++ b/fs/zonefs/trace.h
@@ -20,7 +20,7 @@
#define show_dev(dev) MAJOR(dev), MINOR(dev)
TRACE_EVENT(zonefs_zone_mgmt,
- TP_PROTO(struct inode *inode, enum req_opf op),
+ TP_PROTO(struct inode *inode, enum req_op op),
TP_ARGS(inode, op),
TP_STRUCT__entry(
__field(dev_t, dev)
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index a24d4078fb21..0e6a2af7ed3d 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -337,8 +337,12 @@ enum {
typedef __u32 __bitwise blk_mq_req_flags_t;
-/*
- * Operations and flags common to the bio and request structures.
+#define REQ_OP_BITS 8
+#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1)
+#define REQ_FLAG_BITS 24
+
+/**
+ * enum req_op - Operations common to the bio and request structures.
* We use 8 bits for encoding the operation, and the remaining 24 for flags.
*
* The least significant bit of the operation number indicates the data
@@ -350,11 +354,7 @@ typedef __u32 __bitwise blk_mq_req_flags_t;
* If a operation does not transfer data the least significant bit has no
* meaning.
*/
-#define REQ_OP_BITS 8
-#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1)
-#define REQ_FLAG_BITS 24
-
-enum req_opf {
+enum req_op {
/* read sectors from the device */
REQ_OP_READ = 0,
/* write sectors to the device */
@@ -509,7 +509,7 @@ static inline bool op_is_discard(unsigned int op)
* due to its different handling in the block layer and device response in
* case of command failure.
*/
-static inline bool op_is_zone_mgmt(enum req_opf op)
+static inline bool op_is_zone_mgmt(enum req_op op)
{
switch (op & REQ_OP_MASK) {
case REQ_OP_ZONE_RESET:
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 92b3bffad328..94ceed805e76 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -292,7 +292,7 @@ void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model);
int blkdev_report_zones(struct block_device *bdev, sector_t sector,
unsigned int nr_zones, report_zones_cb cb, void *data);
unsigned int blkdev_nr_zones(struct gendisk *disk);
-extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
+extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
sector_t sectors, sector_t nr_sectors,
gfp_t gfp_mask);
int blk_revalidate_disk_zones(struct gendisk *disk,
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 02/51] block: Use enum req_op where appropriate
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
2022-06-23 18:04 ` [PATCH 01/51] treewide: Rename enum req_opf into enum req_op Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 03/51] block: Change the type of the last .rw_page() argument Bart Van Assche
` (49 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Change the type of the arguments that are used to pass a REQ_OP_* value
from int or unsigned int into enum req_op to improve static type
checking.
Note: the type of the blk_mq_alloc_request() 'op' argument is not
modified by this patch since at least once caller passes an operation
and flags in this argument.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
block/blk-core.c | 6 +++---
block/blk-mq-debugfs.c | 2 +-
block/blk-mq.c | 2 +-
block/blk-wbt.c | 2 +-
block/blk.h | 2 +-
include/linux/blk-mq.h | 2 +-
include/linux/blk_types.h | 2 +-
include/linux/blkdev.h | 6 +++---
8 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/block/blk-core.c b/block/blk-core.c
index eb86c756a7fd..9d420dff90f6 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -136,7 +136,7 @@ static const char *const blk_op_name[] = {
* 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";
@@ -1010,7 +1010,7 @@ void update_io_ticks(struct block_device *part, unsigned long now, bool end)
}
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);
@@ -1051,7 +1051,7 @@ unsigned long bio_start_io_acct(struct bio *bio)
}
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);
diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index 7e4136a60e1c..df0b9a458f34 100644
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -306,7 +306,7 @@ static const char *blk_mq_rq_state_name(enum mq_rq_state rq_state)
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);
diff --git a/block/blk-mq.c b/block/blk-mq.c
index f5cce377f1a8..50fc1194ebc0 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -538,7 +538,7 @@ struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
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)
+ enum req_op op, blk_mq_req_flags_t flags, unsigned int hctx_idx)
{
struct blk_mq_alloc_data data = {
.q = q,
diff --git a/block/blk-wbt.c b/block/blk-wbt.c
index 0c119be0e813..7bf09ae06577 100644
--- a/block/blk-wbt.c
+++ b/block/blk-wbt.c
@@ -670,7 +670,7 @@ u64 wbt_default_latency_nsec(struct request_queue *q)
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;
diff --git a/block/blk.h b/block/blk.h
index 8e79296ee97a..13b43fb28b9f 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -160,7 +160,7 @@ static inline bool blk_discard_mergable(struct request *req)
}
static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
- int op)
+ enum req_op op)
{
if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE))
return min(q->limits.max_discard_sectors,
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index e2d9daf7e8dd..45d69cc46dc7 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -713,7 +713,7 @@ enum {
struct request *blk_mq_alloc_request(struct request_queue *q, unsigned int op,
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,
+ enum req_op op, blk_mq_req_flags_t flags,
unsigned int hctx_idx);
/*
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 0e6a2af7ed3d..cce8768bc00b 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -522,7 +522,7 @@ static inline bool op_is_zone_mgmt(enum req_op op)
}
}
-static inline int op_stat_group(unsigned int op)
+static inline int op_stat_group(enum req_op op)
{
if (op_is_discard(op))
return STAT_DISCARD;
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 94ceed805e76..3f8ee0608d60 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -886,7 +886,7 @@ extern void blk_queue_exit(struct request_queue *q);
extern void blk_sync_queue(struct request_queue *q);
/* Helper to convert REQ_OP_XXX to its string format XXX */
-extern const char *blk_op_str(unsigned int op);
+extern const char *blk_op_str(enum req_op op);
int blk_status_to_errno(blk_status_t status);
blk_status_t errno_to_blk_status(int errno);
@@ -1472,9 +1472,9 @@ static inline void blk_wake_io_task(struct task_struct *waiter)
}
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);
-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);
void bio_start_io_acct_time(struct bio *bio, unsigned long start_time);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 03/51] block: Change the type of the last .rw_page() argument
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
2022-06-23 18:04 ` [PATCH 01/51] treewide: Rename enum req_opf into enum req_op Bart Van Assche
2022-06-23 18:04 ` [PATCH 02/51] block: Use enum req_op where appropriate Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 04/51] block: Change the type of req_op() and bio_op() into enum req_op Bart Van Assche
` (48 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Tejun Heo,
Minchan Kim, Dan Williams
All .rw_page() callers pass an enum req_op value as last argument. Make
this explicit by changing the type of the last argument into enum req_op.
See also commit 3f289dcb4b26 ("block: make bdev_ops->rw_page() take a
REQ_OP instead of bool").
Cc: Tejun Heo <tj@kernel.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/block/brd.c | 2 +-
drivers/block/zram/zram_drv.c | 2 +-
drivers/nvdimm/btt.c | 2 +-
drivers/nvdimm/pmem.c | 2 +-
include/linux/blkdev.h | 2 +-
5 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 6e3f2f0d2352..c3d772bdd89f 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -310,7 +310,7 @@ static void brd_submit_bio(struct bio *bio)
}
static int brd_rw_page(struct block_device *bdev, sector_t sector,
- struct page *page, unsigned int op)
+ struct page *page, enum req_op op)
{
struct brd_device *brd = bdev->bd_disk->private_data;
int err;
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index b8549c61ff2c..481b06a50ab1 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -1631,7 +1631,7 @@ static void zram_slot_free_notify(struct block_device *bdev,
}
static int zram_rw_page(struct block_device *bdev, sector_t sector,
- struct page *page, unsigned int op)
+ struct page *page, enum req_op op)
{
int offset, ret;
u32 index;
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index 9613e54c7a67..143b98e39c38 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1483,7 +1483,7 @@ static void btt_submit_bio(struct bio *bio)
}
static int btt_rw_page(struct block_device *bdev, sector_t sector,
- struct page *page, unsigned int op)
+ struct page *page, enum req_op op)
{
struct btt *btt = bdev->bd_disk->private_data;
int rc;
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 629d10fcf53b..ed58cbe9550f 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -239,7 +239,7 @@ static void pmem_submit_bio(struct bio *bio)
}
static int pmem_rw_page(struct block_device *bdev, sector_t sector,
- struct page *page, unsigned int op)
+ struct page *page, enum req_op op)
{
struct pmem_device *pmem = bdev->bd_disk->private_data;
blk_status_t rc;
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 3f8ee0608d60..de47b0e0e18f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1419,7 +1419,7 @@ struct block_device_operations {
unsigned int flags);
int (*open) (struct block_device *, fmode_t);
void (*release) (struct gendisk *, fmode_t);
- int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int);
+ int (*rw_page)(struct block_device *, sector_t, struct page *, enum req_op);
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
unsigned int (*check_events) (struct gendisk *disk,
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 04/51] block: Change the type of req_op() and bio_op() into enum req_op
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (2 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 03/51] block: Change the type of the last .rw_page() argument Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 05/51] block: Introduce the type blk_opf_t Bart Van Assche
` (47 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Improve static type checking by changing the type of the value returned by
req_op() and bio_op() from unsigned int into enum req_op. Insert
'default: break;' in switch statements on the enum req_op type to prevent
that the compiler warns about these switch statements.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
block/blk-merge.c | 2 ++
drivers/block/paride/pd.c | 2 ++
drivers/md/dm.c | 2 ++
include/linux/blk-mq.h | 6 ++++--
include/linux/blk_types.h | 6 ++++--
5 files changed, 14 insertions(+), 4 deletions(-)
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 0f5f42ebd0bb..9d96c9239219 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -405,6 +405,8 @@ unsigned int blk_recalc_rq_segments(struct request *rq)
return 1;
case REQ_OP_WRITE_ZEROES:
return 0;
+ default:
+ break;
}
rq_for_each_bvec(bv, rq, iter)
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 3637c38c72f9..a186f5bf235e 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -501,6 +501,8 @@ static enum action do_pd_io_start(void)
return do_pd_read_start();
else
return do_pd_write_start();
+ default:
+ break;
}
return Fail;
}
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 789f48e1a0e5..bed7ad573f79 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1539,6 +1539,8 @@ static blk_status_t __process_abnormal_io(struct clone_info *ci,
case REQ_OP_WRITE_ZEROES:
num_bios = ti->num_write_zeroes_bios;
break;
+ default:
+ break;
}
/*
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 45d69cc46dc7..9a1838bbed02 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -197,8 +197,10 @@ struct request {
void *end_io_data;
};
-#define req_op(req) \
- ((req)->cmd_flags & REQ_OP_MASK)
+static inline enum req_op req_op(const struct request *req)
+{
+ return req->cmd_flags & REQ_OP_MASK;
+}
static inline bool blk_rq_is_passthrough(struct request *rq)
{
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index cce8768bc00b..e66cbe377ae8 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -463,8 +463,10 @@ enum stat_group {
NR_STAT_GROUPS
};
-#define bio_op(bio) \
- ((bio)->bi_opf & REQ_OP_MASK)
+static inline enum req_op bio_op(const struct bio *bio)
+{
+ return bio->bi_opf & REQ_OP_MASK;
+}
/* obsolete, don't use in new code */
static inline void bio_set_op_attrs(struct bio *bio, unsigned op,
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 05/51] block: Introduce the type blk_opf_t
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (3 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 04/51] block: Change the type of req_op() and bio_op() into enum req_op Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 06/51] block: Use the new blk_opf_t type Bart Van Assche
` (46 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Introduce the type blk_opf_t for the request operation and flags (REQ_OP_*
and REQ_*). This type will be used to improve documentation of the block
layer code and also to allow sparse to verify whether request flags are used
correctly.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
include/linux/blk_types.h | 97 ++++++++++++++++++++-------------------
1 file changed, 51 insertions(+), 46 deletions(-)
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index e66cbe377ae8..1ef99790f6ed 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -240,6 +240,8 @@ static inline void bio_issue_init(struct bio_issue *issue,
((u64)size << BIO_ISSUE_SIZE_SHIFT));
}
+typedef __u32 __bitwise blk_opf_t;
+
typedef unsigned int blk_qc_t;
#define BLK_QC_T_NONE -1U
@@ -250,7 +252,7 @@ typedef unsigned int blk_qc_t;
struct bio {
struct bio *bi_next; /* request queue link */
struct block_device *bi_bdev;
- unsigned int bi_opf; /* bottom bits REQ_OP, top bits
+ blk_opf_t bi_opf; /* bottom bits REQ_OP, top bits
* req_flags.
*/
unsigned short bi_flags; /* BIO_* below */
@@ -338,7 +340,7 @@ enum {
typedef __u32 __bitwise blk_mq_req_flags_t;
#define REQ_OP_BITS 8
-#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1)
+#define REQ_OP_MASK (__force blk_opf_t)((1 << REQ_OP_BITS) - 1)
#define REQ_FLAG_BITS 24
/**
@@ -356,35 +358,35 @@ typedef __u32 __bitwise blk_mq_req_flags_t;
*/
enum req_op {
/* read sectors from the device */
- REQ_OP_READ = 0,
+ REQ_OP_READ = (__force blk_opf_t)0,
/* write sectors to the device */
- REQ_OP_WRITE = 1,
+ REQ_OP_WRITE = (__force blk_opf_t)1,
/* flush the volatile write cache */
- REQ_OP_FLUSH = 2,
+ REQ_OP_FLUSH = (__force blk_opf_t)2,
/* discard sectors */
- REQ_OP_DISCARD = 3,
+ REQ_OP_DISCARD = (__force blk_opf_t)3,
/* securely erase sectors */
- REQ_OP_SECURE_ERASE = 5,
+ REQ_OP_SECURE_ERASE = (__force blk_opf_t)5,
/* write the zero filled sector many times */
- REQ_OP_WRITE_ZEROES = 9,
+ REQ_OP_WRITE_ZEROES = (__force blk_opf_t)9,
/* Open a zone */
- REQ_OP_ZONE_OPEN = 10,
+ REQ_OP_ZONE_OPEN = (__force blk_opf_t)10,
/* Close a zone */
- REQ_OP_ZONE_CLOSE = 11,
+ REQ_OP_ZONE_CLOSE = (__force blk_opf_t)11,
/* Transition a zone to full */
- REQ_OP_ZONE_FINISH = 12,
+ REQ_OP_ZONE_FINISH = (__force blk_opf_t)12,
/* write data at the current zone write pointer */
- REQ_OP_ZONE_APPEND = 13,
+ REQ_OP_ZONE_APPEND = (__force blk_opf_t)13,
/* reset a zone write pointer */
- REQ_OP_ZONE_RESET = 15,
+ REQ_OP_ZONE_RESET = (__force blk_opf_t)15,
/* reset all the zone present on the device */
- REQ_OP_ZONE_RESET_ALL = 17,
+ REQ_OP_ZONE_RESET_ALL = (__force blk_opf_t)17,
/* Driver private requests */
- REQ_OP_DRV_IN = 34,
- REQ_OP_DRV_OUT = 35,
+ REQ_OP_DRV_IN = (__force blk_opf_t)34,
+ REQ_OP_DRV_OUT = (__force blk_opf_t)35,
- REQ_OP_LAST,
+ REQ_OP_LAST = (__force blk_opf_t)36,
};
enum req_flag_bits {
@@ -425,28 +427,31 @@ enum req_flag_bits {
__REQ_NR_BITS, /* stops here */
};
-#define REQ_FAILFAST_DEV (1ULL << __REQ_FAILFAST_DEV)
-#define REQ_FAILFAST_TRANSPORT (1ULL << __REQ_FAILFAST_TRANSPORT)
-#define REQ_FAILFAST_DRIVER (1ULL << __REQ_FAILFAST_DRIVER)
-#define REQ_SYNC (1ULL << __REQ_SYNC)
-#define REQ_META (1ULL << __REQ_META)
-#define REQ_PRIO (1ULL << __REQ_PRIO)
-#define REQ_NOMERGE (1ULL << __REQ_NOMERGE)
-#define REQ_IDLE (1ULL << __REQ_IDLE)
-#define REQ_INTEGRITY (1ULL << __REQ_INTEGRITY)
-#define REQ_FUA (1ULL << __REQ_FUA)
-#define REQ_PREFLUSH (1ULL << __REQ_PREFLUSH)
-#define REQ_RAHEAD (1ULL << __REQ_RAHEAD)
-#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND)
-#define REQ_NOWAIT (1ULL << __REQ_NOWAIT)
-#define REQ_CGROUP_PUNT (1ULL << __REQ_CGROUP_PUNT)
-
-#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP)
-#define REQ_POLLED (1ULL << __REQ_POLLED)
-#define REQ_ALLOC_CACHE (1ULL << __REQ_ALLOC_CACHE)
-
-#define REQ_DRV (1ULL << __REQ_DRV)
-#define REQ_SWAP (1ULL << __REQ_SWAP)
+#define REQ_FAILFAST_DEV \
+ (__force blk_opf_t)(1ULL << __REQ_FAILFAST_DEV)
+#define REQ_FAILFAST_TRANSPORT \
+ (__force blk_opf_t)(1ULL << __REQ_FAILFAST_TRANSPORT)
+#define REQ_FAILFAST_DRIVER \
+ (__force blk_opf_t)(1ULL << __REQ_FAILFAST_DRIVER)
+#define REQ_SYNC (__force blk_opf_t)(1ULL << __REQ_SYNC)
+#define REQ_META (__force blk_opf_t)(1ULL << __REQ_META)
+#define REQ_PRIO (__force blk_opf_t)(1ULL << __REQ_PRIO)
+#define REQ_NOMERGE (__force blk_opf_t)(1ULL << __REQ_NOMERGE)
+#define REQ_IDLE (__force blk_opf_t)(1ULL << __REQ_IDLE)
+#define REQ_INTEGRITY (__force blk_opf_t)(1ULL << __REQ_INTEGRITY)
+#define REQ_FUA (__force blk_opf_t)(1ULL << __REQ_FUA)
+#define REQ_PREFLUSH (__force blk_opf_t)(1ULL << __REQ_PREFLUSH)
+#define REQ_RAHEAD (__force blk_opf_t)(1ULL << __REQ_RAHEAD)
+#define REQ_BACKGROUND (__force blk_opf_t)(1ULL << __REQ_BACKGROUND)
+#define REQ_NOWAIT (__force blk_opf_t)(1ULL << __REQ_NOWAIT)
+#define REQ_CGROUP_PUNT (__force blk_opf_t)(1ULL << __REQ_CGROUP_PUNT)
+
+#define REQ_NOUNMAP (__force blk_opf_t)(1ULL << __REQ_NOUNMAP)
+#define REQ_POLLED (__force blk_opf_t)(1ULL << __REQ_POLLED)
+#define REQ_ALLOC_CACHE (__force blk_opf_t)(1ULL << __REQ_ALLOC_CACHE)
+
+#define REQ_DRV (__force blk_opf_t)(1ULL << __REQ_DRV)
+#define REQ_SWAP (__force blk_opf_t)(1ULL << __REQ_SWAP)
#define REQ_FAILFAST_MASK \
(REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
@@ -469,22 +474,22 @@ static inline enum req_op bio_op(const struct bio *bio)
}
/* obsolete, don't use in new code */
-static inline void bio_set_op_attrs(struct bio *bio, unsigned op,
- unsigned op_flags)
+static inline void bio_set_op_attrs(struct bio *bio, enum req_op op,
+ blk_opf_t op_flags)
{
bio->bi_opf = op | op_flags;
}
-static inline bool op_is_write(unsigned int op)
+static inline bool op_is_write(blk_opf_t op)
{
- return (op & 1);
+ return !!(op & (__force blk_opf_t)1);
}
/*
* Check if the bio or request is one that needs special treatment in the
* flush state machine.
*/
-static inline bool op_is_flush(unsigned int op)
+static inline bool op_is_flush(blk_opf_t op)
{
return op & (REQ_FUA | REQ_PREFLUSH);
}
@@ -494,13 +499,13 @@ static inline bool op_is_flush(unsigned int op)
* PREFLUSH flag. Other operations may be marked as synchronous using the
* REQ_SYNC flag.
*/
-static inline bool op_is_sync(unsigned int op)
+static inline bool op_is_sync(blk_opf_t op)
{
return (op & REQ_OP_MASK) == REQ_OP_READ ||
(op & (REQ_SYNC | REQ_FUA | REQ_PREFLUSH));
}
-static inline bool op_is_discard(unsigned int op)
+static inline bool op_is_discard(blk_opf_t op)
{
return (op & REQ_OP_MASK) == REQ_OP_DISCARD;
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 06/51] block: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (4 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 05/51] block: Introduce the type blk_opf_t Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 07/51] blktrace: " Bart Van Assche
` (45 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Use the new blk_opf_t type for arguments and variables that represent
request flags or a bitwise combination of a request operation and
request flags. Rename the function arguments and also a structure member
that hold a request operation and flags from 'rw' into 'opf'.
This patch does not change any functionality.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
block/bfq-cgroup.c | 16 ++++++++--------
block/bfq-iosched.c | 8 ++++----
block/bfq-iosched.h | 8 ++++----
block/bio.c | 10 +++++-----
block/blk-cgroup-rwstat.h | 2 +-
block/blk-core.c | 2 +-
block/blk-flush.c | 6 +++---
block/blk-merge.c | 6 +++---
block/blk-mq-debugfs.c | 4 ++--
block/blk-mq.c | 11 ++++++-----
block/blk-mq.h | 6 +++---
block/blk-wbt.c | 16 ++++++++--------
block/elevator.h | 2 +-
block/fops.c | 8 ++++----
block/kyber-iosched.c | 6 +++---
block/mq-deadline.c | 2 +-
include/linux/bio.h | 10 +++++-----
include/linux/blk-mq.h | 4 ++--
include/linux/blkdev.h | 5 +++--
19 files changed, 67 insertions(+), 65 deletions(-)
diff --git a/block/bfq-cgroup.c b/block/bfq-cgroup.c
index 9fc605791b1e..af79028627a5 100644
--- a/block/bfq-cgroup.c
+++ b/block/bfq-cgroup.c
@@ -220,7 +220,7 @@ void bfqg_stats_update_avg_queue_size(struct bfq_group *bfqg)
}
void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
- unsigned int op)
+ blk_opf_t op)
{
blkg_rwstat_add(&bfqg->stats.queued, op, 1);
bfqg_stats_end_empty_time(&bfqg->stats);
@@ -228,18 +228,18 @@ void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
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 op)
{
blkg_rwstat_add(&bfqg->stats.queued, op, -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 op)
{
blkg_rwstat_add(&bfqg->stats.merged, op, 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 op)
{
struct bfqg_stats *stats = &bfqg->stats;
u64 now = ktime_get_ns();
@@ -255,11 +255,11 @@ void bfqg_stats_update_completion(struct bfq_group *bfqg, u64 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) { }
-void bfqg_stats_update_io_remove(struct bfq_group *bfqg, unsigned int op) { }
-void bfqg_stats_update_io_merged(struct bfq_group *bfqg, unsigned int op) { }
+ blk_opf_t op) { }
+void bfqg_stats_update_io_remove(struct bfq_group *bfqg, blk_opf_t op) { }
+void bfqg_stats_update_io_merged(struct bfq_group *bfqg, blk_opf_t op) { }
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 op) { }
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) { }
diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c
index e6d7e6b01a05..a724fc882158 100644
--- a/block/bfq-iosched.c
+++ b/block/bfq-iosched.c
@@ -668,7 +668,7 @@ static bool bfqq_request_over_limit(struct bfq_queue *bfqq, int limit)
* significantly affect service guarantees coming from the BFQ scheduling
* algorithm.
*/
-static void bfq_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)
+static void bfq_limit_depth(blk_opf_t op, struct blk_mq_alloc_data *data)
{
struct bfq_data *bfqd = data->q->elevator->elevator_data;
struct bfq_io_cq *bic = bfq_bic_lookup(data->q);
@@ -6104,7 +6104,7 @@ static bool __bfq_insert_request(struct bfq_data *bfqd, struct request *rq)
static void bfq_update_insert_stats(struct request_queue *q,
struct bfq_queue *bfqq,
bool idle_timer_disabled,
- unsigned int cmd_flags)
+ blk_opf_t cmd_flags)
{
if (!bfqq)
return;
@@ -6129,7 +6129,7 @@ static void bfq_update_insert_stats(struct request_queue *q,
static inline void bfq_update_insert_stats(struct request_queue *q,
struct bfq_queue *bfqq,
bool idle_timer_disabled,
- unsigned int cmd_flags) {}
+ blk_opf_t cmd_flags) {}
#endif /* CONFIG_BFQ_CGROUP_DEBUG */
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,
struct bfq_data *bfqd = q->elevator->elevator_data;
struct bfq_queue *bfqq;
bool idle_timer_disabled = false;
- unsigned int cmd_flags;
+ blk_opf_t cmd_flags;
LIST_HEAD(free);
#ifdef CONFIG_BFQ_GROUP_IOSCHED
diff --git a/block/bfq-iosched.h b/block/bfq-iosched.h
index ca8177d7bf7c..6bde1f4ecc50 100644
--- a/block/bfq-iosched.h
+++ b/block/bfq-iosched.h
@@ -994,11 +994,11 @@ void bfq_put_async_queues(struct bfq_data *bfqd, struct bfq_group *bfqg);
void bfqg_stats_update_legacy_io(struct request_queue *q, struct request *rq);
void bfqg_stats_update_io_add(struct bfq_group *bfqg, struct bfq_queue *bfqq,
- unsigned int op);
-void bfqg_stats_update_io_remove(struct bfq_group *bfqg, unsigned int op);
-void bfqg_stats_update_io_merged(struct bfq_group *bfqg, unsigned int op);
+ blk_opf_t op);
+void bfqg_stats_update_io_remove(struct bfq_group *bfqg, blk_opf_t op);
+void bfqg_stats_update_io_merged(struct bfq_group *bfqg, blk_opf_t op);
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 op);
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);
diff --git a/block/bio.c b/block/bio.c
index 933ea3210954..8978f7d3ae48 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -239,7 +239,7 @@ static void bio_free(struct bio *bio)
* 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;
@@ -292,7 +292,7 @@ EXPORT_SYMBOL(bio_init);
* 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);
@@ -341,7 +341,7 @@ void bio_chain(struct bio *bio, struct bio *parent)
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);
@@ -409,7 +409,7 @@ static void punt_bios_to_rescuer(struct bio_set *bs)
}
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;
@@ -468,7 +468,7 @@ static struct bio *bio_alloc_percpu_cache(struct block_device *bdev,
* 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;
diff --git a/block/blk-cgroup-rwstat.h b/block/blk-cgroup-rwstat.h
index 9f2723b34b75..6c0237148c0d 100644
--- a/block/blk-cgroup-rwstat.h
+++ b/block/blk-cgroup-rwstat.h
@@ -59,7 +59,7 @@ void blkg_rwstat_recursive_sum(struct blkcg_gq *blkg, struct blkcg_policy *pol,
* caller is responsible for synchronizing calls to this function.
*/
static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
- unsigned int op, uint64_t val)
+ blk_opf_t op, uint64_t val)
{
struct percpu_counter *cnt;
diff --git a/block/blk-core.c b/block/blk-core.c
index 9d420dff90f6..ef082aa7b8fb 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1260,7 +1260,7 @@ EXPORT_SYMBOL_GPL(blk_io_schedule);
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 *
diff --git a/block/blk-flush.c b/block/blk-flush.c
index c68968724870..d20a0c6b2c66 100644
--- a/block/blk-flush.c
+++ b/block/blk-flush.c
@@ -94,7 +94,7 @@ enum {
};
static void blk_kick_flush(struct request_queue *q,
- struct blk_flush_queue *fq, unsigned int flags);
+ struct blk_flush_queue *fq, blk_opf_t flags);
static inline struct blk_flush_queue *
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,
{
struct request_queue *q = rq->q;
struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
- unsigned int cmd_flags;
+ blk_opf_t cmd_flags;
BUG_ON(rq->flush.seq & seq);
rq->flush.seq |= seq;
@@ -290,7 +290,7 @@ bool is_flush_rq(struct request *rq)
*
*/
static void blk_kick_flush(struct request_queue *q, struct blk_flush_queue *fq,
- unsigned int flags)
+ blk_opf_t flags)
{
struct list_head *pending = &fq->flush_queue[fq->flush_pending_idx];
struct request *first_rq =
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 9d96c9239219..3a928ebb6b5e 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -712,7 +712,7 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
*/
void blk_rq_set_mixed_merge(struct request *rq)
{
- unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
+ blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;
struct bio *bio;
if (rq->rq_flags & RQF_MIXED_MERGE)
@@ -928,7 +928,7 @@ enum bio_merge_status {
static enum bio_merge_status bio_attempt_back_merge(struct request *req,
struct bio *bio, unsigned int nr_segs)
{
- const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
+ const blk_opf_t ff = bio->bi_opf & REQ_FAILFAST_MASK;
if (!ll_back_merge_fn(req, bio, nr_segs))
return BIO_MERGE_FAILED;
@@ -952,7 +952,7 @@ static enum bio_merge_status bio_attempt_back_merge(struct request *req,
static enum bio_merge_status bio_attempt_front_merge(struct request *req,
struct bio *bio, unsigned int nr_segs)
{
- const int ff = bio->bi_opf & REQ_FAILFAST_MASK;
+ const blk_opf_t ff = bio->bi_opf & REQ_FAILFAST_MASK;
if (!ll_front_merge_fn(req, bio, nr_segs))
return BIO_MERGE_FAILED;
diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index df0b9a458f34..e30ef69dfa39 100644
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -315,8 +315,8 @@ int __blk_mq_debugfs_rq_show(struct seq_file *m, struct request *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,
- ARRAY_SIZE(cmd_flag_name));
+ blk_flags_show(m, (__force unsigned int)(rq->cmd_flags & ~REQ_OP_MASK),
+ 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));
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 50fc1194ebc0..24548dc536cc 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -508,13 +508,13 @@ static struct request *__blk_mq_alloc_requests(struct blk_mq_alloc_data *data)
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;
@@ -655,7 +655,7 @@ void blk_dump_rq_flags(struct request *rq, char *msg)
{
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),
@@ -708,8 +708,9 @@ static void blk_print_req_error(struct request *req, blk_status_t status)
"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)),
- req->cmd_flags & ~REQ_OP_MASK,
+ blk_rq_pos(req), (__force u32)req_op(req),
+ blk_op_str(req_op(req)),
+ (__force u32)(req->cmd_flags & ~REQ_OP_MASK),
req->nr_phys_segments,
IOPRIO_PRIO_CLASS(req->ioprio));
}
diff --git a/block/blk-mq.h b/block/blk-mq.h
index e4c6fe2c8ac8..51fc5d6606e4 100644
--- a/block/blk-mq.h
+++ b/block/blk-mq.h
@@ -86,7 +86,7 @@ static inline struct blk_mq_hw_ctx *blk_mq_map_queue_type(struct request_queue *
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 opf)
+static inline enum hctx_type blk_mq_get_hctx_type(blk_opf_t opf)
{
enum hctx_type type = HCTX_TYPE_DEFAULT;
@@ -107,7 +107,7 @@ static inline enum hctx_type blk_mq_get_hctx_type(unsigned int opf)
* @ctx: software queue cpu ctx
*/
static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,
- unsigned int opf,
+ blk_opf_t opf,
struct blk_mq_ctx *ctx)
{
return ctx->hctxs[blk_mq_get_hctx_type(opf)];
@@ -151,7 +151,7 @@ struct blk_mq_alloc_data {
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 */
diff --git a/block/blk-wbt.c b/block/blk-wbt.c
index 7bf09ae06577..f2e4bf1dca47 100644
--- a/block/blk-wbt.c
+++ b/block/blk-wbt.c
@@ -451,7 +451,7 @@ static bool close_io(struct rq_wb *rwb)
#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;
@@ -462,7 +462,7 @@ static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw)
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;
/*
@@ -473,9 +473,9 @@ static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw)
* 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.
@@ -490,13 +490,13 @@ static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw)
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)
@@ -510,13 +510,13 @@ 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);
diff --git a/block/elevator.h b/block/elevator.h
index 16cd8bdedb7e..3f0593b3bf9d 100644
--- a/block/elevator.h
+++ b/block/elevator.h
@@ -34,7 +34,7 @@ struct elevator_mq_ops {
int (*request_merge)(struct request_queue *q, struct request **, struct bio *);
void (*request_merged)(struct request_queue *, struct request *, enum elv_merge);
void (*requests_merged)(struct request_queue *, struct request *, struct request *);
- void (*limit_depth)(unsigned int, struct blk_mq_alloc_data *);
+ void (*limit_depth)(blk_opf_t, struct blk_mq_alloc_data *);
void (*prepare_request)(struct request *);
void (*finish_request)(struct request *);
void (*insert_requests)(struct blk_mq_hw_ctx *, struct list_head *, bool);
diff --git a/block/fops.c b/block/fops.c
index 86d3cab9bf93..dd22e8c9b76f 100644
--- a/block/fops.c
+++ b/block/fops.c
@@ -32,9 +32,9 @@ static int blkdev_get_block(struct inode *inode, sector_t iblock,
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 op = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;
/* avoid the need for a I/O completion work item */
if (iocb->ki_flags & IOCB_DSYNC)
@@ -175,7 +175,7 @@ static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
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;
@@ -297,7 +297,7 @@ static ssize_t __blkdev_direct_IO_async(struct kiocb *iocb,
{
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;
diff --git a/block/kyber-iosched.c b/block/kyber-iosched.c
index 8f7c745b4a57..102b6a311b5c 100644
--- a/block/kyber-iosched.c
+++ b/block/kyber-iosched.c
@@ -195,9 +195,9 @@ struct kyber_hctx_data {
static int kyber_domain_wake(wait_queue_entry_t *wait, unsigned mode, int flags,
void *key);
-static unsigned int kyber_sched_domain(unsigned int op)
+static unsigned int kyber_sched_domain(blk_opf_t opf)
{
- switch (op & REQ_OP_MASK) {
+ switch (opf & REQ_OP_MASK) {
case REQ_OP_READ:
return KYBER_READ;
case REQ_OP_WRITE:
@@ -553,7 +553,7 @@ static void rq_clear_domain_token(struct kyber_queue_data *kqd,
}
}
-static void kyber_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)
+static void kyber_limit_depth(blk_opf_t op, struct blk_mq_alloc_data *data)
{
/*
* We use the scheduler tags as per-hardware queue queueing tokens.
diff --git a/block/mq-deadline.c b/block/mq-deadline.c
index 1a9e835e816c..c5589e9155e6 100644
--- a/block/mq-deadline.c
+++ b/block/mq-deadline.c
@@ -543,7 +543,7 @@ static struct request *dd_dispatch_request(struct blk_mq_hw_ctx *hctx)
* Called by __blk_mq_alloc_request(). The shallow_depth value set by this
* function is used by __blk_mq_get_tag().
*/
-static void dd_limit_depth(unsigned int op, struct blk_mq_alloc_data *data)
+static void dd_limit_depth(blk_opf_t op, struct blk_mq_alloc_data *data)
{
struct deadline_data *dd = data->q->elevator->elevator_data;
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 992ee987f273..ca22b06700a9 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -405,7 +405,7 @@ extern void bioset_exit(struct bio_set *);
extern int biovec_init_pool(mempool_t *pool, int pool_entries);
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);
struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask);
extern void bio_put(struct bio *);
@@ -418,7 +418,7 @@ int bio_init_clone(struct block_device *bdev, struct bio *bio,
extern struct bio_set fs_bio_set;
static inline struct bio *bio_alloc(struct block_device *bdev,
- unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask)
+ unsigned short nr_vecs, blk_opf_t opf, gfp_t gfp_mask)
{
return bio_alloc_bioset(bdev, nr_vecs, opf, gfp_mask, &fs_bio_set);
}
@@ -456,9 +456,9 @@ struct request_queue;
extern int submit_bio_wait(struct bio *bio);
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);
extern void bio_uninit(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);
void bio_chain(struct bio *, struct bio *);
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)
}
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);
#endif /* __LINUX_BIO_H */
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 9a1838bbed02..fbaacd4607a0 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -79,7 +79,7 @@ struct request {
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;
@@ -712,7 +712,7 @@ enum {
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,
enum req_op op, blk_mq_req_flags_t flags,
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index de47b0e0e18f..9751f164d2f0 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -220,9 +220,10 @@ static inline int blk_validate_block_size(unsigned long bsize)
return 0;
}
-static inline bool blk_op_is_passthrough(unsigned int op)
+static inline bool blk_op_is_passthrough(blk_opf_t opf)
{
- op &= REQ_OP_MASK;
+ enum req_op op = opf & REQ_OP_MASK;
+
return op == REQ_OP_DRV_IN || op == REQ_OP_DRV_OUT;
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 07/51] blktrace: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (5 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 06/51] block: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 08/51] blktrace: Trace remap operations correctly Bart Van Assche
` (44 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Li Zefan,
Steven Rostedt
Improve static type checking by using the new blk_opf_t type for a function
argument that represents a combination of a request operation and request
flags. Rename that argument from 'op' into 'opf' to make its role more
clear.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
include/linux/blktrace_api.h | 3 ++-
kernel/trace/blktrace.c | 20 ++++++++++----------
2 files changed, 12 insertions(+), 11 deletions(-)
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 623e22492afa..de9ef5bb57a7 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -7,6 +7,7 @@
#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)
@@ -115,7 +116,7 @@ struct compat_blk_user_trace_setup {
#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)
{
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 10a32b0f2deb..f24c7351071c 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -205,7 +205,7 @@ static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),
#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))
/*
@@ -213,8 +213,8 @@ static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),
* 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,
- void *pdu_data, u64 cgid)
+ enum req_op op, blk_opf_t op_flags, u32 what, int error,
+ int pdu_len, void *pdu_data, u64 cgid)
{
struct task_struct *tsk = current;
struct ring_buffer_event *event = NULL;
@@ -1895,14 +1895,14 @@ void blk_trace_remove_sysfs(struct device *dev)
* 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;
@@ -1923,13 +1923,13 @@ void blk_fill_rwbs(char *rwbs, unsigned int op)
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';
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 08/51] blktrace: Trace remap operations correctly
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (6 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 07/51] blktrace: " Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 09/51] block/brd: Use the enum req_op type Bart Van Assche
` (43 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Mike Snitzer,
Jun'ichi Nomura
Trace the remapped operation instead of only the data direction of
remapped operations. This issue was detected by analyzing the warnings
reported by sparse related to the new blk_opf_t type.
Cc: Mike Snitzer <snitzer@kernel.org>
Cc: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Fixes: b0da3f0dada7 ("Add a tracepoint for block request remapping")
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
kernel/trace/blktrace.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index f24c7351071c..d9e0530080e2 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1061,7 +1061,7 @@ static void blk_add_trace_rq_remap(void *ignore, struct request *rq, dev_t dev,
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,
+ req_op(rq), 0, BLK_TA_REMAP, 0,
sizeof(r), &r, blk_trace_request_get_cgid(rq));
rcu_read_unlock();
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 09/51] block/brd: Use the enum req_op type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (7 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 08/51] blktrace: Trace remap operations correctly Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 10/51] block/drbd: Use the enum req_op and blk_opf_t types Bart Van Assche
` (42 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Improve static type checking by using the enum req_op type for a
function argument that represents a request operation.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/block/brd.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index c3d772bdd89f..a3dfff0f73f5 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -256,7 +256,7 @@ static void copy_from_brd(void *dst, struct brd_device *brd,
* Process a single bvec of a bio.
*/
static int brd_do_bvec(struct brd_device *brd, struct page *page,
- unsigned int len, unsigned int off, unsigned int op,
+ unsigned int len, unsigned int off, enum req_op op,
sector_t sector)
{
void *mem;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 10/51] block/drbd: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (8 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 09/51] block/brd: Use the enum req_op type Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-24 5:00 ` Christoph Böhmwalder
2022-06-23 18:04 ` [PATCH 11/51] block/floppy: Fix a sparse warning Bart Van Assche
` (41 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Lars Ellenberg,
Philipp Reisner, Christoph Böhmwalder
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Lars Ellenberg <lars.ellenberg@linbit.com>
Cc: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Christoph Böhmwalder <christoph.boehmwalder@linbit.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/block/drbd/drbd_actlog.c | 9 +++++----
drivers/block/drbd/drbd_bitmap.c | 3 ++-
drivers/block/drbd/drbd_int.h | 6 +++---
drivers/block/drbd/drbd_receiver.c | 11 ++++++-----
4 files changed, 16 insertions(+), 13 deletions(-)
diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
index f5bcded3640d..e27478ae579c 100644
--- a/drivers/block/drbd/drbd_actlog.c
+++ b/drivers/block/drbd/drbd_actlog.c
@@ -124,12 +124,13 @@ void wait_until_done_or_force_detached(struct drbd_device *device, struct drbd_b
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;
@@ -174,7 +175,7 @@ static int _drbd_md_sync_page_io(struct drbd_device *device,
}
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);
@@ -385,7 +386,7 @@ static int __al_write_transaction(struct drbd_device *device, struct al_transact
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 {
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index bd2133ef6e0a..0845f28a48a7 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -990,7 +990,8 @@ static inline sector_t drbd_md_last_bitmap_sector(struct drbd_backing_dev *bdev)
static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_hold(local)
{
struct drbd_device *device = ctx->device;
- unsigned int op = (ctx->flags & BM_AIO_READ) ? REQ_OP_READ : REQ_OP_WRITE;
+ const enum req_op op = ctx->flags & BM_AIO_READ ? REQ_OP_READ :
+ REQ_OP_WRITE;
struct drbd_bitmap *b = device->bitmap;
struct bio *bio;
struct page *page;
diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index 4d3efaa20b7b..ecb2ecd8d67d 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -1495,7 +1495,7 @@ extern int drbd_resync_finished(struct drbd_device *device);
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);
@@ -1547,8 +1547,8 @@ extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);
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,
- const unsigned, const int);
+ struct drbd_peer_request *, enum req_op,
+ blk_opf_t, 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,
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 6762be53f409..caf646dd91ba 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -1621,7 +1621,7 @@ static void drbd_issue_peer_discard_or_zero_out(struct drbd_device *device, stru
/* 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 enum req_op op, const blk_opf_t op_flags,
const int fault_type)
{
struct bio *bios = NULL;
@@ -2383,14 +2383,14 @@ static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, co
/* 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;
@@ -2543,7 +2543,8 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
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;
@@ -4951,7 +4952,7 @@ static int receive_rs_deallocated(struct drbd_connection *connection, struct pac
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);
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 10/51] block/drbd: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 ` [PATCH 10/51] block/drbd: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-24 5:00 ` Christoph Böhmwalder
0 siblings, 0 replies; 93+ messages in thread
From: Christoph Böhmwalder @ 2022-06-24 5:00 UTC (permalink / raw)
To: Bart Van Assche
Cc: linux-block, Christoph Hellwig, Lars Ellenberg, Philipp Reisner,
Jens Axboe
Am 23.06.22 um 20:04 schrieb Bart Van Assche:
> Improve static type checking by using the enum req_op type for variables
> that represent a request operation and the new blk_opf_t type for
> variables that represent request flags.
>
> Cc: Lars Ellenberg <lars.ellenberg@linbit.com>
> Cc: Philipp Reisner <philipp.reisner@linbit.com>
> Cc: Christoph Böhmwalder <christoph.boehmwalder@linbit.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
> drivers/block/drbd/drbd_actlog.c | 9 +++++----
> drivers/block/drbd/drbd_bitmap.c | 3 ++-
> drivers/block/drbd/drbd_int.h | 6 +++---
> drivers/block/drbd/drbd_receiver.c | 11 ++++++-----
> 4 files changed, 16 insertions(+), 13 deletions(-)
>
> diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
> index f5bcded3640d..e27478ae579c 100644
> --- a/drivers/block/drbd/drbd_actlog.c
> +++ b/drivers/block/drbd/drbd_actlog.c
> @@ -124,12 +124,13 @@ void wait_until_done_or_force_detached(struct drbd_device *device, struct drbd_b
>
> 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;
> @@ -174,7 +175,7 @@ static int _drbd_md_sync_page_io(struct drbd_device *device,
> }
>
> 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);
> @@ -385,7 +386,7 @@ static int __al_write_transaction(struct drbd_device *device, struct al_transact
> 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 {
> diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
> index bd2133ef6e0a..0845f28a48a7 100644
> --- a/drivers/block/drbd/drbd_bitmap.c
> +++ b/drivers/block/drbd/drbd_bitmap.c
> @@ -990,7 +990,8 @@ static inline sector_t drbd_md_last_bitmap_sector(struct drbd_backing_dev *bdev)
> static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_hold(local)
> {
> struct drbd_device *device = ctx->device;
> - unsigned int op = (ctx->flags & BM_AIO_READ) ? REQ_OP_READ : REQ_OP_WRITE;
> + const enum req_op op = ctx->flags & BM_AIO_READ ? REQ_OP_READ :
> + REQ_OP_WRITE;
> struct drbd_bitmap *b = device->bitmap;
> struct bio *bio;
> struct page *page;
> diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
> index 4d3efaa20b7b..ecb2ecd8d67d 100644
> --- a/drivers/block/drbd/drbd_int.h
> +++ b/drivers/block/drbd/drbd_int.h
> @@ -1495,7 +1495,7 @@ extern int drbd_resync_finished(struct drbd_device *device);
> 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);
> @@ -1547,8 +1547,8 @@ extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device);
> 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,
> - const unsigned, const int);
> + struct drbd_peer_request *, enum req_op,
> + blk_opf_t, 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,
> diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
> index 6762be53f409..caf646dd91ba 100644
> --- a/drivers/block/drbd/drbd_receiver.c
> +++ b/drivers/block/drbd/drbd_receiver.c
> @@ -1621,7 +1621,7 @@ static void drbd_issue_peer_discard_or_zero_out(struct drbd_device *device, stru
> /* 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 enum req_op op, const blk_opf_t op_flags,
> const int fault_type)
> {
> struct bio *bios = NULL;
> @@ -2383,14 +2383,14 @@ static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, co
> /* 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;
> @@ -2543,7 +2543,8 @@ static int receive_Data(struct drbd_connection *connection, struct packet_info *
> 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;
>
> @@ -4951,7 +4952,7 @@ static int receive_rs_deallocated(struct drbd_connection *connection, struct pac
>
> 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);
LGTM, thanks.
Acked-by: Christoph Böhmwalder <christoph.boehmwalder@linbit.com>
--
Christoph Böhmwalder
LINBIT | Keeping the Digital World Running
DRBD HA — Disaster Recovery — Software defined Storage
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 11/51] block/floppy: Fix a sparse warning
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (9 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 10/51] block/drbd: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 12/51] block/null_blk: Fix sparse warnings in tracing code Bart Van Assche
` (40 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Denis Efremov
Since the type of request.cmd_flags has been changed from u32 into
blk_opf_t, use the __force keyword when casting to an integer type to
prevent that sparse warns about this cast.
Cc: Denis Efremov <efremov@linux.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/block/floppy.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 015841f50f4e..2f24de4eb8da 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2859,7 +2859,7 @@ static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx,
if (WARN(atomic_read(&usage_count) == 0,
"warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",
current_req, (long)blk_rq_pos(current_req),
- (unsigned long long) current_req->cmd_flags))
+ (__force unsigned long long) current_req->cmd_flags))
return BLK_STS_IOERR;
if (test_and_set_bit(0, &fdc_busy)) {
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 12/51] block/null_blk: Fix sparse warnings in tracing code
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (10 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 11/51] block/floppy: Fix a sparse warning Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 13/51] um: Use enum req_op where appropriate Bart Van Assche
` (39 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ming Lei
Since the tracing infrastructure does not support bitwise types, store
the request operation as an int. This patch does not change any
functionality.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/block/null_blk/trace.h | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/block/null_blk/trace.h b/drivers/block/null_blk/trace.h
index 6b2b370e786f..f79467e5310f 100644
--- a/drivers/block/null_blk/trace.h
+++ b/drivers/block/null_blk/trace.h
@@ -36,19 +36,19 @@ TRACE_EVENT(nullb_zone_op,
TP_ARGS(cmd, zone_no, zone_cond),
TP_STRUCT__entry(
__array(char, disk, DISK_NAME_LEN)
- __field(enum req_op, op)
+ __field(int, op)
__field(unsigned int, zone_no)
__field(unsigned int, zone_cond)
),
TP_fast_assign(
- __entry->op = req_op(cmd->rq);
+ __entry->op = (__force int)req_op(cmd->rq);
__entry->zone_no = zone_no;
__entry->zone_cond = zone_cond;
__assign_disk_name(__entry->disk, cmd->rq->q->disk);
),
TP_printk("%s req=%-15s zone_no=%u zone_cond=%-10s",
__print_disk_name(__entry->disk),
- blk_op_str(__entry->op),
+ blk_op_str((__force enum req_op)__entry->op),
__entry->zone_no,
blk_zone_cond_str(__entry->zone_cond))
);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 13/51] um: Use enum req_op where appropriate
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (11 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 12/51] block/null_blk: Fix sparse warnings in tracing code Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 14/51] dm/core: Use the enum req_op and blk_opf_t types Bart Van Assche
` (38 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche,
Richard Weinberger, Anton Ivanov
Improve static type checking by using type enum req_op instead of int where
appropriate.
Cc: Richard Weinberger <richard@nod.at>
Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
arch/um/drivers/ubd_kern.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index c4344b67628d..e2a0ebe4872f 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -1262,7 +1262,7 @@ static void ubd_map_req(struct ubd *dev, struct io_thread_req *io_req,
struct req_iterator iter;
int i = 0;
unsigned long byte_offset = io_req->offset;
- int op = req_op(req);
+ enum req_op op = req_op(req);
if (op == REQ_OP_WRITE_ZEROES || op == REQ_OP_DISCARD) {
io_req->io_desc[0].buffer = NULL;
@@ -1325,7 +1325,7 @@ static int ubd_submit_request(struct ubd *dev, struct request *req)
int segs = 0;
struct io_thread_req *io_req;
int ret;
- int op = req_op(req);
+ enum req_op op = req_op(req);
if (op == REQ_OP_FLUSH)
segs = 0;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 14/51] dm/core: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (12 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 13/51] um: Use enum req_op where appropriate Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 15/51] dm/bufio: Change 'int rw' into 'enum req_op op' Bart Van Assche
` (37 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags all or not combined with a request
operation.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-io.c | 18 ++++++++++--------
drivers/md/dm.c | 2 +-
include/linux/dm-io.h | 5 +++--
3 files changed, 14 insertions(+), 11 deletions(-)
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index e4b95eaeec8c..29ff150634cd 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -293,7 +293,7 @@ static void km_dp_init(struct dpages *dp, void *data)
/*-----------------------------------------------------------------
* IO routines that accept a list of pages.
*---------------------------------------------------------------*/
-static void do_region(int op, int op_flags, unsigned region,
+static void do_region(enum req_op op, blk_opf_t op_flags, unsigned region,
struct dm_io_region *where, struct dpages *dp,
struct io *io)
{
@@ -368,9 +368,9 @@ static void do_region(int op, int op_flags, unsigned region,
} while (remaining);
}
-static void dispatch_io(int op, int op_flags, unsigned int num_regions,
- struct dm_io_region *where, struct dpages *dp,
- struct io *io, int sync)
+static void dispatch_io(enum req_op op, blk_opf_t op_flags,
+ unsigned int num_regions, struct dm_io_region *where,
+ struct dpages *dp, struct io *io, int sync)
{
int i;
struct dpages old_pages = *dp;
@@ -411,8 +411,9 @@ static void sync_io_complete(unsigned long error, void *context)
}
static int sync_io(struct dm_io_client *client, unsigned int num_regions,
- struct dm_io_region *where, int op, int op_flags,
- struct dpages *dp, unsigned long *error_bits)
+ struct dm_io_region *where, enum req_op op,
+ blk_opf_t op_flags, struct dpages *dp,
+ unsigned long *error_bits)
{
struct io *io;
struct sync_io sio;
@@ -445,8 +446,9 @@ static int sync_io(struct dm_io_client *client, unsigned int num_regions,
}
static int async_io(struct dm_io_client *client, unsigned int num_regions,
- struct dm_io_region *where, int op, int op_flags,
- struct dpages *dp, io_notify_fn fn, void *context)
+ struct dm_io_region *where, enum req_op op,
+ blk_opf_t op_flags, struct dpages *dp, io_notify_fn fn,
+ void *context)
{
struct io *io;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index bed7ad573f79..ea0bbbd6837f 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1622,7 +1622,7 @@ static blk_status_t __split_and_process_bio(struct clone_info *ci)
* 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);
diff --git a/include/linux/dm-io.h b/include/linux/dm-io.h
index a52c6580cc9a..811f29ca4971 100644
--- a/include/linux/dm-io.h
+++ b/include/linux/dm-io.h
@@ -13,6 +13,7 @@
#ifdef __KERNEL__
#include <linux/types.h>
+#include <linux/blk_types.h>
struct dm_io_region {
struct block_device *bdev;
@@ -57,8 +58,8 @@ struct dm_io_notify {
*/
struct dm_io_client;
struct dm_io_request {
- int bi_op; /* REQ_OP */
- int bi_op_flags; /* req_flag_bits */
+ enum req_op bi_op; /* REQ_OP */
+ blk_opf_t 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 */
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 15/51] dm/bufio: Change 'int rw' into 'enum req_op op'
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (13 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 14/51] dm/core: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 16/51] dm/kcopyd: Rename kcopyd_job.rw into kcopyd_job.op Bart Van Assche
` (36 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer
Improve static type checking by using type 'enum req_op' instead of 'int'.
Make the role of the 'rw' arguments more clear by renaming these into 'op'
(operation). This patch does not change any functionality.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-bufio.c | 19 ++++++++++---------
1 file changed, 10 insertions(+), 9 deletions(-)
diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index 5ffa1dcf84cf..666b36d043d4 100644
--- a/drivers/md/dm-bufio.c
+++ b/drivers/md/dm-bufio.c
@@ -577,12 +577,12 @@ static void dmio_complete(unsigned long error, void *context)
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_op = op,
.bi_op_flags = 0,
.notify.fn = dmio_complete,
.notify.context = b,
@@ -616,7 +616,7 @@ static void bio_complete(struct bio *bio)
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;
@@ -630,10 +630,10 @@ static void use_bio(struct dm_buffer *b, int rw, sector_t sector,
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;
@@ -669,7 +669,8 @@ static inline sector_t block_to_sector(struct dm_bufio_client *c, sector_t block
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;
@@ -679,7 +680,7 @@ static void submit_io(struct dm_buffer *b, int rw, void (*end_io)(struct dm_buff
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 {
@@ -698,9 +699,9 @@ static void submit_io(struct dm_buffer *b, int rw, void (*end_io)(struct dm_buff
}
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);
}
/*----------------------------------------------------------------
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 16/51] dm/kcopyd: Rename kcopyd_job.rw into kcopyd_job.op
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (14 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 15/51] dm/bufio: Change 'int rw' into 'enum req_op op' Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 17/51] dm/ebs: Change 'int rw' into 'enum req_op op' Bart Van Assche
` (35 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer
The code that assigns kcopyd_job.rw to the bio.op member shows that it
represents a request operation type (REQ_OP_). Rename kcopyd_job.rw into
kcopyd_job.op to make this clear and only assign REQ_OP_* constants to
that structure member. This patch does not change any functionality
since REQ_OP_READ = READ = 0 and REQ_OP_WRITE = WRITE = 1.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-kcopyd.c | 25 +++++++++++++------------
1 file changed, 13 insertions(+), 12 deletions(-)
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 37b03ab7e5c9..a3d0d6ca95af 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -350,9 +350,9 @@ struct kcopyd_job {
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;
/*
@@ -418,7 +418,8 @@ static struct kcopyd_job *pop_io_job(struct list_head *jobs,
* 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;
}
@@ -518,7 +519,7 @@ static void complete_io(unsigned long error, void *context)
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;
@@ -530,11 +531,11 @@ static void complete_io(unsigned long error, void *context)
}
}
- 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);
}
@@ -549,7 +550,7 @@ static int run_io_job(struct kcopyd_job *job)
{
int r;
struct dm_io_request io_req = {
- .bi_op = job->rw,
+ .bi_op = job->op,
.bi_op_flags = 0,
.mem.type = DM_IO_PAGE_LIST,
.mem.ptr.pl = job->pages,
@@ -571,7 +572,7 @@ static int run_io_job(struct kcopyd_job *job)
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);
@@ -614,7 +615,7 @@ static int process_jobs(struct list_head *jobs, struct dm_kcopyd_client *kc,
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;
@@ -817,7 +818,7 @@ void dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
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;
@@ -826,10 +827,10 @@ void dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
/*
* 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;
}
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 17/51] dm/ebs: Change 'int rw' into 'enum req_op op'
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (15 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 16/51] dm/kcopyd: Rename kcopyd_job.rw into kcopyd_job.op Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 18/51] dm/dm-flakey: Use the new blk_opf_t type Bart Van Assche
` (34 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer, Heinz Mauelshagen
Improve static type checking by using type 'enum req_op' instead of 'int'.
Make the role of the 'rw' arguments more clear by renaming these into
'op' (operation). This patch does not change any functionality since
REQ_OP_READ = READ = 0 and REQ_OP_WRITE = WRITE = 1.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Cc: Heinz Mauelshagen <heinzm@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-ebs-target.c | 15 ++++++++-------
1 file changed, 8 insertions(+), 7 deletions(-)
diff --git a/drivers/md/dm-ebs-target.c b/drivers/md/dm-ebs-target.c
index 0221fa63f888..223e8e1a7a13 100644
--- a/drivers/md/dm-ebs-target.c
+++ b/drivers/md/dm-ebs-target.c
@@ -61,7 +61,8 @@ static inline bool __ebs_check_bs(unsigned int bs)
*
* 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;
@@ -81,7 +82,7 @@ static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bv
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);
@@ -95,7 +96,7 @@ static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bv
} 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 {
@@ -117,14 +118,14 @@ static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bv
}
/* 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;
}
@@ -205,10 +206,10 @@ static void __ebs_process_bios(struct work_struct *ws)
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);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 18/51] dm/dm-flakey: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (16 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 17/51] dm/ebs: Change 'int rw' into 'enum req_op op' Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 19/51] dm/dm-integrity: Use the enum req_op and blk_opf_t types Bart Van Assche
` (33 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer
Use the new blk_opf_t type for structure members that represent request
flags.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-flakey.c | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c
index f2305eb758a2..89fa7a68c6c4 100644
--- a/drivers/md/dm-flakey.c
+++ b/drivers/md/dm-flakey.c
@@ -32,7 +32,7 @@ struct flakey_c {
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 {
@@ -145,7 +145,11 @@ static int parse_features(struct dm_arg_set *as, struct flakey_c *fc,
/*
* 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--;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 19/51] dm/dm-integrity: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (17 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 18/51] dm/dm-flakey: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 20/51] dm/dm-snap: " Bart Van Assche
` (32 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer, Eric Biggers
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Cc: Eric Biggers <ebiggers@google.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-integrity.c | 12 ++++++++----
1 file changed, 8 insertions(+), 4 deletions(-)
diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index 148978ad03a8..8bb0c7a88176 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -551,7 +551,8 @@ static int sb_mac(struct dm_integrity_c *ic, bool wr)
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, enum req_op op,
+ blk_opf_t op_flags)
{
struct dm_io_request io_req;
struct dm_io_region io_loc;
@@ -1050,8 +1051,10 @@ static void complete_journal_io(unsigned long error, void *context)
complete_journal_op(comp);
}
-static void rw_journal_sectors(struct dm_integrity_c *ic, int op, int op_flags,
- unsigned sector, unsigned n_sectors, struct journal_completion *comp)
+static void rw_journal_sectors(struct dm_integrity_c *ic, enum req_op op,
+ blk_opf_t op_flags, unsigned sector,
+ unsigned n_sectors,
+ struct journal_completion *comp)
{
struct dm_io_request io_req;
struct dm_io_region io_loc;
@@ -1096,7 +1099,8 @@ static void rw_journal_sectors(struct dm_integrity_c *ic, int op, int op_flags,
}
}
-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, enum req_op op,
+ blk_opf_t op_flags, unsigned section,
unsigned n_sections, struct journal_completion *comp)
{
unsigned sector, n_sectors;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 20/51] dm/dm-snap: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (18 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 19/51] dm/dm-integrity: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:04 ` [PATCH 21/51] dm/dm-zoned: Use the enum req_op type Bart Van Assche
` (31 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-snap-persistent.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 3bb5cff5d6fc..e536f6be63b3 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -226,8 +226,8 @@ static void do_metadata(struct work_struct *work)
/*
* 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,
- int op_flags, int metadata)
+static int chunk_io(struct pstore *ps, void *area, chunk_t chunk,
+ enum req_op op, blk_opf_t op_flags, int metadata)
{
struct dm_io_region where = {
.bdev = dm_snap_cow(ps->store->snap)->bdev,
@@ -282,7 +282,7 @@ static void skip_metadata(struct pstore *ps)
* 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, enum req_op op, blk_opf_t op_flags)
{
chunk_t chunk = area_location(ps, ps->current_area);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 21/51] dm/dm-zoned: Use the enum req_op type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (19 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 20/51] dm/dm-snap: " Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 22:46 ` Damien Le Moal
2022-06-23 18:04 ` [PATCH 22/51] md/core: Use the enum req_op and blk_opf_t types Bart Van Assche
` (30 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Alasdair Kergon,
Mike Snitzer, Damien Le Moal
Improve static type checking by using the enum req_op type for arguments
that represent a request operation.
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Cc: Damien Le Moal <damien.lemoal@wdc.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/dm-zoned-metadata.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/md/dm-zoned-metadata.c b/drivers/md/dm-zoned-metadata.c
index d1ea66114d14..9341c46e44b7 100644
--- a/drivers/md/dm-zoned-metadata.c
+++ b/drivers/md/dm-zoned-metadata.c
@@ -737,7 +737,7 @@ static int dmz_write_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk,
/*
* 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;
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 21/51] dm/dm-zoned: Use the enum req_op type
2022-06-23 18:04 ` [PATCH 21/51] dm/dm-zoned: Use the enum req_op type Bart Van Assche
@ 2022-06-23 22:46 ` Damien Le Moal
0 siblings, 0 replies; 93+ messages in thread
From: Damien Le Moal @ 2022-06-23 22:46 UTC (permalink / raw)
To: Bart Van Assche, Jens Axboe
Cc: linux-block, Christoph Hellwig, Alasdair Kergon, Mike Snitzer
On 6/24/22 03:04, Bart Van Assche wrote:
> Improve static type checking by using the enum req_op type for arguments
> that represent a request operation.
>
> Cc: Alasdair Kergon <agk@redhat.com>
> Cc: Mike Snitzer <snitzer@kernel.org>
> Cc: Damien Le Moal <damien.lemoal@wdc.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
> drivers/md/dm-zoned-metadata.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/drivers/md/dm-zoned-metadata.c b/drivers/md/dm-zoned-metadata.c
> index d1ea66114d14..9341c46e44b7 100644
> --- a/drivers/md/dm-zoned-metadata.c
> +++ b/drivers/md/dm-zoned-metadata.c
> @@ -737,7 +737,7 @@ static int dmz_write_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk,
> /*
> * 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;
Looks good.
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 22/51] md/core: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (20 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 21/51] dm/dm-zoned: Use the enum req_op type Bart Van Assche
@ 2022-06-23 18:04 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 23/51] md/bcache: " Bart Van Assche
` (29 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:04 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Song Liu
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Song Liu <song@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/md.c | 3 ++-
drivers/md/md.h | 4 ++--
2 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index c7ecb0bffda0..d354faa95be7 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -993,7 +993,8 @@ int md_super_wait(struct mddev *mddev)
}
int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
- struct page *page, int op, int op_flags, bool metadata_op)
+ struct page *page, enum req_op op, blk_opf_t op_flags,
+ bool metadata_op)
{
struct bio bio;
struct bio_vec bvec;
diff --git a/drivers/md/md.h b/drivers/md/md.h
index cf2cbb17acbd..f93bf7396d86 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -738,8 +738,8 @@ extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
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,
- bool metadata_op);
+ struct page *page, enum req_op op, blk_opf_t op_flags,
+ 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);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 23/51] md/bcache: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (21 preceding siblings ...)
2022-06-23 18:04 ` [PATCH 22/51] md/core: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 24/51] md/raid1: Use the new blk_opf_t type Bart Van Assche
` (28 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Coly Li
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Coly Li <colyli@suse.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/bcache/super.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 3563d15dbaf2..93f18bae28cf 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -414,7 +414,7 @@ static void uuid_io_unlock(struct closure *cl)
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, enum req_op op, blk_opf_t op_flags,
struct bkey *k, struct closure *parent)
{
struct closure *cl = &c->uuid_write;
@@ -588,7 +588,7 @@ static void prio_endio(struct bio *bio)
}
static void prio_io(struct cache *ca, uint64_t bucket, int op,
- unsigned long op_flags)
+ blk_opf_t op_flags)
{
struct closure *cl = &ca->prio;
struct bio *bio = bch_bbio_alloc(ca->set);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 24/51] md/raid1: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (22 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 23/51] md/bcache: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 25/51] md/raid10: " Bart Van Assche
` (27 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Song Liu
Improve static type checking by using the new blk_opf_t type for
variables that represent request flags.
Cc: Song Liu <song@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/raid1.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 258d4eb2d63c..63b3f70abbc3 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1221,7 +1221,7 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio,
struct bio *read_bio;
struct bitmap *bitmap = mddev->bitmap;
const int op = bio_op(bio);
- const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
+ const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
int max_sectors;
int rdisk;
bool r1bio_existed = !!r1_bio;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 25/51] md/raid10: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (23 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 24/51] md/raid1: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 26/51] md/raid5: Use the enum req_op and blk_opf_t types Bart Van Assche
` (26 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Song Liu
Improve static type checking by using the new blk_opf_t type for
variables that represent a request flags.
Cc: Song Liu <song@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/raid10.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index d589f823feb1..649635e04e38 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1137,7 +1137,7 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,
struct r10conf *conf = mddev->private;
struct bio *read_bio;
const int op = bio_op(bio);
- const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
+ const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
int max_sectors;
struct md_rdev *rdev;
char b[BDEVNAME_SIZE];
@@ -1231,8 +1231,8 @@ static void raid10_write_one_disk(struct mddev *mddev, struct r10bio *r10_bio,
int n_copy)
{
const int op = bio_op(bio);
- const unsigned long do_sync = (bio->bi_opf & REQ_SYNC);
- const unsigned long do_fua = (bio->bi_opf & REQ_FUA);
+ const blk_opf_t do_sync = bio->bi_opf & REQ_SYNC;
+ const blk_opf_t do_fua = bio->bi_opf & REQ_FUA;
unsigned long flags;
struct blk_plug_cb *cb;
struct raid1_plug_cb *plug = NULL;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 26/51] md/raid5: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (24 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 25/51] md/raid10: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 27/51] nvme/host: " Bart Van Assche
` (25 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Song Liu
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Song Liu <song@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/md/raid5.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 5d09256d7f81..b11d8b6a2dc2 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -1082,7 +1082,8 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
should_defer = conf->batch_bio_dispatch && conf->group_cnt;
for (i = disks; i--; ) {
- int op, op_flags = 0;
+ enum req_op op;
+ blk_opf_t op_flags = 0;
int replace_only = 0;
struct bio *bi, *rbi;
struct md_rdev *rdev, *rrdev = NULL;
@@ -5896,7 +5897,7 @@ static bool raid5_make_request(struct mddev *mddev, struct bio * bi)
(unsigned long long)logical_sector);
sh = raid5_get_active_stripe(conf, new_sector, previous,
- (bi->bi_opf & REQ_RAHEAD), 0);
+ !!(bi->bi_opf & REQ_RAHEAD), 0);
if (sh) {
if (unlikely(previous)) {
/* expansion might have moved on while waiting for a
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 27/51] nvme/host: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (25 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 26/51] md/raid5: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-26 9:25 ` Sagi Grimberg
2022-06-23 18:05 ` [PATCH 28/51] nvme/target: Use the new blk_opf_t type Bart Van Assche
` (24 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Keith Busch,
Sagi Grimberg
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Keith Busch <kbusch@kernel.org>
Cc: Sagi Grimberg <sagi@grimberg.me>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/nvme/host/ioctl.c | 4 ++--
drivers/nvme/host/nvme.h | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/nvme/host/ioctl.c b/drivers/nvme/host/ioctl.c
index a2e89db1cd63..27614bee7380 100644
--- a/drivers/nvme/host/ioctl.c
+++ b/drivers/nvme/host/ioctl.c
@@ -68,7 +68,7 @@ static struct request *nvme_alloc_user_request(struct request_queue *q,
struct nvme_command *cmd, void __user *ubuffer,
unsigned bufflen, void __user *meta_buffer, unsigned meta_len,
u32 meta_seed, void **metap, unsigned timeout, bool vec,
- unsigned int rq_flags, blk_mq_req_flags_t blk_flags)
+ blk_opf_t rq_flags, blk_mq_req_flags_t blk_flags)
{
bool write = nvme_is_write(cmd);
struct nvme_ns *ns = q->queuedata;
@@ -407,7 +407,7 @@ static int nvme_uring_cmd_io(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
struct nvme_uring_data d;
struct nvme_command c;
struct request *req;
- unsigned int rq_flags = 0;
+ blk_opf_t rq_flags = 0;
blk_mq_req_flags_t blk_flags = 0;
void *meta = NULL;
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index 0da94b233fed..ac9753674d5d 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -733,7 +733,7 @@ void nvme_wait_freeze(struct nvme_ctrl *ctrl);
int nvme_wait_freeze_timeout(struct nvme_ctrl *ctrl, long timeout);
void nvme_start_freeze(struct nvme_ctrl *ctrl);
-static inline unsigned int nvme_req_op(struct nvme_command *cmd)
+static inline enum req_op nvme_req_op(struct nvme_command *cmd)
{
return nvme_is_write(cmd) ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN;
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 28/51] nvme/target: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (26 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 27/51] nvme/host: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-26 9:25 ` Sagi Grimberg
2022-06-23 18:05 ` [PATCH 29/51] scsi/core: Improve static type checking Bart Van Assche
` (23 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Sagi Grimberg,
Chaitanya Kulkarni
Improve static type checking by using the new blk_opf_t type for variables
that represent a request operation combined with request flags.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Sagi Grimberg <sagi@grimberg.me>
Cc: Chaitanya Kulkarni <kch@nvidia.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/nvme/target/io-cmd-bdev.c | 3 ++-
drivers/nvme/target/zns.c | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/drivers/nvme/target/io-cmd-bdev.c b/drivers/nvme/target/io-cmd-bdev.c
index 27a72504d31c..306d97b3840f 100644
--- a/drivers/nvme/target/io-cmd-bdev.c
+++ b/drivers/nvme/target/io-cmd-bdev.c
@@ -246,7 +246,8 @@ static void nvmet_bdev_execute_rw(struct nvmet_req *req)
struct scatterlist *sg;
struct blk_plug plug;
sector_t sector;
- int op, i, rc;
+ blk_opf_t op;
+ 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;
diff --git a/drivers/nvme/target/zns.c b/drivers/nvme/target/zns.c
index 62afb7936132..c5e315d57d60 100644
--- a/drivers/nvme/target/zns.c
+++ b/drivers/nvme/target/zns.c
@@ -525,7 +525,7 @@ static void nvmet_bdev_zone_append_bio_done(struct bio *bio)
void nvmet_bdev_execute_zone_append(struct nvmet_req *req)
{
sector_t sect = nvmet_lba_to_sect(req->ns, req->cmd->rw.slba);
- const unsigned int op = REQ_OP_ZONE_APPEND | REQ_SYNC | REQ_IDLE;
+ const blk_opf_t op = REQ_OP_ZONE_APPEND | REQ_SYNC | REQ_IDLE;
u16 status = NVME_SC_SUCCESS;
unsigned int total_len = 0;
struct scatterlist *sg;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 29/51] scsi/core: Improve static type checking
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (27 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 28/51] nvme/target: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 30/51] scsi/core: Change the return type of scsi_noretry_cmd() into bool Bart Van Assche
` (22 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche,
Martin K . Petersen, John Garry, Mike Christie
Improve static type checking by using enum req_op where appropriate.
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: John Garry <john.garry@huawei.com>
Cc: Mike Christie <michael.christie@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/scsi/scsi_lib.c | 4 ++--
include/scsi/scsi_cmnd.h | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 6ffc9e4258a8..6b6a7a4b0950 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1125,8 +1125,8 @@ static void scsi_initialize_rq(struct request *rq)
cmd->retries = 0;
}
-struct request *scsi_alloc_request(struct request_queue *q,
- unsigned int op, blk_mq_req_flags_t flags)
+struct request *scsi_alloc_request(struct request_queue *q, enum req_op op,
+ blk_mq_req_flags_t flags)
{
struct request *rq;
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 1e80e70dfa92..6df0af7dd508 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -387,6 +387,6 @@ extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
u8 key, u8 asc, u8 ascq);
struct request *scsi_alloc_request(struct request_queue *q,
- unsigned int op, blk_mq_req_flags_t flags);
+ enum req_op op, blk_mq_req_flags_t flags);
#endif /* _SCSI_SCSI_CMND_H */
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 30/51] scsi/core: Change the return type of scsi_noretry_cmd() into bool
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (28 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 29/51] scsi/core: Improve static type checking Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 31/51] scsi/core: Use the new blk_opf_t type Bart Van Assche
` (21 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche,
Martin K . Petersen, John Garry, Mike Christie
This patch prepares for introducing the new blk_opf_t type in the SCSI core.
Since the value returned by scsi_noretry_cmd() is only used in boolean
expressions, this patch does not change any functionality.
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: John Garry <john.garry@huawei.com>
Cc: Mike Christie <michael.christie@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/scsi/scsi_error.c | 10 +++++-----
drivers/scsi/scsi_priv.h | 2 +-
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 49ef864df581..60bcb37acafd 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1779,7 +1779,7 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q,
* scsi_noretry_cmd - determine if command should be failed fast
* @scmd: SCSI cmd to examine.
*/
-int scsi_noretry_cmd(struct scsi_cmnd *scmd)
+bool scsi_noretry_cmd(struct scsi_cmnd *scmd)
{
struct request *req = scsi_cmd_to_rq(scmd);
@@ -1794,14 +1794,14 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
return req->cmd_flags & REQ_FAILFAST_DEV;
case DID_ERROR:
if (get_status_byte(scmd) == SAM_STAT_RESERVATION_CONFLICT)
- return 0;
+ return false;
fallthrough;
case DID_SOFT_ERROR:
return req->cmd_flags & REQ_FAILFAST_DRIVER;
}
if (!scsi_status_is_check_condition(scmd->result))
- return 0;
+ return false;
check_type:
/*
@@ -1809,9 +1809,9 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
* the check condition was retryable.
*/
if (req->cmd_flags & REQ_FAILFAST_DEV || blk_rq_is_passthrough(req))
- return 1;
+ return true;
- return 0;
+ return false;
}
/**
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 5c4786310a31..90fbffca7eb0 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -82,7 +82,7 @@ void scsi_eh_ready_devs(struct Scsi_Host *shost,
struct list_head *done_q);
int scsi_eh_get_sense(struct list_head *work_q,
struct list_head *done_q);
-int scsi_noretry_cmd(struct scsi_cmnd *scmd);
+bool scsi_noretry_cmd(struct scsi_cmnd *scmd);
void scsi_eh_done(struct scsi_cmnd *scmd);
/* scsi_lib.c */
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 31/51] scsi/core: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (29 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 30/51] scsi/core: Change the return type of scsi_noretry_cmd() into bool Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 32/51] scsi/device_handlers: " Bart Van Assche
` (20 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche,
Martin K . Petersen, John Garry, Mike Christie
Use the new blk_opf_t type for arguments and variables that represent
request flags. Use the !! operator in scsi_noretry_cmd() to convert the
blk_opf_t type into a boolean. This patch does not change any functionality.
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: John Garry <john.garry@huawei.com>
Cc: Mike Christie <michael.christie@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/scsi/scsi_error.c | 6 +++---
drivers/scsi/scsi_lib.c | 6 +++---
include/scsi/scsi_device.h | 2 +-
3 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 60bcb37acafd..4b8686162ddd 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1789,15 +1789,15 @@ bool scsi_noretry_cmd(struct scsi_cmnd *scmd)
case DID_TIME_OUT:
goto check_type;
case DID_BUS_BUSY:
- return req->cmd_flags & REQ_FAILFAST_TRANSPORT;
+ return !!(req->cmd_flags & REQ_FAILFAST_TRANSPORT);
case DID_PARITY:
- return req->cmd_flags & REQ_FAILFAST_DEV;
+ return !!(req->cmd_flags & REQ_FAILFAST_DEV);
case DID_ERROR:
if (get_status_byte(scmd) == SAM_STAT_RESERVATION_CONFLICT)
return false;
fallthrough;
case DID_SOFT_ERROR:
- return req->cmd_flags & REQ_FAILFAST_DRIVER;
+ return !!(req->cmd_flags & REQ_FAILFAST_DRIVER);
}
if (!scsi_status_is_check_condition(scmd->result))
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 6b6a7a4b0950..beff0015258a 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -209,8 +209,8 @@ void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
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 *resid)
+ int timeout, int retries, blk_opf_t flags,
+ req_flags_t rq_flags, int *resid)
{
struct request *req;
struct scsi_cmnd *scmd;
@@ -633,7 +633,7 @@ static blk_status_t scsi_result_to_blk_status(struct scsi_cmnd *cmd, int result)
*/
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;
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 7cf5f3b7589f..2493bd65351a 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -457,7 +457,7 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
extern 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,
+ int timeout, int retries, blk_opf_t flags,
req_flags_t rq_flags, int *resid);
/* Make sure any sense buffer is the correct size. */
#define scsi_execute(sdev, cmd, data_direction, buffer, bufflen, sense, \
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 32/51] scsi/device_handlers: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (30 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 31/51] scsi/core: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 33/51] scsi/ufs: Rename a 'dir' argument into 'op' Bart Van Assche
` (19 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Hannes Reinecke
Improve static type checking by using the new blk_opf_t type for variables
that represent request flags.
Cc: Hannes Reinecke <hare@suse.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/scsi/device_handler/scsi_dh_alua.c | 4 ++--
drivers/scsi/device_handler/scsi_dh_emc.c | 2 +-
drivers/scsi/device_handler/scsi_dh_hp_sw.c | 4 ++--
drivers/scsi/device_handler/scsi_dh_rdac.c | 2 +-
4 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 1d9be771f3ee..610a51538f03 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -127,7 +127,7 @@ static int submit_rtpg(struct scsi_device *sdev, unsigned char *buff,
int bufflen, struct scsi_sense_hdr *sshdr, int flags)
{
u8 cdb[MAX_COMMAND_SIZE];
- int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
/* Prepare the command. */
@@ -157,7 +157,7 @@ static int submit_stpg(struct scsi_device *sdev, int group_id,
u8 cdb[MAX_COMMAND_SIZE];
unsigned char stpg_data[8];
int stpg_len = 8;
- int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
/* Prepare the data buffer */
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index bd28ec6cfb72..2e21ab447873 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -239,7 +239,7 @@ static int send_trespass_cmd(struct scsi_device *sdev,
unsigned char cdb[MAX_COMMAND_SIZE];
int err, res = SCSI_DH_OK, len;
struct scsi_sense_hdr sshdr;
- u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
if (csdev->flags & CLARIION_SHORT_TRESPASS) {
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index 4a3f7831a2d6..0d2cfa60aa06 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -83,7 +83,7 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
unsigned char cmd[6] = { TEST_UNIT_READY };
struct scsi_sense_hdr sshdr;
int ret = SCSI_DH_OK, res;
- u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
retry:
@@ -121,7 +121,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
struct scsi_device *sdev = h->sdev;
int res, rc = SCSI_DH_OK;
int retry_cnt = HP_SW_RETRIES;
- u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
retry:
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 66652ab409cc..bf8754741f85 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -536,7 +536,7 @@ static void send_mode_select(struct work_struct *work)
unsigned char cdb[MAX_COMMAND_SIZE];
struct scsi_sense_hdr sshdr;
unsigned int data_size;
- u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
+ blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER;
spin_lock(&ctlr->ms_lock);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 33/51] scsi/ufs: Rename a 'dir' argument into 'op'
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (31 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 32/51] scsi/device_handlers: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 19:09 ` Avri Altman
2022-06-23 18:05 ` [PATCH 34/51] scsi/target: Use the new blk_opf_t type Bart Van Assche
` (18 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche,
Martin K . Petersen, Avri Altman
Improve consistency of the kernel code by renaming a request operation
argument from 'dir' into 'op'.
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: Avri Altman <avri.altman@wdc.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/ufs/core/ufshpb.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/ufs/core/ufshpb.c b/drivers/ufs/core/ufshpb.c
index 24f1ee82c215..a1a7a1175a5a 100644
--- a/drivers/ufs/core/ufshpb.c
+++ b/drivers/ufs/core/ufshpb.c
@@ -434,7 +434,7 @@ int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
}
static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb, int rgn_idx,
- enum req_op dir, bool atomic)
+ enum req_op op, bool atomic)
{
struct ufshpb_req *rq;
struct request *req;
@@ -445,7 +445,7 @@ static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb, int rgn_idx,
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)) {
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 34/51] scsi/target: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (32 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 33/51] scsi/ufs: Rename a 'dir' argument into 'op' Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 35/51] mm: " Bart Van Assche
` (17 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Mike Christie
Improve static type checking by using the new blk_opf_t type for variables
that represent a request operation combined with request flags.
Cc: Mike Christie <michael.christie@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
drivers/target/target_core_iblock.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 378c80313a0f..5fef19af88df 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -343,7 +343,7 @@ static void iblock_bio_done(struct bio *bio)
}
static struct bio *iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num,
- unsigned int opf)
+ blk_opf_t opf)
{
struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
struct bio *bio;
@@ -719,7 +719,7 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
struct bio_list list;
struct scatterlist *sg;
u32 sg_num = sgl_nents;
- unsigned int opf;
+ blk_opf_t opf;
unsigned bio_cnt;
int i, rc;
struct sg_mapping_iter prot_miter;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 35/51] mm: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (33 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 34/51] scsi/target: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 36/51] fs/buffer: " Bart Van Assche
` (16 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Andrew Morton
Improve static type checking by using the new blk_opf_t type for block
layer request flags.
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
include/linux/writeback.h | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index b8c9610c2313..3f045f6d6c4f 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -101,9 +101,9 @@ struct writeback_control {
#endif
};
-static inline int wbc_to_write_flags(struct writeback_control *wbc)
+static inline blk_opf_t wbc_to_write_flags(struct writeback_control *wbc)
{
- int flags = 0;
+ blk_opf_t flags = 0;
if (wbc->punt_to_cgroup)
flags = REQ_CGROUP_PUNT;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 36/51] fs/buffer: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (34 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 35/51] mm: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 37/51] fs/direct-io: Use the enum req_op and blk_opf_t types Bart Van Assche
` (15 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Matthew Wilcox,
Jan Kara
Improve static type checking by using the new blk_opf_t type for block layer
request flags. Change WRITE into REQ_OP_WRITE. This patch does not change
any functionality since REQ_OP_WRITE == WRITE == 1.
Cc: Christoph Hellwig <hch@lst.de>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Jan Kara <jack@suse.cz>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/buffer.c | 21 +++++++++++----------
include/linux/buffer_head.h | 9 +++++----
2 files changed, 16 insertions(+), 14 deletions(-)
diff --git a/fs/buffer.c b/fs/buffer.c
index 898c7f301b1b..4a00b61f35ec 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -52,8 +52,8 @@
#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,
- struct writeback_control *wbc);
+static int submit_bh_wbc(enum req_op op, blk_opf_t op_flags,
+ struct buffer_head *bh, struct writeback_control *wbc);
#define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
@@ -1716,7 +1716,7 @@ int __block_write_full_page(struct inode *inode, struct page *page,
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));
@@ -2994,8 +2994,8 @@ static void end_bio_bh_io_sync(struct bio *bio)
bio_put(bio);
}
-static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
- struct writeback_control *wbc)
+static int submit_bh_wbc(enum req_op op, blk_opf_t op_flags,
+ struct buffer_head *bh, struct writeback_control *wbc)
{
struct bio *bio;
@@ -3040,7 +3040,7 @@ static int submit_bh_wbc(int op, int op_flags, struct buffer_head *bh,
return 0;
}
-int submit_bh(int op, int op_flags, struct buffer_head *bh)
+int submit_bh(enum req_op op, blk_opf_t op_flags, struct buffer_head *bh)
{
return submit_bh_wbc(op, op_flags, bh, NULL);
}
@@ -3072,7 +3072,8 @@ EXPORT_SYMBOL(submit_bh);
* 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(enum req_op op, blk_opf_t op_flags, int nr,
+ struct buffer_head *bhs[])
{
int i;
@@ -3081,7 +3082,7 @@ void ll_rw_block(int op, int op_flags, int nr, struct buffer_head *bhs[])
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);
@@ -3101,7 +3102,7 @@ void ll_rw_block(int op, int op_flags, int nr, struct buffer_head *bhs[])
}
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)) {
@@ -3119,7 +3120,7 @@ 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;
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index c9d1463bb20f..9795df9400bd 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -9,6 +9,7 @@
#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>
@@ -201,11 +202,11 @@ struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
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(enum req_op, 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);
-void write_dirty_buffer(struct buffer_head *bh, int op_flags);
-int submit_bh(int, int, struct buffer_head *);
+int __sync_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
+void write_dirty_buffer(struct buffer_head *bh, blk_opf_t op_flags);
+int submit_bh(enum req_op, 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);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 37/51] fs/direct-io: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (35 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 36/51] fs/buffer: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 38/51] fs/mpage: Use the new blk_opf_t type Bart Van Assche
` (14 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Al Viro
Improve static type checking by using the enum req_op type for block layer
request operations and the new blk_opf_t type for block layer request flags.
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/direct-io.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 840752006f60..9cfbb37ec62a 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -117,8 +117,8 @@ struct dio_submit {
/* dio_state communicated between submission path and end_io */
struct dio {
int flags; /* doesn't change */
- int op;
- int op_flags;
+ enum req_op op;
+ blk_opf_t op_flags;
struct gendisk *bio_disk;
struct inode *inode;
loff_t i_size; /* i_size when submitted */
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 38/51] fs/mpage: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (36 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 37/51] fs/direct-io: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 39/51] fs/btrfs: Use the enum req_op and blk_opf_t types Bart Van Assche
` (13 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Al Viro
Improve static type checking by using the new blk_opf_t type for the
combination of a block layer request with block layer request flags.
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/mpage.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/mpage.c b/fs/mpage.c
index 0d25f44f5707..5830705672dd 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -145,7 +145,7 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)
struct block_device *bdev = NULL;
int length;
int fully_mapped = 1;
- int op = REQ_OP_READ;
+ blk_opf_t op = REQ_OP_READ;
unsigned nblocks;
unsigned relative_block;
gfp_t gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 39/51] fs/btrfs: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (37 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 38/51] fs/mpage: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 40/51] fs/ext4: Use the new blk_opf_t type Bart Van Assche
` (12 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, David Sterba,
Josef Bacik
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: David Sterba <dsterba@suse.com>
Cc: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/btrfs/check-integrity.c | 4 ++--
fs/btrfs/compression.c | 6 +++---
fs/btrfs/compression.h | 2 +-
fs/btrfs/extent_io.c | 18 +++++++++---------
fs/btrfs/inode.c | 4 ++--
fs/btrfs/raid56.c | 4 ++--
6 files changed, 19 insertions(+), 19 deletions(-)
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 5d20137b7b67..98c6e5feab19 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -152,7 +152,7 @@ struct btrfsic_block {
struct btrfsic_block *next_in_same_bio;
void *orig_bio_private;
bio_end_io_t *orig_bio_end_io;
- int submit_bio_bh_rw;
+ blk_opf_t submit_bio_bh_rw;
u64 flush_gen; /* only valid if !never_written */
};
@@ -1681,7 +1681,7 @@ static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state,
u64 dev_bytenr, char **mapped_datav,
unsigned int num_pages,
struct bio *bio, int *bio_is_patched,
- int submit_bio_bh_rw)
+ blk_opf_t submit_bio_bh_rw)
{
int is_metadata;
struct btrfsic_block *block;
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index f4564f32f6d9..a82b9f17f476 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -455,7 +455,7 @@ static blk_status_t submit_compressed_bio(struct btrfs_fs_info *fs_info,
static struct bio *alloc_compressed_bio(struct compressed_bio *cb, u64 disk_bytenr,
- unsigned int opf, bio_end_io_t endio_func,
+ blk_opf_t opf, bio_end_io_t endio_func,
u64 *next_stripe_start)
{
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,
unsigned int compressed_len,
struct page **compressed_pages,
unsigned int nr_pages,
- unsigned int write_flags,
+ blk_opf_t write_flags,
struct cgroup_subsys_state *blkcg_css,
bool writeback)
{
@@ -517,7 +517,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
blk_status_t ret;
int skip_sum = inode->flags & BTRFS_INODE_NODATASUM;
const bool use_append = btrfs_use_zone_append(inode, disk_start);
- const unsigned int bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;
+ const enum req_op bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;
ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
IS_ALIGNED(len, fs_info->sectorsize));
diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h
index 2707404389a5..2b56d63e01ce 100644
--- a/fs/btrfs/compression.h
+++ b/fs/btrfs/compression.h
@@ -99,7 +99,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
unsigned int compressed_len,
struct page **compressed_pages,
unsigned int nr_pages,
- unsigned int write_flags,
+ blk_opf_t write_flags,
struct cgroup_subsys_state *blkcg_css,
bool writeback);
void btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 8f6b544ae616..10f8df7f883d 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3357,7 +3357,7 @@ static int calc_bio_boundaries(struct btrfs_bio_ctrl *bio_ctrl,
static int alloc_new_bio(struct btrfs_inode *inode,
struct btrfs_bio_ctrl *bio_ctrl,
struct writeback_control *wbc,
- unsigned int opf,
+ blk_opf_t opf,
bio_end_io_t end_io_func,
u64 disk_bytenr, u32 offset, u64 file_offset,
enum btrfs_compression_type compress_type)
@@ -3437,7 +3437,7 @@ static int alloc_new_bio(struct btrfs_inode *inode,
* @prev_bio_flags: flags of previous bio to see if we can merge the current one
* @compress_type: compress type for current bio
*/
-static int submit_extent_page(unsigned int opf,
+static int submit_extent_page(blk_opf_t opf,
struct writeback_control *wbc,
struct btrfs_bio_ctrl *bio_ctrl,
struct page *page, u64 disk_bytenr,
@@ -3615,7 +3615,7 @@ __get_extent_map(struct inode *inode, struct page *page, size_t pg_offset,
*/
static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
struct btrfs_bio_ctrl *bio_ctrl,
- unsigned int read_flags, u64 *prev_em_start)
+ blk_opf_t read_flags, u64 *prev_em_start)
{
struct inode *inode = page->mapping->host;
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -3983,8 +3983,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
int saved_ret = 0;
int ret = 0;
int nr = 0;
- u32 opf = REQ_OP_WRITE;
- const unsigned int write_flags = wbc_to_write_flags(wbc);
+ enum req_op op = REQ_OP_WRITE;
+ const blk_opf_t write_flags = wbc_to_write_flags(wbc);
bool has_error = false;
bool compressed;
@@ -4058,7 +4058,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
iosize = min(min(em_end, end + 1), dirty_range_end) - cur;
if (btrfs_use_zone_append(inode, em->block_start))
- opf = REQ_OP_ZONE_APPEND;
+ op = REQ_OP_ZONE_APPEND;
free_extent_map(em);
em = NULL;
@@ -4094,7 +4094,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
*/
btrfs_page_clear_dirty(fs_info, page, cur, iosize);
- ret = submit_extent_page(opf | write_flags, wbc,
+ ret = submit_extent_page(op | write_flags, wbc,
&epd->bio_ctrl, page,
disk_bytenr, iosize,
cur - page_offset(page),
@@ -4575,7 +4575,7 @@ static int write_one_subpage_eb(struct extent_buffer *eb,
{
struct btrfs_fs_info *fs_info = eb->fs_info;
struct page *page = eb->pages[0];
- unsigned int write_flags = wbc_to_write_flags(wbc) | REQ_META;
+ blk_opf_t write_flags = wbc_to_write_flags(wbc) | REQ_META;
bool no_dirty_ebs = false;
int ret;
@@ -4620,7 +4620,7 @@ static noinline_for_stack int write_one_eb(struct extent_buffer *eb,
{
u64 disk_bytenr = eb->start;
int i, num_pages;
- unsigned int write_flags = wbc_to_write_flags(wbc) | REQ_META;
+ blk_opf_t write_flags = wbc_to_write_flags(wbc) | REQ_META;
int ret = 0;
prepare_eb_write(eb);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 81737eff92f3..724f8f7e3599 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -485,7 +485,7 @@ struct async_chunk {
struct page *locked_page;
u64 start;
u64 end;
- unsigned int write_flags;
+ blk_opf_t write_flags;
struct list_head extents;
struct cgroup_subsys_state *blkcg_css;
struct btrfs_work work;
@@ -1435,7 +1435,7 @@ static int cow_file_range_async(struct btrfs_inode *inode,
int i;
bool should_compress;
unsigned nofs_flag;
- const unsigned int write_flags = wbc_to_write_flags(wbc);
+ const blk_opf_t write_flags = wbc_to_write_flags(wbc);
unlock_extent(&inode->io_tree, start, end);
diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index a5b623ee6fac..c520412d1f86 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -1136,7 +1136,7 @@ static int rbio_add_io_sector(struct btrfs_raid_bio *rbio,
unsigned int stripe_nr,
unsigned int sector_nr,
unsigned long bio_max_len,
- unsigned int opf)
+ enum req_op op)
{
const u32 sectorsize = rbio->bioc->fs_info->sectorsize;
struct bio *last = bio_list->tail;
@@ -1181,7 +1181,7 @@ static int rbio_add_io_sector(struct btrfs_raid_bio *rbio,
/* put a new bio on the list */
bio = bio_alloc(stripe->dev->bdev, max(bio_max_len >> PAGE_SHIFT, 1UL),
- opf, GFP_NOFS);
+ op, GFP_NOFS);
bio->bi_iter.bi_sector = disk_start >> 9;
bio->bi_private = rbio;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 40/51] fs/ext4: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (38 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 39/51] fs/btrfs: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 41/51] fs/f2fs: Use the enum req_op and blk_opf_t types Bart Van Assche
` (11 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Theodore Ts'o
Improve static type checking by using the new blk_opf_t type for
variables that represent request flags.
Cc: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/ext4/ext4.h | 8 ++++----
fs/ext4/fast_commit.c | 2 +-
fs/ext4/super.c | 14 +++++++-------
3 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 75b8d81b2469..29fc575a4eb6 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -3058,14 +3058,14 @@ extern unsigned int ext4_list_backups(struct super_block *sb,
/* super.c */
extern struct buffer_head *ext4_sb_bread(struct super_block *sb,
- sector_t block, int op_flags);
+ sector_t block, blk_opf_t op_flags);
extern struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
sector_t block);
-extern void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
+extern void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
bh_end_io_t *end_io);
-extern int ext4_read_bh(struct buffer_head *bh, int op_flags,
+extern int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
bh_end_io_t *end_io);
-extern int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait);
+extern int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait);
extern void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block);
extern int ext4_seq_options_show(struct seq_file *seq, void *offset);
extern int ext4_calculate_overhead(struct super_block *sb);
diff --git a/fs/ext4/fast_commit.c b/fs/ext4/fast_commit.c
index 795a60ad1897..de6c73d0f431 100644
--- a/fs/ext4/fast_commit.c
+++ b/fs/ext4/fast_commit.c
@@ -658,7 +658,7 @@ void ext4_fc_track_range(handle_t *handle, struct inode *inode, ext4_lblk_t star
static void ext4_fc_submit_bh(struct super_block *sb, bool is_tail)
{
- int write_flags = REQ_SYNC;
+ blk_opf_t write_flags = REQ_SYNC;
struct buffer_head *bh = EXT4_SB(sb)->s_fc_bh;
/* Add REQ_FUA | REQ_PREFLUSH only its tail */
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 845f2f8aee5f..1d7f65088ddc 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -159,7 +159,7 @@ MODULE_ALIAS("ext3");
#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
-static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,
+static inline void __ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
bh_end_io_t *end_io)
{
/*
@@ -174,7 +174,7 @@ static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,
submit_bh(REQ_OP_READ, op_flags, bh);
}
-void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
+void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
bh_end_io_t *end_io)
{
BUG_ON(!buffer_locked(bh));
@@ -186,7 +186,7 @@ void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
__ext4_read_bh(bh, op_flags, end_io);
}
-int ext4_read_bh(struct buffer_head *bh, int op_flags, bh_end_io_t *end_io)
+int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags, bh_end_io_t *end_io)
{
BUG_ON(!buffer_locked(bh));
@@ -203,7 +203,7 @@ int ext4_read_bh(struct buffer_head *bh, int op_flags, bh_end_io_t *end_io)
return -EIO;
}
-int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)
+int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait)
{
if (trylock_buffer(bh)) {
if (wait)
@@ -227,8 +227,8 @@ int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)
* return.
*/
static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
- sector_t block, int op_flags,
- gfp_t gfp)
+ sector_t block,
+ blk_opf_t op_flags, gfp_t gfp)
{
struct buffer_head *bh;
int ret;
@@ -248,7 +248,7 @@ static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
}
struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,
- int op_flags)
+ blk_opf_t op_flags)
{
return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
}
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 41/51] fs/f2fs: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (39 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 40/51] fs/ext4: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 42/51] fs/gfs2: " Bart Van Assche
` (10 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Jaegeuk Kim
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/f2fs/data.c | 11 ++++++-----
fs/f2fs/f2fs.h | 6 +++---
fs/f2fs/node.c | 2 +-
fs/f2fs/segment.c | 2 +-
include/trace/events/f2fs.h | 28 +++++++++++++++-------------
5 files changed, 26 insertions(+), 23 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 7fcbcf979737..5c13ee321940 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -387,11 +387,11 @@ int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr)
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;
@@ -999,7 +999,7 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
}
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);
@@ -1047,7 +1047,8 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,
/* 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;
@@ -1181,7 +1182,7 @@ int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index)
}
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;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index d9bbecd008d2..868170b72de9 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1183,8 +1183,8 @@ struct f2fs_io_info {
nid_t ino; /* inode number */
enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
enum temp_type temp; /* contains HOT/WARM/COLD */
- int op; /* contains REQ_OP_ */
- int op_flags; /* req_flag_bits */
+ enum req_op op; /* contains REQ_OP_ */
+ blk_opf_t op_flags; /* req_flag_bits */
block_t new_blkaddr; /* new block address to be written */
block_t old_blkaddr; /* old block address before Cow */
struct page *page; /* page to be written */
@@ -3741,7 +3741,7 @@ int f2fs_reserve_new_block(struct dnode_of_data *dn);
int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
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 page *f2fs_find_data_page(struct inode *inode, pgoff_t index);
struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
bool for_write);
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 836c79a20afc..c4f1e895ebd2 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1327,7 +1327,7 @@ struct page *f2fs_new_node_page(struct dnode_of_data *dn, unsigned int ofs)
* 0: f2fs_put_page(page, 0)
* LOCKED_PAGE or error: f2fs_put_page(page, 1)
*/
-static int read_node_page(struct page *page, int op_flags)
+static int read_node_page(struct page *page, blk_opf_t op_flags)
{
struct f2fs_sb_info *sbi = F2FS_P_SB(page);
struct node_info ni;
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 874c1b9c41a2..c7afc588cf26 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1082,7 +1082,7 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,
struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
struct list_head *wait_list = (dpolicy->type == DPOLICY_FSTRIM) ?
&(dcc->fstrim_list) : &(dcc->wait_list);
- int flag = dpolicy->sync ? REQ_SYNC : 0;
+ blk_opf_t flag = dpolicy->sync ? REQ_SYNC : 0;
block_t lstart, start, len, total_len;
int err = 0;
diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index 513e889ef8aa..0f51b2e9c3d0 100644
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -66,7 +66,7 @@ TRACE_DEFINE_ENUM(CP_RESIZE);
#define F2FS_OP_FLAGS (REQ_RAHEAD | REQ_SYNC | REQ_META | REQ_PRIO | \
REQ_PREFLUSH | REQ_FUA)
-#define F2FS_BIO_FLAG_MASK(t) (t & F2FS_OP_FLAGS)
+#define F2FS_BIO_FLAG_MASK(t) ((t) & (__force u32)F2FS_OP_FLAGS)
#define show_bio_type(op,op_flags) show_bio_op(op), \
show_bio_op_flags(op_flags)
@@ -75,12 +75,12 @@ TRACE_DEFINE_ENUM(CP_RESIZE);
#define show_bio_op_flags(flags) \
__print_flags(F2FS_BIO_FLAG_MASK(flags), "|", \
- { REQ_RAHEAD, "R" }, \
- { REQ_SYNC, "S" }, \
- { REQ_META, "M" }, \
- { REQ_PRIO, "P" }, \
- { REQ_PREFLUSH, "PF" }, \
- { REQ_FUA, "FUA" })
+ { (__force u32)REQ_RAHEAD, "R" }, \
+ { (__force u32)REQ_SYNC, "S" }, \
+ { (__force u32)REQ_META, "M" }, \
+ { (__force u32)REQ_PRIO, "P" }, \
+ { (__force u32)REQ_PREFLUSH, "PF" }, \
+ { (__force u32)REQ_FUA, "FUA" })
#define show_data_type(type) \
__print_symbolic(type, \
@@ -1048,8 +1048,8 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
__entry->index = page->index;
__entry->old_blkaddr = fio->old_blkaddr;
__entry->new_blkaddr = fio->new_blkaddr;
- __entry->op = fio->op;
- __entry->op_flags = fio->op_flags;
+ __entry->op = (__force int)fio->op;
+ __entry->op_flags = (__force int)fio->op_flags;
__entry->temp = fio->temp;
__entry->type = fio->type;
),
@@ -1060,7 +1060,8 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
(unsigned long)__entry->index,
(unsigned long long)__entry->old_blkaddr,
(unsigned long long)__entry->new_blkaddr,
- show_bio_type(__entry->op, __entry->op_flags),
+ show_bio_type((__force enum req_op)__entry->op,
+ __entry->op_flags),
show_block_temp(__entry->temp),
show_block_type(__entry->type))
);
@@ -1102,8 +1103,8 @@ DECLARE_EVENT_CLASS(f2fs__bio,
TP_fast_assign(
__entry->dev = sb->s_dev;
__entry->target = bio_dev(bio);
- __entry->op = bio_op(bio);
- __entry->op_flags = bio->bi_opf;
+ __entry->op = (__force int)bio_op(bio);
+ __entry->op_flags = (__force int)bio->bi_opf;
__entry->type = type;
__entry->sector = bio->bi_iter.bi_sector;
__entry->size = bio->bi_iter.bi_size;
@@ -1112,7 +1113,8 @@ DECLARE_EVENT_CLASS(f2fs__bio,
TP_printk("dev = (%d,%d)/(%d,%d), rw = %s(%s), %s, sector = %lld, size = %u",
show_dev(__entry->target),
show_dev(__entry->dev),
- show_bio_type(__entry->op, __entry->op_flags),
+ show_bio_type((__force enum req_op)__entry->op,
+ __entry->op_flags),
show_block_type(__entry->type),
(unsigned long long)__entry->sector,
__entry->size)
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 42/51] fs/gfs2: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (40 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 41/51] fs/f2fs: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 43/51] fs/hfsplus: " Bart Van Assche
` (9 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Bob Peterson,
Andreas Gruenbacher
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Bob Peterson <rpeterso@redhat.com>
Cc: Andreas Gruenbacher <agruenba@redhat.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/gfs2/log.c | 4 ++--
fs/gfs2/log.h | 2 +-
fs/gfs2/lops.c | 4 ++--
fs/gfs2/lops.h | 2 +-
fs/gfs2/meta_io.c | 6 +++---
5 files changed, 9 insertions(+), 9 deletions(-)
diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index f0ee3ff6f9a8..eec4159b08aa 100644
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -823,7 +823,7 @@ void gfs2_flush_revokes(struct gfs2_sbd *sdp)
void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
u64 seq, u32 tail, u32 lblock, u32 flags,
- int op_flags)
+ blk_opf_t op_flags)
{
struct gfs2_log_header *lh;
u32 hash, crc;
@@ -905,7 +905,7 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
{
- int op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC;
+ blk_opf_t op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC;
enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
gfs2_assert_withdraw(sdp, (state != SFS_FROZEN));
diff --git a/fs/gfs2/log.h b/fs/gfs2/log.h
index fc905c2af53c..653cffcbf869 100644
--- a/fs/gfs2/log.h
+++ b/fs/gfs2/log.h
@@ -82,7 +82,7 @@ extern void gfs2_log_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
unsigned int *extra_revokes);
extern void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
u64 seq, u32 tail, u32 lblock, u32 flags,
- int op_flags);
+ blk_opf_t op_flags);
extern void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
u32 type);
extern void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *trans);
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 6ba51cbb94cf..90a2d7bc91c4 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -238,7 +238,7 @@ static void gfs2_end_log_write(struct bio *bio)
* there is no pending bio, then this is a no-op.
*/
-void gfs2_log_submit_bio(struct bio **biop, int opf)
+void gfs2_log_submit_bio(struct bio **biop, blk_opf_t opf)
{
struct bio *bio = *biop;
if (bio) {
@@ -292,7 +292,7 @@ static struct bio *gfs2_log_alloc_bio(struct gfs2_sbd *sdp, u64 blkno,
*/
static struct bio *gfs2_log_get_bio(struct gfs2_sbd *sdp, u64 blkno,
- struct bio **biop, int op,
+ struct bio **biop, enum req_op op,
bio_end_io_t *end_io, bool flush)
{
struct bio *bio = *biop;
diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
index f707601597dc..1412ffba1d44 100644
--- a/fs/gfs2/lops.h
+++ b/fs/gfs2/lops.h
@@ -16,7 +16,7 @@ extern u64 gfs2_log_bmap(struct gfs2_jdesc *jd, unsigned int lbn);
extern void gfs2_log_write(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
struct page *page, unsigned size, unsigned offset,
u64 blkno);
-extern void gfs2_log_submit_bio(struct bio **biop, int opf);
+extern void gfs2_log_submit_bio(struct bio **biop, blk_opf_t opf);
extern void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh);
extern int gfs2_find_jhead(struct gfs2_jdesc *jd,
struct gfs2_log_header_host *head, bool keep_cache);
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 868dcc71b581..fe0fdec628ea 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -34,7 +34,7 @@ static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wb
{
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));
@@ -217,8 +217,8 @@ static void gfs2_meta_read_endio(struct bio *bio)
* 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[],
- int num)
+static void gfs2_submit_bhs(enum req_op op, blk_opf_t op_flags,
+ struct buffer_head *bhs[], int num)
{
while (num > 0) {
struct buffer_head *bh = *bhs;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 43/51] fs/hfsplus: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (41 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 42/51] fs/gfs2: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 44/51] fs/iomap: Use the new blk_opf_t type Bart Van Assche
` (8 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/hfsplus/hfsplus_fs.h | 2 +-
fs/hfsplus/wrapper.c | 5 +++--
2 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 396e73aa0961..ac93c2445b29 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -525,7 +525,7 @@ int hfsplus_compare_dentry(const struct dentry *dentry, unsigned int len,
/* wrapper.c */
int hfsplus_submit_bio(struct super_block *sb, sector_t sector, void *buf,
- void **data, int op, int op_flags);
+ void **data, enum req_op op, blk_opf_t op_flags);
int hfsplus_read_wrapper(struct super_block *sb);
/*
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 0b8ad6586df5..bf5e89748df0 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -45,7 +45,8 @@ struct hfsplus_wd {
* 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, enum req_op op,
+ blk_opf_t op_flags)
{
struct bio *bio;
int ret = 0;
@@ -66,7 +67,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
bio = bio_alloc(sb->s_bdev, 1, op | op_flags, 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) {
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 44/51] fs/iomap: Use the new blk_opf_t type
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (42 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 43/51] fs/hfsplus: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 45/51] fs/jbd2: Fix the documentation of the jbd2_write_superblock() callers Bart Van Assche
` (7 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe; +Cc: linux-block, Christoph Hellwig, Bart Van Assche, Al Viro
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
the combination of a request operation and request flags.
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/iomap/direct-io.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
index 5d098adba443..18a3d9357dce 100644
--- a/fs/iomap/direct-io.c
+++ b/fs/iomap/direct-io.c
@@ -52,7 +52,7 @@ struct iomap_dio {
};
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,
@@ -212,10 +212,10 @@ static void iomap_dio_zero(const struct iomap_iter *iter, struct iomap_dio *dio,
* 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);
@@ -244,7 +244,7 @@ static loff_t iomap_dio_bio_iter(const struct iomap_iter *iter,
unsigned int fs_block_size = i_blocksize(inode), pad;
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;
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 45/51] fs/jbd2: Fix the documentation of the jbd2_write_superblock() callers
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (43 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 44/51] fs/iomap: Use the new blk_opf_t type Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types Bart Van Assche
` (6 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Mike Christie,
Theodore Ts'o
Commit 2a222ca992c3 ("fs: have submit_bh users pass in op and flags
separately") renamed the jbd2_write_superblock() 'write_op' argument into
'write_flags'. Propagate this change to the jbd2_write_superblock()
callers. Additionally, change the type of 'write_flags' into blk_opf_t.
Cc: Mike Christie <michael.christie@oracle.com>
Cc: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/jbd2/journal.c | 15 ++++++++-------
include/linux/jbd2.h | 2 +-
include/trace/events/jbd2.h | 12 ++++++------
3 files changed, 15 insertions(+), 14 deletions(-)
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index c0cbeeaec2d1..b1be8450c50c 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -1602,7 +1602,7 @@ static int journal_reset(journal_t *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;
@@ -1659,13 +1659,14 @@ static int jbd2_write_superblock(journal_t *journal, int write_flags)
* @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;
@@ -1685,7 +1686,7 @@ int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
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;
@@ -1702,12 +1703,12 @@ int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
/**
* 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;
@@ -1733,7 +1734,7 @@ static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
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);
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index e79d6e0b14e8..dc1724131300 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1557,7 +1557,7 @@ extern int jbd2_journal_wipe (journal_t *, int);
extern int jbd2_journal_skip_recovery (journal_t *);
extern void jbd2_journal_update_sb_errno(journal_t *);
extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
- unsigned long, int);
+ unsigned long, blk_opf_t);
extern void jbd2_journal_abort (journal_t *, int);
extern int jbd2_journal_errno (journal_t *);
extern void jbd2_journal_ack_err (journal_t *);
diff --git a/include/trace/events/jbd2.h b/include/trace/events/jbd2.h
index a4dfe005983d..91dae1f678fe 100644
--- a/include/trace/events/jbd2.h
+++ b/include/trace/events/jbd2.h
@@ -355,22 +355,22 @@ TRACE_EVENT(jbd2_update_log_tail,
TRACE_EVENT(jbd2_write_superblock,
- TP_PROTO(journal_t *journal, int write_op),
+ TP_PROTO(journal_t *journal, blk_opf_t write_flags),
- TP_ARGS(journal, write_op),
+ TP_ARGS(journal, write_flags),
TP_STRUCT__entry(
__field( dev_t, dev )
- __field( int, write_op )
+ __field( u32, write_flags )
),
TP_fast_assign(
__entry->dev = journal->j_fs_dev->bd_dev;
- __entry->write_op = write_op;
+ __entry->write_flags = (__force u32)write_flags;
),
- TP_printk("dev %d,%d write_op %x", MAJOR(__entry->dev),
- MINOR(__entry->dev), __entry->write_op)
+ TP_printk("dev %d,%d write_flags %x", MAJOR(__entry->dev),
+ MINOR(__entry->dev), __entry->write_flags)
);
TRACE_EVENT(jbd2_lock_buffer_stall,
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (44 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 45/51] fs/jbd2: Fix the documentation of the jbd2_write_superblock() callers Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-24 3:43 ` Ryusuke Konishi
2022-06-23 18:05 ` [PATCH 47/51] fs/ntfs3: Use enum req_op where appropriate Bart Van Assche
` (5 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Ryusuke Konishi
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/nilfs2/btnode.c | 4 ++--
fs/nilfs2/btnode.h | 5 +++--
fs/nilfs2/mdt.c | 3 ++-
include/trace/events/nilfs2.h | 4 ++--
4 files changed, 9 insertions(+), 7 deletions(-)
diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
index ca611ac09f7c..13784cf169ca 100644
--- a/fs/nilfs2/btnode.c
+++ b/fs/nilfs2/btnode.c
@@ -70,8 +70,8 @@ nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr)
}
int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
- sector_t pblocknr, int mode, int mode_flags,
- struct buffer_head **pbh, sector_t *submit_ptr)
+ sector_t pblocknr, enum req_op mode, blk_opf_t mode_flags,
+ struct buffer_head **pbh, sector_t *submit_ptr)
{
struct buffer_head *bh;
struct inode *inode = btnc->host;
diff --git a/fs/nilfs2/btnode.h b/fs/nilfs2/btnode.h
index bd5544e63a01..b7d2948dc74f 100644
--- a/fs/nilfs2/btnode.h
+++ b/fs/nilfs2/btnode.h
@@ -34,8 +34,9 @@ void nilfs_init_btnc_inode(struct inode *btnc_inode);
void nilfs_btnode_cache_clear(struct address_space *);
struct buffer_head *nilfs_btnode_create_block(struct address_space *btnc,
__u64 blocknr);
-int nilfs_btnode_submit_block(struct address_space *, __u64, sector_t, int,
- int, struct buffer_head **, sector_t *);
+int nilfs_btnode_submit_block(struct address_space *, __u64, sector_t,
+ enum req_op, blk_opf_t, struct buffer_head **,
+ sector_t *);
void nilfs_btnode_delete(struct buffer_head *);
int nilfs_btnode_prepare_change_key(struct address_space *,
struct nilfs_btnode_chkey_ctxt *);
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index d29a0f2b9c16..19d878f0e923 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -112,7 +112,8 @@ static int nilfs_mdt_create_block(struct inode *inode, unsigned long block,
static int
nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,
- int mode, int mode_flags, struct buffer_head **out_bh)
+ enum req_op mode, blk_opf_t mode_flags,
+ struct buffer_head **out_bh)
{
struct buffer_head *bh;
__u64 blknum = 0;
diff --git a/include/trace/events/nilfs2.h b/include/trace/events/nilfs2.h
index 84ee31fc04cc..05668a783042 100644
--- a/include/trace/events/nilfs2.h
+++ b/include/trace/events/nilfs2.h
@@ -192,7 +192,7 @@ TRACE_EVENT(nilfs2_mdt_submit_block,
TP_PROTO(struct inode *inode,
unsigned long ino,
unsigned long blkoff,
- int mode),
+ enum req_op mode),
TP_ARGS(inode, ino, blkoff, mode),
@@ -207,7 +207,7 @@ TRACE_EVENT(nilfs2_mdt_submit_block,
__entry->inode = inode;
__entry->ino = ino;
__entry->blkoff = blkoff;
- __entry->mode = mode;
+ __entry->mode = (__force int)mode;
),
TP_printk("inode = %p ino = %lu blkoff = %lu mode = %x",
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types
2022-06-23 18:05 ` [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-24 3:43 ` Ryusuke Konishi
2022-06-25 0:02 ` Bart Van Assche
0 siblings, 1 reply; 93+ messages in thread
From: Ryusuke Konishi @ 2022-06-24 3:43 UTC (permalink / raw)
To: Bart Van Assche; +Cc: Jens Axboe, linux-block, Christoph Hellwig
On Fri, Jun 24, 2022 at 3:06 AM Bart Van Assche wrote:
>
> Improve static type checking by using the enum req_op type for variables
> that represent a request operation and the new blk_opf_t type for
> variables that represent request flags.
>
> Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
> fs/nilfs2/btnode.c | 4 ++--
> fs/nilfs2/btnode.h | 5 +++--
> fs/nilfs2/mdt.c | 3 ++-
> include/trace/events/nilfs2.h | 4 ++--
> 4 files changed, 9 insertions(+), 7 deletions(-)
Acked-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
I've checked this patch, picking up some of the block layer patches needed
to understand this conversion from the list of linux-block.
Ryusuke Konishi
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types
2022-06-24 3:43 ` Ryusuke Konishi
@ 2022-06-25 0:02 ` Bart Van Assche
2022-06-25 0:55 ` Ryusuke Konishi
0 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-25 0:02 UTC (permalink / raw)
To: Ryusuke Konishi; +Cc: Jens Axboe, linux-block, Christoph Hellwig
On 6/23/22 20:43, Ryusuke Konishi wrote:
> On Fri, Jun 24, 2022 at 3:06 AM Bart Van Assche wrote:
>>
>> Improve static type checking by using the enum req_op type for variables
>> that represent a request operation and the new blk_opf_t type for
>> variables that represent request flags.
>>
>> Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
>> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
>> ---
>> fs/nilfs2/btnode.c | 4 ++--
>> fs/nilfs2/btnode.h | 5 +++--
>> fs/nilfs2/mdt.c | 3 ++-
>> include/trace/events/nilfs2.h | 4 ++--
>> 4 files changed, 9 insertions(+), 7 deletions(-)
>
> Acked-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
>
> I've checked this patch, picking up some of the block layer patches needed
> to understand this conversion from the list of linux-block.
Hi Ryusuke,
Thank you for the quick review.
Does "picking up" perhaps mean that you plan to send a subset of this
patch series to Linus yourself? I prefer that the entire patch series is
sent to Linus by a single kernel maintainer.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types
2022-06-25 0:02 ` Bart Van Assche
@ 2022-06-25 0:55 ` Ryusuke Konishi
0 siblings, 0 replies; 93+ messages in thread
From: Ryusuke Konishi @ 2022-06-25 0:55 UTC (permalink / raw)
To: Bart Van Assche; +Cc: Jens Axboe, linux-block, Christoph Hellwig
Hi Bart,
On Sat, Jun 25, 2022 at 9:02 AM Bart Van Assche wrote:
>
> On 6/23/22 20:43, Ryusuke Konishi wrote:
> > On Fri, Jun 24, 2022 at 3:06 AM Bart Van Assche wrote:
> >>
> >> Improve static type checking by using the enum req_op type for variables
> >> that represent a request operation and the new blk_opf_t type for
> >> variables that represent request flags.
> >>
> >> Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
> >> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> >> ---
> >> fs/nilfs2/btnode.c | 4 ++--
> >> fs/nilfs2/btnode.h | 5 +++--
> >> fs/nilfs2/mdt.c | 3 ++-
> >> include/trace/events/nilfs2.h | 4 ++--
> >> 4 files changed, 9 insertions(+), 7 deletions(-)
> >
> > Acked-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
> >
> > I've checked this patch, picking up some of the block layer patches needed
> > to understand this conversion from the list of linux-block.
>
> Hi Ryusuke,
>
> Thank you for the quick review.
>
> Does "picking up" perhaps mean that you plan to send a subset of this
> patch series to Linus yourself? I prefer that the entire patch series is
> sent to Linus by a single kernel maintainer.
Sorry for the misleading wording.
That just means that I tracked and confirmed the related block layer patches
in the series to properly review this patch. I recognize that the entire patch
series should be sent through the same maintainer.
Regards,
Ryusuke Konishi
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 47/51] fs/ntfs3: Use enum req_op where appropriate
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (45 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 46/51] fs/nilfs: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 18:05 ` [PATCH 48/51] fs/ocfs2: Use the enum req_op and blk_opf_t types Bart Van Assche
` (4 subsequent siblings)
51 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Konstantin Komarov
Improve static type checking by using enum req_op instead of u32 for
block layer request operations.
Cc: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/ntfs3/fsntfs.c | 2 +-
fs/ntfs3/ntfs_fs.h | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/fs/ntfs3/fsntfs.c b/fs/ntfs3/fsntfs.c
index 3de5700a9b83..1835e35199c2 100644
--- a/fs/ntfs3/fsntfs.c
+++ b/fs/ntfs3/fsntfs.c
@@ -1448,7 +1448,7 @@ int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr,
*/
int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run,
struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
- u32 op)
+ enum req_op op)
{
int err = 0;
struct bio *new, *bio = NULL;
diff --git a/fs/ntfs3/ntfs_fs.h b/fs/ntfs3/ntfs_fs.h
index 8de129a6419b..3a8abf13143e 100644
--- a/fs/ntfs3/ntfs_fs.h
+++ b/fs/ntfs3/ntfs_fs.h
@@ -617,7 +617,7 @@ int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr,
struct ntfs_buffers *nb, int sync);
int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run,
struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
- u32 op);
+ enum req_op op);
int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run);
int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,
u64 vbo, u64 *lbo, u64 *bytes);
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 48/51] fs/ocfs2: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (46 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 47/51] fs/ntfs3: Use enum req_op where appropriate Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-24 2:04 ` Joseph Qi
2022-06-23 18:05 ` [PATCH 49/51] PM: " Bart Van Assche
` (3 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Mark Fasheh,
Joel Becker, Joseph Qi
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Mark Fasheh <mark@fasheh.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Joseph Qi <joseph.qi@linux.alibaba.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/ocfs2/cluster/heartbeat.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index ea0e70c0fce0..e955aca87936 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -503,8 +503,8 @@ static void o2hb_bio_end_io(struct bio *bio)
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,
- int op_flags)
+ unsigned int max_slots, enum req_op op,
+ blk_opf_t op_flags)
{
int len, current_page;
unsigned int vec_len, vec_start;
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 48/51] fs/ocfs2: Use the enum req_op and blk_opf_t types
2022-06-23 18:05 ` [PATCH 48/51] fs/ocfs2: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-24 2:04 ` Joseph Qi
0 siblings, 0 replies; 93+ messages in thread
From: Joseph Qi @ 2022-06-24 2:04 UTC (permalink / raw)
To: Bart Van Assche, Jens Axboe
Cc: linux-block, Christoph Hellwig, Mark Fasheh, Joel Becker
On 6/24/22 2:05 AM, Bart Van Assche wrote:
> Improve static type checking by using the enum req_op type for variables
> that represent a request operation and the new blk_opf_t type for
> variables that represent request flags.
>
> Cc: Mark Fasheh <mark@fasheh.com>
> Cc: Joel Becker <jlbec@evilplan.org>
> Cc: Joseph Qi <joseph.qi@linux.alibaba.com>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Looks fine to me.
Acked-by: Joseph Qi <joseph.qi@linux.alibaba.com>
> ---
> fs/ocfs2/cluster/heartbeat.c | 4 ++--
> 1 file changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
> index ea0e70c0fce0..e955aca87936 100644
> --- a/fs/ocfs2/cluster/heartbeat.c
> +++ b/fs/ocfs2/cluster/heartbeat.c
> @@ -503,8 +503,8 @@ static void o2hb_bio_end_io(struct bio *bio)
> 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,
> - int op_flags)
> + unsigned int max_slots, enum req_op op,
> + blk_opf_t op_flags)
> {
> int len, current_page;
> unsigned int vec_len, vec_start;
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 49/51] PM: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (47 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 48/51] fs/ocfs2: Use the enum req_op and blk_opf_t types Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-27 13:04 ` Rafael J. Wysocki
2022-06-23 18:05 ` [PATCH 50/51] fs/xfs: " Bart Van Assche
` (2 subsequent siblings)
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Rafael J . Wysocki
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for
variables that represent request flags.
Cc: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
kernel/power/swap.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/kernel/power/swap.c b/kernel/power/swap.c
index 91fffdd2c7fb..db01cac40a4c 100644
--- a/kernel/power/swap.c
+++ b/kernel/power/swap.c
@@ -269,8 +269,8 @@ static void hib_end_io(struct bio *bio)
bio_put(bio);
}
-static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr,
- struct hib_bio_batch *hb)
+static int hib_submit_io(enum req_op op, blk_opf_t op_flags,
+ pgoff_t page_off, void *addr, struct hib_bio_batch *hb)
{
struct page *page = virt_to_page(addr);
struct bio *bio;
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 49/51] PM: Use the enum req_op and blk_opf_t types
2022-06-23 18:05 ` [PATCH 49/51] PM: " Bart Van Assche
@ 2022-06-27 13:04 ` Rafael J. Wysocki
0 siblings, 0 replies; 93+ messages in thread
From: Rafael J. Wysocki @ 2022-06-27 13:04 UTC (permalink / raw)
To: Bart Van Assche, Jens Axboe; +Cc: linux-block, Christoph Hellwig
On 6/23/2022 8:05 PM, Bart Van Assche wrote:
> Improve static type checking by using the enum req_op type for variables
> that represent a request operation and the new blk_opf_t type for
> variables that represent request flags.
>
> Cc: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> Cc: Christoph Hellwig <hch@lst.de>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Or if you want me to pick it up, please resend it with a CC to
linux-pm@vger.kernel.org.
Thanks!
> ---
> kernel/power/swap.c | 4 ++--
> 1 file changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/kernel/power/swap.c b/kernel/power/swap.c
> index 91fffdd2c7fb..db01cac40a4c 100644
> --- a/kernel/power/swap.c
> +++ b/kernel/power/swap.c
> @@ -269,8 +269,8 @@ static void hib_end_io(struct bio *bio)
> bio_put(bio);
> }
>
> -static int hib_submit_io(int op, int op_flags, pgoff_t page_off, void *addr,
> - struct hib_bio_batch *hb)
> +static int hib_submit_io(enum req_op op, blk_opf_t op_flags,
> + pgoff_t page_off, void *addr, struct hib_bio_batch *hb)
> {
> struct page *page = virt_to_page(addr);
> struct bio *bio;
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 50/51] fs/xfs: Use the enum req_op and blk_opf_t types
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (48 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 49/51] PM: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-25 3:23 ` Darrick J. Wong
2022-06-23 18:05 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Bart Van Assche
2022-06-24 5:05 ` [PATCH 00/51] Improve static type checking for request flags Christoph Hellwig
51 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Darrick J . Wong
Improve static type checking by using the enum req_op type for variables
that represent a request operation and the new blk_opf_t type for the
combination of a request operation with request flags.
Cc: Darrick J. Wong <djwong@kernel.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/xfs/xfs_bio_io.c | 2 +-
fs/xfs/xfs_buf.c | 4 ++--
fs/xfs/xfs_linux.h | 2 +-
fs/xfs/xfs_log_recover.c | 2 +-
4 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/fs/xfs/xfs_bio_io.c b/fs/xfs/xfs_bio_io.c
index ae4345b37621..fe21c76f75b8 100644
--- a/fs/xfs/xfs_bio_io.c
+++ b/fs/xfs/xfs_bio_io.c
@@ -15,7 +15,7 @@ xfs_rw_bdev(
sector_t sector,
unsigned int count,
char *data,
- unsigned int op)
+ enum req_op op)
{
unsigned int is_vmalloc = is_vmalloc_addr(data);
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index bf4e60871068..5e8f40d8c052 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1416,7 +1416,7 @@ xfs_buf_ioapply_map(
int map,
int *buf_offset,
int *count,
- int op)
+ blk_opf_t op)
{
int page_index;
unsigned int total_nr_pages = bp->b_page_count;
@@ -1493,7 +1493,7 @@ _xfs_buf_ioapply(
struct xfs_buf *bp)
{
struct blk_plug plug;
- int op;
+ blk_opf_t op;
int offset;
int size;
int i;
diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
index cb9105d667db..f9878021e7d0 100644
--- a/fs/xfs/xfs_linux.h
+++ b/fs/xfs/xfs_linux.h
@@ -196,7 +196,7 @@ static inline uint64_t howmany_64(uint64_t x, uint32_t y)
}
int xfs_rw_bdev(struct block_device *bdev, sector_t sector, unsigned int count,
- char *data, unsigned int op);
+ char *data, enum req_op op);
#define ASSERT_ALWAYS(expr) \
(likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 5f7e4e6e33ce..940c8107cbd4 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -122,7 +122,7 @@ xlog_do_io(
xfs_daddr_t blk_no,
unsigned int nbblks,
char *data,
- unsigned int op)
+ enum req_op op)
{
int error;
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 50/51] fs/xfs: Use the enum req_op and blk_opf_t types
2022-06-23 18:05 ` [PATCH 50/51] fs/xfs: " Bart Van Assche
@ 2022-06-25 3:23 ` Darrick J. Wong
0 siblings, 0 replies; 93+ messages in thread
From: Darrick J. Wong @ 2022-06-25 3:23 UTC (permalink / raw)
To: Bart Van Assche; +Cc: Jens Axboe, linux-block, Christoph Hellwig, xfs
[+linux-xfs]
On Thu, Jun 23, 2022 at 11:05:27AM -0700, Bart Van Assche wrote:
> Improve static type checking by using the enum req_op type for variables
> that represent a request operation and the new blk_opf_t type for the
> combination of a request operation with request flags.
>
> Cc: Darrick J. Wong <djwong@kernel.org>
> Cc: Christoph Hellwig <hch@lst.de>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Looks good to me, though I had to dig around to find out what these new
types were.
Acked-by: Darrick J. Wong <djwong@kernel.org>
--D
> ---
> fs/xfs/xfs_bio_io.c | 2 +-
> fs/xfs/xfs_buf.c | 4 ++--
> fs/xfs/xfs_linux.h | 2 +-
> fs/xfs/xfs_log_recover.c | 2 +-
> 4 files changed, 5 insertions(+), 5 deletions(-)
>
> diff --git a/fs/xfs/xfs_bio_io.c b/fs/xfs/xfs_bio_io.c
> index ae4345b37621..fe21c76f75b8 100644
> --- a/fs/xfs/xfs_bio_io.c
> +++ b/fs/xfs/xfs_bio_io.c
> @@ -15,7 +15,7 @@ xfs_rw_bdev(
> sector_t sector,
> unsigned int count,
> char *data,
> - unsigned int op)
> + enum req_op op)
>
> {
> unsigned int is_vmalloc = is_vmalloc_addr(data);
> diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
> index bf4e60871068..5e8f40d8c052 100644
> --- a/fs/xfs/xfs_buf.c
> +++ b/fs/xfs/xfs_buf.c
> @@ -1416,7 +1416,7 @@ xfs_buf_ioapply_map(
> int map,
> int *buf_offset,
> int *count,
> - int op)
> + blk_opf_t op)
> {
> int page_index;
> unsigned int total_nr_pages = bp->b_page_count;
> @@ -1493,7 +1493,7 @@ _xfs_buf_ioapply(
> struct xfs_buf *bp)
> {
> struct blk_plug plug;
> - int op;
> + blk_opf_t op;
> int offset;
> int size;
> int i;
> diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
> index cb9105d667db..f9878021e7d0 100644
> --- a/fs/xfs/xfs_linux.h
> +++ b/fs/xfs/xfs_linux.h
> @@ -196,7 +196,7 @@ static inline uint64_t howmany_64(uint64_t x, uint32_t y)
> }
>
> int xfs_rw_bdev(struct block_device *bdev, sector_t sector, unsigned int count,
> - char *data, unsigned int op);
> + char *data, enum req_op op);
>
> #define ASSERT_ALWAYS(expr) \
> (likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))
> diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
> index 5f7e4e6e33ce..940c8107cbd4 100644
> --- a/fs/xfs/xfs_log_recover.c
> +++ b/fs/xfs/xfs_log_recover.c
> @@ -122,7 +122,7 @@ xlog_do_io(
> xfs_daddr_t blk_no,
> unsigned int nbblks,
> char *data,
> - unsigned int op)
> + enum req_op op)
> {
> int error;
>
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (49 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 50/51] fs/xfs: " Bart Van Assche
@ 2022-06-23 18:05 ` Bart Van Assche
2022-06-23 22:48 ` Damien Le Moal
2022-06-24 4:56 ` Christoph Hellwig
2022-06-24 5:05 ` [PATCH 00/51] Improve static type checking for request flags Christoph Hellwig
51 siblings, 2 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 18:05 UTC (permalink / raw)
To: Jens Axboe
Cc: linux-block, Christoph Hellwig, Bart Van Assche, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn
Since __bitwise types are not supported by the tracing infrastructure, store
the operation type as an int in the tracing event.
Cc: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Cc: Naohiro Aota <naohiro.aota@wdc.com>
Cc: Johannes Thumshirn <jth@kernel.org>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
fs/zonefs/trace.h | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/fs/zonefs/trace.h b/fs/zonefs/trace.h
index 21501da764bd..8707e1c3023c 100644
--- a/fs/zonefs/trace.h
+++ b/fs/zonefs/trace.h
@@ -32,15 +32,15 @@ TRACE_EVENT(zonefs_zone_mgmt,
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
- __entry->op = op;
+ __entry->op = (__force int)op;
__entry->sector = ZONEFS_I(inode)->i_zsector;
__entry->nr_sectors =
ZONEFS_I(inode)->i_zone_size >> SECTOR_SHIFT;
),
TP_printk("bdev=(%d,%d), ino=%lu op=%s, sector=%llu, nr_sectors=%llu",
show_dev(__entry->dev), (unsigned long)__entry->ino,
- blk_op_str(__entry->op), __entry->sector,
- __entry->nr_sectors
+ blk_op_str((__force enum req_op)__entry->op),
+ __entry->sector, __entry->nr_sectors
)
);
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-23 18:05 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Bart Van Assche
@ 2022-06-23 22:48 ` Damien Le Moal
2022-06-23 23:19 ` Bart Van Assche
2022-06-24 4:56 ` Christoph Hellwig
1 sibling, 1 reply; 93+ messages in thread
From: Damien Le Moal @ 2022-06-23 22:48 UTC (permalink / raw)
To: Bart Van Assche, Jens Axboe
Cc: linux-block, Christoph Hellwig, Naohiro Aota, Johannes Thumshirn
On 6/24/22 03:05, Bart Van Assche wrote:
> Since __bitwise types are not supported by the tracing infrastructure, store
> the operation type as an int in the tracing event.
>
> Cc: Damien Le Moal <damien.lemoal@opensource.wdc.com>
> Cc: Naohiro Aota <naohiro.aota@wdc.com>
> Cc: Johannes Thumshirn <jth@kernel.org>
> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
> ---
> fs/zonefs/trace.h | 6 +++---
> 1 file changed, 3 insertions(+), 3 deletions(-)
>
> diff --git a/fs/zonefs/trace.h b/fs/zonefs/trace.h
> index 21501da764bd..8707e1c3023c 100644
> --- a/fs/zonefs/trace.h
> +++ b/fs/zonefs/trace.h
> @@ -32,15 +32,15 @@ TRACE_EVENT(zonefs_zone_mgmt,
> TP_fast_assign(
> __entry->dev = inode->i_sb->s_dev;
> __entry->ino = inode->i_ino;
> - __entry->op = op;
> + __entry->op = (__force int)op;
> __entry->sector = ZONEFS_I(inode)->i_zsector;
> __entry->nr_sectors =
> ZONEFS_I(inode)->i_zone_size >> SECTOR_SHIFT;
> ),
> TP_printk("bdev=(%d,%d), ino=%lu op=%s, sector=%llu, nr_sectors=%llu",
> show_dev(__entry->dev), (unsigned long)__entry->ino,
> - blk_op_str(__entry->op), __entry->sector,
> - __entry->nr_sectors
> + blk_op_str((__force enum req_op)__entry->op),
> + __entry->sector, __entry->nr_sectors
> )
> );
>
How do you get the warning ? I always run sparse and have not seen any
warning... Looks good anyway, will apply.
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-23 22:48 ` Damien Le Moal
@ 2022-06-23 23:19 ` Bart Van Assche
2022-06-24 0:03 ` Damien Le Moal
0 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-23 23:19 UTC (permalink / raw)
To: Damien Le Moal, Jens Axboe
Cc: linux-block, Christoph Hellwig, Naohiro Aota, Johannes Thumshirn
On 6/23/22 15:48, Damien Le Moal wrote:
> On 6/24/22 03:05, Bart Van Assche wrote:
>> Since __bitwise types are not supported by the tracing infrastructure, store
>> the operation type as an int in the tracing event.
>>
>> Cc: Damien Le Moal <damien.lemoal@opensource.wdc.com>
>> Cc: Naohiro Aota <naohiro.aota@wdc.com>
>> Cc: Johannes Thumshirn <jth@kernel.org>
>> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
>> ---
>> fs/zonefs/trace.h | 6 +++---
>> 1 file changed, 3 insertions(+), 3 deletions(-)
>>
>> diff --git a/fs/zonefs/trace.h b/fs/zonefs/trace.h
>> index 21501da764bd..8707e1c3023c 100644
>> --- a/fs/zonefs/trace.h
>> +++ b/fs/zonefs/trace.h
>> @@ -32,15 +32,15 @@ TRACE_EVENT(zonefs_zone_mgmt,
>> TP_fast_assign(
>> __entry->dev = inode->i_sb->s_dev;
>> __entry->ino = inode->i_ino;
>> - __entry->op = op;
>> + __entry->op = (__force int)op;
>> __entry->sector = ZONEFS_I(inode)->i_zsector;
>> __entry->nr_sectors =
>> ZONEFS_I(inode)->i_zone_size >> SECTOR_SHIFT;
>> ),
>> TP_printk("bdev=(%d,%d), ino=%lu op=%s, sector=%llu, nr_sectors=%llu",
>> show_dev(__entry->dev), (unsigned long)__entry->ino,
>> - blk_op_str(__entry->op), __entry->sector,
>> - __entry->nr_sectors
>> + blk_op_str((__force enum req_op)__entry->op),
>> + __entry->sector, __entry->nr_sectors
>> )
>> );
>>
>
> How do you get the warning ? I always run sparse and have not seen any
> warning... Looks good anyway, will apply.
Hi Damien,
The warning fixed by this patch has been introduced by the patch that
changes enum req_op from a regular enum into a bitwise enum. The warning
does not occur with Jens' latest for-next branch.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-23 23:19 ` Bart Van Assche
@ 2022-06-24 0:03 ` Damien Le Moal
0 siblings, 0 replies; 93+ messages in thread
From: Damien Le Moal @ 2022-06-24 0:03 UTC (permalink / raw)
To: Bart Van Assche, Jens Axboe
Cc: linux-block, Christoph Hellwig, Naohiro Aota, Johannes Thumshirn
On 6/24/22 08:19, Bart Van Assche wrote:
> On 6/23/22 15:48, Damien Le Moal wrote:
>> On 6/24/22 03:05, Bart Van Assche wrote:
>>> Since __bitwise types are not supported by the tracing infrastructure, store
>>> the operation type as an int in the tracing event.
>>>
>>> Cc: Damien Le Moal <damien.lemoal@opensource.wdc.com>
>>> Cc: Naohiro Aota <naohiro.aota@wdc.com>
>>> Cc: Johannes Thumshirn <jth@kernel.org>
>>> Signed-off-by: Bart Van Assche <bvanassche@acm.org>
>>> ---
>>> fs/zonefs/trace.h | 6 +++---
>>> 1 file changed, 3 insertions(+), 3 deletions(-)
>>>
>>> diff --git a/fs/zonefs/trace.h b/fs/zonefs/trace.h
>>> index 21501da764bd..8707e1c3023c 100644
>>> --- a/fs/zonefs/trace.h
>>> +++ b/fs/zonefs/trace.h
>>> @@ -32,15 +32,15 @@ TRACE_EVENT(zonefs_zone_mgmt,
>>> TP_fast_assign(
>>> __entry->dev = inode->i_sb->s_dev;
>>> __entry->ino = inode->i_ino;
>>> - __entry->op = op;
>>> + __entry->op = (__force int)op;
>>> __entry->sector = ZONEFS_I(inode)->i_zsector;
>>> __entry->nr_sectors =
>>> ZONEFS_I(inode)->i_zone_size >> SECTOR_SHIFT;
>>> ),
>>> TP_printk("bdev=(%d,%d), ino=%lu op=%s, sector=%llu, nr_sectors=%llu",
>>> show_dev(__entry->dev), (unsigned long)__entry->ino,
>>> - blk_op_str(__entry->op), __entry->sector,
>>> - __entry->nr_sectors
>>> + blk_op_str((__force enum req_op)__entry->op),
>>> + __entry->sector, __entry->nr_sectors
>>> )
>>> );
>>>
>>
>> How do you get the warning ? I always run sparse and have not seen any
>> warning... Looks good anyway, will apply.
>
> Hi Damien,
>
> The warning fixed by this patch has been introduced by the patch that
> changes enum req_op from a regular enum into a bitwise enum. The warning
> does not occur with Jens' latest for-next branch.
I see. Thanks.
Acked-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
>
> Thanks,
>
> Bart.
>
>
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-23 18:05 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Bart Van Assche
2022-06-23 22:48 ` Damien Le Moal
@ 2022-06-24 4:56 ` Christoph Hellwig
2022-06-24 19:57 ` Bart Van Assche
1 sibling, 1 reply; 93+ messages in thread
From: Christoph Hellwig @ 2022-06-24 4:56 UTC (permalink / raw)
To: Bart Van Assche
Cc: Jens Axboe, linux-block, Christoph Hellwig, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn
On Thu, Jun 23, 2022 at 11:05:28AM -0700, Bart Van Assche wrote:
> Since __bitwise types are not supported by the tracing infrastructure, store
> the operation type as an int in the tracing event.
Please give the field in the trace even the proper type instead of
all the crazy casting.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-24 4:56 ` Christoph Hellwig
@ 2022-06-24 19:57 ` Bart Van Assche
2022-06-25 9:23 ` Christoph Hellwig
0 siblings, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-24 19:57 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Jens Axboe, linux-block, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn
On 6/23/22 21:56, Christoph Hellwig wrote:
> On Thu, Jun 23, 2022 at 11:05:28AM -0700, Bart Van Assche wrote:
>> Since __bitwise types are not supported by the tracing infrastructure, store
>> the operation type as an int in the tracing event.
>
> Please give the field in the trace even the proper type instead of
> all the crazy casting.
Hi Christoph,
I will do that. BTW, I discovered the code in the tracing infrastructure
that makes sparse unhappy:
#define is_signed_type(type) (((type)(-1)) < (type)1)
Sparse reports four warnings for that expression if 'type' is a bitwise
type. Two of these warnings can be suppressed by changing 'type' into
'__force type'. I have not yet found a way to suppress all the sparse
warnings triggered by the is_signed_type() macro for bitwise types.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-24 19:57 ` Bart Van Assche
@ 2022-06-25 9:23 ` Christoph Hellwig
2022-06-26 0:44 ` Bart Van Assche
2022-06-26 19:41 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Steven Rostedt
0 siblings, 2 replies; 93+ messages in thread
From: Christoph Hellwig @ 2022-06-25 9:23 UTC (permalink / raw)
To: Bart Van Assche
Cc: Christoph Hellwig, Jens Axboe, linux-block, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Rasmus Villemoes,
Steven Rostedt
On Fri, Jun 24, 2022 at 12:57:56PM -0700, Bart Van Assche wrote:
> On 6/23/22 21:56, Christoph Hellwig wrote:
>> On Thu, Jun 23, 2022 at 11:05:28AM -0700, Bart Van Assche wrote:
>>> Since __bitwise types are not supported by the tracing infrastructure, store
>>> the operation type as an int in the tracing event.
>>
>> Please give the field in the trace even the proper type instead of
>> all the crazy casting.
>
> Hi Christoph,
>
> I will do that. BTW, I discovered the code in the tracing infrastructure
> that makes sparse unhappy:
>
> #define is_signed_type(type) (((type)(-1)) < (type)1)
>
> Sparse reports four warnings for that expression if 'type' is a bitwise
> type. Two of these warnings can be suppressed by changing 'type' into
> '__force type'. I have not yet found a way to suppress all the sparse
> warnings triggered by the is_signed_type() macro for bitwise types.
Yeah, that is a bit of a mess. Rasmus, Steven - any good idea how
we can make the trace even macros fit for sparse? Maybe just drop the
is_signed_type check for __CHECKER__ ?
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-25 9:23 ` Christoph Hellwig
@ 2022-06-26 0:44 ` Bart Van Assche
2022-06-26 9:58 ` Luc Van Oostenryck
2022-06-26 19:41 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Steven Rostedt
1 sibling, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-26 0:44 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Jens Axboe, linux-block, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn, Rasmus Villemoes, Steven Rostedt,
Luc Van Oostenryck
On 6/25/22 02:23, Christoph Hellwig wrote:
> On Fri, Jun 24, 2022 at 12:57:56PM -0700, Bart Van Assche wrote:
>> BTW, I discovered the code in the tracing infrastructure
>> that makes sparse unhappy:
>>
>> #define is_signed_type(type) (((type)(-1)) < (type)1)
>>
>> Sparse reports four warnings for that expression if 'type' is a bitwise
>> type. Two of these warnings can be suppressed by changing 'type' into
>> '__force type'. I have not yet found a way to suppress all the sparse
>> warnings triggered by the is_signed_type() macro for bitwise types.
>
> Yeah, that is a bit of a mess. Rasmus, Steven - any good idea how
> we can make the trace even macros fit for sparse? Maybe just drop the
> is_signed_type check for __CHECKER__ ?
How about the patch below?
Subject: [PATCH] tracing: Suppress sparse warnings triggered by
is_signed_type()
Using a __bitwise type in a tracing __field() definition triggers four
sparse warnings in stage 4 of expanding the TRACE_EVENT() macro. These
warnings are triggered by the is_signed_type() macro implementation.
Since there is no known way of checking signedness of a bitwise type
without triggering sparse warnings, disable signedness checking when
verifying code with sparse.
Suggested-by: Christoph Hellwig <hch@lst.de>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Cc: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
include/linux/trace_events.h | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
index e6e95a9f07a5..f7b2a5467361 100644
--- a/include/linux/trace_events.h
+++ b/include/linux/trace_events.h
@@ -814,7 +814,19 @@ extern int trace_add_event_call(struct trace_event_call *call);
extern int trace_remove_event_call(struct trace_event_call *call);
extern int trace_event_get_offsets(struct trace_event_call *call);
+/*
+ * There is no known way to check signedness of __bitwise types without
+ * triggering a sparse warning. Hence the #ifdef __CHECKER__.
+ *
+ * There is another definition of is_signed_type() in <linux/overflow.h>.
+ * Hence undefine is_signed_type() before redefining it.
+ */
+#undef is_signed_type
+#ifdef __CHECKER__
+#define is_signed_type(type) 0
+#else
#define is_signed_type(type) (((type)(-1)) < (type)1)
+#endif
int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set);
int trace_set_clr_event(const char *system, const char *event, int set);
^ permalink raw reply related [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 0:44 ` Bart Van Assche
@ 2022-06-26 9:58 ` Luc Van Oostenryck
2022-06-26 15:42 ` Bart Van Assche
2022-06-26 16:33 ` Linus Torvalds
0 siblings, 2 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-26 9:58 UTC (permalink / raw)
To: Bart Van Assche
Cc: Christoph Hellwig, Jens Axboe, linux-block, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Rasmus Villemoes,
Steven Rostedt, linux-sparse
On Sat, Jun 25, 2022 at 05:44:54PM -0700, Bart Van Assche wrote:
> On 6/25/22 02:23, Christoph Hellwig wrote:
> > On Fri, Jun 24, 2022 at 12:57:56PM -0700, Bart Van Assche wrote:
> > > BTW, I discovered the code in the tracing infrastructure
> > > that makes sparse unhappy:
> > >
> > > #define is_signed_type(type) (((type)(-1)) < (type)1)
> > >
> > > Sparse reports four warnings for that expression if 'type' is a bitwise
> > > type. Two of these warnings can be suppressed by changing 'type' into
> > > '__force type'. I have not yet found a way to suppress all the sparse
> > > warnings triggered by the is_signed_type() macro for bitwise types.
Yes, __bitwise is quite strict and only support the bitwise operations
(&, |, ^ and).
> > Yeah, that is a bit of a mess. Rasmus, Steven - any good idea how
> > we can make the trace even macros fit for sparse? Maybe just drop the
> > is_signed_type check for __CHECKER__ ?
I would strongly advise against this:
-) the macro is sued elsewhere too (for overflow checking)
-) sparse wouldn't check anymore the same code as the one seen by the
compiler
What about I would add to sparse something to strip away the bitwise/
recover the underlying type? Something like __unbitwiseof() or
__underlying_typeof() (some better name is needed)?
Implementing directly what's needed here, something like __is_signed_type()
would be possible too but is a bit too specialized and so much less useful.
-- Luc Van Oostenryck
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 9:58 ` Luc Van Oostenryck
@ 2022-06-26 15:42 ` Bart Van Assche
2022-06-26 16:24 ` Luc Van Oostenryck
2022-06-26 16:33 ` Linus Torvalds
1 sibling, 1 reply; 93+ messages in thread
From: Bart Van Assche @ 2022-06-26 15:42 UTC (permalink / raw)
To: Luc Van Oostenryck
Cc: Christoph Hellwig, Jens Axboe, linux-block, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Rasmus Villemoes,
Steven Rostedt, linux-sparse
On 6/26/22 02:58, Luc Van Oostenryck wrote:
> On Sat, Jun 25, 2022 at 05:44:54PM -0700, Bart Van Assche wrote:
>> On 6/25/22 02:23, Christoph Hellwig wrote:
>>> Yeah, that is a bit of a mess. Rasmus, Steven - any good idea how
>>> we can make the trace even macros fit for sparse? Maybe just drop the
>>> is_signed_type check for __CHECKER__ ?
>
> I would strongly advise against this:
> -) the macro is sued elsewhere too (for overflow checking)
> -) sparse wouldn't check anymore the same code as the one seen by the
> compiler
>
> What about I would add to sparse something to strip away the bitwise/
> recover the underlying type? Something like __unbitwiseof() or
> __underlying_typeof() (some better name is needed)?
>
> Implementing directly what's needed here, something like __is_signed_type()
> would be possible too but is a bit too specialized and so much less useful.
Another question is how to keep the non-sparse build working. Does
anyone want to comment on the following alternatives or propose another
alternative?
(1) sparse implements __strip_bitwise as a macro.
(in compiler.h)
#ifndef __strip_bitwise
#define __strip_bitwise(type) type
#endif
(in trace_events.h)
#define is_signed_type(type) ((__strip_bitwise(type))(-1) < (__strip_bitwise(type))1)
(2) sparse implements __strip_bitwise as an operator that works on types.
#ifdef __CHECKER__
#define is_signed_type(type) ((__strip_bitwise(type))(-1) < (__strip_bitwise(type))1)
#else
#define is_signed_type(type) (((type)(-1)) < (type)1)
#endif
(1) would work better than (2) for kernel developers who are using a
version of sparse that does not support __strip_bitwise().
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 15:42 ` Bart Van Assche
@ 2022-06-26 16:24 ` Luc Van Oostenryck
0 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-26 16:24 UTC (permalink / raw)
To: Bart Van Assche
Cc: Christoph Hellwig, Jens Axboe, linux-block, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Rasmus Villemoes,
Steven Rostedt, linux-sparse
On Sun, Jun 26, 2022 at 08:42:27AM -0700, Bart Van Assche wrote:
> On 6/26/22 02:58, Luc Van Oostenryck wrote:
> > On Sat, Jun 25, 2022 at 05:44:54PM -0700, Bart Van Assche wrote:
> > > On 6/25/22 02:23, Christoph Hellwig wrote:
> > > > Yeah, that is a bit of a mess. Rasmus, Steven - any good idea how
> > > > we can make the trace even macros fit for sparse? Maybe just drop the
> > > > is_signed_type check for __CHECKER__ ?
> >
> > I would strongly advise against this:
> > -) the macro is sued elsewhere too (for overflow checking)
> > -) sparse wouldn't check anymore the same code as the one seen by the
> > compiler
> >
> > What about I would add to sparse something to strip away the bitwise/
> > recover the underlying type? Something like __unbitwiseof() or
> > __underlying_typeof() (some better name is needed)?
>
> Another question is how to keep the non-sparse build working. Does
> anyone want to comment on the following alternatives or propose another
> alternative?
>
> (1) sparse implements __strip_bitwise as a macro.
>
> (in compiler.h)
>
> #ifndef __strip_bitwise
> #define __strip_bitwise(type) type
> #endif
...
> (1) would work better than (2) for kernel developers who are using a
> version of sparse that does not support __strip_bitwise().
Yes, sure. I was thinking about using (and adding) __has_feature()
but the goal is the same.
[I prefer this because, internally, an operator is needed anyway and
__has_feature() would be more general (but then it would need to be
protected by its own #ifndef __has_feature).]
-- Luc
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 9:58 ` Luc Van Oostenryck
2022-06-26 15:42 ` Bart Van Assche
@ 2022-06-26 16:33 ` Linus Torvalds
2022-06-26 16:50 ` Linus Torvalds
` (2 more replies)
1 sibling, 3 replies; 93+ messages in thread
From: Linus Torvalds @ 2022-06-26 16:33 UTC (permalink / raw)
To: Luc Van Oostenryck
Cc: Bart Van Assche, Christoph Hellwig, Jens Axboe, linux-block,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn,
Rasmus Villemoes, Steven Rostedt, Sparse Mailing-list
On Sun, Jun 26, 2022 at 2:58 AM Luc Van Oostenryck
<luc.vanoostenryck@gmail.com> wrote:
>
> What about I would add to sparse something to strip away the bitwise/
> recover the underlying type? Something like __unbitwiseof() or
> __underlying_typeof() (some better name is needed)?
Please no, we don't want to make random macros have to have sparse
logic in them when it's not actually sparse-related.
I think it would be better if sparse just recognized some of these
kinds of situation. In particular:
(a) for the casting part, I actually suspect we should drop the
warning about castign integers to restricted types.
Note that this is actually one of the main causes of "__force" use in
the kernel, with code like
VM_FAULT_OOM = (__force vm_fault_t)0x000001,
VM_FAULT_SIGBUS = (__force vm_fault_t)0x000002,
VM_FAULT_MAJOR = (__force vm_fault_t)0x000004,
VM_FAULT_WRITE = (__force vm_fault_t)0x000008,
and I think that we could/should just say that "explicit casts of
constants are ok".
That would remove two of the four warnings right there, and probably
make bitwise types more convenient in general.
We already treat "0" as special (because for bitwise things, zero is
kind of the universal constant), and we should continue to warn about
_implicit_ casts of restricted types, but I think the use of "__force"
in the kernel does show that the explicit casts are probably a bad
idea.
(b) I think we could also recognize "comparison of constants" to be
something that doesn't necessarily require a warning.
And here in particular the "compare with zero" and "compare with all
bits set" - which is exactly that "-1" case.
In fact, there's a very good argument that "-1" is as special as zero
is ("all bits set" vs "all bits clear"), so for that (a) case, I think
at a _minimum_ we shouldn't warn about that particular constant.
So I think we could silence this sparse warning entirely, without
really introducing any new syntax, and actually improving on how
bitwise works.
Linus
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 16:33 ` Linus Torvalds
@ 2022-06-26 16:50 ` Linus Torvalds
2022-06-26 20:10 ` Luc Van Oostenryck
2022-06-26 19:44 ` Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
2 siblings, 1 reply; 93+ messages in thread
From: Linus Torvalds @ 2022-06-26 16:50 UTC (permalink / raw)
To: Luc Van Oostenryck
Cc: Bart Van Assche, Christoph Hellwig, Jens Axboe, linux-block,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn,
Rasmus Villemoes, Steven Rostedt, Sparse Mailing-list
On Sun, Jun 26, 2022 at 9:33 AM Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> (a) for the casting part, I actually suspect we should drop the
> warning about castign integers to restricted types.
Heh. Trying that out, I find we seem to do this at the wrong point anyway.
I removed the check for "value of 0 is ok", and it continues to warn
about casting "-1".
Because it does that before "-1" has even been simplified, so it
actually sees it as an *expression* ("negate the constant 1") rather
than as the *value* -1, and it warns.
That's a bit sad since really -1 and ~0 really both should be ok for
the same reason plain zero is ok - regardless of the whole "do we just
allow it for constants in general" thing.
I think the bitwise thing was always a bit half-baked. It was designed
for detecting little-endian and big-endian issues, and "bitmask"
types. And it's wonderful for the basics of that, but I think it was
never really thought through for this kind of extended use where we
end up having generic macros that do still make sense for them, but
aren't that exact "avoid assigning bitwise values to other values"
Linus
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 16:50 ` Linus Torvalds
@ 2022-06-26 20:10 ` Luc Van Oostenryck
0 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-26 20:10 UTC (permalink / raw)
To: Linus Torvalds
Cc: Bart Van Assche, Christoph Hellwig, Jens Axboe, linux-block,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn,
Rasmus Villemoes, Steven Rostedt, Sparse Mailing-list
On Sun, Jun 26, 2022 at 09:50:50AM -0700, Linus Torvalds wrote:
> On Sun, Jun 26, 2022 at 9:33 AM Linus Torvalds
> <torvalds@linux-foundation.org> wrote:
> >
> > (a) for the casting part, I actually suspect we should drop the
> > warning about castign integers to restricted types.
>
> Heh. Trying that out, I find we seem to do this at the wrong point anyway.
>
> I removed the check for "value of 0 is ok", and it continues to warn
> about casting "-1".
>
> Because it does that before "-1" has even been simplified, so it
> actually sees it as an *expression* ("negate the constant 1") rather
> than as the *value* -1, and it warns.
>
> That's a bit sad since really -1 and ~0 really both should be ok for
> the same reason plain zero is ok - regardless of the whole "do we just
> allow it for constants in general" thing.
Well, this "there is no negative constants, only minus positive ones"
is kinda special. Maybe we can special-case this, just doing an early
mini-expansion of PREOP('-', EXPR_VALUE). I'm not sure about all
implications it would have on typechecking though.
> I think the bitwise thing was always a bit half-baked. It was designed
> for detecting little-endian and big-endian issues, and "bitmask"
> types. And it's wonderful for the basics of that, but I think it was
> never really thought through for this kind of extended use where we
> end up having generic macros that do still make sense for them, but
> aren't that exact "avoid assigning bitwise values to other values"
Yes, I fully agree
Also, it's the only 'strong' type that sparse has (IIRC nocast was
too weak), so it's used for everything. Allowing only the bitwise
operators is often too restrictive. I think that often what people
just need is an unique type that doesn't mix with other types
but that can 1) mix with constants (certainly with 0, 1 and -1) and
2) can use the usual arithmetic operations (certainly the compares).
-- Luc
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-26 16:33 ` Linus Torvalds
2022-06-26 16:50 ` Linus Torvalds
@ 2022-06-26 19:44 ` Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
2 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-26 19:44 UTC (permalink / raw)
To: Linus Torvalds
Cc: Bart Van Assche, Christoph Hellwig, Jens Axboe, linux-block,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn,
Rasmus Villemoes, Steven Rostedt, Sparse Mailing-list
On Sun, Jun 26, 2022 at 09:33:57AM -0700, Linus Torvalds wrote:
> On Sun, Jun 26, 2022 at 2:58 AM Luc Van Oostenryck
> <luc.vanoostenryck@gmail.com> wrote:
> >
> > What about I would add to sparse something to strip away the bitwise/
> > recover the underlying type? Something like __unbitwiseof() or
> > __underlying_typeof() (some better name is needed)?
>
> Please no, we don't want to make random macros have to have sparse
> logic in them when it's not actually sparse-related.
>
> I think it would be better if sparse just recognized some of these
> kinds of situation. In particular:
Yes, sure, it's ideal.
> (a) for the casting part, I actually suspect we should drop the
> warning about castign integers to restricted types.
>
> Note that this is actually one of the main causes of "__force" use in
> the kernel, with code like
>
> VM_FAULT_OOM = (__force vm_fault_t)0x000001,
> VM_FAULT_SIGBUS = (__force vm_fault_t)0x000002,
> VM_FAULT_MAJOR = (__force vm_fault_t)0x000004,
> VM_FAULT_WRITE = (__force vm_fault_t)0x000008,
This example is about an enumeration. It's, IMO, a very special case
in its own. Two years ago or so, I had proposed to have 'bitwise'
enums where the cast was not needed. In itself is was very easy to do
but there was a lot of subtle issues about type attributes. I think
I've since solved these issues but on the way I've lost my motivation
for these bitwise enums. I'll take a look at it again.
> and I think that we could/should just say that "explicit casts of
> constants are ok".
I'm not convinced, for example when thinking about __be{16,32}.
But on the principle, I fully agree: unneeded casts should be avoided.
> That would remove two of the four warnings right there, and probably
> make bitwise types more convenient in general.
>
> We already treat "0" as special (because for bitwise things, zero is
> kind of the universal constant), and we should continue to warn about
> _implicit_ casts of restricted types, but I think the use of "__force"
> in the kernel does show that the explicit casts are probably a bad
> idea.
Yes.
> (b) I think we could also recognize "comparison of constants" to be
> something that doesn't necessarily require a warning.
>
> And here in particular the "compare with zero" and "compare with all
> bits set" - which is exactly that "-1" case.
>
> In fact, there's a very good argument that "-1" is as special as zero
> is ("all bits set" vs "all bits clear"), so for that (a) case, I think
> at a _minimum_ we shouldn't warn about that particular constant.
>
> So I think we could silence this sparse warning entirely, without
> really introducing any new syntax, and actually improving on how
> bitwise works.
Yes, indeed.
-- Luc
^ permalink raw reply [flat|nested] 93+ messages in thread* [PATCH 0/5] allow -1 and compares in bitwise types
2022-06-26 16:33 ` Linus Torvalds
2022-06-26 16:50 ` Linus Torvalds
2022-06-26 19:44 ` Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 1/5] bitwise: add testcases Luc Van Oostenryck
` (6 more replies)
2 siblings, 7 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
Allow using -1 and compare operators with bitwise types
This series is an experiment for allowing constants like
-1 or ~0 with bitwise types, as well as using compares
on them.
the motivation for allowing this is to avoid useless casts
and warnings on using some generic macros on bitwise types.
The case of interest here is:
#define is_signed_type(T) (((T)(-1)) < (T)1)
for which Sparse reports four warnings when 'T' is a bitwise
type. Two of these warnings can be suppressed by using
'__force' in the casts. But the other two can't be worked
around because explicitly reject using any constants other
than 0 with bitwise type.
The changes in the series allow to use the following testcase
without any warnings:
#define __bitwise __attribute__((bitwise))
typedef signed int __bitwise s;
typedef unsigned int __bitwise u;
#define is_signed_type(type) (((type)-1) <= 0)
int fs(void) { return ((s)-1) <= 0; }
int fu(void) { return ((u)-1) <= 0; }
and result in a modest but significant decrease in the number
of warnings issued by sparse (x86 {def,all}config):
- 2736 2735 cast to restricted type
+ 774 792 cast truncates bits from constant value
- 3183 3152 incorrect type in assignment (different base types)
- 162 159 incorrect type in initializer (different base types)
- 789 661 restricted type degrades to integer
- 13002 12857 Total
@Linus,
This seems to work correctly and I think it correspond to
what you wished (maybe modulo this 'early constant expansion'
I added) and I think that accepting the -1/all-ones is fine.
OTOH, I don't think we can allow the compares because they
don't make any sense for the 'endian' types. Surely we want
to catch things like:
typedef unsigned int __bitwise __be32;
__be32 x, y;
...
... (x < y)
@Bart,
Is there a good reason why the macro compares against 1 and
not against 0? Is it just because of -Wtype-limits? If so,
is it possible to use '<= 0' like here above?
The series is available for review and testing at:
https://git.kernel.org/pub/scm/devel/sparse/sparse.git bitwise-ones
Luc Van Oostenryck (5):
bitwise: add testcases
bitwise: accept all ones as non-restricted value
bitwise: allow compares for bitwise types
bitwise: do not remove the signedness of bitwise types
bitwise: early expansion of simple constants
evaluate.c | 52 +++++++++++++++++++++++++++++++-
parse.c | 1 -
show-parse.c | 2 +-
validation/bitwise-cast.c | 26 ++++++++++++++++
validation/bitwise-cmp.c | 31 +++++++++++++++++++
validation/bitwise-is-signed.c | 21 +++++++++++++
validation/linear/bitwise-cmps.c | 17 +++++++++++
validation/linear/bitwise-cmpu.c | 17 +++++++++++
8 files changed, 164 insertions(+), 3 deletions(-)
create mode 100644 validation/bitwise-cmp.c
create mode 100644 validation/bitwise-is-signed.c
create mode 100644 validation/linear/bitwise-cmps.c
create mode 100644 validation/linear/bitwise-cmpu.c
--
2.36.1
^ permalink raw reply [flat|nested] 93+ messages in thread* [PATCH 1/5] bitwise: add testcases
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 2/5] bitwise: accept all ones as non-restricted value Luc Van Oostenryck
` (5 subsequent siblings)
6 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
Currently bitwise types only support bitwise operations
(&, |, ^ and ~) and the constant 0 (since this value is
invariant for all bitwise operations and endianness conversion).
But the incoming series will relax this a little bit.
So, add a few testcases for it.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
validation/bitwise-cmp.c | 32 ++++++++++++++++++++++++++++++++
validation/bitwise-is-signed.c | 22 ++++++++++++++++++++++
validation/linear/bitwise-cmps.c | 18 ++++++++++++++++++
validation/linear/bitwise-cmpu.c | 18 ++++++++++++++++++
4 files changed, 90 insertions(+)
create mode 100644 validation/bitwise-cmp.c
create mode 100644 validation/bitwise-is-signed.c
create mode 100644 validation/linear/bitwise-cmps.c
create mode 100644 validation/linear/bitwise-cmpu.c
diff --git a/validation/bitwise-cmp.c b/validation/bitwise-cmp.c
new file mode 100644
index 000000000000..ca12b5e51e8e
--- /dev/null
+++ b/validation/bitwise-cmp.c
@@ -0,0 +1,32 @@
+#define M 0xffffffff
+
+typedef int __attribute__((bitwise)) b32;
+
+static int eq0(b32 x, b32 y) { return (x == 0); }
+static int eqm(b32 x, b32 y) { return (x == M); }
+static int eqx(b32 x, b32 y) { return (x == y); }
+
+static int ne0(b32 x, b32 y) { return (x != 0); }
+static int nem(b32 x, b32 y) { return (x != M); }
+static int nex(b32 x, b32 y) { return (x != y); }
+
+static int lt0(b32 x, b32 y) { return (x < 0); }
+static int ltm(b32 x, b32 y) { return (x < M); }
+static int ltx(b32 x, b32 y) { return (x < y); }
+
+static int lte0(b32 x, b32 y) { return (x <= 0); }
+static int ltem(b32 x, b32 y) { return (x <= M); }
+static int ltex(b32 x, b32 y) { return (x <= y); }
+
+static int gte0(b32 x, b32 y) { return (x >= 0); }
+static int gtem(b32 x, b32 y) { return (x >= M); }
+static int gtex(b32 x, b32 y) { return (x >= y); }
+
+static int gt0(b32 x, b32 y) { return (x > 0); }
+static int gtm(b32 x, b32 y) { return (x > M); }
+static int gtx(b32 x, b32 y) { return (x > y); }
+
+/*
+ * check-name: bitwise-cmp
+ * check-known-to-fail
+ */
diff --git a/validation/bitwise-is-signed.c b/validation/bitwise-is-signed.c
new file mode 100644
index 000000000000..dd9c147173cd
--- /dev/null
+++ b/validation/bitwise-is-signed.c
@@ -0,0 +1,22 @@
+#define __bitwise __attribute__((bitwise))
+
+#define is_signed_type(type) (((type)-1) <= 0)
+
+typedef signed int __bitwise s;
+typedef unsigned int __bitwise u;
+
+int fos(void);
+int fou(void);
+
+
+int fos(void) { return is_signed_type(s); }
+int fou(void) { return !is_signed_type(u); }
+
+/*
+ * check-name: bitwise-is-signed
+ * check-command: test-linearize -Wno-decl $file
+ * check-known-to-fail
+ *
+ * check-output-ignore
+ * check-output-returns: 1
+ */
diff --git a/validation/linear/bitwise-cmps.c b/validation/linear/bitwise-cmps.c
new file mode 100644
index 000000000000..6122944a42c6
--- /dev/null
+++ b/validation/linear/bitwise-cmps.c
@@ -0,0 +1,18 @@
+typedef signed int __attribute__((bitwise)) bs32;
+
+static int ltu(bs32 x, bs32 y) { return (x < y); }
+static int lteu(bs32 x, bs32 y) { return (x <= y); }
+static int gteu(bs32 x, bs32 y) { return (x >= y); }
+static int gtu(bs32 x, bs32 y) { return (x > y); }
+
+/*
+ * check-name: bitwise-cmps
+ * check-command: test-linearize -Wno-decl $file
+ * check-known-to-fail
+ *
+ * check-output-ignore
+ * check-output-excludes: setb\\.
+ * check-output-excludes: setbe\\.
+ * check-output-excludes: setae\\.
+ * check-output-excludes: seta\\.
+ */
diff --git a/validation/linear/bitwise-cmpu.c b/validation/linear/bitwise-cmpu.c
new file mode 100644
index 000000000000..8932436a7764
--- /dev/null
+++ b/validation/linear/bitwise-cmpu.c
@@ -0,0 +1,18 @@
+typedef unsigned int __attribute__((bitwise)) bu32;
+
+static int ltu(bu32 x, bu32 y) { return (x < y); }
+static int lteu(bu32 x, bu32 y) { return (x <= y); }
+static int gteu(bu32 x, bu32 y) { return (x >= y); }
+static int gtu(bu32 x, bu32 y) { return (x > y); }
+
+/*
+ * check-name: bitwise-cmpu
+ * check-command: test-linearize -Wno-decl $file
+ * check-known-to-fail
+ *
+ * check-output-ignore
+ * check-output-excludes: setlt\\.
+ * check-output-excludes: setlte\\.
+ * check-output-excludes: setgte\\.
+ * check-output-excludes: setgt\\.
+ */
--
2.36.1
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 2/5] bitwise: accept all ones as non-restricted value
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 1/5] bitwise: add testcases Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 23:32 ` Ramsay Jones
2022-06-27 19:05 ` [PATCH 3/5] bitwise: allow compares for bitwise types Luc Van Oostenryck
` (4 subsequent siblings)
6 siblings, 1 reply; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
Currently, the only value bitwise types can act on is 0
because the this value is anyway invariant for all bitwise
operations and endianness conversions.
But, a bit-pattern of all ones has the same properties and
is also very often used.
So, accept all ones as a valid value for bitwise operations.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
evaluate.c | 2 +-
validation/bitwise-cast.c | 13 +++++++++++++
2 files changed, 14 insertions(+), 1 deletion(-)
diff --git a/evaluate.c b/evaluate.c
index 61f59ee3908e..bcbcdf1ef0cc 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -417,7 +417,7 @@ static int restricted_value(struct expression *v, struct symbol *type)
{
if (v->type != EXPR_VALUE)
return 1;
- if (v->value != 0)
+ if (v->value != 0 && v->value != bits_mask(type->bit_size))
return 1;
return 0;
}
diff --git a/validation/bitwise-cast.c b/validation/bitwise-cast.c
index 0583461cb745..1075a3e9410c 100644
--- a/validation/bitwise-cast.c
+++ b/validation/bitwise-cast.c
@@ -35,6 +35,19 @@ static __be32 quuy(void)
return (__attribute__((force)) __be32) 1730;
}
+/* Implicit casts of all ones, legal */
+static __be32 foo1(void)
+{
+ __be32 x = 0xffffffff;
+ return x;
+}
+
+/* Explicit cast of all ones, legal */
+static __be32 bar1(void)
+{
+ return (__be32)0xffffffff;
+}
+
/*
* check-name: conversions to bitwise types
* check-command: sparse -Wbitwise $file
--
2.36.1
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 2/5] bitwise: accept all ones as non-restricted value
2022-06-27 19:05 ` [PATCH 2/5] bitwise: accept all ones as non-restricted value Luc Van Oostenryck
@ 2022-06-27 23:32 ` Ramsay Jones
0 siblings, 0 replies; 93+ messages in thread
From: Ramsay Jones @ 2022-06-27 23:32 UTC (permalink / raw)
To: Luc Van Oostenryck, linux-sparse; +Cc: Linus Torvalds, Bart Van Assche
On 27/06/2022 20:05, Luc Van Oostenryck wrote:
> Currently, the only value bitwise types can act on is 0
> because the this value is anyway invariant for all bitwise
s/the this/this/
s/anyway//
ATB,
Ramsay Jones
> operations and endianness conversions.
>
> But, a bit-pattern of all ones has the same properties and
> is also very often used.
>
> So, accept all ones as a valid value for bitwise operations.
>
> Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
> ---
> evaluate.c | 2 +-
> validation/bitwise-cast.c | 13 +++++++++++++
> 2 files changed, 14 insertions(+), 1 deletion(-)
>
> diff --git a/evaluate.c b/evaluate.c
> index 61f59ee3908e..bcbcdf1ef0cc 100644
> --- a/evaluate.c
> +++ b/evaluate.c
> @@ -417,7 +417,7 @@ static int restricted_value(struct expression *v, struct symbol *type)
> {
> if (v->type != EXPR_VALUE)
> return 1;
> - if (v->value != 0)
> + if (v->value != 0 && v->value != bits_mask(type->bit_size))
> return 1;
> return 0;
> }
> diff --git a/validation/bitwise-cast.c b/validation/bitwise-cast.c
> index 0583461cb745..1075a3e9410c 100644
> --- a/validation/bitwise-cast.c
> +++ b/validation/bitwise-cast.c
> @@ -35,6 +35,19 @@ static __be32 quuy(void)
> return (__attribute__((force)) __be32) 1730;
> }
>
> +/* Implicit casts of all ones, legal */
> +static __be32 foo1(void)
> +{
> + __be32 x = 0xffffffff;
> + return x;
> +}
> +
> +/* Explicit cast of all ones, legal */
> +static __be32 bar1(void)
> +{
> + return (__be32)0xffffffff;
> +}
> +
> /*
> * check-name: conversions to bitwise types
> * check-command: sparse -Wbitwise $file
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 3/5] bitwise: allow compares for bitwise types
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 1/5] bitwise: add testcases Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 2/5] bitwise: accept all ones as non-restricted value Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 19:20 ` Linus Torvalds
2022-06-27 23:34 ` Ramsay Jones
2022-06-27 19:05 ` [PATCH 4/5] bitwise: do not remove the signedness of " Luc Van Oostenryck
` (3 subsequent siblings)
6 siblings, 2 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
Currently, bitwise types are restricted to bitwise operations
(&, |, ^ and ~) as well as equality comparisons.
This patch makes the others comparisons valid for bitwise types
too.
Warning: This change make sense in the context of [1] but
doesn't make sense for the 'main' bitwise types:
__be32 and friends.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
evaluate.c | 4 ++++
validation/bitwise-cmp.c | 1 -
validation/linear/bitwise-cmps.c | 1 -
3 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/evaluate.c b/evaluate.c
index bcbcdf1ef0cc..bb8c0caa905a 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -435,6 +435,10 @@ static int restricted_binop(int op, struct symbol *type)
case '^':
case '?':
return 2; /* keep fouled */
+ case '<':
+ case '>':
+ case SPECIAL_LTE:
+ case SPECIAL_GTE:
case SPECIAL_EQUAL:
case SPECIAL_NOTEQUAL:
return 3; /* warn if fouled */
diff --git a/validation/bitwise-cmp.c b/validation/bitwise-cmp.c
index ca12b5e51e8e..8c3e6894072d 100644
--- a/validation/bitwise-cmp.c
+++ b/validation/bitwise-cmp.c
@@ -28,5 +28,4 @@ static int gtx(b32 x, b32 y) { return (x > y); }
/*
* check-name: bitwise-cmp
- * check-known-to-fail
*/
diff --git a/validation/linear/bitwise-cmps.c b/validation/linear/bitwise-cmps.c
index 6122944a42c6..f83ab7fe47db 100644
--- a/validation/linear/bitwise-cmps.c
+++ b/validation/linear/bitwise-cmps.c
@@ -8,7 +8,6 @@ static int gtu(bs32 x, bs32 y) { return (x > y); }
/*
* check-name: bitwise-cmps
* check-command: test-linearize -Wno-decl $file
- * check-known-to-fail
*
* check-output-ignore
* check-output-excludes: setb\\.
--
2.36.1
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 3/5] bitwise: allow compares for bitwise types
2022-06-27 19:05 ` [PATCH 3/5] bitwise: allow compares for bitwise types Luc Van Oostenryck
@ 2022-06-27 19:20 ` Linus Torvalds
2022-06-27 23:34 ` Ramsay Jones
1 sibling, 0 replies; 93+ messages in thread
From: Linus Torvalds @ 2022-06-27 19:20 UTC (permalink / raw)
To: Luc Van Oostenryck; +Cc: Sparse Mailing-list, Bart Van Assche
On Mon, Jun 27, 2022 at 12:05 PM Luc Van Oostenryck
<luc.vanoostenryck@gmail.com> wrote:
>
> Currently, bitwise types are restricted to bitwise operations
> (&, |, ^ and ~) as well as equality comparisons.
>
> This patch makes the others comparisons valid for bitwise types
> too.
>
> Warning: This change make sense in the context of [1] but
> doesn't make sense for the 'main' bitwise types:
> __be32 and friends.
Yeah, this is wrong.
It will literally break one of the use-cases, which is endianness comparisons.
You cannot compare values in the wrong endianness for greater-than or
less-than, because you will get the wrong answer - the ordering is
different in different byte-orders.
But comparing for equality (and inequality) is fine, and we actually
do that in the kernel (ie you can take a big-endian value, and compare
it with another big-endian value for being equal, without converting
it to the local CPU endianness).
Now, comparing the *constants* 0 and all-ones is fine. They are
smaller than (and larger than) all other values, regardless of any
byte/bit order issues.
So I think that really needs to check that one (or both) sides are the
magic constants.
Linus
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 3/5] bitwise: allow compares for bitwise types
2022-06-27 19:05 ` [PATCH 3/5] bitwise: allow compares for bitwise types Luc Van Oostenryck
2022-06-27 19:20 ` Linus Torvalds
@ 2022-06-27 23:34 ` Ramsay Jones
1 sibling, 0 replies; 93+ messages in thread
From: Ramsay Jones @ 2022-06-27 23:34 UTC (permalink / raw)
To: Luc Van Oostenryck, linux-sparse; +Cc: Linus Torvalds, Bart Van Assche
On 27/06/2022 20:05, Luc Van Oostenryck wrote:
> Currently, bitwise types are restricted to bitwise operations
> (&, |, ^ and ~) as well as equality comparisons.
>
> This patch makes the others comparisons valid for bitwise types
> too.
>
> Warning: This change make sense in the context of [1] but
The [1] reference seems to be missing :)
ATB,
Ramsay Jones
> doesn't make sense for the 'main' bitwise types:
> __be32 and friends.
> Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
> ---
> evaluate.c | 4 ++++
> validation/bitwise-cmp.c | 1 -
> validation/linear/bitwise-cmps.c | 1 -
> 3 files changed, 4 insertions(+), 2 deletions(-)
>
> diff --git a/evaluate.c b/evaluate.c
> index bcbcdf1ef0cc..bb8c0caa905a 100644
> --- a/evaluate.c
> +++ b/evaluate.c
> @@ -435,6 +435,10 @@ static int restricted_binop(int op, struct symbol *type)
> case '^':
> case '?':
> return 2; /* keep fouled */
> + case '<':
> + case '>':
> + case SPECIAL_LTE:
> + case SPECIAL_GTE:
> case SPECIAL_EQUAL:
> case SPECIAL_NOTEQUAL:
> return 3; /* warn if fouled */
> diff --git a/validation/bitwise-cmp.c b/validation/bitwise-cmp.c
> index ca12b5e51e8e..8c3e6894072d 100644
> --- a/validation/bitwise-cmp.c
> +++ b/validation/bitwise-cmp.c
> @@ -28,5 +28,4 @@ static int gtx(b32 x, b32 y) { return (x > y); }
>
> /*
> * check-name: bitwise-cmp
> - * check-known-to-fail
> */
> diff --git a/validation/linear/bitwise-cmps.c b/validation/linear/bitwise-cmps.c
> index 6122944a42c6..f83ab7fe47db 100644
> --- a/validation/linear/bitwise-cmps.c
> +++ b/validation/linear/bitwise-cmps.c
> @@ -8,7 +8,6 @@ static int gtu(bs32 x, bs32 y) { return (x > y); }
> /*
> * check-name: bitwise-cmps
> * check-command: test-linearize -Wno-decl $file
> - * check-known-to-fail
> *
> * check-output-ignore
> * check-output-excludes: setb\\.
^ permalink raw reply [flat|nested] 93+ messages in thread
* [PATCH 4/5] bitwise: do not remove the signedness of bitwise types
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
` (2 preceding siblings ...)
2022-06-27 19:05 ` [PATCH 3/5] bitwise: allow compares for bitwise types Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 19:05 ` [PATCH 5/5] bitwise: early expansion of simple constants Luc Van Oostenryck
` (2 subsequent siblings)
6 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
When bitwise types were added [1] the signedness modifiers
were removed from them. More exactly, it was MOD_SPECIFIER
which was removed. I suppose this was done because then
MOD_SPECIFIER contained the signedness bits but also MOD_CHAR,
MOD_LONG, ... and those had to be removed.
But currently MOD_SPECIFIER contains only MOD_SIGNEDNESS
and the signedness info can be useful for bitwise types too.
So, do not removed anymore MOD_SPECIFIER from the bitwise
types' modifiers.
[1] commit 032f492af0ac ("[PATCH] __attribute__((bitwise))")
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
parse.c | 1 -
show-parse.c | 2 +-
validation/linear/bitwise-cmpu.c | 1 -
3 files changed, 1 insertion(+), 3 deletions(-)
diff --git a/parse.c b/parse.c
index 3d6fef7cb011..14fe9e15448a 100644
--- a/parse.c
+++ b/parse.c
@@ -1586,7 +1586,6 @@ static struct token *declaration_specifiers(struct token *token, struct decl_sta
}
type = alloc_symbol(token->pos, SYM_BASETYPE);
*type = *ctx->ctype.base_type;
- type->ctype.modifiers &= ~MOD_SPECIFIER;
type->ctype.base_type = ctx->ctype.base_type;
type->type = SYM_RESTRICT;
ctx->ctype.base_type = type;
diff --git a/show-parse.c b/show-parse.c
index e2fc18bb4b3d..2ab2479b8181 100644
--- a/show-parse.c
+++ b/show-parse.c
@@ -318,7 +318,7 @@ deeper:
if (as)
prepend(name, "%s ", show_as(as));
- if (sym && (sym->type == SYM_BASETYPE || sym->type == SYM_ENUM))
+ if (sym && (sym->type == SYM_BASETYPE || sym->type == SYM_ENUM || sym->type == SYM_RESTRICT))
mod &= ~MOD_SPECIFIER;
s = modifier_string(mod);
len = strlen(s);
diff --git a/validation/linear/bitwise-cmpu.c b/validation/linear/bitwise-cmpu.c
index 8932436a7764..e151b9741fa3 100644
--- a/validation/linear/bitwise-cmpu.c
+++ b/validation/linear/bitwise-cmpu.c
@@ -8,7 +8,6 @@ static int gtu(bu32 x, bu32 y) { return (x > y); }
/*
* check-name: bitwise-cmpu
* check-command: test-linearize -Wno-decl $file
- * check-known-to-fail
*
* check-output-ignore
* check-output-excludes: setlt\\.
--
2.36.1
^ permalink raw reply related [flat|nested] 93+ messages in thread* [PATCH 5/5] bitwise: early expansion of simple constants
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
` (3 preceding siblings ...)
2022-06-27 19:05 ` [PATCH 4/5] bitwise: do not remove the signedness of " Luc Van Oostenryck
@ 2022-06-27 19:05 ` Luc Van Oostenryck
2022-06-27 19:14 ` [PATCH 0/5] allow -1 and compares in bitwise types Linus Torvalds
2022-06-27 19:15 ` Bart Van Assche
6 siblings, 0 replies; 93+ messages in thread
From: Luc Van Oostenryck @ 2022-06-27 19:05 UTC (permalink / raw)
To: linux-sparse; +Cc: Linus Torvalds, Bart Van Assche, Luc Van Oostenryck
C has only positive constants: -1 is really an expression,
the unary '-' operator applied to the constant 1. '-1' as
a constant value only exists after the expansion of constant
expressions.
This is rather unfortunate since it inhibits easy testing
of such constants in the evaluation phase, like here for
restricted_value().
So, expand expressions like +CTE, -CTE or ~CTE before
calling restricted_value().
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
---
evaluate.c | 48 +++++++++++++++++++++++++++++++++-
validation/bitwise-cast.c | 13 +++++++++
validation/bitwise-is-signed.c | 1 -
3 files changed, 60 insertions(+), 2 deletions(-)
diff --git a/evaluate.c b/evaluate.c
index bb8c0caa905a..33cc85c8d40f 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -413,11 +413,56 @@ static struct symbol *bad_expr_type(struct expression *expr)
return expr->ctype = &bad_ctype;
}
+static bool expand_simple_constant(struct expression *expr, struct symbol *type)
+{
+ unsigned long long val, mask;
+ struct expression *pre;
+ struct symbol *ctype;
+ unsigned size;
+
+ if (expr->type != EXPR_PREOP)
+ return false;
+ pre = expr->unop;
+ if (pre->type != EXPR_VALUE)
+ return false;
+
+ ctype = pre->ctype;
+ if (!ctype || ctype != type)
+ return false;
+
+ size = ctype->bit_size;
+ if (!size)
+ return false;
+
+ mask = sign_bit(size);
+ switch (expr->op) {
+ case '+':
+ val = pre->value;
+ break;
+ case '-':
+ val = pre->value;
+ if (val == mask && !(ctype->ctype.modifiers & MOD_UNSIGNED))
+ return false;
+ val = -val;
+ break;
+ case '~':
+ val = pre->value;
+ val = ~val;
+ break;
+ default:
+ return false;
+ }
+ expr->op = 0;
+ expr->type = EXPR_VALUE;
+ expr->value = val & bits_mask(size);
+ return true;
+}
+
static int restricted_value(struct expression *v, struct symbol *type)
{
if (v->type != EXPR_VALUE)
return 1;
- if (v->value != 0 && v->value != bits_mask(type->bit_size))
+ if (v->value != 0 && v->value != bits_mask(v->ctype->bit_size))
return 1;
return 0;
}
@@ -1919,6 +1964,7 @@ Normal:
if (!(class & TYPE_FLOAT)) {
ctype = integer_promotion(ctype);
expr->unop = cast_to(expr->unop, ctype);
+ expand_simple_constant(expr, ctype);
} else if (expr->op != '~') {
/* no conversions needed */
} else {
diff --git a/validation/bitwise-cast.c b/validation/bitwise-cast.c
index 1075a3e9410c..01af56c73751 100644
--- a/validation/bitwise-cast.c
+++ b/validation/bitwise-cast.c
@@ -48,6 +48,19 @@ static __be32 bar1(void)
return (__be32)0xffffffff;
}
+/* Implicit casts of minus one, legal */
+static __be32 foom(void)
+{
+ __be32 x = -1;
+ return x;
+}
+
+/* Explicit cast of minus one, legal */
+static __be32 barm(void)
+{
+ return (__be32)-1;
+}
+
/*
* check-name: conversions to bitwise types
* check-command: sparse -Wbitwise $file
diff --git a/validation/bitwise-is-signed.c b/validation/bitwise-is-signed.c
index dd9c147173cd..99d16bd20f9b 100644
--- a/validation/bitwise-is-signed.c
+++ b/validation/bitwise-is-signed.c
@@ -15,7 +15,6 @@ int fou(void) { return !is_signed_type(u); }
/*
* check-name: bitwise-is-signed
* check-command: test-linearize -Wno-decl $file
- * check-known-to-fail
*
* check-output-ignore
* check-output-returns: 1
--
2.36.1
^ permalink raw reply related [flat|nested] 93+ messages in thread* Re: [PATCH 0/5] allow -1 and compares in bitwise types
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
` (4 preceding siblings ...)
2022-06-27 19:05 ` [PATCH 5/5] bitwise: early expansion of simple constants Luc Van Oostenryck
@ 2022-06-27 19:14 ` Linus Torvalds
2022-06-27 19:15 ` Bart Van Assche
6 siblings, 0 replies; 93+ messages in thread
From: Linus Torvalds @ 2022-06-27 19:14 UTC (permalink / raw)
To: Luc Van Oostenryck; +Cc: Sparse Mailing-list, Bart Van Assche
On Mon, Jun 27, 2022 at 12:05 PM Luc Van Oostenryck
<luc.vanoostenryck@gmail.com> wrote:
>
> #define is_signed_type(type) (((type)-1) <= 0)
Side note: the reason we *don't* use this form in the kernel is
because broken compilers will complain about compares with zero in
unsigned types.
Using "<=" like you do may be an acceptable way to avoid it (the most
obvious thing is to use "< 0"), but it makes me nervous.
Regardless, I think you need the cast of the zero. I think "type"
might be a pointer, and sparse should be complaining about the horrid
use of a bare 0 as NULL.
Similar issues might happen for enums, where various compilers will
complain about comparing an enum to a non-enum.
So I'm pretty sure you would want casts on both values, instead of
assuming "it's an integer type, I don't need to cast 0".
But yeah, maybe
#define is_signed_type(type) (((type)-1) <= (type)0)
works fine and avoids warnings in all the cases.
Famous last words. Warnings can happen for almost anything, and I
wonder if that use of "1" had some other reason.
Linus
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 0/5] allow -1 and compares in bitwise types
2022-06-27 19:05 ` [PATCH 0/5] allow -1 and compares in bitwise types Luc Van Oostenryck
` (5 preceding siblings ...)
2022-06-27 19:14 ` [PATCH 0/5] allow -1 and compares in bitwise types Linus Torvalds
@ 2022-06-27 19:15 ` Bart Van Assche
6 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-27 19:15 UTC (permalink / raw)
To: Luc Van Oostenryck, linux-sparse; +Cc: Linus Torvalds
On 6/27/22 12:05, Luc Van Oostenryck wrote:
> Allow using -1 and compare operators with bitwise types
>
> This series is an experiment for allowing constants like
> -1 or ~0 with bitwise types, as well as using compares
> on them.
Will these changes cause sparse to stop complaining about
the following expression?
cpu_to_le32(1) < cpu_to_le32(2)
Shouldn't sparse keep complaining about the above expression?
> @Bart,
> Is there a good reason why the macro compares against 1 and
> not against 0?
Maybe to prevent that gcc or clang issues the following
warning: "warning: comparison of unsigned expression in ‘< 0’
is always false"?
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code
2022-06-25 9:23 ` Christoph Hellwig
2022-06-26 0:44 ` Bart Van Assche
@ 2022-06-26 19:41 ` Steven Rostedt
1 sibling, 0 replies; 93+ messages in thread
From: Steven Rostedt @ 2022-06-26 19:41 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Bart Van Assche, Jens Axboe, linux-block, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Rasmus Villemoes,
Linus Torvalds
On Sat, 25 Jun 2022 11:23:49 +0200
Christoph Hellwig <hch@lst.de> wrote:
> eah, that is a bit of a mess. Rasmus, Steven - any good idea how
> we can make the trace even macros fit for sparse? Maybe just drop the
> is_signed_type check for __CHECKER__ ?
I'm fine with whatever sparse folks come up with. If you want, I can
test any updates to this macro to make sure it doesn't change the
result in other use cases within trace events.
-- Steve
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 00/51] Improve static type checking for request flags
2022-06-23 18:04 [PATCH 00/51] Improve static type checking for request flags Bart Van Assche
` (50 preceding siblings ...)
2022-06-23 18:05 ` [PATCH 51/51] fs/zonefs: Fix sparse warnings in tracing code Bart Van Assche
@ 2022-06-24 5:05 ` Christoph Hellwig
2022-06-24 5:07 ` Christoph Hellwig
2022-06-28 22:44 ` Bart Van Assche
51 siblings, 2 replies; 93+ messages in thread
From: Christoph Hellwig @ 2022-06-24 5:05 UTC (permalink / raw)
To: Bart Van Assche; +Cc: Jens Axboe, linux-block, Christoph Hellwig
Hi Bart,
I generally like this. Two thoughs:
- I suspect most places that currently pass a enum req_op might really
want a blk_opf_t for future extensibility, exceptions are very
low-level helpers like req_op() and bio_op() where the enum is
very nice to force switch statements to handle all ops or have
a default statements
- a lot of the flags printinting is a mess, and introduce the code
smell of __force casts. It migh make sense to introduce a new
%psomething format specifier first to print a blk_opf_t using
printk/vsprintf/etc and switch everyone to that first instead of
hand crafted printing.
^ permalink raw reply [flat|nested] 93+ messages in thread* Re: [PATCH 00/51] Improve static type checking for request flags
2022-06-24 5:05 ` [PATCH 00/51] Improve static type checking for request flags Christoph Hellwig
@ 2022-06-24 5:07 ` Christoph Hellwig
2022-06-28 23:10 ` Bart Van Assche
2022-06-28 22:44 ` Bart Van Assche
1 sibling, 1 reply; 93+ messages in thread
From: Christoph Hellwig @ 2022-06-24 5:07 UTC (permalink / raw)
To: Bart Van Assche; +Cc: Jens Axboe, linux-block, Christoph Hellwig
On Fri, Jun 24, 2022 at 07:05:27AM +0200, Christoph Hellwig wrote:
> Hi Bart,
>
> I generally like this. Two thoughs:
>
> - I suspect most places that currently pass a enum req_op might really
> want a blk_opf_t for future extensibility, exceptions are very
> low-level helpers like req_op() and bio_op() where the enum is
> very nice to force switch statements to handle all ops or have
> a default statements
> - a lot of the flags printinting is a mess, and introduce the code
> smell of __force casts. It migh make sense to introduce a new
> %psomething format specifier first to print a blk_opf_t using
> printk/vsprintf/etc and switch everyone to that first instead of
> hand crafted printing.
Oh, and a third: there is still various places passing the op
separately from the flags and/or using bio_set_op_attrs. This
would be a good time to clean the rest of those up (I already did
a lot of that gradually).
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 00/51] Improve static type checking for request flags
2022-06-24 5:07 ` Christoph Hellwig
@ 2022-06-28 23:10 ` Bart Van Assche
0 siblings, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-28 23:10 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: Jens Axboe, linux-block
On 6/23/22 22:07, Christoph Hellwig wrote:
> Oh, and a third: there is still various places passing the op
> separately from the flags and/or using bio_set_op_attrs. This
> would be a good time to clean the rest of those up (I already did
> a lot of that gradually).
I will look into combining 'op' and 'op_flags' arguments but I would
like to postpone removing bio_set_op_attrs() since this patch series is
already too big.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread
* Re: [PATCH 00/51] Improve static type checking for request flags
2022-06-24 5:05 ` [PATCH 00/51] Improve static type checking for request flags Christoph Hellwig
2022-06-24 5:07 ` Christoph Hellwig
@ 2022-06-28 22:44 ` Bart Van Assche
1 sibling, 0 replies; 93+ messages in thread
From: Bart Van Assche @ 2022-06-28 22:44 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: Jens Axboe, linux-block
On 6/23/22 22:05, Christoph Hellwig wrote:
> I generally like this. Two thoughs:
>
> - I suspect most places that currently pass a enum req_op might really
> want a blk_opf_t for future extensibility, exceptions are very
> low-level helpers like req_op() and bio_op() where the enum is
> very nice to force switch statements to handle all ops or have
> a default statements
Agreed. I will use blk_opf_t where enum req_op is passed today but where
request flags might be passed in addition to the request type in the future.
> - a lot of the flags printinting is a mess, and introduce the code
> smell of __force casts. It migh make sense to introduce a new
> %psomething format specifier first to print a blk_opf_t using
> printk/vsprintf/etc and switch everyone to that first instead of
> hand crafted printing.
How about using blk_fill_rwbs() instead, a function that is already
being used by the bcache tracing code?
No matter how tracing the request operation type and flags is unified,
I'd like to defer this unification to a future patch series since this
patch series is already too big.
Thanks,
Bart.
^ permalink raw reply [flat|nested] 93+ messages in thread