fsdax: dedup file range to use a compare function

[linux-2.6-microblaze.git] / fs / dax.c

diff --git a/fs/dax.c b/fs/dax.c
index 0aab323..e0f9c4a 100644 (file)
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -1873,3 +1873,85 @@ 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_iter(struct iomap_iter *it_src,
+               struct iomap_iter *it_dest, u64 len, bool *same)
+{
+       const struct iomap *smap = &it_src->iomap;
+       const struct iomap *dmap = &it_dest->iomap;
+       loff_t pos1 = it_src->pos, pos2 = it_dest->pos;
+       void *saddr, *daddr;
+       int id, ret;
+
+       len = min(len, min(smap->length, dmap->length));
+
+       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;
+       }
+
+       id = dax_read_lock();
+       ret = dax_iomap_direct_access(smap, pos1, ALIGN(pos1 + len, PAGE_SIZE),
+                                     &saddr, NULL);
+       if (ret < 0)
+               goto out_unlock;
+
+       ret = dax_iomap_direct_access(dmap, pos2, ALIGN(pos2 + len, PAGE_SIZE),
+                                     &daddr, NULL);
+       if (ret < 0)
+               goto out_unlock;
+
+       *same = !memcmp(saddr, daddr, len);
+       if (!*same)
+               len = 0;
+       dax_read_unlock(id);
+       return len;
+
+out_unlock:
+       dax_read_unlock(id);
+       return -EIO;
+}
+
+int dax_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
+               struct inode *dst, loff_t dstoff, loff_t len, bool *same,
+               const struct iomap_ops *ops)
+{
+       struct iomap_iter src_iter = {
+               .inode          = src,
+               .pos            = srcoff,
+               .len            = len,
+               .flags          = IOMAP_DAX,
+       };
+       struct iomap_iter dst_iter = {
+               .inode          = dst,
+               .pos            = dstoff,
+               .len            = len,
+               .flags          = IOMAP_DAX,
+       };
+       int ret;
+
+       while ((ret = iomap_iter(&src_iter, ops)) > 0) {
+               while ((ret = iomap_iter(&dst_iter, ops)) > 0) {
+                       dst_iter.processed = dax_range_compare_iter(&src_iter,
+                                               &dst_iter, len, same);
+               }
+               if (ret <= 0)
+                       src_iter.processed = ret;
+       }
+       return ret;
+}
+
+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);
+}
+EXPORT_SYMBOL_GPL(dax_remap_file_range_prep);