1 files changed, 69 insertions, 0 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index 52517f28e6f4..47e6bfd45a91 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2974,6 +2974,75 @@ inline ssize_t generic_write_checks(struct kiocb *iocb, struct iov_iter *from)
 }
 EXPORT_SYMBOL(generic_write_checks);
 
+/*
+ * Performs necessary checks before doing a clone.
+ *
+ * Can adjust amount of bytes to clone.
+ * Returns appropriate error code that caller should return or
+ * zero in case the clone should be allowed.
+ */
+int generic_remap_checks(struct file *file_in, loff_t pos_in,
+                         struct file *file_out, loff_t pos_out,
+                         uint64_t *req_count, bool is_dedupe)
+{
+        struct inode *inode_in = file_in->f_mapping->host;
+        struct inode *inode_out = file_out->f_mapping->host;
+        uint64_t count = *req_count;
+        uint64_t bcount;
+        loff_t size_in, size_out;
+        loff_t bs = inode_out->i_sb->s_blocksize;
+
+        /* The start of both ranges must be aligned to an fs block. */
+        if (!IS_ALIGNED(pos_in, bs) || !IS_ALIGNED(pos_out, bs))
+                return -EINVAL;
+
+        /* Ensure offsets don't wrap. */
+        if (pos_in + count < pos_in || pos_out + count < pos_out)
+                return -EINVAL;
+
+        size_in = i_size_read(inode_in);
+        size_out = i_size_read(inode_out);
+
+        /* Dedupe requires both ranges to be within EOF. */
+        if (is_dedupe &&
+            (pos_in >= size_in || pos_in + count > size_in ||
+             pos_out >= size_out || pos_out + count > size_out))
+                return -EINVAL;
+
+        /* Ensure the infile range is within the infile. */
+        if (pos_in >= size_in)
+                return -EINVAL;
+        count = min(count, size_in - (uint64_t)pos_in);
+
+        /*
+         * If the user wanted us to link to the infile's EOF, round up to the
+         * next block boundary for this check.
+         *
+         * Otherwise, make sure the count is also block-aligned, having
+         * already confirmed the starting offsets' block alignment.
+         */
+        if (pos_in + count == size_in) {
+                bcount = ALIGN(size_in, bs) - pos_in;
+        } else {
+                if (!IS_ALIGNED(count, bs))
+                        return -EINVAL;
+
+                bcount = count;
+        }
+
+        /* Don't allow overlapped cloning within the same file. */
+        if (inode_in == inode_out &&
+            pos_out + bcount > pos_in &&
+            pos_out < pos_in + bcount)
+                return -EINVAL;
+
+        /* For now we don't support changing the length. */
+        if (*req_count != count)
+                return -EINVAL;
+
+        return 0;
+}
+
 int pagecache_write_begin(struct file *file, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned flags,
                                 struct page **pagep, void **fsdata)