Received: by 2002:a05:6a10:206:0:0:0:0 with SMTP id 6csp4036357pxj; Tue, 11 May 2021 18:28:26 -0700 (PDT) X-Google-Smtp-Source: ABdhPJw+WLnMMoTJlI0Ydj04h2LinEpyDQxTu1tncHFLMAysI1FIRwxRXeqR2LHBhCV/8ziWFsLz X-Received: by 2002:a50:eb47:: with SMTP id z7mr40485683edp.68.1620782906661; Tue, 11 May 2021 18:28:26 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1620782906; cv=none; d=google.com; s=arc-20160816; b=T1/nmOFcPu8eQw5Py+4LLuwig/sndXTrEetY6MRtyUhcMS5j2iCYGX3z9DYn38Ubzy mpPdA/y0lgQJt0P1xJduvs+pFu0HNNIgQ8vQuqK4ZnmJn9huPpwSbs8q20AgzZuKMXAB VcJzFEv9kIK3CVLsd0jAmIMlakjPsgiXwY/7aQUR1Zr/e1A8dIP1bnfNqNFDqu7HwRVo RMXmlx6q3h6D7cRRwcsrs18VdojAwJxtIdftfoKb8ap8Cq/6egDUxlHpUUmKiTV99XHC dxJRlJ+Wc95RsCRW+CJH/OayEB7VhYjZlmmF5wxCtGxxfKRG0TQQ0uNcwMxlJJd/JXw3 zeew== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:in-reply-to:content-disposition:mime-version :references:message-id:subject:cc:to:from:date:dkim-signature; bh=yni3SwdxcHTYVVivA/Q1vEfYAp5bfG/8G9g3/6tyO4s=; b=Z60gG+HA+PuZeZwtPBCULToim7TDixo7YuRY+ymcocqH9j3iszT5IVPRHGFCuFtYSG Tu070xRJjOb9a/Rem5i48vG5kTpeboVBW1l8OjoXVDMsmD3iPq08VmfLnm34OMs2cY4X Dox60pCXR2XXBNyKVU54Is5rp8Y8Y1IhFuJHJu/Y32k5ZQMGUaHGVaNbIBFQmI50swi7 5pzbx1c6kwPMuIVsmPItqH3qBfF+OvCVLi07lZXPYqGb1eL/oGF5dhq/MrbPULh7DYG6 2fCjWPmcSg37oLf1shhSlCVTSWaj59sTOaWqcekJqSlGDBO4yfYb5RKGM8UInnpK1jYh CNvw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b="G5WB+/fE"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id af15si18137131ejc.400.2021.05.11.18.28.02; Tue, 11 May 2021 18:28:26 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b="G5WB+/fE"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230095AbhELBYr (ORCPT + 99 others); Tue, 11 May 2021 21:24:47 -0400 Received: from mail.kernel.org ([198.145.29.99]:38130 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229920AbhELBYr (ORCPT ); Tue, 11 May 2021 21:24:47 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id C074661928; Wed, 12 May 2021 01:23:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1620782619; bh=EuquOXa6sdUy29wXYEo+mtbqiM5nYJmbHZRuly0nuEY=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=G5WB+/fE83IHq4sPSz5Sxnzb9GVOiLU+OyuLr/iBkXDxxO/aTJxmUMXSdCFByTUj7 A1eoYI29ji7qed+aPUkVvg9T7PlPYrdgTkstrqMWrxYcLVCHFoLUwNmbUDt5LBvDkb KxlkssBeoEZYzWp02e4uHr2GL7iJ5VN9erDOnK0/Mz0W1N1MR6FrdHN5m04yb09tD7 8FKa2DprYI4O0T9kYpQ4EadNT1Mo44zdBCHiVdNKp75be505egvBDCS5BeQhG13dC9 AxmSkIF829XgY8jq8Sb6XEOqQSKAnAiyNNEmhVmO7B11F1CVJ9HRE4TXyEadEaGcAW BnvpPbszh8ZIg== Date: Tue, 11 May 2021 18:23:36 -0700 From: "Darrick J. Wong" To: Shiyang Ruan Cc: linux-kernel@vger.kernel.org, linux-xfs@vger.kernel.org, linux-nvdimm@lists.01.org, linux-fsdevel@vger.kernel.org, darrick.wong@oracle.com, dan.j.williams@intel.com, willy@infradead.org, viro@zeniv.linux.org.uk, david@fromorbit.com, hch@lst.de, rgoldwyn@suse.de, Goldwyn Rodrigues Subject: Re: [PATCH v5 5/7] fsdax: Dedup file range to use a compare function Message-ID: <20210512012336.GU8582@magnolia> References: <20210511030933.3080921-1-ruansy.fnst@fujitsu.com> <20210511030933.3080921-6-ruansy.fnst@fujitsu.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20210511030933.3080921-6-ruansy.fnst@fujitsu.com> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, May 11, 2021 at 11:09:31AM +0800, Shiyang Ruan wrote: > With dax we cannot deal with readpage() etc. So, we create a dax > comparison funciton which is similar with > vfs_dedupe_file_range_compare(). > And introduce dax_remap_file_range_prep() for filesystem use. > > Signed-off-by: Goldwyn Rodrigues > Signed-off-by: Shiyang Ruan > --- > fs/dax.c | 56 +++++++++++++++++++++++++++++++++++++++++++ > fs/remap_range.c | 57 +++++++++++++++++++++++++++++++++++++------- > fs/xfs/xfs_reflink.c | 8 +++++-- > include/linux/dax.h | 4 ++++ > include/linux/fs.h | 12 ++++++---- > 5 files changed, 123 insertions(+), 14 deletions(-) > > diff --git a/fs/dax.c b/fs/dax.c > index ee9d28a79bfb..dedf1be0155c 100644 > --- a/fs/dax.c > +++ b/fs/dax.c > @@ -1853,3 +1853,59 @@ vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf, > return dax_insert_pfn_mkwrite(vmf, pfn, order); > } > EXPORT_SYMBOL_GPL(dax_finish_sync_fault); > + > +static loff_t dax_range_compare_actor(struct inode *ino1, loff_t pos1, > + struct inode *ino2, loff_t pos2, loff_t len, void *data, > + struct iomap *smap, struct iomap *dmap) > +{ > + void *saddr, *daddr; > + bool *same = data; > + int ret; > + > + if (smap->type == IOMAP_HOLE && dmap->type == IOMAP_HOLE) { > + *same = true; > + return len; > + } > + > + if (smap->type == IOMAP_HOLE || dmap->type == IOMAP_HOLE) { > + *same = false; > + return 0; > + } > + > + ret = dax_iomap_direct_access(smap, pos1, ALIGN(pos1 + len, PAGE_SIZE), > + &saddr, NULL); > + if (ret < 0) > + return -EIO; > + > + ret = dax_iomap_direct_access(dmap, pos2, ALIGN(pos2 + len, PAGE_SIZE), > + &daddr, NULL); > + if (ret < 0) > + return -EIO; > + > + *same = !memcmp(saddr, daddr, len); > + return len; > +} > + > +int dax_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > + struct inode *dest, loff_t destoff, loff_t len, bool *is_same, > + const struct iomap_ops *ops) > +{ > + int id, ret = 0; > + > + id = dax_read_lock(); > + while (len) { > + ret = iomap_apply2(src, srcoff, dest, destoff, len, 0, ops, > + is_same, dax_range_compare_actor); > + if (ret < 0 || !*is_same) > + goto out; > + > + len -= ret; > + srcoff += ret; > + destoff += ret; > + } > + ret = 0; > +out: > + dax_read_unlock(id); > + return ret; > +} > +EXPORT_SYMBOL_GPL(dax_dedupe_file_range_compare); > diff --git a/fs/remap_range.c b/fs/remap_range.c > index e4a5fdd7ad7b..7bc4c8e3aa9f 100644 > --- a/fs/remap_range.c > +++ b/fs/remap_range.c > @@ -14,6 +14,7 @@ > #include > #include > #include > +#include > #include "internal.h" > > #include > @@ -199,9 +200,9 @@ static void vfs_unlock_two_pages(struct page *page1, struct page *page2) > * Compare extents of two files to see if they are the same. > * Caller must have locked both inodes to prevent write races. > */ > -static int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > - struct inode *dest, loff_t destoff, > - loff_t len, bool *is_same) > +int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > + struct inode *dest, loff_t destoff, > + loff_t len, bool *is_same) > { > loff_t src_poff; > loff_t dest_poff; > @@ -280,6 +281,7 @@ static int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > out_error: > return error; > } > +EXPORT_SYMBOL(vfs_dedupe_file_range_compare); > > /* > * Check that the two inodes are eligible for cloning, the ranges make > @@ -289,9 +291,11 @@ static int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > * If there's an error, then the usual negative error code is returned. > * Otherwise returns 0 with *len set to the request length. > */ > -int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > - struct file *file_out, loff_t pos_out, > - loff_t *len, unsigned int remap_flags) > +static int > +__generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *len, unsigned int remap_flags, > + const struct iomap_ops *dax_read_ops) > { > struct inode *inode_in = file_inode(file_in); > struct inode *inode_out = file_inode(file_out); > @@ -351,8 +355,17 @@ int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > if (remap_flags & REMAP_FILE_DEDUP) { > bool is_same = false; > > - ret = vfs_dedupe_file_range_compare(inode_in, pos_in, > - inode_out, pos_out, *len, &is_same); > + if (!IS_DAX(inode_in)) > + ret = vfs_dedupe_file_range_compare(inode_in, pos_in, > + inode_out, pos_out, *len, &is_same); > +#ifdef CONFIG_FS_DAX > + else if (dax_read_ops) > + ret = dax_dedupe_file_range_compare(inode_in, pos_in, > + inode_out, pos_out, *len, &is_same, > + dax_read_ops); > +#endif /* CONFIG_FS_DAX */ Hmm, can you add an entry to the !IS_ENABLED(CONFIG_DAX) part of dax.h that defines dax_dedupe_file_range_compare as a dummy function that returns -EOPNOTSUPP? We try not to sprinkle preprocessor directives into the middle of functions, per Linus rules. > + else > + return -EINVAL; > if (ret) > return ret; > if (!is_same) > @@ -370,6 +383,34 @@ int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > > return ret; > } > + > +#ifdef CONFIG_FS_DAX > +int dax_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *len, unsigned int remap_flags, > + const struct iomap_ops *ops) > +{ > + return __generic_remap_file_range_prep(file_in, pos_in, file_out, > + pos_out, len, remap_flags, ops); > +} > +#else > +int dax_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *len, unsigned int remap_flags, > + const struct iomap_ops *ops) > +{ > + return -EOPNOTSUPP; > +} > +#endif /* CONFIG_FS_DAX */ > +EXPORT_SYMBOL(dax_remap_file_range_prep); I think this symbol belongs in fs/dax.c and the declaration in dax.h? --D > +int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *len, unsigned int remap_flags) > +{ > + return __generic_remap_file_range_prep(file_in, pos_in, file_out, > + pos_out, len, remap_flags, NULL); > +} > EXPORT_SYMBOL(generic_remap_file_range_prep); > > loff_t do_clone_file_range(struct file *file_in, loff_t pos_in, > diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c > index 060695d6d56a..d25434f93235 100644 > --- a/fs/xfs/xfs_reflink.c > +++ b/fs/xfs/xfs_reflink.c > @@ -1329,8 +1329,12 @@ xfs_reflink_remap_prep( > if (IS_DAX(inode_in) || IS_DAX(inode_out)) > goto out_unlock; > > - ret = generic_remap_file_range_prep(file_in, pos_in, file_out, pos_out, > - len, remap_flags); > + if (!IS_DAX(inode_in)) > + ret = generic_remap_file_range_prep(file_in, pos_in, file_out, > + pos_out, len, remap_flags); > + else > + ret = dax_remap_file_range_prep(file_in, pos_in, file_out, > + pos_out, len, remap_flags, &xfs_read_iomap_ops); > if (ret || *len == 0) > goto out_unlock; > > diff --git a/include/linux/dax.h b/include/linux/dax.h > index 3275e01ed33d..32e1c34349f2 100644 > --- a/include/linux/dax.h > +++ b/include/linux/dax.h > @@ -239,6 +239,10 @@ int dax_invalidate_mapping_entry_sync(struct address_space *mapping, > pgoff_t index); > s64 dax_iomap_zero(loff_t pos, u64 length, struct iomap *iomap, > struct iomap *srcmap); > +int dax_dedupe_file_range_compare(struct inode *src, loff_t srcoff, > + struct inode *dest, loff_t destoff, > + loff_t len, bool *is_same, > + const struct iomap_ops *ops); > static inline bool dax_mapping(struct address_space *mapping) > { > return mapping->host && IS_DAX(mapping->host); > diff --git a/include/linux/fs.h b/include/linux/fs.h > index c3c88fdb9b2a..e2c348553d87 100644 > --- a/include/linux/fs.h > +++ b/include/linux/fs.h > @@ -71,6 +71,7 @@ struct fsverity_operations; > struct fs_context; > struct fs_parameter_spec; > struct fileattr; > +struct iomap_ops; > > extern void __init inode_init(void); > extern void __init inode_init_early(void); > @@ -2126,10 +2127,13 @@ extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *, > extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, > struct file *file_out, loff_t pos_out, > size_t len, unsigned int flags); > -extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > - struct file *file_out, loff_t pos_out, > - loff_t *count, > - unsigned int remap_flags); > +int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *count, unsigned int remap_flags); > +int dax_remap_file_range_prep(struct file *file_in, loff_t pos_in, > + struct file *file_out, loff_t pos_out, > + loff_t *len, unsigned int remap_flags, > + const struct iomap_ops *ops); > extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in, > struct file *file_out, loff_t pos_out, > loff_t len, unsigned int remap_flags); > -- > 2.31.1 > > >