Re: [PATCH v10.1 1/9] dax: Introduce holder for dax_device

[Dan Williams]

On Sun, Feb 13, 2022 at 4:58 AM Shiyang Ruan  wrote:
>
> v10.1 update:
>  - Fix build error reported by kernel test robot
>  - Add return code to dax_register_holder()
>  - Add write lock to prevent concurrent registrations
>  - Rename dax_get_holder() to dax_holder()
>  - Add kernel doc for new added functions
>
> To easily track filesystem from a pmem device, we introduce a holder for
> dax_device structure, and also its operation.  This holder is used to
> remember who is using this dax_device:
>  - When it is the backend of a filesystem, the holder will be the
>instance of this filesystem.
>  - When this pmem device is one of the targets in a mapped device, the
>holder will be this mapped device.  In this case, the mapped device
>has its own dax_device and it will follow the first rule.  So that we
>can finally track to the filesystem we needed.
>
> The holder and holder_ops will be set when filesystem is being mounted,
> or an target device is being activated.
>
> Signed-off-by: Shiyang Ruan 
> ---
>  drivers/dax/super.c | 95 +
>  include/linux/dax.h | 30 ++
>  2 files changed, 125 insertions(+)
>
> diff --git a/drivers/dax/super.c b/drivers/dax/super.c
> index e3029389d809..d7fb4c36bf16 100644
> --- a/drivers/dax/super.c
> +++ b/drivers/dax/super.c
> @@ -21,6 +21,9 @@
>   * @cdev: optional character interface for "device dax"
>   * @private: dax driver private data
>   * @flags: state and boolean properties
> + * @ops: operations for dax_device
> + * @holder_data: holder of a dax_device: could be filesystem or mapped device
> + * @holder_ops: operations for the inner holder
>   */
>  struct dax_device {
> struct inode inode;
> @@ -28,6 +31,9 @@ struct dax_device {
> void *private;
> unsigned long flags;
> const struct dax_operations *ops;
> +   void *holder_data;
> +   struct percpu_rw_semaphore holder_rwsem;

This lock is not necessary, see below...

> +   const struct dax_holder_operations *holder_ops;
>  };
>
>  static dev_t dax_devt;
> @@ -193,6 +199,29 @@ int dax_zero_page_range(struct dax_device *dax_dev, 
> pgoff_t pgoff,
>  }
>  EXPORT_SYMBOL_GPL(dax_zero_page_range);
>
> +int dax_holder_notify_failure(struct dax_device *dax_dev, u64 off,
> + u64 len, int mf_flags)
> +{
> +   int rc, id;
> +
> +   id = dax_read_lock();
> +   if (!dax_alive(dax_dev)) {
> +   rc = -ENXIO;
> +   goto out;
> +   }
> +
> +   if (!dax_dev->holder_ops) {
> +   rc = -EOPNOTSUPP;
> +   goto out;
> +   }
> +
> +   rc = dax_dev->holder_ops->notify_failure(dax_dev, off, len, mf_flags);
> +out:
> +   dax_read_unlock(id);
> +   return rc;
> +}
> +EXPORT_SYMBOL_GPL(dax_holder_notify_failure);
> +
>  #ifdef CONFIG_ARCH_HAS_PMEM_API
>  void arch_wb_cache_pmem(void *addr, size_t size);
>  void dax_flush(struct dax_device *dax_dev, void *addr, size_t size)
> @@ -268,6 +297,13 @@ void kill_dax(struct dax_device *dax_dev)
>
> clear_bit(DAXDEV_ALIVE, _dev->flags);
> synchronize_srcu(_srcu);
> +
> +   /* Lock to prevent concurrent registrations. */
> +   percpu_down_write(_dev->holder_rwsem);
> +   /* clear holder data */
> +   dax_dev->holder_ops = NULL;
> +   dax_dev->holder_data = NULL;
> +   percpu_up_write(_dev->holder_rwsem);
>  }
>  EXPORT_SYMBOL_GPL(kill_dax);
>
> @@ -393,6 +429,7 @@ struct dax_device *alloc_dax(void *private, const struct 
> dax_operations *ops)
>
> dax_dev->ops = ops;
> dax_dev->private = private;
> +   percpu_init_rwsem(_dev->holder_rwsem);
> return dax_dev;
>
>   err_dev:
> @@ -409,6 +446,64 @@ void put_dax(struct dax_device *dax_dev)
>  }
>  EXPORT_SYMBOL_GPL(put_dax);
>
> +/**
> + * dax_holder() - obtain the holder of a dax device
> + * @dax_dev: a dax_device instance
> +
> + * Return: the holder's data which represents the holder if registered,
> + * otherwize NULL.
> + */
> +void *dax_holder(struct dax_device *dax_dev)
> +{
> +   if (!dax_alive(dax_dev))
> +   return NULL;
> +
> +   return dax_dev->holder_data;
> +}
> +EXPORT_SYMBOL_GPL(dax_holder);
> +
> +/**
> + * dax_register_holder() - register a holder to a dax device
> + * @dax_dev: a dax_device instance
> + * @holder: a pointer to a holder's data which represents the holder
> + * @ops: operations of this holder
> +
> + * Return: negative errno if an error occurs, otherwise 0.
> + */
> +int dax_register_holder(struct dax_device *dax_dev, void *holder,
> +   const struct dax_holder_operations *ops)
> +{
> +   if (!dax_alive(dax_dev))
> +   return -ENXIO;
> +
> +   /* Already registered */
> +   if (dax_holder(dax_dev))
> +   return -EBUSY;

Delete this...

> +
> +   /* Lock to prevent concurrent registrations. */
> +   percpu_down_write(_dev->holder_rwsem);

...and just use 

[PATCH v10.1 1/9] dax: Introduce holder for dax_device

[Shiyang Ruan]

v10.1 update:
 - Fix build error reported by kernel test robot
 - Add return code to dax_register_holder()
 - Add write lock to prevent concurrent registrations
 - Rename dax_get_holder() to dax_holder()
 - Add kernel doc for new added functions

To easily track filesystem from a pmem device, we introduce a holder for
dax_device structure, and also its operation.  This holder is used to
remember who is using this dax_device:
 - When it is the backend of a filesystem, the holder will be the
   instance of this filesystem.
 - When this pmem device is one of the targets in a mapped device, the
   holder will be this mapped device.  In this case, the mapped device
   has its own dax_device and it will follow the first rule.  So that we
   can finally track to the filesystem we needed.

The holder and holder_ops will be set when filesystem is being mounted,
or an target device is being activated.

Signed-off-by: Shiyang Ruan 
---
 drivers/dax/super.c | 95 +
 include/linux/dax.h | 30 ++
 2 files changed, 125 insertions(+)

diff --git a/drivers/dax/super.c b/drivers/dax/super.c
index e3029389d809..d7fb4c36bf16 100644
--- a/drivers/dax/super.c
+++ b/drivers/dax/super.c
@@ -21,6 +21,9 @@
  * @cdev: optional character interface for "device dax"
  * @private: dax driver private data
  * @flags: state and boolean properties
+ * @ops: operations for dax_device
+ * @holder_data: holder of a dax_device: could be filesystem or mapped device
+ * @holder_ops: operations for the inner holder
  */
 struct dax_device {
struct inode inode;
@@ -28,6 +31,9 @@ struct dax_device {
void *private;
unsigned long flags;
const struct dax_operations *ops;
+   void *holder_data;
+   struct percpu_rw_semaphore holder_rwsem;
+   const struct dax_holder_operations *holder_ops;
 };
 
 static dev_t dax_devt;
@@ -193,6 +199,29 @@ int dax_zero_page_range(struct dax_device *dax_dev, 
pgoff_t pgoff,
 }
 EXPORT_SYMBOL_GPL(dax_zero_page_range);
 
+int dax_holder_notify_failure(struct dax_device *dax_dev, u64 off,
+ u64 len, int mf_flags)
+{
+   int rc, id;
+
+   id = dax_read_lock();
+   if (!dax_alive(dax_dev)) {
+   rc = -ENXIO;
+   goto out;
+   }
+
+   if (!dax_dev->holder_ops) {
+   rc = -EOPNOTSUPP;
+   goto out;
+   }
+
+   rc = dax_dev->holder_ops->notify_failure(dax_dev, off, len, mf_flags);
+out:
+   dax_read_unlock(id);
+   return rc;
+}
+EXPORT_SYMBOL_GPL(dax_holder_notify_failure);
+
 #ifdef CONFIG_ARCH_HAS_PMEM_API
 void arch_wb_cache_pmem(void *addr, size_t size);
 void dax_flush(struct dax_device *dax_dev, void *addr, size_t size)
@@ -268,6 +297,13 @@ void kill_dax(struct dax_device *dax_dev)
 
clear_bit(DAXDEV_ALIVE, _dev->flags);
synchronize_srcu(_srcu);
+
+   /* Lock to prevent concurrent registrations. */
+   percpu_down_write(_dev->holder_rwsem);
+   /* clear holder data */
+   dax_dev->holder_ops = NULL;
+   dax_dev->holder_data = NULL;
+   percpu_up_write(_dev->holder_rwsem);
 }
 EXPORT_SYMBOL_GPL(kill_dax);
 
@@ -393,6 +429,7 @@ struct dax_device *alloc_dax(void *private, const struct 
dax_operations *ops)
 
dax_dev->ops = ops;
dax_dev->private = private;
+   percpu_init_rwsem(_dev->holder_rwsem);
return dax_dev;
 
  err_dev:
@@ -409,6 +446,64 @@ void put_dax(struct dax_device *dax_dev)
 }
 EXPORT_SYMBOL_GPL(put_dax);
 
+/**
+ * dax_holder() - obtain the holder of a dax device
+ * @dax_dev: a dax_device instance
+
+ * Return: the holder's data which represents the holder if registered,
+ * otherwize NULL.
+ */
+void *dax_holder(struct dax_device *dax_dev)
+{
+   if (!dax_alive(dax_dev))
+   return NULL;
+
+   return dax_dev->holder_data;
+}
+EXPORT_SYMBOL_GPL(dax_holder);
+
+/**
+ * dax_register_holder() - register a holder to a dax device
+ * @dax_dev: a dax_device instance
+ * @holder: a pointer to a holder's data which represents the holder
+ * @ops: operations of this holder
+
+ * Return: negative errno if an error occurs, otherwise 0.
+ */
+int dax_register_holder(struct dax_device *dax_dev, void *holder,
+   const struct dax_holder_operations *ops)
+{
+   if (!dax_alive(dax_dev))
+   return -ENXIO;
+
+   /* Already registered */
+   if (dax_holder(dax_dev))
+   return -EBUSY;
+
+   /* Lock to prevent concurrent registrations. */
+   percpu_down_write(_dev->holder_rwsem);
+   dax_dev->holder_data = holder;
+   dax_dev->holder_ops = ops;
+   percpu_up_write(_dev->holder_rwsem);
+
+   return 0;
+}
+EXPORT_SYMBOL_GPL(dax_register_holder);
+
+/**
+ * dax_unregister_holder() - unregister the holder for a dax device
+ * @dax_dev: a dax_device instance
+ */
+void dax_unregister_holder(struct dax_device *dax_dev)
+{
+   if (!dax_alive(dax_dev))
+