From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9F54BC433EF for ; Tue, 15 Feb 2022 22:06:37 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id EC7836B0078; Tue, 15 Feb 2022 17:06:36 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id E76C46B007B; Tue, 15 Feb 2022 17:06:36 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id D17016B007D; Tue, 15 Feb 2022 17:06:36 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0135.hostedemail.com [216.40.44.135]) by kanga.kvack.org (Postfix) with ESMTP id C44CF6B0078 for ; Tue, 15 Feb 2022 17:06:36 -0500 (EST) Received: from smtpin12.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with ESMTP id 7884695AF9 for ; Tue, 15 Feb 2022 22:06:36 +0000 (UTC) X-FDA: 79146399192.12.CCD8FE0 Received: from mail-pl1-f173.google.com (mail-pl1-f173.google.com [209.85.214.173]) by imf06.hostedemail.com (Postfix) with ESMTP id A2C85180003 for ; Tue, 15 Feb 2022 22:06:35 +0000 (UTC) Received: by mail-pl1-f173.google.com with SMTP id c3so332933pls.5 for ; Tue, 15 Feb 2022 14:06:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=intel-com.20210112.gappssmtp.com; s=20210112; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=VVrjCQk0e2bEXbKTkyebIDZYiYKF0U8p5xUNgx6nAe0=; b=nE35RWa6oDgBalrevFEPRO4+2X1WpWNqXc18NzpTgKw5LYA/qcTsaEbTbUcF5+1vny yinI0tL2Ot6PPN326SGxQFjZJw7wM6Ak/gPKz3EexZH9k6ekyuItMdahLbM5M328yY9f IB1FQymUIQ5G+Q/15li4O96F2jwU1xjrnmCkkyUVXlCXvgjP8jBgYvFO/miqvK26On6U guLecixg3/nlWPYYO9/Fy4Rc2CSSKsXpjLwSBwBiGyY/V86ic7L+kpL/cbjgLb+mrNnU Dj4LsAPhCboWHCBb7jVbBlNPYixLLKaDYizQHgOchXufz+VZR2/rExv3NHWvYNjoqIKV +DUw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=VVrjCQk0e2bEXbKTkyebIDZYiYKF0U8p5xUNgx6nAe0=; b=nd7ws+t6MC04xoS5q7jxFTfnwFuWwhHwu5+aE38KnBvRb88m0O2BzDePINtwNRs0ls bTXTN2Sn75Hcfx+6X/MHzEKLCcdsud7OZXkFwKBiyirT1chboJBc0DI7onBM3UJr4PLe UZqykv7dE9qW+Cu9w+Ctzfsg2F314NR+8ppOmqpfi53+6B8bf9150H8hP6lI0J0H9qaX jdPfgm75G6BXZTCIB8Zk+jUPOMpu26tEY0I6qIv2kcsxSqsmhiuI0vZIPnWKPlVFMDEV 6lqx2oT8smhUF4d7+O0yL+ORXUUaoShTwe8PJ68f8+OhbtHfrsYc9k1f5uF2YBs5ovzz SIrw== X-Gm-Message-State: AOAM530/wIW8k0KbCusc8yDHJz7e3ZIaSwS1+oBzfpdT+Q0Qb5Ceh2H4 TS20RVM4U0tZjqTSUnbgZipA0vYnCoZgG901ROwoTw== X-Google-Smtp-Source: ABdhPJwlpdC05oj7M5BjmWhQxUU9avBLaGs7R0OLF51skyfT2cwCjdpjxdAijHrqBSuda/rYLUu8zubxJ+5FrHrRYqg= X-Received: by 2002:a17:90a:e7cb:: with SMTP id kb11mr1025329pjb.220.1644962794472; Tue, 15 Feb 2022 14:06:34 -0800 (PST) MIME-Version: 1.0 References: <20220213125832.2722009-1-ruansy.fnst@fujitsu.com> In-Reply-To: <20220213125832.2722009-1-ruansy.fnst@fujitsu.com> From: Dan Williams Date: Tue, 15 Feb 2022 14:06:26 -0800 Message-ID: Subject: Re: [PATCH v10.1 1/9] dax: Introduce holder for dax_device To: Shiyang Ruan Cc: Christoph Hellwig , Linux Kernel Mailing List , linux-xfs , Linux NVDIMM , Linux MM , linux-fsdevel , "Darrick J. Wong" , david , Jane Chu Content-Type: text/plain; charset="UTF-8" X-Stat-Signature: 84kc9ztjca95xjz9tfzuj9iz5chaf5u7 X-Rspamd-Server: rspam02 X-Rspamd-Queue-Id: A2C85180003 Authentication-Results: imf06.hostedemail.com; dkim=pass header.d=intel-com.20210112.gappssmtp.com header.s=20210112 header.b=nE35RWa6; dmarc=fail reason="No valid SPF, DKIM not aligned (relaxed)" header.from=intel.com (policy=none); spf=none (imf06.hostedemail.com: domain of dan.j.williams@intel.com has no SPF policy when checking 209.85.214.173) smtp.mailfrom=dan.j.williams@intel.com X-Rspam-User: X-HE-Tag: 1644962795-808091 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: 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, &dax_dev->flags); > synchronize_srcu(&dax_srcu); > + > + /* Lock to prevent concurrent registrations. */ > + percpu_down_write(&dax_dev->holder_rwsem); > + /* clear holder data */ > + dax_dev->holder_ops = NULL; > + dax_dev->holder_data = NULL; > + percpu_up_write(&dax_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(&dax_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(&dax_dev->holder_rwsem); ...and just use cmpxchg: if (cmpxchg(&dax_dev->holder_data, NULL, holder)) return -EBUSY; dax_dev->holder_ops = ops; ...and then on the release side you can require that the caller specify @holder before clearing to make the unregistration symmetric: if (cmpxchg(&dax_dev->holder_data, holder, NULL) != holder)) return -EBUSY; dax_dev->holder_ops = NULL; > + dax_dev->holder_data = holder; > + dax_dev->holder_ops = ops; > + percpu_up_write(&dax_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) Per above, require the holder to pass in their holder_data again. > +{ > + if (!dax_alive(dax_dev)) > + return; > + > + dax_dev->holder_data = NULL; > + dax_dev->holder_ops = NULL; > +} > +EXPORT_SYMBOL_GPL(dax_unregister_holder); > + > /** > * inode_dax: convert a public inode into its dax_dev > * @inode: An inode with i_cdev pointing to a dax_dev > diff --git a/include/linux/dax.h b/include/linux/dax.h > index 9fc5f99a0ae2..9800d84e5b7d 100644 > --- a/include/linux/dax.h > +++ b/include/linux/dax.h > @@ -32,8 +32,24 @@ struct dax_operations { > int (*zero_page_range)(struct dax_device *, pgoff_t, size_t); > }; > > +struct dax_holder_operations { > + /* > + * notify_failure - notify memory failure into inner holder device > + * @dax_dev: the dax device which contains the holder > + * @offset: offset on this dax device where memory failure occurs > + * @len: length of this memory failure event > + * @flags: action flags for memory failure handler > + */ > + int (*notify_failure)(struct dax_device *dax_dev, u64 offset, > + u64 len, int mf_flags); > +}; > + > #if IS_ENABLED(CONFIG_DAX) > struct dax_device *alloc_dax(void *private, const struct dax_operations *ops); > +int dax_register_holder(struct dax_device *dax_dev, void *holder, > + const struct dax_holder_operations *ops); > +void dax_unregister_holder(struct dax_device *dax_dev); > +void *dax_holder(struct dax_device *dax_dev); > void put_dax(struct dax_device *dax_dev); > void kill_dax(struct dax_device *dax_dev); > void dax_write_cache(struct dax_device *dax_dev, bool wc); > @@ -53,6 +69,18 @@ static inline bool daxdev_mapping_supported(struct vm_area_struct *vma, > return dax_synchronous(dax_dev); > } > #else > +static inline int dax_register_holder(struct dax_device *dax_dev, void *holder, > + const struct dax_holder_operations *ops) > +{ > + return 0; > +} > +static inline void dax_unregister_holder(struct dax_device *dax_dev) > +{ > +} > +static inline void *dax_holder(struct dax_device *dax_dev) > +{ > + return NULL; > +} > static inline struct dax_device *alloc_dax(void *private, > const struct dax_operations *ops) > { > @@ -185,6 +213,8 @@ size_t dax_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr, > size_t bytes, struct iov_iter *i); > int dax_zero_page_range(struct dax_device *dax_dev, pgoff_t pgoff, > size_t nr_pages); > +int dax_holder_notify_failure(struct dax_device *dax_dev, u64 off, u64 len, > + int mf_flags); > void dax_flush(struct dax_device *dax_dev, void *addr, size_t size); > > ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter, > -- > 2.34.1 > > >