ocfs2: Add normal functions for reflink a normal file's extents.

2 major functions are added in this patch.

ocfs2_attach_refcount_tree will create a new refcount tree to the
old file if it doesn't have one and insert all the extent records
to the tree if they are not refcounted.

ocfs2_create_reflink_node will:
1. set the refcount tree to the new file.
2. call ocfs2_duplicate_extent_list which will iterate all the
   extents for the old file, insert it to the new file and increase
   the corresponding referennce count.

Signed-off-by: Tao Ma <tao.ma@oracle.com>

1 files changed, 286 insertions, 0 deletions

diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 37aa0c8696d6..e3171c483685 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -3282,3 +3282,289 @@ int ocfs2_refcount_cow(struct inode *inode,
 
         return ret;
 }
+
+/*
+ * Insert a new extent into refcount tree and mark a extent rec
+ * as refcounted in the dinode tree.
+ */
+int ocfs2_add_refcount_flag(struct inode *inode,
+                            struct ocfs2_extent_tree *data_et,
+                            struct ocfs2_caching_info *ref_ci,
+                            struct buffer_head *ref_root_bh,
+                            u32 cpos, u32 p_cluster, u32 num_clusters,
+                            struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret;
+        handle_t *handle;
+        int credits = 1, ref_blocks = 0;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_alloc_context *meta_ac = NULL;
+
+        ret = ocfs2_calc_refcount_meta_credits(inode->i_sb,
+                                               ref_ci, ref_root_bh,
+                                               p_cluster, num_clusters,
+                                               &ref_blocks, &credits);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        mlog(0, "reserve new metadata %d, credits = %d\n",
+             ref_blocks, credits);
+
+        if (ref_blocks) {
+                ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb),
+                                                        ref_blocks, &meta_ac);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_mark_extent_refcounted(inode, data_et, handle,
+                                           cpos, num_clusters, p_cluster,
+                                           meta_ac, dealloc);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+
+        ret = __ocfs2_increase_refcount(handle, ref_ci, ref_root_bh,
+                                        p_cluster, num_clusters,
+                                        meta_ac, dealloc);
+        if (ret)
+                mlog_errno(ret);
+
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        return ret;
+}
+
+static int ocfs2_attach_refcount_tree(struct inode *inode,
+                                      struct buffer_head *di_bh)
+{
+        int ret;
+        struct buffer_head *ref_root_bh = NULL;
+        struct ocfs2_inode_info *oi = OCFS2_I(inode);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_refcount_tree *ref_tree;
+        unsigned int ext_flags;
+        loff_t size;
+        u32 cpos, num_clusters, clusters, p_cluster;
+        struct ocfs2_cached_dealloc_ctxt dealloc;
+        struct ocfs2_extent_tree di_et;
+
+        ocfs2_init_dealloc_ctxt(&dealloc);
+
+        if (!(oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL)) {
+                ret = ocfs2_create_refcount_tree(inode, di_bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+        BUG_ON(!di->i_refcount_loc);
+        ret = ocfs2_lock_refcount_tree(osb,
+                                       le64_to_cpu(di->i_refcount_loc), 1,
+                                       &ref_tree, &ref_root_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ocfs2_init_dinode_extent_tree(&di_et, INODE_CACHE(inode), di_bh);
+
+        size = i_size_read(inode);
+        clusters = ocfs2_clusters_for_bytes(inode->i_sb, size);
+
+        cpos = 0;
+        while (cpos < clusters) {
+                ret = ocfs2_get_clusters(inode, cpos, &p_cluster,
+                                         &num_clusters, &ext_flags);
+
+                if (p_cluster && !(ext_flags & OCFS2_EXT_REFCOUNTED)) {
+                        ret = ocfs2_add_refcount_flag(inode, &di_et,
+                                                      &ref_tree->rf_ci,
+                                                      ref_root_bh, cpos,
+                                                      p_cluster, num_clusters,
+                                                      &dealloc);
+                        if (ret) {
+                                mlog_errno(ret);
+                                break;
+                        }
+                }
+                cpos += num_clusters;
+        }
+
+        ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
+        brelse(ref_root_bh);
+
+        if (!ret && ocfs2_dealloc_has_cluster(&dealloc)) {
+                ocfs2_schedule_truncate_log_flush(osb, 1);
+                ocfs2_run_deallocs(osb, &dealloc);
+        }
+out:
+        /*
+         * Empty the extent map so that we may get the right extent
+         * record from the disk.
+         */
+        ocfs2_extent_map_trunc(inode, 0);
+
+        return ret;
+}
+
+static int ocfs2_add_refcounted_extent(struct inode *inode,
+                                   struct ocfs2_extent_tree *et,
+                                   struct ocfs2_caching_info *ref_ci,
+                                   struct buffer_head *ref_root_bh,
+                                   u32 cpos, u32 p_cluster, u32 num_clusters,
+                                   unsigned int ext_flags,
+                                   struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret;
+        handle_t *handle;
+        int credits = 0;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_alloc_context *meta_ac = NULL;
+
+        ret = ocfs2_lock_refcount_allocators(inode->i_sb,
+                                             p_cluster, num_clusters,
+                                             et, ref_ci,
+                                             ref_root_bh, &meta_ac,
+                                             NULL, &credits);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        handle = ocfs2_start_trans(osb, credits);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_insert_extent(handle, et, cpos,
+                        cpu_to_le64(ocfs2_clusters_to_blocks(inode->i_sb,
+                                                             p_cluster)),
+                        num_clusters, ext_flags, meta_ac);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+
+        ret = __ocfs2_increase_refcount(handle, ref_ci, ref_root_bh,
+                                        p_cluster, num_clusters,
+                                        meta_ac, dealloc);
+        if (ret)
+                mlog_errno(ret);
+
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        return ret;
+}
+
+static int ocfs2_duplicate_extent_list(struct inode *s_inode,
+                                struct inode *t_inode,
+                                struct buffer_head *t_bh,
+                                struct ocfs2_caching_info *ref_ci,
+                                struct buffer_head *ref_root_bh,
+                                struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret = 0;
+        u32 p_cluster, num_clusters, clusters, cpos;
+        loff_t size;
+        unsigned int ext_flags;
+        struct ocfs2_extent_tree et;
+
+        ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(t_inode), t_bh);
+
+        size = i_size_read(s_inode);
+        clusters = ocfs2_clusters_for_bytes(s_inode->i_sb, size);
+
+        cpos = 0;
+        while (cpos < clusters) {
+                ret = ocfs2_get_clusters(s_inode, cpos, &p_cluster,
+                                         &num_clusters, &ext_flags);
+
+                if (p_cluster) {
+                        ret = ocfs2_add_refcounted_extent(t_inode, &et,
+                                                          ref_ci, ref_root_bh,
+                                                          cpos, p_cluster,
+                                                          num_clusters,
+                                                          ext_flags,
+                                                          dealloc);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                }
+
+                cpos += num_clusters;
+        }
+
+out:
+        return ret;
+}
+
+static int ocfs2_create_reflink_node(struct inode *s_inode,
+                                     struct buffer_head *s_bh,
+                                     struct inode *t_inode,
+                                     struct buffer_head *t_bh)
+{
+        int ret;
+        struct buffer_head *ref_root_bh = NULL;
+        struct ocfs2_cached_dealloc_ctxt dealloc;
+        struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb);
+        struct ocfs2_refcount_block *rb;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)s_bh->b_data;
+        struct ocfs2_refcount_tree *ref_tree;
+
+        ocfs2_init_dealloc_ctxt(&dealloc);
+
+        ret = ocfs2_set_refcount_tree(t_inode, t_bh,
+                                      le64_to_cpu(di->i_refcount_loc));
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
+                                       1, &ref_tree, &ref_root_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
+
+        ret = ocfs2_duplicate_extent_list(s_inode, t_inode, t_bh,
+                                          &ref_tree->rf_ci, ref_root_bh,
+                                          &dealloc);
+        if (ret)
+                mlog_errno(ret);
+
+        ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
+        brelse(ref_root_bh);
+out:
+        if (ocfs2_dealloc_has_cluster(&dealloc)) {
+                ocfs2_schedule_truncate_log_flush(osb, 1);
+                ocfs2_run_deallocs(osb, &dealloc);
+        }
+
+        return ret;
+}