Skip to contentSkip to conversation

block: expose 'read_keys' and 'read_reservation' PR callbacks

PATCH New Hannes Reinecke 1 participant 4 messages Jun 3, 2025

Subsystems (2)
SCSI Block layer
lore
Share & tools
lore

Hannes Reinecke

author
#0 lore raw

cover block: expose 'read_keys' and 'read_reservation' PR callbacks

Hi all,

the generic persistent reservation framework already has callbacks for 'read_keys' and 'read_reservation', but these callbacks are not exposed via ioctls (unlike the other callbacks). As we need this information if we want to work with persistent reservations reliably add two new persistent reservation ioctls 'IOC_PR_READ_KEYS' and 'IOC_PR_READ_RESV' to expose this information to userspace.

As usual, comments and reviews are welcome.

Hannes Reinecke (3):
block: add 'read_keys' persistent reservation ioctl
block: add 'read_reservation' persistent reservation ioctl
scsi: return PR generation if no reservation is held

 block/ioctl.c           | 61 +++++++++++++++++++++++++++++++++++++++++
 drivers/scsi/sd.c       | 10 +++++--
 include/linux/pr.h      | 12 --------
 include/uapi/linux/pr.h | 14 ++++++++++
 4 files changed, 82 insertions(+), 15 deletions(-)
Signature · 1 line
2.35.3
author
#1 lore raw

PATCH 1/3 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 <[email protected]>
---
 block/ioctl.c           | 39 +++++++++++++++++++++++++++++++++++++++
 include/linux/pr.h      |  6 ------
 include/uapi/linux/pr.h |  7 +++++++
 3 files changed, 46 insertions(+), 6 deletions(-)
block/ioctl.c +39 -0
index e472cc1030c6..71f87974e044 100644
@@ -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;
 	}
include/linux/pr.h +0 -6
index 3003daec28a5..6f293c3e27a1 100644
@@ -4,12 +4,6 @@
 
 #include <uapi/linux/pr.h>
 
-struct pr_keys {
-	u32	generation;
-	u32	num_keys;
-	u64	keys[];
-};
-
 struct pr_held_reservation {
 	u64		key;
 	u32		generation;
include/uapi/linux/pr.h +7 -0
index d8126415966f..6e0d91d43c54 100644
@@ -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 */
Signature · 1 line
2.35.3
author
#2 lore raw

PATCH 2/3 block: add 'read_reservation' persistent reservation ioctl

In reply to Hannes Reinecke

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 <[email protected]>
---
 block/ioctl.c           | 22 ++++++++++++++++++++++
 include/linux/pr.h      |  6 ------
 include/uapi/linux/pr.h |  7 +++++++
 3 files changed, 29 insertions(+), 6 deletions(-)
block/ioctl.c +22 -0
index 71f87974e044..3612352a1d83 100644
@@ -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;
 	}
include/linux/pr.h +0 -6
index 6f293c3e27a1..e3ccfbd9dfba 100644
@@ -4,12 +4,6 @@
 
 #include <uapi/linux/pr.h>
 
-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);
include/uapi/linux/pr.h +7 -0
index 6e0d91d43c54..20198c7e68e8 100644
@@ -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 */
Signature · 1 line
2.35.3
author
#3 lore raw

PATCH 3/3 scsi: return PR generation if no reservation is held

In reply to Hannes Reinecke

For READ RESERVATION the PRgeneration value is always present, even if no reservations are held.

Signed-off-by Hannes Reinecke <[email protected]>
---
 drivers/scsi/sd.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)
drivers/scsi/sd.c +7 -3
index 950d8c9fb884..daa61feaf441 100644
@@ -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;
 }
Signature · 1 line
2.35.3