f2fs: check PageWriteback flag for ordered case

For all ordered cases in f2fs_wait_on_page_writeback(), we need to
check PageWriteback status, so let's clean up to relocate the check
into f2fs_wait_on_page_writeback().

Signed-off-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 5401ea5e491dcea018e508f47edeed6c6758979a..f955cd3e067798142c3f0f812af8912f55e75707 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -44,7 +44,7 @@ repeat:
                cond_resched();
                goto repeat;
        }
-       f2fs_wait_on_page_writeback(page, META, true);
+       f2fs_wait_on_page_writeback(page, META, true, true);
        if (!PageUptodate(page))
                SetPageUptodate(page);
        return page;
@@ -370,9 +370,8 @@ continue_unlock:
                                goto continue_unlock;
                        }
 
-                       f2fs_wait_on_page_writeback(page, META, true);
+                       f2fs_wait_on_page_writeback(page, META, true, true);
 
-                       BUG_ON(PageWriteback(page));
                        if (!clear_page_dirty_for_io(page))
                                goto continue_unlock;
 
@@ -1290,8 +1289,7 @@ static void commit_checkpoint(struct f2fs_sb_info *sbi,
        struct page *page = f2fs_grab_meta_page(sbi, blk_addr);
        int err;
 
-       f2fs_wait_on_page_writeback(page, META, true);
-       f2fs_bug_on(sbi, PageWriteback(page));
+       f2fs_wait_on_page_writeback(page, META, true, true);
 
        memcpy(page_address(page), src, PAGE_SIZE);
 

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 59d86f692c84e35afda8fe7ebe272f244d7cfca1..a0524616f3f160b2892513a11414ae2ea0c76aec 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -626,7 +626,7 @@ static void __set_data_blkaddr(struct dnode_of_data *dn)
  */
 void f2fs_set_data_blkaddr(struct dnode_of_data *dn)
 {
-       f2fs_wait_on_page_writeback(dn->node_page, NODE, true);
+       f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);
        __set_data_blkaddr(dn);
        if (set_page_dirty(dn->node_page))
                dn->node_changed = true;
@@ -656,7 +656,7 @@ int f2fs_reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count)
        trace_f2fs_reserve_new_blocks(dn->inode, dn->nid,
                                                dn->ofs_in_node, count);
 
-       f2fs_wait_on_page_writeback(dn->node_page, NODE, true);
+       f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);
 
        for (; count > 0; dn->ofs_in_node++) {
                block_t blkaddr = datablock_addr(dn->inode,
@@ -2149,12 +2149,11 @@ continue_unlock:
                        if (PageWriteback(page)) {
                                if (wbc->sync_mode != WB_SYNC_NONE)
                                        f2fs_wait_on_page_writeback(page,
-                                                               DATA, true);
+                                                       DATA, true, true);
                                else
                                        goto continue_unlock;
                        }
 
-                       BUG_ON(PageWriteback(page));
                        if (!clear_page_dirty_for_io(page))
                                goto continue_unlock;
 
@@ -2472,7 +2471,7 @@ repeat:
                }
        }
 
-       f2fs_wait_on_page_writeback(page, DATA, false);
+       f2fs_wait_on_page_writeback(page, DATA, false, true);
 
        if (len == PAGE_SIZE || PageUptodate(page))
                return 0;

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index c0c845da12fa5cfa33f5953a0b5c7d847d48598a..50d0d36280fac5e92094743c1a868bad55a25bda 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -293,7 +293,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
 {
        enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
        lock_page(page);
-       f2fs_wait_on_page_writeback(page, type, true);
+       f2fs_wait_on_page_writeback(page, type, true, true);
        de->ino = cpu_to_le32(inode->i_ino);
        set_de_type(de, inode->i_mode);
        set_page_dirty(page);
@@ -307,7 +307,7 @@ static void init_dent_inode(const struct qstr *name, struct page *ipage)
 {
        struct f2fs_inode *ri;
 
-       f2fs_wait_on_page_writeback(ipage, NODE, true);
+       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
 
        /* copy name info. to this inode page */
        ri = F2FS_INODE(ipage);
@@ -550,7 +550,7 @@ start:
        ++level;
        goto start;
 add_dentry:
-       f2fs_wait_on_page_writeback(dentry_page, DATA, true);
+       f2fs_wait_on_page_writeback(dentry_page, DATA, true, true);
 
        if (inode) {
                down_write(&F2FS_I(inode)->i_sem);
@@ -705,7 +705,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
                return f2fs_delete_inline_entry(dentry, page, dir, inode);
 
        lock_page(page);
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
 
        dentry_blk = page_address(page);
        bit_pos = dentry - dentry_blk->dentry;

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 9e56c78fe519ce0566c46651e754f76e95793ace..12fabd6735ddb88e3eab3460b8a912924d164636 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3038,7 +3038,7 @@ void f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
                        struct f2fs_summary *sum, int type,
                        struct f2fs_io_info *fio, bool add_list);
 void f2fs_wait_on_page_writeback(struct page *page,
-                       enum page_type type, bool ordered);
+                       enum page_type type, bool ordered, bool locked);
 void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr);
 void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
                                                                block_t len);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 7bf28be811ab43c2d5df90ce641374f46ef37c2f..bba56b39dcc55a1b15da3a90ddb3c53cb894e7f2 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -82,7 +82,7 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
        }
 
        /* fill the page */
-       f2fs_wait_on_page_writeback(page, DATA, false);
+       f2fs_wait_on_page_writeback(page, DATA, false, true);
 
        /* wait for GCed page writeback via META_MAPPING */
        f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
@@ -578,7 +578,7 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
        if (IS_ERR(page))
                return PTR_ERR(page) == -ENOENT ? 0 : PTR_ERR(page);
 truncate_out:
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
        zero_user(page, offset, PAGE_SIZE - offset);
 
        /* An encrypted inode should have a key and truncate the last page. */
@@ -895,7 +895,7 @@ static int fill_zero(struct inode *inode, pgoff_t index,
        if (IS_ERR(page))
                return PTR_ERR(page);
 
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
        zero_user(page, start, len);
        set_page_dirty(page);
        f2fs_put_page(page, 1);

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index aed7084e8443775264ae1c0b2b9f506c360ca672..195cf0f9d9ef90794e2b9a80649729511ea4ab60 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -679,7 +679,7 @@ got_it:
         * don't cache encrypted data into meta inode until previous dirty
         * data were writebacked to avoid racing between GC and flush.
         */
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
 
        f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
 
@@ -768,7 +768,7 @@ static int move_data_block(struct inode *inode, block_t bidx,
         * don't cache encrypted data into meta inode until previous dirty
         * data were writebacked to avoid racing between GC and flush.
         */
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
 
        f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
 
@@ -829,7 +829,7 @@ static int move_data_block(struct inode *inode, block_t bidx,
        }
 
 write_page:
-       f2fs_wait_on_page_writeback(fio.encrypted_page, DATA, true);
+       f2fs_wait_on_page_writeback(fio.encrypted_page, DATA, true, true);
        set_page_dirty(fio.encrypted_page);
        if (clear_page_dirty_for_io(fio.encrypted_page))
                dec_page_count(fio.sbi, F2FS_DIRTY_META);
@@ -838,7 +838,7 @@ write_page:
        ClearPageError(page);
 
        /* allocate block address */
-       f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
+       f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
 
        fio.op = REQ_OP_WRITE;
        fio.op_flags = REQ_SYNC;
@@ -924,7 +924,7 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
                bool is_dirty = PageDirty(page);
 
 retry:
-               f2fs_wait_on_page_writeback(page, DATA, true);
+               f2fs_wait_on_page_writeback(page, DATA, true, true);
 
                set_page_dirty(page);
                if (clear_page_dirty_for_io(page)) {

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 0113bebe2ea8755ccd1fbf7c872c80775e0ed827..d636cbcf68f2ef331cc83b40e31206a3ae6d3df7 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -72,7 +72,7 @@ void f2fs_truncate_inline_inode(struct inode *inode,
 
        addr = inline_data_addr(inode, ipage);
 
-       f2fs_wait_on_page_writeback(ipage, NODE, true);
+       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
        memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);
        set_page_dirty(ipage);
 
@@ -161,7 +161,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
        fio.old_blkaddr = dn->data_blkaddr;
        set_inode_flag(dn->inode, FI_HOT_DATA);
        f2fs_outplace_write_data(dn, &fio);
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
        if (dirty) {
                inode_dec_dirty_pages(dn->inode);
                f2fs_remove_dirty_inode(dn->inode);
@@ -236,7 +236,7 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page)
 
        f2fs_bug_on(F2FS_I_SB(inode), page->index);
 
-       f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
+       f2fs_wait_on_page_writeback(dn.inode_page, NODE, true, true);
        src_addr = kmap_atomic(page);
        dst_addr = inline_data_addr(inode, dn.inode_page);
        memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
@@ -277,7 +277,7 @@ process_inline:
                ipage = f2fs_get_node_page(sbi, inode->i_ino);
                f2fs_bug_on(sbi, IS_ERR(ipage));
 
-               f2fs_wait_on_page_writeback(ipage, NODE, true);
+               f2fs_wait_on_page_writeback(ipage, NODE, true, true);
 
                src_addr = inline_data_addr(inode, npage);
                dst_addr = inline_data_addr(inode, ipage);
@@ -391,7 +391,7 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
                goto out;
        }
 
-       f2fs_wait_on_page_writeback(page, DATA, true);
+       f2fs_wait_on_page_writeback(page, DATA, true, true);
 
        dentry_blk = page_address(page);
 
@@ -505,7 +505,7 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
        return 0;
 recover:
        lock_page(ipage);
-       f2fs_wait_on_page_writeback(ipage, NODE, true);
+       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
        memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));
        f2fs_i_depth_write(dir, 0);
        f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));
@@ -565,7 +565,7 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
                }
        }
 
-       f2fs_wait_on_page_writeback(ipage, NODE, true);
+       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
 
        name_hash = f2fs_dentry_hash(new_name, NULL);
        f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
@@ -597,7 +597,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
        int i;
 
        lock_page(page);
-       f2fs_wait_on_page_writeback(page, NODE, true);
+       f2fs_wait_on_page_writeback(page, NODE, true, true);
 
        inline_dentry = inline_data_addr(dir, page);
        make_dentry_ptr_inline(dir, &d, inline_dentry);

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index f63d4fe6156d5be0d9f563bc7d32abc0af904063..bec52961630b91215eeb107029ad78610779201b 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -103,7 +103,7 @@ static void __recover_inline_status(struct inode *inode, struct page *ipage)
 
        while (start < end) {
                if (*start++) {
-                       f2fs_wait_on_page_writeback(ipage, NODE, true);
+                       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
 
                        set_inode_flag(inode, FI_DATA_EXIST);
                        set_raw_inline(inode, F2FS_INODE(ipage));
@@ -497,7 +497,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
        struct f2fs_inode *ri;
        struct extent_tree *et = F2FS_I(inode)->extent_tree;
 
-       f2fs_wait_on_page_writeback(node_page, NODE, true);
+       f2fs_wait_on_page_writeback(node_page, NODE, true, true);
        set_page_dirty(node_page);
 
        f2fs_inode_synced(inode);

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 20c08fb70bc36bb59ec4f90763ed30cf1fdad129..4f450e5733124655761f3f61c408cb7583da06e7 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1106,7 +1106,7 @@ skip_partial:
                                ri->i_nid[offset[0] - NODE_DIR1_BLOCK]) {
                        lock_page(page);
                        BUG_ON(page->mapping != NODE_MAPPING(sbi));
-                       f2fs_wait_on_page_writeback(page, NODE, true);
+                       f2fs_wait_on_page_writeback(page, NODE, true, true);
                        ri->i_nid[offset[0] - NODE_DIR1_BLOCK] = 0;
                        set_page_dirty(page);
                        unlock_page(page);
@@ -1234,7 +1234,7 @@ struct page *f2fs_new_node_page(struct dnode_of_data *dn, unsigned int ofs)
        new_ni.version = 0;
        set_node_addr(sbi, &new_ni, NEW_ADDR, false);
 
-       f2fs_wait_on_page_writeback(page, NODE, true);
+       f2fs_wait_on_page_writeback(page, NODE, true, true);
        fill_node_footer(page, dn->nid, dn->inode->i_ino, ofs, true);
        set_cold_node(page, S_ISDIR(dn->inode->i_mode));
        if (!PageUptodate(page))
@@ -1598,8 +1598,7 @@ int f2fs_move_node_page(struct page *node_page, int gc_type)
                        .for_reclaim = 0,
                };
 
-               f2fs_wait_on_page_writeback(node_page, NODE, true);
-               f2fs_bug_on(F2FS_P_SB(node_page), PageWriteback(node_page));
+               f2fs_wait_on_page_writeback(node_page, NODE, true, true);
 
                set_page_dirty(node_page);
 
@@ -1690,8 +1689,7 @@ continue_unlock:
                                goto continue_unlock;
                        }
 
-                       f2fs_wait_on_page_writeback(page, NODE, true);
-                       BUG_ON(PageWriteback(page));
+                       f2fs_wait_on_page_writeback(page, NODE, true, true);
 
                        set_fsync_mark(page, 0);
                        set_dentry_mark(page, 0);
@@ -1742,7 +1740,7 @@ continue_unlock:
                        "Retry to write fsync mark: ino=%u, idx=%lx",
                                        ino, last_page->index);
                lock_page(last_page);
-               f2fs_wait_on_page_writeback(last_page, NODE, true);
+               f2fs_wait_on_page_writeback(last_page, NODE, true, true);
                set_page_dirty(last_page);
                unlock_page(last_page);
                goto retry;
@@ -1823,9 +1821,8 @@ continue_unlock:
                                goto lock_node;
                        }
 
-                       f2fs_wait_on_page_writeback(page, NODE, true);
+                       f2fs_wait_on_page_writeback(page, NODE, true, true);
 
-                       BUG_ON(PageWriteback(page));
                        if (!clear_page_dirty_for_io(page))
                                goto continue_unlock;
 
@@ -1892,7 +1889,7 @@ int f2fs_wait_on_node_pages_writeback(struct f2fs_sb_info *sbi,
                get_page(page);
                spin_unlock_irqrestore(&sbi->fsync_node_lock, flags);
 
-               f2fs_wait_on_page_writeback(page, NODE, true);
+               f2fs_wait_on_page_writeback(page, NODE, true, false);
                if (TestClearPageError(page))
                        ret = -EIO;
 
@@ -2470,7 +2467,7 @@ void f2fs_recover_inline_xattr(struct inode *inode, struct page *page)
        src_addr = inline_xattr_addr(inode, page);
        inline_size = inline_xattr_size(inode);
 
-       f2fs_wait_on_page_writeback(ipage, NODE, true);
+       f2fs_wait_on_page_writeback(ipage, NODE, true, true);
        memcpy(dst_addr, src_addr, inline_size);
 update_inode:
        f2fs_update_inode(inode, ipage);

diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index 1c73d879a9bc94c32f83ffb34eaf54f91eb2c7d3..e05af5df56485eff71c95f58b5d3f877cbcb8e53 100644 (file)
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -361,7 +361,7 @@ static inline int set_nid(struct page *p, int off, nid_t nid, bool i)
 {
        struct f2fs_node *rn = F2FS_NODE(p);
 
-       f2fs_wait_on_page_writeback(p, NODE, true);
+       f2fs_wait_on_page_writeback(p, NODE, true, true);
 
        if (i)
                rn->i.i_nid[off - NODE_DIR1_BLOCK] = cpu_to_le32(nid);

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index c22f9d0011ba88369e20cba3f7116753135b0c78..e3883db868d81ee6fa92fb6cbd6e68dc2e1bf367 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -539,7 +539,7 @@ retry_dn:
                goto out;
        }
 
-       f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
+       f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
 
        err = f2fs_get_node_info(sbi, dn.nid, &ni);
        if (err)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 009971ea8f08d38ffca643b66ed26127f2cfa7d0..9b79056d705d2b2f031eb716de2f030fe77e3a57 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -229,7 +229,7 @@ static int __revoke_inmem_pages(struct inode *inode,
 
                lock_page(page);
 
-               f2fs_wait_on_page_writeback(page, DATA, true);
+               f2fs_wait_on_page_writeback(page, DATA, true, true);
 
                if (recover) {
                        struct dnode_of_data dn;
@@ -387,7 +387,7 @@ static int __f2fs_commit_inmem_pages(struct inode *inode)
                if (page->mapping == inode->i_mapping) {
                        trace_f2fs_commit_inmem_page(page, INMEM);
 
-                       f2fs_wait_on_page_writeback(page, DATA, true);
+                       f2fs_wait_on_page_writeback(page, DATA, true, true);
 
                        set_page_dirty(page);
                        if (clear_page_dirty_for_io(page)) {
@@ -3279,16 +3279,18 @@ void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
 }
 
 void f2fs_wait_on_page_writeback(struct page *page,
-                               enum page_type type, bool ordered)
+                               enum page_type type, bool ordered, bool locked)
 {
        if (PageWriteback(page)) {
                struct f2fs_sb_info *sbi = F2FS_P_SB(page);
 
                f2fs_submit_merged_write_cond(sbi, NULL, page, 0, type);
-               if (ordered)
+               if (ordered) {
                        wait_on_page_writeback(page);
-               else
+                       f2fs_bug_on(sbi, locked && PageWriteback(page));
+               } else {
                        wait_for_stable_page(page);
+               }
        }
 }
 
@@ -3305,7 +3307,7 @@ void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr)
 
        cpage = find_lock_page(META_MAPPING(sbi), blkaddr);
        if (cpage) {
-               f2fs_wait_on_page_writeback(cpage, DATA, true);
+               f2fs_wait_on_page_writeback(cpage, DATA, true, true);
                f2fs_put_page(cpage, 1);
        }
 }

diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 7261245c208dc5f0ebd229460b2cfadf74119d7d..f44b0c38398bc1cc9929fb951b760fc4c609beff 100644 (file)
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -415,7 +415,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
                }
 
                f2fs_wait_on_page_writeback(ipage ? ipage : in_page,
-                                                       NODE, true);
+                                                       NODE, true, true);
                /* no need to use xattr node block */
                if (hsize <= inline_size) {
                        err = f2fs_truncate_xattr_node(inode);
@@ -439,7 +439,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
                        goto in_page_out;
                }
                f2fs_bug_on(sbi, new_nid);
-               f2fs_wait_on_page_writeback(xpage, NODE, true);
+               f2fs_wait_on_page_writeback(xpage, NODE, true, true);
        } else {
                struct dnode_of_data dn;
                set_new_dnode(&dn, inode, NULL, NULL, new_nid);