From 3d460ec444940d50f4d87d023a660df31d7963bc Mon Sep 17 00:00:00 2001 From: Shin'ichiro Kawasaki Date: Mon, 9 Jun 2025 20:58:41 +0900 Subject: [PATCH 1/4] adding ci files --- .github/workflows/kernel_build.yml | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 .github/workflows/kernel_build.yml diff --git a/.github/workflows/kernel_build.yml b/.github/workflows/kernel_build.yml new file mode 100644 index 0000000000000..cd0f9d145429c --- /dev/null +++ b/.github/workflows/kernel_build.yml @@ -0,0 +1,28 @@ +name: blktests-ci + +on: + pull_request: + +jobs: + build-kernel: + runs-on: ubuntu-latest + steps: + - name: Configure git + run: | + git config --global --add safe.directory '*' + - name: Checkout git + run: | + sudo apt-get install -y libelf-dev + mkdir -p linux + cd linux + git init + git remote add origin https://github.com/${{ github.repository }} + git fetch origin --depth=5 ${{ github.event.pull_request.head.sha }} + git reset --hard ${{ github.event.pull_request.head.sha }} + git log -1 + - name: Build kernel + run: | + cd linux + make defconfig + make -j 8 + From f64cfd8eb395ca87d3c4d5f891d2d1ec41953a90 Mon Sep 17 00:00:00 2001 From: Hannes Reinecke Date: Tue, 3 Jun 2025 12:04:14 +0200 Subject: [PATCH 2/4] block: add 'read_keys' persistent reservation ioctl The persistent reservation operations already have a callback for 'read_keys', but this is not accessible via an ioctl (unlike the other callbacks). So add a new persistent reservation ioctl 'READ_KEYS' to allow userspace to use this functionality. Signed-off-by: Hannes Reinecke --- block/ioctl.c | 39 +++++++++++++++++++++++++++++++++++++++ include/linux/pr.h | 6 ------ include/uapi/linux/pr.h | 7 +++++++ 3 files changed, 46 insertions(+), 6 deletions(-) diff --git a/block/ioctl.c b/block/ioctl.c index e472cc1030c60..71f87974e0447 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -422,6 +422,43 @@ static int blkdev_pr_clear(struct block_device *bdev, blk_mode_t mode, return ops->pr_clear(bdev, c.key); } +static int blkdev_pr_read_keys(struct block_device *bdev, blk_mode_t mode, + struct pr_keys __user *arg) +{ + const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; + struct pr_keys k_in, *k_out; + size_t k_len; + int ret, num_keys; + + if (!blkdev_pr_allowed(bdev, mode)) + return -EPERM; + if (!ops || !ops->pr_read_keys) + return -EOPNOTSUPP; + + if (copy_from_user(&k_in, arg, sizeof(k_in))) + return -EFAULT; + + num_keys = k_in.num_keys; + k_out = kzalloc(sizeof(struct pr_keys) + num_keys * sizeof(u64), + GFP_KERNEL); + if (!k_out) + return -ENOMEM; + + k_out->num_keys = num_keys; + ret = ops->pr_read_keys(bdev, k_out); + if (ret) { + kfree(k_out); + return ret; + } + + k_len = sizeof(k_in) + num_keys * sizeof(u64); + if (copy_to_user(arg, k_out, k_len)) + ret = -EFAULT; + + kfree(k_out); + return ret; +} + static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd, unsigned long arg) { @@ -643,6 +680,8 @@ static int blkdev_common_ioctl(struct block_device *bdev, blk_mode_t mode, return blkdev_pr_preempt(bdev, mode, argp, true); case IOC_PR_CLEAR: return blkdev_pr_clear(bdev, mode, argp); + case IOC_PR_READ_KEYS: + return blkdev_pr_read_keys(bdev, mode, argp); default: return -ENOIOCTLCMD; } diff --git a/include/linux/pr.h b/include/linux/pr.h index 3003daec28a55..6f293c3e27a11 100644 --- a/include/linux/pr.h +++ b/include/linux/pr.h @@ -4,12 +4,6 @@ #include -struct pr_keys { - u32 generation; - u32 num_keys; - u64 keys[]; -}; - struct pr_held_reservation { u64 key; u32 generation; diff --git a/include/uapi/linux/pr.h b/include/uapi/linux/pr.h index d8126415966f3..6e0d91d43c545 100644 --- a/include/uapi/linux/pr.h +++ b/include/uapi/linux/pr.h @@ -56,6 +56,12 @@ struct pr_clear { __u32 __pad; }; +struct pr_keys { + __u32 generation; + __u32 num_keys; + __u64 keys[]; +}; + #define PR_FL_IGNORE_KEY (1 << 0) /* ignore existing key */ #define IOC_PR_REGISTER _IOW('p', 200, struct pr_registration) @@ -64,5 +70,6 @@ struct pr_clear { #define IOC_PR_PREEMPT _IOW('p', 203, struct pr_preempt) #define IOC_PR_PREEMPT_ABORT _IOW('p', 204, struct pr_preempt) #define IOC_PR_CLEAR _IOW('p', 205, struct pr_clear) +#define IOC_PR_READ_KEYS _IOWR('p', 206, struct pr_keys) #endif /* _UAPI_PR_H */ From 2831934b36bc7b351d341cdbb4f065a9ee5532ad Mon Sep 17 00:00:00 2001 From: Hannes Reinecke Date: Tue, 3 Jun 2025 12:04:15 +0200 Subject: [PATCH 3/4] block: add 'read_reservation' persistent reservation ioctl The persistent reservation operations already have a callback for 'read_reservation', but this is not accessible via an ioctl (unlike the other callbacks). So add a new persistent reservation ioctl 'READ_RESV' to allow userspace to use this functionality. Signed-off-by: Hannes Reinecke --- block/ioctl.c | 22 ++++++++++++++++++++++ include/linux/pr.h | 6 ------ include/uapi/linux/pr.h | 7 +++++++ 3 files changed, 29 insertions(+), 6 deletions(-) diff --git a/block/ioctl.c b/block/ioctl.c index 71f87974e0447..3612352a1d83f 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -459,6 +459,26 @@ static int blkdev_pr_read_keys(struct block_device *bdev, blk_mode_t mode, return ret; } +static int blkdev_pr_read_reservation(struct block_device *bdev, + blk_mode_t mode, struct pr_held_reservation __user *arg) +{ + const struct pr_ops *ops = bdev->bd_disk->fops->pr_ops; + struct pr_held_reservation r; + int ret; + + if (!blkdev_pr_allowed(bdev, mode)) + return -EPERM; + if (!ops || !ops->pr_read_reservation) + return -EOPNOTSUPP; + + ret = ops->pr_read_reservation(bdev, &r); + if (ret) + return ret; + if (copy_to_user(arg, &r, sizeof(r))) + return -EFAULT; + return 0; +} + static int blkdev_flushbuf(struct block_device *bdev, unsigned cmd, unsigned long arg) { @@ -682,6 +702,8 @@ static int blkdev_common_ioctl(struct block_device *bdev, blk_mode_t mode, return blkdev_pr_clear(bdev, mode, argp); case IOC_PR_READ_KEYS: return blkdev_pr_read_keys(bdev, mode, argp); + case IOC_PR_READ_RESV: + return blkdev_pr_read_reservation(bdev, mode, argp); default: return -ENOIOCTLCMD; } diff --git a/include/linux/pr.h b/include/linux/pr.h index 6f293c3e27a11..e3ccfbd9dfbab 100644 --- a/include/linux/pr.h +++ b/include/linux/pr.h @@ -4,12 +4,6 @@ #include -struct pr_held_reservation { - u64 key; - u32 generation; - enum pr_type type; -}; - struct pr_ops { int (*pr_register)(struct block_device *bdev, u64 old_key, u64 new_key, u32 flags); diff --git a/include/uapi/linux/pr.h b/include/uapi/linux/pr.h index 6e0d91d43c545..20198c7e68e8e 100644 --- a/include/uapi/linux/pr.h +++ b/include/uapi/linux/pr.h @@ -62,6 +62,12 @@ struct pr_keys { __u64 keys[]; }; +struct pr_held_reservation { + __u64 key; + __u32 generation; + __u32 type; +}; + #define PR_FL_IGNORE_KEY (1 << 0) /* ignore existing key */ #define IOC_PR_REGISTER _IOW('p', 200, struct pr_registration) @@ -71,5 +77,6 @@ struct pr_keys { #define IOC_PR_PREEMPT_ABORT _IOW('p', 204, struct pr_preempt) #define IOC_PR_CLEAR _IOW('p', 205, struct pr_clear) #define IOC_PR_READ_KEYS _IOWR('p', 206, struct pr_keys) +#define IOC_PR_READ_RESV _IOWR('p', 207, struct pr_held_reservation) #endif /* _UAPI_PR_H */ From a4312695a703a723b911ccb7cda833db9151f437 Mon Sep 17 00:00:00 2001 From: Hannes Reinecke Date: Tue, 3 Jun 2025 12:04:16 +0200 Subject: [PATCH 4/4] scsi: return PR generation if no reservation is held For READ RESERVATION the PRgeneration value is always present, even if no reservations are held. Signed-off-by: Hannes Reinecke --- drivers/scsi/sd.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 3f6e87705b62e..591a27375590b 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -2008,9 +2008,13 @@ static int sd_pr_read_reservation(struct block_device *bdev, if (result) return result; + rsv->generation = get_unaligned_be32(&data[0]); + rsv->type = 0; len = get_unaligned_be32(&data[4]); - if (!len) + if (!len) { + rsv->key = 0; return 0; + } /* Make sure we have at least the key and type */ if (len < 14) { @@ -2020,9 +2024,9 @@ static int sd_pr_read_reservation(struct block_device *bdev, return -EINVAL; } - rsv->generation = get_unaligned_be32(&data[0]); rsv->key = get_unaligned_be64(&data[8]); - rsv->type = scsi_pr_type_to_block(data[21] & 0x0f); + if (len == 16) + rsv->type = scsi_pr_type_to_block(data[21] & 0x0f); return 0; }