1ccd979bdSMark Fasheh /* -*- mode: c; c-basic-offset: 8; -*- 2ccd979bdSMark Fasheh * vim: noexpandtab sw=8 ts=8 sts=0: 3ccd979bdSMark Fasheh * 4ccd979bdSMark Fasheh * alloc.c 5ccd979bdSMark Fasheh * 6ccd979bdSMark Fasheh * Extent allocs and frees 7ccd979bdSMark Fasheh * 8ccd979bdSMark Fasheh * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9ccd979bdSMark Fasheh * 10ccd979bdSMark Fasheh * This program is free software; you can redistribute it and/or 11ccd979bdSMark Fasheh * modify it under the terms of the GNU General Public 12ccd979bdSMark Fasheh * License as published by the Free Software Foundation; either 13ccd979bdSMark Fasheh * version 2 of the License, or (at your option) any later version. 14ccd979bdSMark Fasheh * 15ccd979bdSMark Fasheh * This program is distributed in the hope that it will be useful, 16ccd979bdSMark Fasheh * but WITHOUT ANY WARRANTY; without even the implied warranty of 17ccd979bdSMark Fasheh * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18ccd979bdSMark Fasheh * General Public License for more details. 19ccd979bdSMark Fasheh * 20ccd979bdSMark Fasheh * You should have received a copy of the GNU General Public 21ccd979bdSMark Fasheh * License along with this program; if not, write to the 22ccd979bdSMark Fasheh * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23ccd979bdSMark Fasheh * Boston, MA 021110-1307, USA. 24ccd979bdSMark Fasheh */ 25ccd979bdSMark Fasheh 26ccd979bdSMark Fasheh #include <linux/fs.h> 27ccd979bdSMark Fasheh #include <linux/types.h> 28ccd979bdSMark Fasheh #include <linux/slab.h> 29ccd979bdSMark Fasheh #include <linux/highmem.h> 3060b11392SMark Fasheh #include <linux/swap.h> 31ccd979bdSMark Fasheh 32ccd979bdSMark Fasheh #define MLOG_MASK_PREFIX ML_DISK_ALLOC 33ccd979bdSMark Fasheh #include <cluster/masklog.h> 34ccd979bdSMark Fasheh 35ccd979bdSMark Fasheh #include "ocfs2.h" 36ccd979bdSMark Fasheh 37ccd979bdSMark Fasheh #include "alloc.h" 3860b11392SMark Fasheh #include "aops.h" 39ccd979bdSMark Fasheh #include "dlmglue.h" 40ccd979bdSMark Fasheh #include "extent_map.h" 41ccd979bdSMark Fasheh #include "inode.h" 42ccd979bdSMark Fasheh #include "journal.h" 43ccd979bdSMark Fasheh #include "localalloc.h" 44ccd979bdSMark Fasheh #include "suballoc.h" 45ccd979bdSMark Fasheh #include "sysfile.h" 46ccd979bdSMark Fasheh #include "file.h" 47ccd979bdSMark Fasheh #include "super.h" 48ccd979bdSMark Fasheh #include "uptodate.h" 49ccd979bdSMark Fasheh 50ccd979bdSMark Fasheh #include "buffer_head_io.h" 51ccd979bdSMark Fasheh 52e7d4cb6bSTao Ma /* 53e7d4cb6bSTao Ma * ocfs2_extent_tree and ocfs2_extent_tree_operations are used to abstract 54e7d4cb6bSTao Ma * the b-tree operations in ocfs2. Now all the b-tree operations are not 55e7d4cb6bSTao Ma * limited to ocfs2_dinode only. Any data which need to allocate clusters 56e7d4cb6bSTao Ma * to store can use b-tree. And it only needs to implement its ocfs2_extent_tree 57e7d4cb6bSTao Ma * and operation. 58e7d4cb6bSTao Ma * 59e7d4cb6bSTao Ma * ocfs2_extent_tree contains info for the root of the b-tree, it must have a 60e7d4cb6bSTao Ma * root ocfs2_extent_list and a root_bh so that they can be used in the b-tree 61e7d4cb6bSTao Ma * functions. 62e7d4cb6bSTao Ma * ocfs2_extent_tree_operations abstract the normal operations we do for 63e7d4cb6bSTao Ma * the root of extent b-tree. 64e7d4cb6bSTao Ma */ 65e7d4cb6bSTao Ma struct ocfs2_extent_tree; 66e7d4cb6bSTao Ma 67e7d4cb6bSTao Ma struct ocfs2_extent_tree_operations { 6835dc0aa3SJoel Becker void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et, 6935dc0aa3SJoel Becker u64 blkno); 7035dc0aa3SJoel Becker u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et); 7135dc0aa3SJoel Becker void (*eo_update_clusters)(struct inode *inode, 72e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 73e7d4cb6bSTao Ma u32 new_clusters); 741e61ee79SJoel Becker int (*eo_insert_check)(struct inode *inode, 751e61ee79SJoel Becker struct ocfs2_extent_tree *et, 761e61ee79SJoel Becker struct ocfs2_extent_rec *rec); 7735dc0aa3SJoel Becker int (*eo_sanity_check)(struct inode *inode, struct ocfs2_extent_tree *et); 780ce1010fSJoel Becker 790ce1010fSJoel Becker /* These are internal to ocfs2_extent_tree and don't have 800ce1010fSJoel Becker * accessor functions */ 810ce1010fSJoel Becker void (*eo_fill_root_el)(struct ocfs2_extent_tree *et); 82943cced3SJoel Becker void (*eo_fill_max_leaf_clusters)(struct inode *inode, 83943cced3SJoel Becker struct ocfs2_extent_tree *et); 84e7d4cb6bSTao Ma }; 85e7d4cb6bSTao Ma 86e7d4cb6bSTao Ma struct ocfs2_extent_tree { 87ce1d9ea6SJoel Becker enum ocfs2_extent_tree_type et_type; 88ce1d9ea6SJoel Becker struct ocfs2_extent_tree_operations *et_ops; 89ce1d9ea6SJoel Becker struct buffer_head *et_root_bh; 90ce1d9ea6SJoel Becker struct ocfs2_extent_list *et_root_el; 91ea5efa15SJoel Becker void *et_object; 92ce1d9ea6SJoel Becker unsigned int et_max_leaf_clusters; 93e7d4cb6bSTao Ma }; 94e7d4cb6bSTao Ma 950ce1010fSJoel Becker static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et) 960ce1010fSJoel Becker { 970ce1010fSJoel Becker struct ocfs2_dinode *di = et->et_object; 980ce1010fSJoel Becker 990ce1010fSJoel Becker et->et_root_el = &di->id2.i_list; 1000ce1010fSJoel Becker } 1010ce1010fSJoel Becker 102e7d4cb6bSTao Ma static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et, 103e7d4cb6bSTao Ma u64 blkno) 104e7d4cb6bSTao Ma { 105ea5efa15SJoel Becker struct ocfs2_dinode *di = et->et_object; 106e7d4cb6bSTao Ma 107ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 108e7d4cb6bSTao Ma di->i_last_eb_blk = cpu_to_le64(blkno); 109e7d4cb6bSTao Ma } 110e7d4cb6bSTao Ma 111e7d4cb6bSTao Ma static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et) 112e7d4cb6bSTao Ma { 113ea5efa15SJoel Becker struct ocfs2_dinode *di = et->et_object; 114e7d4cb6bSTao Ma 115ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 116e7d4cb6bSTao Ma return le64_to_cpu(di->i_last_eb_blk); 117e7d4cb6bSTao Ma } 118e7d4cb6bSTao Ma 119e7d4cb6bSTao Ma static void ocfs2_dinode_update_clusters(struct inode *inode, 120e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 121e7d4cb6bSTao Ma u32 clusters) 122e7d4cb6bSTao Ma { 123ea5efa15SJoel Becker struct ocfs2_dinode *di = et->et_object; 124e7d4cb6bSTao Ma 125e7d4cb6bSTao Ma le32_add_cpu(&di->i_clusters, clusters); 126e7d4cb6bSTao Ma spin_lock(&OCFS2_I(inode)->ip_lock); 127e7d4cb6bSTao Ma OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters); 128e7d4cb6bSTao Ma spin_unlock(&OCFS2_I(inode)->ip_lock); 129e7d4cb6bSTao Ma } 130e7d4cb6bSTao Ma 1311e61ee79SJoel Becker static int ocfs2_dinode_insert_check(struct inode *inode, 1321e61ee79SJoel Becker struct ocfs2_extent_tree *et, 1331e61ee79SJoel Becker struct ocfs2_extent_rec *rec) 1341e61ee79SJoel Becker { 1351e61ee79SJoel Becker struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1361e61ee79SJoel Becker 1371e61ee79SJoel Becker BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL); 1381e61ee79SJoel Becker mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) && 1391e61ee79SJoel Becker (OCFS2_I(inode)->ip_clusters != rec->e_cpos), 1401e61ee79SJoel Becker "Device %s, asking for sparse allocation: inode %llu, " 1411e61ee79SJoel Becker "cpos %u, clusters %u\n", 1421e61ee79SJoel Becker osb->dev_str, 1431e61ee79SJoel Becker (unsigned long long)OCFS2_I(inode)->ip_blkno, 1441e61ee79SJoel Becker rec->e_cpos, 1451e61ee79SJoel Becker OCFS2_I(inode)->ip_clusters); 1461e61ee79SJoel Becker 1471e61ee79SJoel Becker return 0; 1481e61ee79SJoel Becker } 1491e61ee79SJoel Becker 150e7d4cb6bSTao Ma static int ocfs2_dinode_sanity_check(struct inode *inode, 151e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 152e7d4cb6bSTao Ma { 153e7d4cb6bSTao Ma int ret = 0; 154e7d4cb6bSTao Ma struct ocfs2_dinode *di; 155e7d4cb6bSTao Ma 156ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 157e7d4cb6bSTao Ma 158ea5efa15SJoel Becker di = et->et_object; 159e7d4cb6bSTao Ma if (!OCFS2_IS_VALID_DINODE(di)) { 160e7d4cb6bSTao Ma ret = -EIO; 161e7d4cb6bSTao Ma ocfs2_error(inode->i_sb, 162e7d4cb6bSTao Ma "Inode %llu has invalid path root", 163e7d4cb6bSTao Ma (unsigned long long)OCFS2_I(inode)->ip_blkno); 164e7d4cb6bSTao Ma } 165e7d4cb6bSTao Ma 166e7d4cb6bSTao Ma return ret; 167e7d4cb6bSTao Ma } 168e7d4cb6bSTao Ma 169e7d4cb6bSTao Ma static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = { 17035dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk, 17135dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk, 17235dc0aa3SJoel Becker .eo_update_clusters = ocfs2_dinode_update_clusters, 1731e61ee79SJoel Becker .eo_insert_check = ocfs2_dinode_insert_check, 17435dc0aa3SJoel Becker .eo_sanity_check = ocfs2_dinode_sanity_check, 1750ce1010fSJoel Becker .eo_fill_root_el = ocfs2_dinode_fill_root_el, 176e7d4cb6bSTao Ma }; 177e7d4cb6bSTao Ma 1780ce1010fSJoel Becker static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et) 1790ce1010fSJoel Becker { 1800ce1010fSJoel Becker struct ocfs2_xattr_value_root *xv = et->et_object; 1810ce1010fSJoel Becker 1820ce1010fSJoel Becker et->et_root_el = &xv->xr_list; 1830ce1010fSJoel Becker } 1840ce1010fSJoel Becker 185f56654c4STao Ma static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et, 186f56654c4STao Ma u64 blkno) 187f56654c4STao Ma { 188f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 189ea5efa15SJoel Becker (struct ocfs2_xattr_value_root *)et->et_object; 190f56654c4STao Ma 191f56654c4STao Ma xv->xr_last_eb_blk = cpu_to_le64(blkno); 192f56654c4STao Ma } 193f56654c4STao Ma 194f56654c4STao Ma static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et) 195f56654c4STao Ma { 196f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 197ea5efa15SJoel Becker (struct ocfs2_xattr_value_root *) et->et_object; 198f56654c4STao Ma 199f56654c4STao Ma return le64_to_cpu(xv->xr_last_eb_blk); 200f56654c4STao Ma } 201f56654c4STao Ma 202f56654c4STao Ma static void ocfs2_xattr_value_update_clusters(struct inode *inode, 203f56654c4STao Ma struct ocfs2_extent_tree *et, 204f56654c4STao Ma u32 clusters) 205f56654c4STao Ma { 206f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 207ea5efa15SJoel Becker (struct ocfs2_xattr_value_root *)et->et_object; 208f56654c4STao Ma 209f56654c4STao Ma le32_add_cpu(&xv->xr_clusters, clusters); 210f56654c4STao Ma } 211f56654c4STao Ma 2121a09f556SJoel Becker static struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = { 21335dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk, 21435dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk, 21535dc0aa3SJoel Becker .eo_update_clusters = ocfs2_xattr_value_update_clusters, 2160ce1010fSJoel Becker .eo_fill_root_el = ocfs2_xattr_value_fill_root_el, 217f56654c4STao Ma }; 218f56654c4STao Ma 2190ce1010fSJoel Becker static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et) 2200ce1010fSJoel Becker { 2210ce1010fSJoel Becker struct ocfs2_xattr_block *xb = et->et_object; 2220ce1010fSJoel Becker 2230ce1010fSJoel Becker et->et_root_el = &xb->xb_attrs.xb_root.xt_list; 2240ce1010fSJoel Becker } 2250ce1010fSJoel Becker 226943cced3SJoel Becker static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct inode *inode, 227943cced3SJoel Becker struct ocfs2_extent_tree *et) 228943cced3SJoel Becker { 229943cced3SJoel Becker et->et_max_leaf_clusters = 230943cced3SJoel Becker ocfs2_clusters_for_bytes(inode->i_sb, 231943cced3SJoel Becker OCFS2_MAX_XATTR_TREE_LEAF_SIZE); 232943cced3SJoel Becker } 233943cced3SJoel Becker 234ba492615STao Ma static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et, 235ba492615STao Ma u64 blkno) 236ba492615STao Ma { 237ea5efa15SJoel Becker struct ocfs2_xattr_block *xb = et->et_object; 238ba492615STao Ma struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root; 239ba492615STao Ma 240ba492615STao Ma xt->xt_last_eb_blk = cpu_to_le64(blkno); 241ba492615STao Ma } 242ba492615STao Ma 243ba492615STao Ma static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et) 244ba492615STao Ma { 245ea5efa15SJoel Becker struct ocfs2_xattr_block *xb = et->et_object; 246ba492615STao Ma struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root; 247ba492615STao Ma 248ba492615STao Ma return le64_to_cpu(xt->xt_last_eb_blk); 249ba492615STao Ma } 250ba492615STao Ma 251ba492615STao Ma static void ocfs2_xattr_tree_update_clusters(struct inode *inode, 252ba492615STao Ma struct ocfs2_extent_tree *et, 253ba492615STao Ma u32 clusters) 254ba492615STao Ma { 255ea5efa15SJoel Becker struct ocfs2_xattr_block *xb = et->et_object; 256ba492615STao Ma 257ba492615STao Ma le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters); 258ba492615STao Ma } 259ba492615STao Ma 260ba492615STao Ma static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = { 26135dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk, 26235dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk, 26335dc0aa3SJoel Becker .eo_update_clusters = ocfs2_xattr_tree_update_clusters, 2640ce1010fSJoel Becker .eo_fill_root_el = ocfs2_xattr_tree_fill_root_el, 265943cced3SJoel Becker .eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters, 266ba492615STao Ma }; 267ba492615STao Ma 2681a09f556SJoel Becker static void __ocfs2_get_extent_tree(struct ocfs2_extent_tree *et, 269dc0ce61aSJoel Becker struct inode *inode, 270ca12b7c4STao Ma struct buffer_head *bh, 2711a09f556SJoel Becker void *obj, 272f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 2731a09f556SJoel Becker struct ocfs2_extent_tree_operations *ops) 274e7d4cb6bSTao Ma { 275ce1d9ea6SJoel Becker et->et_type = et_type; 2761a09f556SJoel Becker et->et_ops = ops; 277e7d4cb6bSTao Ma get_bh(bh); 278ce1d9ea6SJoel Becker et->et_root_bh = bh; 279ea5efa15SJoel Becker if (!obj) 280ea5efa15SJoel Becker obj = (void *)bh->b_data; 281ea5efa15SJoel Becker et->et_object = obj; 282e7d4cb6bSTao Ma 2830ce1010fSJoel Becker et->et_ops->eo_fill_root_el(et); 284943cced3SJoel Becker if (!et->et_ops->eo_fill_max_leaf_clusters) 285943cced3SJoel Becker et->et_max_leaf_clusters = 0; 286943cced3SJoel Becker else 287943cced3SJoel Becker et->et_ops->eo_fill_max_leaf_clusters(inode, et); 288e7d4cb6bSTao Ma } 289e7d4cb6bSTao Ma 2901a09f556SJoel Becker static void ocfs2_get_dinode_extent_tree(struct ocfs2_extent_tree *et, 2911a09f556SJoel Becker struct inode *inode, 2921a09f556SJoel Becker struct buffer_head *bh) 2931a09f556SJoel Becker { 2941a09f556SJoel Becker __ocfs2_get_extent_tree(et, inode, bh, NULL, OCFS2_DINODE_EXTENT, 2951a09f556SJoel Becker &ocfs2_dinode_et_ops); 2961a09f556SJoel Becker } 2971a09f556SJoel Becker 2981a09f556SJoel Becker static void ocfs2_get_xattr_tree_extent_tree(struct ocfs2_extent_tree *et, 2991a09f556SJoel Becker struct inode *inode, 3001a09f556SJoel Becker struct buffer_head *bh) 3011a09f556SJoel Becker { 3021a09f556SJoel Becker __ocfs2_get_extent_tree(et, inode, bh, NULL, 3031a09f556SJoel Becker OCFS2_XATTR_TREE_EXTENT, 3041a09f556SJoel Becker &ocfs2_xattr_tree_et_ops); 3051a09f556SJoel Becker } 3061a09f556SJoel Becker 3071a09f556SJoel Becker static void ocfs2_get_xattr_value_extent_tree(struct ocfs2_extent_tree *et, 3081a09f556SJoel Becker struct inode *inode, 3091a09f556SJoel Becker struct buffer_head *bh, 3101a09f556SJoel Becker struct ocfs2_xattr_value_root *xv) 3111a09f556SJoel Becker { 3121a09f556SJoel Becker __ocfs2_get_extent_tree(et, inode, bh, xv, 3131a09f556SJoel Becker OCFS2_XATTR_VALUE_EXTENT, 3141a09f556SJoel Becker &ocfs2_xattr_value_et_ops); 3151a09f556SJoel Becker } 3161a09f556SJoel Becker 3171a09f556SJoel Becker static void ocfs2_get_extent_tree(struct ocfs2_extent_tree *et, 3181a09f556SJoel Becker struct inode *inode, 3191a09f556SJoel Becker struct buffer_head *bh, 3201a09f556SJoel Becker enum ocfs2_extent_tree_type et_type, 3211a09f556SJoel Becker void *obj) 3221a09f556SJoel Becker { 3231a09f556SJoel Becker if (et_type == OCFS2_DINODE_EXTENT) 3241a09f556SJoel Becker ocfs2_get_dinode_extent_tree(et, inode, bh); 3251a09f556SJoel Becker else if (et_type == OCFS2_XATTR_VALUE_EXTENT) 3261a09f556SJoel Becker ocfs2_get_xattr_tree_extent_tree(et, inode, bh); 3271a09f556SJoel Becker else if (et_type == OCFS2_XATTR_TREE_EXTENT) 3281a09f556SJoel Becker ocfs2_get_xattr_value_extent_tree(et, inode, bh, obj); 3291a09f556SJoel Becker else 3301a09f556SJoel Becker BUG(); 3311a09f556SJoel Becker } 3321a09f556SJoel Becker 333dc0ce61aSJoel Becker static void ocfs2_put_extent_tree(struct ocfs2_extent_tree *et) 334e7d4cb6bSTao Ma { 335ce1d9ea6SJoel Becker brelse(et->et_root_bh); 336e7d4cb6bSTao Ma } 337e7d4cb6bSTao Ma 33835dc0aa3SJoel Becker static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et, 339e7d4cb6bSTao Ma u64 new_last_eb_blk) 340e7d4cb6bSTao Ma { 341ce1d9ea6SJoel Becker et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk); 342e7d4cb6bSTao Ma } 343e7d4cb6bSTao Ma 34435dc0aa3SJoel Becker static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et) 345e7d4cb6bSTao Ma { 346ce1d9ea6SJoel Becker return et->et_ops->eo_get_last_eb_blk(et); 347e7d4cb6bSTao Ma } 348e7d4cb6bSTao Ma 34935dc0aa3SJoel Becker static inline void ocfs2_et_update_clusters(struct inode *inode, 350e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 351e7d4cb6bSTao Ma u32 clusters) 352e7d4cb6bSTao Ma { 353ce1d9ea6SJoel Becker et->et_ops->eo_update_clusters(inode, et, clusters); 35435dc0aa3SJoel Becker } 35535dc0aa3SJoel Becker 3561e61ee79SJoel Becker static inline int ocfs2_et_insert_check(struct inode *inode, 3571e61ee79SJoel Becker struct ocfs2_extent_tree *et, 3581e61ee79SJoel Becker struct ocfs2_extent_rec *rec) 3591e61ee79SJoel Becker { 3601e61ee79SJoel Becker int ret = 0; 3611e61ee79SJoel Becker 3621e61ee79SJoel Becker if (et->et_ops->eo_insert_check) 3631e61ee79SJoel Becker ret = et->et_ops->eo_insert_check(inode, et, rec); 3641e61ee79SJoel Becker return ret; 3651e61ee79SJoel Becker } 3661e61ee79SJoel Becker 36735dc0aa3SJoel Becker static inline int ocfs2_et_sanity_check(struct inode *inode, 36835dc0aa3SJoel Becker struct ocfs2_extent_tree *et) 36935dc0aa3SJoel Becker { 3701e61ee79SJoel Becker int ret = 0; 3711e61ee79SJoel Becker 3721e61ee79SJoel Becker if (et->et_ops->eo_sanity_check) 3731e61ee79SJoel Becker ret = et->et_ops->eo_sanity_check(inode, et); 3741e61ee79SJoel Becker return ret; 375e7d4cb6bSTao Ma } 376e7d4cb6bSTao Ma 377ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc); 37859a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, 37959a5e416SMark Fasheh struct ocfs2_extent_block *eb); 380ccd979bdSMark Fasheh 381dcd0538fSMark Fasheh /* 382dcd0538fSMark Fasheh * Structures which describe a path through a btree, and functions to 383dcd0538fSMark Fasheh * manipulate them. 384dcd0538fSMark Fasheh * 385dcd0538fSMark Fasheh * The idea here is to be as generic as possible with the tree 386dcd0538fSMark Fasheh * manipulation code. 387dcd0538fSMark Fasheh */ 388dcd0538fSMark Fasheh struct ocfs2_path_item { 389dcd0538fSMark Fasheh struct buffer_head *bh; 390dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 391dcd0538fSMark Fasheh }; 392dcd0538fSMark Fasheh 393dcd0538fSMark Fasheh #define OCFS2_MAX_PATH_DEPTH 5 394dcd0538fSMark Fasheh 395dcd0538fSMark Fasheh struct ocfs2_path { 396dcd0538fSMark Fasheh int p_tree_depth; 397dcd0538fSMark Fasheh struct ocfs2_path_item p_node[OCFS2_MAX_PATH_DEPTH]; 398dcd0538fSMark Fasheh }; 399dcd0538fSMark Fasheh 400dcd0538fSMark Fasheh #define path_root_bh(_path) ((_path)->p_node[0].bh) 401dcd0538fSMark Fasheh #define path_root_el(_path) ((_path)->p_node[0].el) 402dcd0538fSMark Fasheh #define path_leaf_bh(_path) ((_path)->p_node[(_path)->p_tree_depth].bh) 403dcd0538fSMark Fasheh #define path_leaf_el(_path) ((_path)->p_node[(_path)->p_tree_depth].el) 404dcd0538fSMark Fasheh #define path_num_items(_path) ((_path)->p_tree_depth + 1) 405dcd0538fSMark Fasheh 406dcd0538fSMark Fasheh /* 407dcd0538fSMark Fasheh * Reset the actual path elements so that we can re-use the structure 408dcd0538fSMark Fasheh * to build another path. Generally, this involves freeing the buffer 409dcd0538fSMark Fasheh * heads. 410dcd0538fSMark Fasheh */ 411dcd0538fSMark Fasheh static void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root) 412dcd0538fSMark Fasheh { 413dcd0538fSMark Fasheh int i, start = 0, depth = 0; 414dcd0538fSMark Fasheh struct ocfs2_path_item *node; 415dcd0538fSMark Fasheh 416dcd0538fSMark Fasheh if (keep_root) 417dcd0538fSMark Fasheh start = 1; 418dcd0538fSMark Fasheh 419dcd0538fSMark Fasheh for(i = start; i < path_num_items(path); i++) { 420dcd0538fSMark Fasheh node = &path->p_node[i]; 421dcd0538fSMark Fasheh 422dcd0538fSMark Fasheh brelse(node->bh); 423dcd0538fSMark Fasheh node->bh = NULL; 424dcd0538fSMark Fasheh node->el = NULL; 425dcd0538fSMark Fasheh } 426dcd0538fSMark Fasheh 427dcd0538fSMark Fasheh /* 428dcd0538fSMark Fasheh * Tree depth may change during truncate, or insert. If we're 429dcd0538fSMark Fasheh * keeping the root extent list, then make sure that our path 430dcd0538fSMark Fasheh * structure reflects the proper depth. 431dcd0538fSMark Fasheh */ 432dcd0538fSMark Fasheh if (keep_root) 433dcd0538fSMark Fasheh depth = le16_to_cpu(path_root_el(path)->l_tree_depth); 434dcd0538fSMark Fasheh 435dcd0538fSMark Fasheh path->p_tree_depth = depth; 436dcd0538fSMark Fasheh } 437dcd0538fSMark Fasheh 438dcd0538fSMark Fasheh static void ocfs2_free_path(struct ocfs2_path *path) 439dcd0538fSMark Fasheh { 440dcd0538fSMark Fasheh if (path) { 441dcd0538fSMark Fasheh ocfs2_reinit_path(path, 0); 442dcd0538fSMark Fasheh kfree(path); 443dcd0538fSMark Fasheh } 444dcd0538fSMark Fasheh } 445dcd0538fSMark Fasheh 446dcd0538fSMark Fasheh /* 447328d5752SMark Fasheh * All the elements of src into dest. After this call, src could be freed 448328d5752SMark Fasheh * without affecting dest. 449328d5752SMark Fasheh * 450328d5752SMark Fasheh * Both paths should have the same root. Any non-root elements of dest 451328d5752SMark Fasheh * will be freed. 452328d5752SMark Fasheh */ 453328d5752SMark Fasheh static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src) 454328d5752SMark Fasheh { 455328d5752SMark Fasheh int i; 456328d5752SMark Fasheh 457328d5752SMark Fasheh BUG_ON(path_root_bh(dest) != path_root_bh(src)); 458328d5752SMark Fasheh BUG_ON(path_root_el(dest) != path_root_el(src)); 459328d5752SMark Fasheh 460328d5752SMark Fasheh ocfs2_reinit_path(dest, 1); 461328d5752SMark Fasheh 462328d5752SMark Fasheh for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) { 463328d5752SMark Fasheh dest->p_node[i].bh = src->p_node[i].bh; 464328d5752SMark Fasheh dest->p_node[i].el = src->p_node[i].el; 465328d5752SMark Fasheh 466328d5752SMark Fasheh if (dest->p_node[i].bh) 467328d5752SMark Fasheh get_bh(dest->p_node[i].bh); 468328d5752SMark Fasheh } 469328d5752SMark Fasheh } 470328d5752SMark Fasheh 471328d5752SMark Fasheh /* 472dcd0538fSMark Fasheh * Make the *dest path the same as src and re-initialize src path to 473dcd0538fSMark Fasheh * have a root only. 474dcd0538fSMark Fasheh */ 475dcd0538fSMark Fasheh static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src) 476dcd0538fSMark Fasheh { 477dcd0538fSMark Fasheh int i; 478dcd0538fSMark Fasheh 479dcd0538fSMark Fasheh BUG_ON(path_root_bh(dest) != path_root_bh(src)); 480dcd0538fSMark Fasheh 481dcd0538fSMark Fasheh for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) { 482dcd0538fSMark Fasheh brelse(dest->p_node[i].bh); 483dcd0538fSMark Fasheh 484dcd0538fSMark Fasheh dest->p_node[i].bh = src->p_node[i].bh; 485dcd0538fSMark Fasheh dest->p_node[i].el = src->p_node[i].el; 486dcd0538fSMark Fasheh 487dcd0538fSMark Fasheh src->p_node[i].bh = NULL; 488dcd0538fSMark Fasheh src->p_node[i].el = NULL; 489dcd0538fSMark Fasheh } 490dcd0538fSMark Fasheh } 491dcd0538fSMark Fasheh 492dcd0538fSMark Fasheh /* 493dcd0538fSMark Fasheh * Insert an extent block at given index. 494dcd0538fSMark Fasheh * 495dcd0538fSMark Fasheh * This will not take an additional reference on eb_bh. 496dcd0538fSMark Fasheh */ 497dcd0538fSMark Fasheh static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index, 498dcd0538fSMark Fasheh struct buffer_head *eb_bh) 499dcd0538fSMark Fasheh { 500dcd0538fSMark Fasheh struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data; 501dcd0538fSMark Fasheh 502dcd0538fSMark Fasheh /* 503dcd0538fSMark Fasheh * Right now, no root bh is an extent block, so this helps 504dcd0538fSMark Fasheh * catch code errors with dinode trees. The assertion can be 505dcd0538fSMark Fasheh * safely removed if we ever need to insert extent block 506dcd0538fSMark Fasheh * structures at the root. 507dcd0538fSMark Fasheh */ 508dcd0538fSMark Fasheh BUG_ON(index == 0); 509dcd0538fSMark Fasheh 510dcd0538fSMark Fasheh path->p_node[index].bh = eb_bh; 511dcd0538fSMark Fasheh path->p_node[index].el = &eb->h_list; 512dcd0538fSMark Fasheh } 513dcd0538fSMark Fasheh 514dcd0538fSMark Fasheh static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh, 515dcd0538fSMark Fasheh struct ocfs2_extent_list *root_el) 516dcd0538fSMark Fasheh { 517dcd0538fSMark Fasheh struct ocfs2_path *path; 518dcd0538fSMark Fasheh 519dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH); 520dcd0538fSMark Fasheh 521dcd0538fSMark Fasheh path = kzalloc(sizeof(*path), GFP_NOFS); 522dcd0538fSMark Fasheh if (path) { 523dcd0538fSMark Fasheh path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth); 524dcd0538fSMark Fasheh get_bh(root_bh); 525dcd0538fSMark Fasheh path_root_bh(path) = root_bh; 526dcd0538fSMark Fasheh path_root_el(path) = root_el; 527dcd0538fSMark Fasheh } 528dcd0538fSMark Fasheh 529dcd0538fSMark Fasheh return path; 530dcd0538fSMark Fasheh } 531dcd0538fSMark Fasheh 532dcd0538fSMark Fasheh /* 533dcd0538fSMark Fasheh * Convenience function to journal all components in a path. 534dcd0538fSMark Fasheh */ 535dcd0538fSMark Fasheh static int ocfs2_journal_access_path(struct inode *inode, handle_t *handle, 536dcd0538fSMark Fasheh struct ocfs2_path *path) 537dcd0538fSMark Fasheh { 538dcd0538fSMark Fasheh int i, ret = 0; 539dcd0538fSMark Fasheh 540dcd0538fSMark Fasheh if (!path) 541dcd0538fSMark Fasheh goto out; 542dcd0538fSMark Fasheh 543dcd0538fSMark Fasheh for(i = 0; i < path_num_items(path); i++) { 544dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, path->p_node[i].bh, 545dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 546dcd0538fSMark Fasheh if (ret < 0) { 547dcd0538fSMark Fasheh mlog_errno(ret); 548dcd0538fSMark Fasheh goto out; 549dcd0538fSMark Fasheh } 550dcd0538fSMark Fasheh } 551dcd0538fSMark Fasheh 552dcd0538fSMark Fasheh out: 553dcd0538fSMark Fasheh return ret; 554dcd0538fSMark Fasheh } 555dcd0538fSMark Fasheh 556328d5752SMark Fasheh /* 557328d5752SMark Fasheh * Return the index of the extent record which contains cluster #v_cluster. 558328d5752SMark Fasheh * -1 is returned if it was not found. 559328d5752SMark Fasheh * 560328d5752SMark Fasheh * Should work fine on interior and exterior nodes. 561328d5752SMark Fasheh */ 562328d5752SMark Fasheh int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster) 563328d5752SMark Fasheh { 564328d5752SMark Fasheh int ret = -1; 565328d5752SMark Fasheh int i; 566328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 567328d5752SMark Fasheh u32 rec_end, rec_start, clusters; 568328d5752SMark Fasheh 569328d5752SMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 570328d5752SMark Fasheh rec = &el->l_recs[i]; 571328d5752SMark Fasheh 572328d5752SMark Fasheh rec_start = le32_to_cpu(rec->e_cpos); 573328d5752SMark Fasheh clusters = ocfs2_rec_clusters(el, rec); 574328d5752SMark Fasheh 575328d5752SMark Fasheh rec_end = rec_start + clusters; 576328d5752SMark Fasheh 577328d5752SMark Fasheh if (v_cluster >= rec_start && v_cluster < rec_end) { 578328d5752SMark Fasheh ret = i; 579328d5752SMark Fasheh break; 580328d5752SMark Fasheh } 581328d5752SMark Fasheh } 582328d5752SMark Fasheh 583328d5752SMark Fasheh return ret; 584328d5752SMark Fasheh } 585328d5752SMark Fasheh 586dcd0538fSMark Fasheh enum ocfs2_contig_type { 587dcd0538fSMark Fasheh CONTIG_NONE = 0, 588dcd0538fSMark Fasheh CONTIG_LEFT, 589328d5752SMark Fasheh CONTIG_RIGHT, 590328d5752SMark Fasheh CONTIG_LEFTRIGHT, 591dcd0538fSMark Fasheh }; 592dcd0538fSMark Fasheh 593e48edee2SMark Fasheh 594e48edee2SMark Fasheh /* 595e48edee2SMark Fasheh * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and 596e48edee2SMark Fasheh * ocfs2_extent_contig only work properly against leaf nodes! 597e48edee2SMark Fasheh */ 598dcd0538fSMark Fasheh static int ocfs2_block_extent_contig(struct super_block *sb, 599ccd979bdSMark Fasheh struct ocfs2_extent_rec *ext, 600ccd979bdSMark Fasheh u64 blkno) 601ccd979bdSMark Fasheh { 602e48edee2SMark Fasheh u64 blk_end = le64_to_cpu(ext->e_blkno); 603e48edee2SMark Fasheh 604e48edee2SMark Fasheh blk_end += ocfs2_clusters_to_blocks(sb, 605e48edee2SMark Fasheh le16_to_cpu(ext->e_leaf_clusters)); 606e48edee2SMark Fasheh 607e48edee2SMark Fasheh return blkno == blk_end; 608ccd979bdSMark Fasheh } 609ccd979bdSMark Fasheh 610dcd0538fSMark Fasheh static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left, 611dcd0538fSMark Fasheh struct ocfs2_extent_rec *right) 612dcd0538fSMark Fasheh { 613e48edee2SMark Fasheh u32 left_range; 614e48edee2SMark Fasheh 615e48edee2SMark Fasheh left_range = le32_to_cpu(left->e_cpos) + 616e48edee2SMark Fasheh le16_to_cpu(left->e_leaf_clusters); 617e48edee2SMark Fasheh 618e48edee2SMark Fasheh return (left_range == le32_to_cpu(right->e_cpos)); 619dcd0538fSMark Fasheh } 620dcd0538fSMark Fasheh 621dcd0538fSMark Fasheh static enum ocfs2_contig_type 622dcd0538fSMark Fasheh ocfs2_extent_contig(struct inode *inode, 623dcd0538fSMark Fasheh struct ocfs2_extent_rec *ext, 624dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 625dcd0538fSMark Fasheh { 626dcd0538fSMark Fasheh u64 blkno = le64_to_cpu(insert_rec->e_blkno); 627dcd0538fSMark Fasheh 628328d5752SMark Fasheh /* 629328d5752SMark Fasheh * Refuse to coalesce extent records with different flag 630328d5752SMark Fasheh * fields - we don't want to mix unwritten extents with user 631328d5752SMark Fasheh * data. 632328d5752SMark Fasheh */ 633328d5752SMark Fasheh if (ext->e_flags != insert_rec->e_flags) 634328d5752SMark Fasheh return CONTIG_NONE; 635328d5752SMark Fasheh 636dcd0538fSMark Fasheh if (ocfs2_extents_adjacent(ext, insert_rec) && 637dcd0538fSMark Fasheh ocfs2_block_extent_contig(inode->i_sb, ext, blkno)) 638dcd0538fSMark Fasheh return CONTIG_RIGHT; 639dcd0538fSMark Fasheh 640dcd0538fSMark Fasheh blkno = le64_to_cpu(ext->e_blkno); 641dcd0538fSMark Fasheh if (ocfs2_extents_adjacent(insert_rec, ext) && 642dcd0538fSMark Fasheh ocfs2_block_extent_contig(inode->i_sb, insert_rec, blkno)) 643dcd0538fSMark Fasheh return CONTIG_LEFT; 644dcd0538fSMark Fasheh 645dcd0538fSMark Fasheh return CONTIG_NONE; 646dcd0538fSMark Fasheh } 647dcd0538fSMark Fasheh 648dcd0538fSMark Fasheh /* 649dcd0538fSMark Fasheh * NOTE: We can have pretty much any combination of contiguousness and 650dcd0538fSMark Fasheh * appending. 651dcd0538fSMark Fasheh * 652dcd0538fSMark Fasheh * The usefulness of APPEND_TAIL is more in that it lets us know that 653dcd0538fSMark Fasheh * we'll have to update the path to that leaf. 654dcd0538fSMark Fasheh */ 655dcd0538fSMark Fasheh enum ocfs2_append_type { 656dcd0538fSMark Fasheh APPEND_NONE = 0, 657dcd0538fSMark Fasheh APPEND_TAIL, 658dcd0538fSMark Fasheh }; 659dcd0538fSMark Fasheh 660328d5752SMark Fasheh enum ocfs2_split_type { 661328d5752SMark Fasheh SPLIT_NONE = 0, 662328d5752SMark Fasheh SPLIT_LEFT, 663328d5752SMark Fasheh SPLIT_RIGHT, 664328d5752SMark Fasheh }; 665328d5752SMark Fasheh 666dcd0538fSMark Fasheh struct ocfs2_insert_type { 667328d5752SMark Fasheh enum ocfs2_split_type ins_split; 668dcd0538fSMark Fasheh enum ocfs2_append_type ins_appending; 669dcd0538fSMark Fasheh enum ocfs2_contig_type ins_contig; 670dcd0538fSMark Fasheh int ins_contig_index; 671dcd0538fSMark Fasheh int ins_tree_depth; 672dcd0538fSMark Fasheh }; 673dcd0538fSMark Fasheh 674328d5752SMark Fasheh struct ocfs2_merge_ctxt { 675328d5752SMark Fasheh enum ocfs2_contig_type c_contig_type; 676328d5752SMark Fasheh int c_has_empty_extent; 677328d5752SMark Fasheh int c_split_covers_rec; 678328d5752SMark Fasheh }; 679328d5752SMark Fasheh 680ccd979bdSMark Fasheh /* 681ccd979bdSMark Fasheh * How many free extents have we got before we need more meta data? 682ccd979bdSMark Fasheh */ 683ccd979bdSMark Fasheh int ocfs2_num_free_extents(struct ocfs2_super *osb, 684ccd979bdSMark Fasheh struct inode *inode, 685e7d4cb6bSTao Ma struct buffer_head *root_bh, 686f56654c4STao Ma enum ocfs2_extent_tree_type type, 687ea5efa15SJoel Becker void *obj) 688ccd979bdSMark Fasheh { 689ccd979bdSMark Fasheh int retval; 690e7d4cb6bSTao Ma struct ocfs2_extent_list *el = NULL; 691ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 692ccd979bdSMark Fasheh struct buffer_head *eb_bh = NULL; 693e7d4cb6bSTao Ma u64 last_eb_blk = 0; 6941c25d93aSJoel Becker struct ocfs2_extent_tree et; 695ccd979bdSMark Fasheh 696ccd979bdSMark Fasheh mlog_entry_void(); 697ccd979bdSMark Fasheh 6981c25d93aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, type, obj); 6991c25d93aSJoel Becker el = et.et_root_el; 7001c25d93aSJoel Becker last_eb_blk = ocfs2_et_get_last_eb_blk(&et); 701e7d4cb6bSTao Ma 702e7d4cb6bSTao Ma if (last_eb_blk) { 703e7d4cb6bSTao Ma retval = ocfs2_read_block(osb, last_eb_blk, 704ccd979bdSMark Fasheh &eb_bh, OCFS2_BH_CACHED, inode); 705ccd979bdSMark Fasheh if (retval < 0) { 706ccd979bdSMark Fasheh mlog_errno(retval); 707ccd979bdSMark Fasheh goto bail; 708ccd979bdSMark Fasheh } 709ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) eb_bh->b_data; 710ccd979bdSMark Fasheh el = &eb->h_list; 711e7d4cb6bSTao Ma } 712ccd979bdSMark Fasheh 713ccd979bdSMark Fasheh BUG_ON(el->l_tree_depth != 0); 714ccd979bdSMark Fasheh 715ccd979bdSMark Fasheh retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec); 716ccd979bdSMark Fasheh bail: 717ccd979bdSMark Fasheh if (eb_bh) 718ccd979bdSMark Fasheh brelse(eb_bh); 719ccd979bdSMark Fasheh 7201c25d93aSJoel Becker ocfs2_put_extent_tree(&et); 721ccd979bdSMark Fasheh mlog_exit(retval); 722ccd979bdSMark Fasheh return retval; 723ccd979bdSMark Fasheh } 724ccd979bdSMark Fasheh 725ccd979bdSMark Fasheh /* expects array to already be allocated 726ccd979bdSMark Fasheh * 727ccd979bdSMark Fasheh * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and 728ccd979bdSMark Fasheh * l_count for you 729ccd979bdSMark Fasheh */ 730ccd979bdSMark Fasheh static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb, 7311fabe148SMark Fasheh handle_t *handle, 732ccd979bdSMark Fasheh struct inode *inode, 733ccd979bdSMark Fasheh int wanted, 734ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac, 735ccd979bdSMark Fasheh struct buffer_head *bhs[]) 736ccd979bdSMark Fasheh { 737ccd979bdSMark Fasheh int count, status, i; 738ccd979bdSMark Fasheh u16 suballoc_bit_start; 739ccd979bdSMark Fasheh u32 num_got; 740ccd979bdSMark Fasheh u64 first_blkno; 741ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 742ccd979bdSMark Fasheh 743ccd979bdSMark Fasheh mlog_entry_void(); 744ccd979bdSMark Fasheh 745ccd979bdSMark Fasheh count = 0; 746ccd979bdSMark Fasheh while (count < wanted) { 747ccd979bdSMark Fasheh status = ocfs2_claim_metadata(osb, 748ccd979bdSMark Fasheh handle, 749ccd979bdSMark Fasheh meta_ac, 750ccd979bdSMark Fasheh wanted - count, 751ccd979bdSMark Fasheh &suballoc_bit_start, 752ccd979bdSMark Fasheh &num_got, 753ccd979bdSMark Fasheh &first_blkno); 754ccd979bdSMark Fasheh if (status < 0) { 755ccd979bdSMark Fasheh mlog_errno(status); 756ccd979bdSMark Fasheh goto bail; 757ccd979bdSMark Fasheh } 758ccd979bdSMark Fasheh 759ccd979bdSMark Fasheh for(i = count; i < (num_got + count); i++) { 760ccd979bdSMark Fasheh bhs[i] = sb_getblk(osb->sb, first_blkno); 761ccd979bdSMark Fasheh if (bhs[i] == NULL) { 762ccd979bdSMark Fasheh status = -EIO; 763ccd979bdSMark Fasheh mlog_errno(status); 764ccd979bdSMark Fasheh goto bail; 765ccd979bdSMark Fasheh } 766ccd979bdSMark Fasheh ocfs2_set_new_buffer_uptodate(inode, bhs[i]); 767ccd979bdSMark Fasheh 768ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, bhs[i], 769ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 770ccd979bdSMark Fasheh if (status < 0) { 771ccd979bdSMark Fasheh mlog_errno(status); 772ccd979bdSMark Fasheh goto bail; 773ccd979bdSMark Fasheh } 774ccd979bdSMark Fasheh 775ccd979bdSMark Fasheh memset(bhs[i]->b_data, 0, osb->sb->s_blocksize); 776ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bhs[i]->b_data; 777ccd979bdSMark Fasheh /* Ok, setup the minimal stuff here. */ 778ccd979bdSMark Fasheh strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE); 779ccd979bdSMark Fasheh eb->h_blkno = cpu_to_le64(first_blkno); 780ccd979bdSMark Fasheh eb->h_fs_generation = cpu_to_le32(osb->fs_generation); 781ccd979bdSMark Fasheh eb->h_suballoc_slot = cpu_to_le16(osb->slot_num); 782ccd979bdSMark Fasheh eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start); 783ccd979bdSMark Fasheh eb->h_list.l_count = 784ccd979bdSMark Fasheh cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb)); 785ccd979bdSMark Fasheh 786ccd979bdSMark Fasheh suballoc_bit_start++; 787ccd979bdSMark Fasheh first_blkno++; 788ccd979bdSMark Fasheh 789ccd979bdSMark Fasheh /* We'll also be dirtied by the caller, so 790ccd979bdSMark Fasheh * this isn't absolutely necessary. */ 791ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, bhs[i]); 792ccd979bdSMark Fasheh if (status < 0) { 793ccd979bdSMark Fasheh mlog_errno(status); 794ccd979bdSMark Fasheh goto bail; 795ccd979bdSMark Fasheh } 796ccd979bdSMark Fasheh } 797ccd979bdSMark Fasheh 798ccd979bdSMark Fasheh count += num_got; 799ccd979bdSMark Fasheh } 800ccd979bdSMark Fasheh 801ccd979bdSMark Fasheh status = 0; 802ccd979bdSMark Fasheh bail: 803ccd979bdSMark Fasheh if (status < 0) { 804ccd979bdSMark Fasheh for(i = 0; i < wanted; i++) { 805ccd979bdSMark Fasheh if (bhs[i]) 806ccd979bdSMark Fasheh brelse(bhs[i]); 807ccd979bdSMark Fasheh bhs[i] = NULL; 808ccd979bdSMark Fasheh } 809ccd979bdSMark Fasheh } 810ccd979bdSMark Fasheh mlog_exit(status); 811ccd979bdSMark Fasheh return status; 812ccd979bdSMark Fasheh } 813ccd979bdSMark Fasheh 814ccd979bdSMark Fasheh /* 815dcd0538fSMark Fasheh * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth(). 816dcd0538fSMark Fasheh * 817dcd0538fSMark Fasheh * Returns the sum of the rightmost extent rec logical offset and 818dcd0538fSMark Fasheh * cluster count. 819dcd0538fSMark Fasheh * 820dcd0538fSMark Fasheh * ocfs2_add_branch() uses this to determine what logical cluster 821dcd0538fSMark Fasheh * value should be populated into the leftmost new branch records. 822dcd0538fSMark Fasheh * 823dcd0538fSMark Fasheh * ocfs2_shift_tree_depth() uses this to determine the # clusters 824dcd0538fSMark Fasheh * value for the new topmost tree record. 825dcd0538fSMark Fasheh */ 826dcd0538fSMark Fasheh static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el) 827dcd0538fSMark Fasheh { 828dcd0538fSMark Fasheh int i; 829dcd0538fSMark Fasheh 830dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 831dcd0538fSMark Fasheh 832dcd0538fSMark Fasheh return le32_to_cpu(el->l_recs[i].e_cpos) + 833e48edee2SMark Fasheh ocfs2_rec_clusters(el, &el->l_recs[i]); 834dcd0538fSMark Fasheh } 835dcd0538fSMark Fasheh 836dcd0538fSMark Fasheh /* 837ccd979bdSMark Fasheh * Add an entire tree branch to our inode. eb_bh is the extent block 838ccd979bdSMark Fasheh * to start at, if we don't want to start the branch at the dinode 839ccd979bdSMark Fasheh * structure. 840ccd979bdSMark Fasheh * 841ccd979bdSMark Fasheh * last_eb_bh is required as we have to update it's next_leaf pointer 842ccd979bdSMark Fasheh * for the new last extent block. 843ccd979bdSMark Fasheh * 844ccd979bdSMark Fasheh * the new branch will be 'empty' in the sense that every block will 845e48edee2SMark Fasheh * contain a single record with cluster count == 0. 846ccd979bdSMark Fasheh */ 847ccd979bdSMark Fasheh static int ocfs2_add_branch(struct ocfs2_super *osb, 8481fabe148SMark Fasheh handle_t *handle, 849ccd979bdSMark Fasheh struct inode *inode, 850e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 851ccd979bdSMark Fasheh struct buffer_head *eb_bh, 852328d5752SMark Fasheh struct buffer_head **last_eb_bh, 853ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac) 854ccd979bdSMark Fasheh { 855ccd979bdSMark Fasheh int status, new_blocks, i; 856ccd979bdSMark Fasheh u64 next_blkno, new_last_eb_blk; 857ccd979bdSMark Fasheh struct buffer_head *bh; 858ccd979bdSMark Fasheh struct buffer_head **new_eb_bhs = NULL; 859ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 860ccd979bdSMark Fasheh struct ocfs2_extent_list *eb_el; 861ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 862dcd0538fSMark Fasheh u32 new_cpos; 863ccd979bdSMark Fasheh 864ccd979bdSMark Fasheh mlog_entry_void(); 865ccd979bdSMark Fasheh 866328d5752SMark Fasheh BUG_ON(!last_eb_bh || !*last_eb_bh); 867ccd979bdSMark Fasheh 868ccd979bdSMark Fasheh if (eb_bh) { 869ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) eb_bh->b_data; 870ccd979bdSMark Fasheh el = &eb->h_list; 871ccd979bdSMark Fasheh } else 872ce1d9ea6SJoel Becker el = et->et_root_el; 873ccd979bdSMark Fasheh 874ccd979bdSMark Fasheh /* we never add a branch to a leaf. */ 875ccd979bdSMark Fasheh BUG_ON(!el->l_tree_depth); 876ccd979bdSMark Fasheh 877ccd979bdSMark Fasheh new_blocks = le16_to_cpu(el->l_tree_depth); 878ccd979bdSMark Fasheh 879ccd979bdSMark Fasheh /* allocate the number of new eb blocks we need */ 880ccd979bdSMark Fasheh new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *), 881ccd979bdSMark Fasheh GFP_KERNEL); 882ccd979bdSMark Fasheh if (!new_eb_bhs) { 883ccd979bdSMark Fasheh status = -ENOMEM; 884ccd979bdSMark Fasheh mlog_errno(status); 885ccd979bdSMark Fasheh goto bail; 886ccd979bdSMark Fasheh } 887ccd979bdSMark Fasheh 888ccd979bdSMark Fasheh status = ocfs2_create_new_meta_bhs(osb, handle, inode, new_blocks, 889ccd979bdSMark Fasheh meta_ac, new_eb_bhs); 890ccd979bdSMark Fasheh if (status < 0) { 891ccd979bdSMark Fasheh mlog_errno(status); 892ccd979bdSMark Fasheh goto bail; 893ccd979bdSMark Fasheh } 894ccd979bdSMark Fasheh 895328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data; 896dcd0538fSMark Fasheh new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list); 897dcd0538fSMark Fasheh 898ccd979bdSMark Fasheh /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be 899ccd979bdSMark Fasheh * linked with the rest of the tree. 900ccd979bdSMark Fasheh * conversly, new_eb_bhs[0] is the new bottommost leaf. 901ccd979bdSMark Fasheh * 902ccd979bdSMark Fasheh * when we leave the loop, new_last_eb_blk will point to the 903ccd979bdSMark Fasheh * newest leaf, and next_blkno will point to the topmost extent 904ccd979bdSMark Fasheh * block. */ 905ccd979bdSMark Fasheh next_blkno = new_last_eb_blk = 0; 906ccd979bdSMark Fasheh for(i = 0; i < new_blocks; i++) { 907ccd979bdSMark Fasheh bh = new_eb_bhs[i]; 908ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 909ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 910ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 911ccd979bdSMark Fasheh status = -EIO; 912ccd979bdSMark Fasheh goto bail; 913ccd979bdSMark Fasheh } 914ccd979bdSMark Fasheh eb_el = &eb->h_list; 915ccd979bdSMark Fasheh 916ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, bh, 917ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 918ccd979bdSMark Fasheh if (status < 0) { 919ccd979bdSMark Fasheh mlog_errno(status); 920ccd979bdSMark Fasheh goto bail; 921ccd979bdSMark Fasheh } 922ccd979bdSMark Fasheh 923ccd979bdSMark Fasheh eb->h_next_leaf_blk = 0; 924ccd979bdSMark Fasheh eb_el->l_tree_depth = cpu_to_le16(i); 925ccd979bdSMark Fasheh eb_el->l_next_free_rec = cpu_to_le16(1); 926dcd0538fSMark Fasheh /* 927dcd0538fSMark Fasheh * This actually counts as an empty extent as 928dcd0538fSMark Fasheh * c_clusters == 0 929dcd0538fSMark Fasheh */ 930dcd0538fSMark Fasheh eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos); 931ccd979bdSMark Fasheh eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno); 932e48edee2SMark Fasheh /* 933e48edee2SMark Fasheh * eb_el isn't always an interior node, but even leaf 934e48edee2SMark Fasheh * nodes want a zero'd flags and reserved field so 935e48edee2SMark Fasheh * this gets the whole 32 bits regardless of use. 936e48edee2SMark Fasheh */ 937e48edee2SMark Fasheh eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0); 938ccd979bdSMark Fasheh if (!eb_el->l_tree_depth) 939ccd979bdSMark Fasheh new_last_eb_blk = le64_to_cpu(eb->h_blkno); 940ccd979bdSMark Fasheh 941ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, bh); 942ccd979bdSMark Fasheh if (status < 0) { 943ccd979bdSMark Fasheh mlog_errno(status); 944ccd979bdSMark Fasheh goto bail; 945ccd979bdSMark Fasheh } 946ccd979bdSMark Fasheh 947ccd979bdSMark Fasheh next_blkno = le64_to_cpu(eb->h_blkno); 948ccd979bdSMark Fasheh } 949ccd979bdSMark Fasheh 950ccd979bdSMark Fasheh /* This is a bit hairy. We want to update up to three blocks 951ccd979bdSMark Fasheh * here without leaving any of them in an inconsistent state 952ccd979bdSMark Fasheh * in case of error. We don't have to worry about 953ccd979bdSMark Fasheh * journal_dirty erroring as it won't unless we've aborted the 954ccd979bdSMark Fasheh * handle (in which case we would never be here) so reserving 955ccd979bdSMark Fasheh * the write with journal_access is all we need to do. */ 956328d5752SMark Fasheh status = ocfs2_journal_access(handle, inode, *last_eb_bh, 957ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 958ccd979bdSMark Fasheh if (status < 0) { 959ccd979bdSMark Fasheh mlog_errno(status); 960ccd979bdSMark Fasheh goto bail; 961ccd979bdSMark Fasheh } 962ce1d9ea6SJoel Becker status = ocfs2_journal_access(handle, inode, et->et_root_bh, 963ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 964ccd979bdSMark Fasheh if (status < 0) { 965ccd979bdSMark Fasheh mlog_errno(status); 966ccd979bdSMark Fasheh goto bail; 967ccd979bdSMark Fasheh } 968ccd979bdSMark Fasheh if (eb_bh) { 969ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, eb_bh, 970ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 971ccd979bdSMark Fasheh if (status < 0) { 972ccd979bdSMark Fasheh mlog_errno(status); 973ccd979bdSMark Fasheh goto bail; 974ccd979bdSMark Fasheh } 975ccd979bdSMark Fasheh } 976ccd979bdSMark Fasheh 977ccd979bdSMark Fasheh /* Link the new branch into the rest of the tree (el will 978e7d4cb6bSTao Ma * either be on the root_bh, or the extent block passed in. */ 979ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec); 980ccd979bdSMark Fasheh el->l_recs[i].e_blkno = cpu_to_le64(next_blkno); 981dcd0538fSMark Fasheh el->l_recs[i].e_cpos = cpu_to_le32(new_cpos); 982e48edee2SMark Fasheh el->l_recs[i].e_int_clusters = 0; 983ccd979bdSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 984ccd979bdSMark Fasheh 985ccd979bdSMark Fasheh /* fe needs a new last extent block pointer, as does the 986ccd979bdSMark Fasheh * next_leaf on the previously last-extent-block. */ 98735dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, new_last_eb_blk); 988ccd979bdSMark Fasheh 989328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data; 990ccd979bdSMark Fasheh eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk); 991ccd979bdSMark Fasheh 992328d5752SMark Fasheh status = ocfs2_journal_dirty(handle, *last_eb_bh); 993ccd979bdSMark Fasheh if (status < 0) 994ccd979bdSMark Fasheh mlog_errno(status); 995ce1d9ea6SJoel Becker status = ocfs2_journal_dirty(handle, et->et_root_bh); 996ccd979bdSMark Fasheh if (status < 0) 997ccd979bdSMark Fasheh mlog_errno(status); 998ccd979bdSMark Fasheh if (eb_bh) { 999ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, eb_bh); 1000ccd979bdSMark Fasheh if (status < 0) 1001ccd979bdSMark Fasheh mlog_errno(status); 1002ccd979bdSMark Fasheh } 1003ccd979bdSMark Fasheh 1004328d5752SMark Fasheh /* 1005328d5752SMark Fasheh * Some callers want to track the rightmost leaf so pass it 1006328d5752SMark Fasheh * back here. 1007328d5752SMark Fasheh */ 1008328d5752SMark Fasheh brelse(*last_eb_bh); 1009328d5752SMark Fasheh get_bh(new_eb_bhs[0]); 1010328d5752SMark Fasheh *last_eb_bh = new_eb_bhs[0]; 1011328d5752SMark Fasheh 1012ccd979bdSMark Fasheh status = 0; 1013ccd979bdSMark Fasheh bail: 1014ccd979bdSMark Fasheh if (new_eb_bhs) { 1015ccd979bdSMark Fasheh for (i = 0; i < new_blocks; i++) 1016ccd979bdSMark Fasheh if (new_eb_bhs[i]) 1017ccd979bdSMark Fasheh brelse(new_eb_bhs[i]); 1018ccd979bdSMark Fasheh kfree(new_eb_bhs); 1019ccd979bdSMark Fasheh } 1020ccd979bdSMark Fasheh 1021ccd979bdSMark Fasheh mlog_exit(status); 1022ccd979bdSMark Fasheh return status; 1023ccd979bdSMark Fasheh } 1024ccd979bdSMark Fasheh 1025ccd979bdSMark Fasheh /* 1026ccd979bdSMark Fasheh * adds another level to the allocation tree. 1027ccd979bdSMark Fasheh * returns back the new extent block so you can add a branch to it 1028ccd979bdSMark Fasheh * after this call. 1029ccd979bdSMark Fasheh */ 1030ccd979bdSMark Fasheh static int ocfs2_shift_tree_depth(struct ocfs2_super *osb, 10311fabe148SMark Fasheh handle_t *handle, 1032ccd979bdSMark Fasheh struct inode *inode, 1033e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 1034ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac, 1035ccd979bdSMark Fasheh struct buffer_head **ret_new_eb_bh) 1036ccd979bdSMark Fasheh { 1037ccd979bdSMark Fasheh int status, i; 1038dcd0538fSMark Fasheh u32 new_clusters; 1039ccd979bdSMark Fasheh struct buffer_head *new_eb_bh = NULL; 1040ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 1041e7d4cb6bSTao Ma struct ocfs2_extent_list *root_el; 1042ccd979bdSMark Fasheh struct ocfs2_extent_list *eb_el; 1043ccd979bdSMark Fasheh 1044ccd979bdSMark Fasheh mlog_entry_void(); 1045ccd979bdSMark Fasheh 1046ccd979bdSMark Fasheh status = ocfs2_create_new_meta_bhs(osb, handle, inode, 1, meta_ac, 1047ccd979bdSMark Fasheh &new_eb_bh); 1048ccd979bdSMark Fasheh if (status < 0) { 1049ccd979bdSMark Fasheh mlog_errno(status); 1050ccd979bdSMark Fasheh goto bail; 1051ccd979bdSMark Fasheh } 1052ccd979bdSMark Fasheh 1053ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) new_eb_bh->b_data; 1054ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 1055ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 1056ccd979bdSMark Fasheh status = -EIO; 1057ccd979bdSMark Fasheh goto bail; 1058ccd979bdSMark Fasheh } 1059ccd979bdSMark Fasheh 1060ccd979bdSMark Fasheh eb_el = &eb->h_list; 1061ce1d9ea6SJoel Becker root_el = et->et_root_el; 1062ccd979bdSMark Fasheh 1063ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, new_eb_bh, 1064ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 1065ccd979bdSMark Fasheh if (status < 0) { 1066ccd979bdSMark Fasheh mlog_errno(status); 1067ccd979bdSMark Fasheh goto bail; 1068ccd979bdSMark Fasheh } 1069ccd979bdSMark Fasheh 1070e7d4cb6bSTao Ma /* copy the root extent list data into the new extent block */ 1071e7d4cb6bSTao Ma eb_el->l_tree_depth = root_el->l_tree_depth; 1072e7d4cb6bSTao Ma eb_el->l_next_free_rec = root_el->l_next_free_rec; 1073e7d4cb6bSTao Ma for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++) 1074e7d4cb6bSTao Ma eb_el->l_recs[i] = root_el->l_recs[i]; 1075ccd979bdSMark Fasheh 1076ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, new_eb_bh); 1077ccd979bdSMark Fasheh if (status < 0) { 1078ccd979bdSMark Fasheh mlog_errno(status); 1079ccd979bdSMark Fasheh goto bail; 1080ccd979bdSMark Fasheh } 1081ccd979bdSMark Fasheh 1082ce1d9ea6SJoel Becker status = ocfs2_journal_access(handle, inode, et->et_root_bh, 1083ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1084ccd979bdSMark Fasheh if (status < 0) { 1085ccd979bdSMark Fasheh mlog_errno(status); 1086ccd979bdSMark Fasheh goto bail; 1087ccd979bdSMark Fasheh } 1088ccd979bdSMark Fasheh 1089dcd0538fSMark Fasheh new_clusters = ocfs2_sum_rightmost_rec(eb_el); 1090dcd0538fSMark Fasheh 1091e7d4cb6bSTao Ma /* update root_bh now */ 1092e7d4cb6bSTao Ma le16_add_cpu(&root_el->l_tree_depth, 1); 1093e7d4cb6bSTao Ma root_el->l_recs[0].e_cpos = 0; 1094e7d4cb6bSTao Ma root_el->l_recs[0].e_blkno = eb->h_blkno; 1095e7d4cb6bSTao Ma root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters); 1096e7d4cb6bSTao Ma for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++) 1097e7d4cb6bSTao Ma memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec)); 1098e7d4cb6bSTao Ma root_el->l_next_free_rec = cpu_to_le16(1); 1099ccd979bdSMark Fasheh 1100ccd979bdSMark Fasheh /* If this is our 1st tree depth shift, then last_eb_blk 1101ccd979bdSMark Fasheh * becomes the allocated extent block */ 1102e7d4cb6bSTao Ma if (root_el->l_tree_depth == cpu_to_le16(1)) 110335dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 1104ccd979bdSMark Fasheh 1105ce1d9ea6SJoel Becker status = ocfs2_journal_dirty(handle, et->et_root_bh); 1106ccd979bdSMark Fasheh if (status < 0) { 1107ccd979bdSMark Fasheh mlog_errno(status); 1108ccd979bdSMark Fasheh goto bail; 1109ccd979bdSMark Fasheh } 1110ccd979bdSMark Fasheh 1111ccd979bdSMark Fasheh *ret_new_eb_bh = new_eb_bh; 1112ccd979bdSMark Fasheh new_eb_bh = NULL; 1113ccd979bdSMark Fasheh status = 0; 1114ccd979bdSMark Fasheh bail: 1115ccd979bdSMark Fasheh if (new_eb_bh) 1116ccd979bdSMark Fasheh brelse(new_eb_bh); 1117ccd979bdSMark Fasheh 1118ccd979bdSMark Fasheh mlog_exit(status); 1119ccd979bdSMark Fasheh return status; 1120ccd979bdSMark Fasheh } 1121ccd979bdSMark Fasheh 1122ccd979bdSMark Fasheh /* 1123ccd979bdSMark Fasheh * Should only be called when there is no space left in any of the 1124ccd979bdSMark Fasheh * leaf nodes. What we want to do is find the lowest tree depth 1125ccd979bdSMark Fasheh * non-leaf extent block with room for new records. There are three 1126ccd979bdSMark Fasheh * valid results of this search: 1127ccd979bdSMark Fasheh * 1128ccd979bdSMark Fasheh * 1) a lowest extent block is found, then we pass it back in 1129ccd979bdSMark Fasheh * *lowest_eb_bh and return '0' 1130ccd979bdSMark Fasheh * 1131e7d4cb6bSTao Ma * 2) the search fails to find anything, but the root_el has room. We 1132ccd979bdSMark Fasheh * pass NULL back in *lowest_eb_bh, but still return '0' 1133ccd979bdSMark Fasheh * 1134e7d4cb6bSTao Ma * 3) the search fails to find anything AND the root_el is full, in 1135ccd979bdSMark Fasheh * which case we return > 0 1136ccd979bdSMark Fasheh * 1137ccd979bdSMark Fasheh * return status < 0 indicates an error. 1138ccd979bdSMark Fasheh */ 1139ccd979bdSMark Fasheh static int ocfs2_find_branch_target(struct ocfs2_super *osb, 1140ccd979bdSMark Fasheh struct inode *inode, 1141e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 1142ccd979bdSMark Fasheh struct buffer_head **target_bh) 1143ccd979bdSMark Fasheh { 1144ccd979bdSMark Fasheh int status = 0, i; 1145ccd979bdSMark Fasheh u64 blkno; 1146ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 1147ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 1148ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 1149ccd979bdSMark Fasheh struct buffer_head *lowest_bh = NULL; 1150ccd979bdSMark Fasheh 1151ccd979bdSMark Fasheh mlog_entry_void(); 1152ccd979bdSMark Fasheh 1153ccd979bdSMark Fasheh *target_bh = NULL; 1154ccd979bdSMark Fasheh 1155ce1d9ea6SJoel Becker el = et->et_root_el; 1156ccd979bdSMark Fasheh 1157ccd979bdSMark Fasheh while(le16_to_cpu(el->l_tree_depth) > 1) { 1158ccd979bdSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 1159b0697053SMark Fasheh ocfs2_error(inode->i_sb, "Dinode %llu has empty " 1160ccd979bdSMark Fasheh "extent list (next_free_rec == 0)", 1161b0697053SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 1162ccd979bdSMark Fasheh status = -EIO; 1163ccd979bdSMark Fasheh goto bail; 1164ccd979bdSMark Fasheh } 1165ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 1166ccd979bdSMark Fasheh blkno = le64_to_cpu(el->l_recs[i].e_blkno); 1167ccd979bdSMark Fasheh if (!blkno) { 1168b0697053SMark Fasheh ocfs2_error(inode->i_sb, "Dinode %llu has extent " 1169ccd979bdSMark Fasheh "list where extent # %d has no physical " 1170ccd979bdSMark Fasheh "block start", 1171b0697053SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, i); 1172ccd979bdSMark Fasheh status = -EIO; 1173ccd979bdSMark Fasheh goto bail; 1174ccd979bdSMark Fasheh } 1175ccd979bdSMark Fasheh 1176ccd979bdSMark Fasheh if (bh) { 1177ccd979bdSMark Fasheh brelse(bh); 1178ccd979bdSMark Fasheh bh = NULL; 1179ccd979bdSMark Fasheh } 1180ccd979bdSMark Fasheh 1181ccd979bdSMark Fasheh status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED, 1182ccd979bdSMark Fasheh inode); 1183ccd979bdSMark Fasheh if (status < 0) { 1184ccd979bdSMark Fasheh mlog_errno(status); 1185ccd979bdSMark Fasheh goto bail; 1186ccd979bdSMark Fasheh } 1187ccd979bdSMark Fasheh 1188ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 1189ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 1190ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 1191ccd979bdSMark Fasheh status = -EIO; 1192ccd979bdSMark Fasheh goto bail; 1193ccd979bdSMark Fasheh } 1194ccd979bdSMark Fasheh el = &eb->h_list; 1195ccd979bdSMark Fasheh 1196ccd979bdSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) < 1197ccd979bdSMark Fasheh le16_to_cpu(el->l_count)) { 1198ccd979bdSMark Fasheh if (lowest_bh) 1199ccd979bdSMark Fasheh brelse(lowest_bh); 1200ccd979bdSMark Fasheh lowest_bh = bh; 1201ccd979bdSMark Fasheh get_bh(lowest_bh); 1202ccd979bdSMark Fasheh } 1203ccd979bdSMark Fasheh } 1204ccd979bdSMark Fasheh 1205ccd979bdSMark Fasheh /* If we didn't find one and the fe doesn't have any room, 1206ccd979bdSMark Fasheh * then return '1' */ 1207ce1d9ea6SJoel Becker el = et->et_root_el; 1208e7d4cb6bSTao Ma if (!lowest_bh && (el->l_next_free_rec == el->l_count)) 1209ccd979bdSMark Fasheh status = 1; 1210ccd979bdSMark Fasheh 1211ccd979bdSMark Fasheh *target_bh = lowest_bh; 1212ccd979bdSMark Fasheh bail: 1213ccd979bdSMark Fasheh if (bh) 1214ccd979bdSMark Fasheh brelse(bh); 1215ccd979bdSMark Fasheh 1216ccd979bdSMark Fasheh mlog_exit(status); 1217ccd979bdSMark Fasheh return status; 1218ccd979bdSMark Fasheh } 1219ccd979bdSMark Fasheh 1220e48edee2SMark Fasheh /* 1221c3afcbb3SMark Fasheh * Grow a b-tree so that it has more records. 1222c3afcbb3SMark Fasheh * 1223c3afcbb3SMark Fasheh * We might shift the tree depth in which case existing paths should 1224c3afcbb3SMark Fasheh * be considered invalid. 1225c3afcbb3SMark Fasheh * 1226c3afcbb3SMark Fasheh * Tree depth after the grow is returned via *final_depth. 1227328d5752SMark Fasheh * 1228328d5752SMark Fasheh * *last_eb_bh will be updated by ocfs2_add_branch(). 1229c3afcbb3SMark Fasheh */ 1230c3afcbb3SMark Fasheh static int ocfs2_grow_tree(struct inode *inode, handle_t *handle, 1231e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, int *final_depth, 1232328d5752SMark Fasheh struct buffer_head **last_eb_bh, 1233c3afcbb3SMark Fasheh struct ocfs2_alloc_context *meta_ac) 1234c3afcbb3SMark Fasheh { 1235c3afcbb3SMark Fasheh int ret, shift; 1236ce1d9ea6SJoel Becker struct ocfs2_extent_list *el = et->et_root_el; 1237e7d4cb6bSTao Ma int depth = le16_to_cpu(el->l_tree_depth); 1238c3afcbb3SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1239c3afcbb3SMark Fasheh struct buffer_head *bh = NULL; 1240c3afcbb3SMark Fasheh 1241c3afcbb3SMark Fasheh BUG_ON(meta_ac == NULL); 1242c3afcbb3SMark Fasheh 1243e7d4cb6bSTao Ma shift = ocfs2_find_branch_target(osb, inode, et, &bh); 1244c3afcbb3SMark Fasheh if (shift < 0) { 1245c3afcbb3SMark Fasheh ret = shift; 1246c3afcbb3SMark Fasheh mlog_errno(ret); 1247c3afcbb3SMark Fasheh goto out; 1248c3afcbb3SMark Fasheh } 1249c3afcbb3SMark Fasheh 1250c3afcbb3SMark Fasheh /* We traveled all the way to the bottom of the allocation tree 1251c3afcbb3SMark Fasheh * and didn't find room for any more extents - we need to add 1252c3afcbb3SMark Fasheh * another tree level */ 1253c3afcbb3SMark Fasheh if (shift) { 1254c3afcbb3SMark Fasheh BUG_ON(bh); 1255c3afcbb3SMark Fasheh mlog(0, "need to shift tree depth (current = %d)\n", depth); 1256c3afcbb3SMark Fasheh 1257c3afcbb3SMark Fasheh /* ocfs2_shift_tree_depth will return us a buffer with 1258c3afcbb3SMark Fasheh * the new extent block (so we can pass that to 1259c3afcbb3SMark Fasheh * ocfs2_add_branch). */ 1260e7d4cb6bSTao Ma ret = ocfs2_shift_tree_depth(osb, handle, inode, et, 1261c3afcbb3SMark Fasheh meta_ac, &bh); 1262c3afcbb3SMark Fasheh if (ret < 0) { 1263c3afcbb3SMark Fasheh mlog_errno(ret); 1264c3afcbb3SMark Fasheh goto out; 1265c3afcbb3SMark Fasheh } 1266c3afcbb3SMark Fasheh depth++; 1267328d5752SMark Fasheh if (depth == 1) { 1268328d5752SMark Fasheh /* 1269328d5752SMark Fasheh * Special case: we have room now if we shifted from 1270328d5752SMark Fasheh * tree_depth 0, so no more work needs to be done. 1271328d5752SMark Fasheh * 1272328d5752SMark Fasheh * We won't be calling add_branch, so pass 1273328d5752SMark Fasheh * back *last_eb_bh as the new leaf. At depth 1274328d5752SMark Fasheh * zero, it should always be null so there's 1275328d5752SMark Fasheh * no reason to brelse. 1276328d5752SMark Fasheh */ 1277328d5752SMark Fasheh BUG_ON(*last_eb_bh); 1278328d5752SMark Fasheh get_bh(bh); 1279328d5752SMark Fasheh *last_eb_bh = bh; 1280c3afcbb3SMark Fasheh goto out; 1281c3afcbb3SMark Fasheh } 1282328d5752SMark Fasheh } 1283c3afcbb3SMark Fasheh 1284c3afcbb3SMark Fasheh /* call ocfs2_add_branch to add the final part of the tree with 1285c3afcbb3SMark Fasheh * the new data. */ 1286c3afcbb3SMark Fasheh mlog(0, "add branch. bh = %p\n", bh); 1287e7d4cb6bSTao Ma ret = ocfs2_add_branch(osb, handle, inode, et, bh, last_eb_bh, 1288c3afcbb3SMark Fasheh meta_ac); 1289c3afcbb3SMark Fasheh if (ret < 0) { 1290c3afcbb3SMark Fasheh mlog_errno(ret); 1291c3afcbb3SMark Fasheh goto out; 1292c3afcbb3SMark Fasheh } 1293c3afcbb3SMark Fasheh 1294c3afcbb3SMark Fasheh out: 1295c3afcbb3SMark Fasheh if (final_depth) 1296c3afcbb3SMark Fasheh *final_depth = depth; 1297c3afcbb3SMark Fasheh brelse(bh); 1298c3afcbb3SMark Fasheh return ret; 1299c3afcbb3SMark Fasheh } 1300c3afcbb3SMark Fasheh 1301c3afcbb3SMark Fasheh /* 1302dcd0538fSMark Fasheh * This function will discard the rightmost extent record. 1303dcd0538fSMark Fasheh */ 1304dcd0538fSMark Fasheh static void ocfs2_shift_records_right(struct ocfs2_extent_list *el) 1305dcd0538fSMark Fasheh { 1306dcd0538fSMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 1307dcd0538fSMark Fasheh int count = le16_to_cpu(el->l_count); 1308dcd0538fSMark Fasheh unsigned int num_bytes; 1309dcd0538fSMark Fasheh 1310dcd0538fSMark Fasheh BUG_ON(!next_free); 1311dcd0538fSMark Fasheh /* This will cause us to go off the end of our extent list. */ 1312dcd0538fSMark Fasheh BUG_ON(next_free >= count); 1313dcd0538fSMark Fasheh 1314dcd0538fSMark Fasheh num_bytes = sizeof(struct ocfs2_extent_rec) * next_free; 1315dcd0538fSMark Fasheh 1316dcd0538fSMark Fasheh memmove(&el->l_recs[1], &el->l_recs[0], num_bytes); 1317dcd0538fSMark Fasheh } 1318dcd0538fSMark Fasheh 1319dcd0538fSMark Fasheh static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el, 1320dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 1321dcd0538fSMark Fasheh { 1322dcd0538fSMark Fasheh int i, insert_index, next_free, has_empty, num_bytes; 1323dcd0538fSMark Fasheh u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos); 1324dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 1325dcd0538fSMark Fasheh 1326dcd0538fSMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 1327dcd0538fSMark Fasheh has_empty = ocfs2_is_empty_extent(&el->l_recs[0]); 1328dcd0538fSMark Fasheh 1329dcd0538fSMark Fasheh BUG_ON(!next_free); 1330dcd0538fSMark Fasheh 1331dcd0538fSMark Fasheh /* The tree code before us didn't allow enough room in the leaf. */ 1332b1f3550fSJulia Lawall BUG_ON(el->l_next_free_rec == el->l_count && !has_empty); 1333dcd0538fSMark Fasheh 1334dcd0538fSMark Fasheh /* 1335dcd0538fSMark Fasheh * The easiest way to approach this is to just remove the 1336dcd0538fSMark Fasheh * empty extent and temporarily decrement next_free. 1337dcd0538fSMark Fasheh */ 1338dcd0538fSMark Fasheh if (has_empty) { 1339dcd0538fSMark Fasheh /* 1340dcd0538fSMark Fasheh * If next_free was 1 (only an empty extent), this 1341dcd0538fSMark Fasheh * loop won't execute, which is fine. We still want 1342dcd0538fSMark Fasheh * the decrement above to happen. 1343dcd0538fSMark Fasheh */ 1344dcd0538fSMark Fasheh for(i = 0; i < (next_free - 1); i++) 1345dcd0538fSMark Fasheh el->l_recs[i] = el->l_recs[i+1]; 1346dcd0538fSMark Fasheh 1347dcd0538fSMark Fasheh next_free--; 1348dcd0538fSMark Fasheh } 1349dcd0538fSMark Fasheh 1350dcd0538fSMark Fasheh /* 1351dcd0538fSMark Fasheh * Figure out what the new record index should be. 1352dcd0538fSMark Fasheh */ 1353dcd0538fSMark Fasheh for(i = 0; i < next_free; i++) { 1354dcd0538fSMark Fasheh rec = &el->l_recs[i]; 1355dcd0538fSMark Fasheh 1356dcd0538fSMark Fasheh if (insert_cpos < le32_to_cpu(rec->e_cpos)) 1357dcd0538fSMark Fasheh break; 1358dcd0538fSMark Fasheh } 1359dcd0538fSMark Fasheh insert_index = i; 1360dcd0538fSMark Fasheh 1361dcd0538fSMark Fasheh mlog(0, "ins %u: index %d, has_empty %d, next_free %d, count %d\n", 1362dcd0538fSMark Fasheh insert_cpos, insert_index, has_empty, next_free, le16_to_cpu(el->l_count)); 1363dcd0538fSMark Fasheh 1364dcd0538fSMark Fasheh BUG_ON(insert_index < 0); 1365dcd0538fSMark Fasheh BUG_ON(insert_index >= le16_to_cpu(el->l_count)); 1366dcd0538fSMark Fasheh BUG_ON(insert_index > next_free); 1367dcd0538fSMark Fasheh 1368dcd0538fSMark Fasheh /* 1369dcd0538fSMark Fasheh * No need to memmove if we're just adding to the tail. 1370dcd0538fSMark Fasheh */ 1371dcd0538fSMark Fasheh if (insert_index != next_free) { 1372dcd0538fSMark Fasheh BUG_ON(next_free >= le16_to_cpu(el->l_count)); 1373dcd0538fSMark Fasheh 1374dcd0538fSMark Fasheh num_bytes = next_free - insert_index; 1375dcd0538fSMark Fasheh num_bytes *= sizeof(struct ocfs2_extent_rec); 1376dcd0538fSMark Fasheh memmove(&el->l_recs[insert_index + 1], 1377dcd0538fSMark Fasheh &el->l_recs[insert_index], 1378dcd0538fSMark Fasheh num_bytes); 1379dcd0538fSMark Fasheh } 1380dcd0538fSMark Fasheh 1381dcd0538fSMark Fasheh /* 1382dcd0538fSMark Fasheh * Either we had an empty extent, and need to re-increment or 1383dcd0538fSMark Fasheh * there was no empty extent on a non full rightmost leaf node, 1384dcd0538fSMark Fasheh * in which case we still need to increment. 1385dcd0538fSMark Fasheh */ 1386dcd0538fSMark Fasheh next_free++; 1387dcd0538fSMark Fasheh el->l_next_free_rec = cpu_to_le16(next_free); 1388dcd0538fSMark Fasheh /* 1389dcd0538fSMark Fasheh * Make sure none of the math above just messed up our tree. 1390dcd0538fSMark Fasheh */ 1391dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count)); 1392dcd0538fSMark Fasheh 1393dcd0538fSMark Fasheh el->l_recs[insert_index] = *insert_rec; 1394dcd0538fSMark Fasheh 1395dcd0538fSMark Fasheh } 1396dcd0538fSMark Fasheh 1397328d5752SMark Fasheh static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el) 1398328d5752SMark Fasheh { 1399328d5752SMark Fasheh int size, num_recs = le16_to_cpu(el->l_next_free_rec); 1400328d5752SMark Fasheh 1401328d5752SMark Fasheh BUG_ON(num_recs == 0); 1402328d5752SMark Fasheh 1403328d5752SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 1404328d5752SMark Fasheh num_recs--; 1405328d5752SMark Fasheh size = num_recs * sizeof(struct ocfs2_extent_rec); 1406328d5752SMark Fasheh memmove(&el->l_recs[0], &el->l_recs[1], size); 1407328d5752SMark Fasheh memset(&el->l_recs[num_recs], 0, 1408328d5752SMark Fasheh sizeof(struct ocfs2_extent_rec)); 1409328d5752SMark Fasheh el->l_next_free_rec = cpu_to_le16(num_recs); 1410328d5752SMark Fasheh } 1411328d5752SMark Fasheh } 1412328d5752SMark Fasheh 1413dcd0538fSMark Fasheh /* 1414dcd0538fSMark Fasheh * Create an empty extent record . 1415dcd0538fSMark Fasheh * 1416dcd0538fSMark Fasheh * l_next_free_rec may be updated. 1417dcd0538fSMark Fasheh * 1418dcd0538fSMark Fasheh * If an empty extent already exists do nothing. 1419dcd0538fSMark Fasheh */ 1420dcd0538fSMark Fasheh static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el) 1421dcd0538fSMark Fasheh { 1422dcd0538fSMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 1423dcd0538fSMark Fasheh 1424e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 1425e48edee2SMark Fasheh 1426dcd0538fSMark Fasheh if (next_free == 0) 1427dcd0538fSMark Fasheh goto set_and_inc; 1428dcd0538fSMark Fasheh 1429dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) 1430dcd0538fSMark Fasheh return; 1431dcd0538fSMark Fasheh 1432dcd0538fSMark Fasheh mlog_bug_on_msg(el->l_count == el->l_next_free_rec, 1433dcd0538fSMark Fasheh "Asked to create an empty extent in a full list:\n" 1434dcd0538fSMark Fasheh "count = %u, tree depth = %u", 1435dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 1436dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth)); 1437dcd0538fSMark Fasheh 1438dcd0538fSMark Fasheh ocfs2_shift_records_right(el); 1439dcd0538fSMark Fasheh 1440dcd0538fSMark Fasheh set_and_inc: 1441dcd0538fSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 1442dcd0538fSMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 1443dcd0538fSMark Fasheh } 1444dcd0538fSMark Fasheh 1445dcd0538fSMark Fasheh /* 1446dcd0538fSMark Fasheh * For a rotation which involves two leaf nodes, the "root node" is 1447dcd0538fSMark Fasheh * the lowest level tree node which contains a path to both leafs. This 1448dcd0538fSMark Fasheh * resulting set of information can be used to form a complete "subtree" 1449dcd0538fSMark Fasheh * 1450dcd0538fSMark Fasheh * This function is passed two full paths from the dinode down to a 1451dcd0538fSMark Fasheh * pair of adjacent leaves. It's task is to figure out which path 1452dcd0538fSMark Fasheh * index contains the subtree root - this can be the root index itself 1453dcd0538fSMark Fasheh * in a worst-case rotation. 1454dcd0538fSMark Fasheh * 1455dcd0538fSMark Fasheh * The array index of the subtree root is passed back. 1456dcd0538fSMark Fasheh */ 1457dcd0538fSMark Fasheh static int ocfs2_find_subtree_root(struct inode *inode, 1458dcd0538fSMark Fasheh struct ocfs2_path *left, 1459dcd0538fSMark Fasheh struct ocfs2_path *right) 1460dcd0538fSMark Fasheh { 1461dcd0538fSMark Fasheh int i = 0; 1462dcd0538fSMark Fasheh 1463dcd0538fSMark Fasheh /* 1464dcd0538fSMark Fasheh * Check that the caller passed in two paths from the same tree. 1465dcd0538fSMark Fasheh */ 1466dcd0538fSMark Fasheh BUG_ON(path_root_bh(left) != path_root_bh(right)); 1467dcd0538fSMark Fasheh 1468dcd0538fSMark Fasheh do { 1469dcd0538fSMark Fasheh i++; 1470dcd0538fSMark Fasheh 1471dcd0538fSMark Fasheh /* 1472dcd0538fSMark Fasheh * The caller didn't pass two adjacent paths. 1473dcd0538fSMark Fasheh */ 1474dcd0538fSMark Fasheh mlog_bug_on_msg(i > left->p_tree_depth, 1475dcd0538fSMark Fasheh "Inode %lu, left depth %u, right depth %u\n" 1476dcd0538fSMark Fasheh "left leaf blk %llu, right leaf blk %llu\n", 1477dcd0538fSMark Fasheh inode->i_ino, left->p_tree_depth, 1478dcd0538fSMark Fasheh right->p_tree_depth, 1479dcd0538fSMark Fasheh (unsigned long long)path_leaf_bh(left)->b_blocknr, 1480dcd0538fSMark Fasheh (unsigned long long)path_leaf_bh(right)->b_blocknr); 1481dcd0538fSMark Fasheh } while (left->p_node[i].bh->b_blocknr == 1482dcd0538fSMark Fasheh right->p_node[i].bh->b_blocknr); 1483dcd0538fSMark Fasheh 1484dcd0538fSMark Fasheh return i - 1; 1485dcd0538fSMark Fasheh } 1486dcd0538fSMark Fasheh 1487dcd0538fSMark Fasheh typedef void (path_insert_t)(void *, struct buffer_head *); 1488dcd0538fSMark Fasheh 1489dcd0538fSMark Fasheh /* 1490dcd0538fSMark Fasheh * Traverse a btree path in search of cpos, starting at root_el. 1491dcd0538fSMark Fasheh * 1492dcd0538fSMark Fasheh * This code can be called with a cpos larger than the tree, in which 1493dcd0538fSMark Fasheh * case it will return the rightmost path. 1494dcd0538fSMark Fasheh */ 1495dcd0538fSMark Fasheh static int __ocfs2_find_path(struct inode *inode, 1496dcd0538fSMark Fasheh struct ocfs2_extent_list *root_el, u32 cpos, 1497dcd0538fSMark Fasheh path_insert_t *func, void *data) 1498dcd0538fSMark Fasheh { 1499dcd0538fSMark Fasheh int i, ret = 0; 1500dcd0538fSMark Fasheh u32 range; 1501dcd0538fSMark Fasheh u64 blkno; 1502dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 1503dcd0538fSMark Fasheh struct ocfs2_extent_block *eb; 1504dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 1505dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 1506dcd0538fSMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 1507dcd0538fSMark Fasheh 1508dcd0538fSMark Fasheh el = root_el; 1509dcd0538fSMark Fasheh while (el->l_tree_depth) { 1510dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 1511dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1512dcd0538fSMark Fasheh "Inode %llu has empty extent list at " 1513dcd0538fSMark Fasheh "depth %u\n", 1514dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1515dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth)); 1516dcd0538fSMark Fasheh ret = -EROFS; 1517dcd0538fSMark Fasheh goto out; 1518dcd0538fSMark Fasheh 1519dcd0538fSMark Fasheh } 1520dcd0538fSMark Fasheh 1521dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) { 1522dcd0538fSMark Fasheh rec = &el->l_recs[i]; 1523dcd0538fSMark Fasheh 1524dcd0538fSMark Fasheh /* 1525dcd0538fSMark Fasheh * In the case that cpos is off the allocation 1526dcd0538fSMark Fasheh * tree, this should just wind up returning the 1527dcd0538fSMark Fasheh * rightmost record. 1528dcd0538fSMark Fasheh */ 1529dcd0538fSMark Fasheh range = le32_to_cpu(rec->e_cpos) + 1530e48edee2SMark Fasheh ocfs2_rec_clusters(el, rec); 1531dcd0538fSMark Fasheh if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range) 1532dcd0538fSMark Fasheh break; 1533dcd0538fSMark Fasheh } 1534dcd0538fSMark Fasheh 1535dcd0538fSMark Fasheh blkno = le64_to_cpu(el->l_recs[i].e_blkno); 1536dcd0538fSMark Fasheh if (blkno == 0) { 1537dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1538dcd0538fSMark Fasheh "Inode %llu has bad blkno in extent list " 1539dcd0538fSMark Fasheh "at depth %u (index %d)\n", 1540dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1541dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth), i); 1542dcd0538fSMark Fasheh ret = -EROFS; 1543dcd0538fSMark Fasheh goto out; 1544dcd0538fSMark Fasheh } 1545dcd0538fSMark Fasheh 1546dcd0538fSMark Fasheh brelse(bh); 1547dcd0538fSMark Fasheh bh = NULL; 1548dcd0538fSMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno, 1549dcd0538fSMark Fasheh &bh, OCFS2_BH_CACHED, inode); 1550dcd0538fSMark Fasheh if (ret) { 1551dcd0538fSMark Fasheh mlog_errno(ret); 1552dcd0538fSMark Fasheh goto out; 1553dcd0538fSMark Fasheh } 1554dcd0538fSMark Fasheh 1555dcd0538fSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 1556dcd0538fSMark Fasheh el = &eb->h_list; 1557dcd0538fSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 1558dcd0538fSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 1559dcd0538fSMark Fasheh ret = -EIO; 1560dcd0538fSMark Fasheh goto out; 1561dcd0538fSMark Fasheh } 1562dcd0538fSMark Fasheh 1563dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1564dcd0538fSMark Fasheh le16_to_cpu(el->l_count)) { 1565dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1566dcd0538fSMark Fasheh "Inode %llu has bad count in extent list " 1567dcd0538fSMark Fasheh "at block %llu (next free=%u, count=%u)\n", 1568dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1569dcd0538fSMark Fasheh (unsigned long long)bh->b_blocknr, 1570dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec), 1571dcd0538fSMark Fasheh le16_to_cpu(el->l_count)); 1572dcd0538fSMark Fasheh ret = -EROFS; 1573dcd0538fSMark Fasheh goto out; 1574dcd0538fSMark Fasheh } 1575dcd0538fSMark Fasheh 1576dcd0538fSMark Fasheh if (func) 1577dcd0538fSMark Fasheh func(data, bh); 1578dcd0538fSMark Fasheh } 1579dcd0538fSMark Fasheh 1580dcd0538fSMark Fasheh out: 1581dcd0538fSMark Fasheh /* 1582dcd0538fSMark Fasheh * Catch any trailing bh that the loop didn't handle. 1583dcd0538fSMark Fasheh */ 1584dcd0538fSMark Fasheh brelse(bh); 1585dcd0538fSMark Fasheh 1586dcd0538fSMark Fasheh return ret; 1587dcd0538fSMark Fasheh } 1588dcd0538fSMark Fasheh 1589dcd0538fSMark Fasheh /* 1590dcd0538fSMark Fasheh * Given an initialized path (that is, it has a valid root extent 1591dcd0538fSMark Fasheh * list), this function will traverse the btree in search of the path 1592dcd0538fSMark Fasheh * which would contain cpos. 1593dcd0538fSMark Fasheh * 1594dcd0538fSMark Fasheh * The path traveled is recorded in the path structure. 1595dcd0538fSMark Fasheh * 1596dcd0538fSMark Fasheh * Note that this will not do any comparisons on leaf node extent 1597dcd0538fSMark Fasheh * records, so it will work fine in the case that we just added a tree 1598dcd0538fSMark Fasheh * branch. 1599dcd0538fSMark Fasheh */ 1600dcd0538fSMark Fasheh struct find_path_data { 1601dcd0538fSMark Fasheh int index; 1602dcd0538fSMark Fasheh struct ocfs2_path *path; 1603dcd0538fSMark Fasheh }; 1604dcd0538fSMark Fasheh static void find_path_ins(void *data, struct buffer_head *bh) 1605dcd0538fSMark Fasheh { 1606dcd0538fSMark Fasheh struct find_path_data *fp = data; 1607dcd0538fSMark Fasheh 1608dcd0538fSMark Fasheh get_bh(bh); 1609dcd0538fSMark Fasheh ocfs2_path_insert_eb(fp->path, fp->index, bh); 1610dcd0538fSMark Fasheh fp->index++; 1611dcd0538fSMark Fasheh } 1612dcd0538fSMark Fasheh static int ocfs2_find_path(struct inode *inode, struct ocfs2_path *path, 1613dcd0538fSMark Fasheh u32 cpos) 1614dcd0538fSMark Fasheh { 1615dcd0538fSMark Fasheh struct find_path_data data; 1616dcd0538fSMark Fasheh 1617dcd0538fSMark Fasheh data.index = 1; 1618dcd0538fSMark Fasheh data.path = path; 1619dcd0538fSMark Fasheh return __ocfs2_find_path(inode, path_root_el(path), cpos, 1620dcd0538fSMark Fasheh find_path_ins, &data); 1621dcd0538fSMark Fasheh } 1622dcd0538fSMark Fasheh 1623dcd0538fSMark Fasheh static void find_leaf_ins(void *data, struct buffer_head *bh) 1624dcd0538fSMark Fasheh { 1625dcd0538fSMark Fasheh struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data; 1626dcd0538fSMark Fasheh struct ocfs2_extent_list *el = &eb->h_list; 1627dcd0538fSMark Fasheh struct buffer_head **ret = data; 1628dcd0538fSMark Fasheh 1629dcd0538fSMark Fasheh /* We want to retain only the leaf block. */ 1630dcd0538fSMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 1631dcd0538fSMark Fasheh get_bh(bh); 1632dcd0538fSMark Fasheh *ret = bh; 1633dcd0538fSMark Fasheh } 1634dcd0538fSMark Fasheh } 1635dcd0538fSMark Fasheh /* 1636dcd0538fSMark Fasheh * Find the leaf block in the tree which would contain cpos. No 1637dcd0538fSMark Fasheh * checking of the actual leaf is done. 1638dcd0538fSMark Fasheh * 1639dcd0538fSMark Fasheh * Some paths want to call this instead of allocating a path structure 1640dcd0538fSMark Fasheh * and calling ocfs2_find_path(). 1641dcd0538fSMark Fasheh * 1642dcd0538fSMark Fasheh * This function doesn't handle non btree extent lists. 1643dcd0538fSMark Fasheh */ 1644363041a5SMark Fasheh int ocfs2_find_leaf(struct inode *inode, struct ocfs2_extent_list *root_el, 1645363041a5SMark Fasheh u32 cpos, struct buffer_head **leaf_bh) 1646dcd0538fSMark Fasheh { 1647dcd0538fSMark Fasheh int ret; 1648dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 1649dcd0538fSMark Fasheh 1650dcd0538fSMark Fasheh ret = __ocfs2_find_path(inode, root_el, cpos, find_leaf_ins, &bh); 1651dcd0538fSMark Fasheh if (ret) { 1652dcd0538fSMark Fasheh mlog_errno(ret); 1653dcd0538fSMark Fasheh goto out; 1654dcd0538fSMark Fasheh } 1655dcd0538fSMark Fasheh 1656dcd0538fSMark Fasheh *leaf_bh = bh; 1657dcd0538fSMark Fasheh out: 1658dcd0538fSMark Fasheh return ret; 1659dcd0538fSMark Fasheh } 1660dcd0538fSMark Fasheh 1661dcd0538fSMark Fasheh /* 1662dcd0538fSMark Fasheh * Adjust the adjacent records (left_rec, right_rec) involved in a rotation. 1663dcd0538fSMark Fasheh * 1664dcd0538fSMark Fasheh * Basically, we've moved stuff around at the bottom of the tree and 1665dcd0538fSMark Fasheh * we need to fix up the extent records above the changes to reflect 1666dcd0538fSMark Fasheh * the new changes. 1667dcd0538fSMark Fasheh * 1668dcd0538fSMark Fasheh * left_rec: the record on the left. 1669dcd0538fSMark Fasheh * left_child_el: is the child list pointed to by left_rec 1670dcd0538fSMark Fasheh * right_rec: the record to the right of left_rec 1671dcd0538fSMark Fasheh * right_child_el: is the child list pointed to by right_rec 1672dcd0538fSMark Fasheh * 1673dcd0538fSMark Fasheh * By definition, this only works on interior nodes. 1674dcd0538fSMark Fasheh */ 1675dcd0538fSMark Fasheh static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec, 1676dcd0538fSMark Fasheh struct ocfs2_extent_list *left_child_el, 1677dcd0538fSMark Fasheh struct ocfs2_extent_rec *right_rec, 1678dcd0538fSMark Fasheh struct ocfs2_extent_list *right_child_el) 1679dcd0538fSMark Fasheh { 1680dcd0538fSMark Fasheh u32 left_clusters, right_end; 1681dcd0538fSMark Fasheh 1682dcd0538fSMark Fasheh /* 1683dcd0538fSMark Fasheh * Interior nodes never have holes. Their cpos is the cpos of 1684dcd0538fSMark Fasheh * the leftmost record in their child list. Their cluster 1685dcd0538fSMark Fasheh * count covers the full theoretical range of their child list 1686dcd0538fSMark Fasheh * - the range between their cpos and the cpos of the record 1687dcd0538fSMark Fasheh * immediately to their right. 1688dcd0538fSMark Fasheh */ 1689dcd0538fSMark Fasheh left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos); 1690328d5752SMark Fasheh if (ocfs2_is_empty_extent(&right_child_el->l_recs[0])) { 1691328d5752SMark Fasheh BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1); 1692328d5752SMark Fasheh left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos); 1693328d5752SMark Fasheh } 1694dcd0538fSMark Fasheh left_clusters -= le32_to_cpu(left_rec->e_cpos); 1695e48edee2SMark Fasheh left_rec->e_int_clusters = cpu_to_le32(left_clusters); 1696dcd0538fSMark Fasheh 1697dcd0538fSMark Fasheh /* 1698dcd0538fSMark Fasheh * Calculate the rightmost cluster count boundary before 1699e48edee2SMark Fasheh * moving cpos - we will need to adjust clusters after 1700dcd0538fSMark Fasheh * updating e_cpos to keep the same highest cluster count. 1701dcd0538fSMark Fasheh */ 1702dcd0538fSMark Fasheh right_end = le32_to_cpu(right_rec->e_cpos); 1703e48edee2SMark Fasheh right_end += le32_to_cpu(right_rec->e_int_clusters); 1704dcd0538fSMark Fasheh 1705dcd0538fSMark Fasheh right_rec->e_cpos = left_rec->e_cpos; 1706dcd0538fSMark Fasheh le32_add_cpu(&right_rec->e_cpos, left_clusters); 1707dcd0538fSMark Fasheh 1708dcd0538fSMark Fasheh right_end -= le32_to_cpu(right_rec->e_cpos); 1709e48edee2SMark Fasheh right_rec->e_int_clusters = cpu_to_le32(right_end); 1710dcd0538fSMark Fasheh } 1711dcd0538fSMark Fasheh 1712dcd0538fSMark Fasheh /* 1713dcd0538fSMark Fasheh * Adjust the adjacent root node records involved in a 1714dcd0538fSMark Fasheh * rotation. left_el_blkno is passed in as a key so that we can easily 1715dcd0538fSMark Fasheh * find it's index in the root list. 1716dcd0538fSMark Fasheh */ 1717dcd0538fSMark Fasheh static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el, 1718dcd0538fSMark Fasheh struct ocfs2_extent_list *left_el, 1719dcd0538fSMark Fasheh struct ocfs2_extent_list *right_el, 1720dcd0538fSMark Fasheh u64 left_el_blkno) 1721dcd0538fSMark Fasheh { 1722dcd0538fSMark Fasheh int i; 1723dcd0538fSMark Fasheh 1724dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(root_el->l_tree_depth) <= 1725dcd0538fSMark Fasheh le16_to_cpu(left_el->l_tree_depth)); 1726dcd0538fSMark Fasheh 1727dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) { 1728dcd0538fSMark Fasheh if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno) 1729dcd0538fSMark Fasheh break; 1730dcd0538fSMark Fasheh } 1731dcd0538fSMark Fasheh 1732dcd0538fSMark Fasheh /* 1733dcd0538fSMark Fasheh * The path walking code should have never returned a root and 1734dcd0538fSMark Fasheh * two paths which are not adjacent. 1735dcd0538fSMark Fasheh */ 1736dcd0538fSMark Fasheh BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1)); 1737dcd0538fSMark Fasheh 1738dcd0538fSMark Fasheh ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el, 1739dcd0538fSMark Fasheh &root_el->l_recs[i + 1], right_el); 1740dcd0538fSMark Fasheh } 1741dcd0538fSMark Fasheh 1742dcd0538fSMark Fasheh /* 1743dcd0538fSMark Fasheh * We've changed a leaf block (in right_path) and need to reflect that 1744dcd0538fSMark Fasheh * change back up the subtree. 1745dcd0538fSMark Fasheh * 1746dcd0538fSMark Fasheh * This happens in multiple places: 1747dcd0538fSMark Fasheh * - When we've moved an extent record from the left path leaf to the right 1748dcd0538fSMark Fasheh * path leaf to make room for an empty extent in the left path leaf. 1749dcd0538fSMark Fasheh * - When our insert into the right path leaf is at the leftmost edge 1750dcd0538fSMark Fasheh * and requires an update of the path immediately to it's left. This 1751dcd0538fSMark Fasheh * can occur at the end of some types of rotation and appending inserts. 1752677b9752STao Ma * - When we've adjusted the last extent record in the left path leaf and the 1753677b9752STao Ma * 1st extent record in the right path leaf during cross extent block merge. 1754dcd0538fSMark Fasheh */ 1755dcd0538fSMark Fasheh static void ocfs2_complete_edge_insert(struct inode *inode, handle_t *handle, 1756dcd0538fSMark Fasheh struct ocfs2_path *left_path, 1757dcd0538fSMark Fasheh struct ocfs2_path *right_path, 1758dcd0538fSMark Fasheh int subtree_index) 1759dcd0538fSMark Fasheh { 1760dcd0538fSMark Fasheh int ret, i, idx; 1761dcd0538fSMark Fasheh struct ocfs2_extent_list *el, *left_el, *right_el; 1762dcd0538fSMark Fasheh struct ocfs2_extent_rec *left_rec, *right_rec; 1763dcd0538fSMark Fasheh struct buffer_head *root_bh = left_path->p_node[subtree_index].bh; 1764dcd0538fSMark Fasheh 1765dcd0538fSMark Fasheh /* 1766dcd0538fSMark Fasheh * Update the counts and position values within all the 1767dcd0538fSMark Fasheh * interior nodes to reflect the leaf rotation we just did. 1768dcd0538fSMark Fasheh * 1769dcd0538fSMark Fasheh * The root node is handled below the loop. 1770dcd0538fSMark Fasheh * 1771dcd0538fSMark Fasheh * We begin the loop with right_el and left_el pointing to the 1772dcd0538fSMark Fasheh * leaf lists and work our way up. 1773dcd0538fSMark Fasheh * 1774dcd0538fSMark Fasheh * NOTE: within this loop, left_el and right_el always refer 1775dcd0538fSMark Fasheh * to the *child* lists. 1776dcd0538fSMark Fasheh */ 1777dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 1778dcd0538fSMark Fasheh right_el = path_leaf_el(right_path); 1779dcd0538fSMark Fasheh for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) { 1780dcd0538fSMark Fasheh mlog(0, "Adjust records at index %u\n", i); 1781dcd0538fSMark Fasheh 1782dcd0538fSMark Fasheh /* 1783dcd0538fSMark Fasheh * One nice property of knowing that all of these 1784dcd0538fSMark Fasheh * nodes are below the root is that we only deal with 1785dcd0538fSMark Fasheh * the leftmost right node record and the rightmost 1786dcd0538fSMark Fasheh * left node record. 1787dcd0538fSMark Fasheh */ 1788dcd0538fSMark Fasheh el = left_path->p_node[i].el; 1789dcd0538fSMark Fasheh idx = le16_to_cpu(left_el->l_next_free_rec) - 1; 1790dcd0538fSMark Fasheh left_rec = &el->l_recs[idx]; 1791dcd0538fSMark Fasheh 1792dcd0538fSMark Fasheh el = right_path->p_node[i].el; 1793dcd0538fSMark Fasheh right_rec = &el->l_recs[0]; 1794dcd0538fSMark Fasheh 1795dcd0538fSMark Fasheh ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec, 1796dcd0538fSMark Fasheh right_el); 1797dcd0538fSMark Fasheh 1798dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, left_path->p_node[i].bh); 1799dcd0538fSMark Fasheh if (ret) 1800dcd0538fSMark Fasheh mlog_errno(ret); 1801dcd0538fSMark Fasheh 1802dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, right_path->p_node[i].bh); 1803dcd0538fSMark Fasheh if (ret) 1804dcd0538fSMark Fasheh mlog_errno(ret); 1805dcd0538fSMark Fasheh 1806dcd0538fSMark Fasheh /* 1807dcd0538fSMark Fasheh * Setup our list pointers now so that the current 1808dcd0538fSMark Fasheh * parents become children in the next iteration. 1809dcd0538fSMark Fasheh */ 1810dcd0538fSMark Fasheh left_el = left_path->p_node[i].el; 1811dcd0538fSMark Fasheh right_el = right_path->p_node[i].el; 1812dcd0538fSMark Fasheh } 1813dcd0538fSMark Fasheh 1814dcd0538fSMark Fasheh /* 1815dcd0538fSMark Fasheh * At the root node, adjust the two adjacent records which 1816dcd0538fSMark Fasheh * begin our path to the leaves. 1817dcd0538fSMark Fasheh */ 1818dcd0538fSMark Fasheh 1819dcd0538fSMark Fasheh el = left_path->p_node[subtree_index].el; 1820dcd0538fSMark Fasheh left_el = left_path->p_node[subtree_index + 1].el; 1821dcd0538fSMark Fasheh right_el = right_path->p_node[subtree_index + 1].el; 1822dcd0538fSMark Fasheh 1823dcd0538fSMark Fasheh ocfs2_adjust_root_records(el, left_el, right_el, 1824dcd0538fSMark Fasheh left_path->p_node[subtree_index + 1].bh->b_blocknr); 1825dcd0538fSMark Fasheh 1826dcd0538fSMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 1827dcd0538fSMark Fasheh 1828dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, root_bh); 1829dcd0538fSMark Fasheh if (ret) 1830dcd0538fSMark Fasheh mlog_errno(ret); 1831dcd0538fSMark Fasheh } 1832dcd0538fSMark Fasheh 1833dcd0538fSMark Fasheh static int ocfs2_rotate_subtree_right(struct inode *inode, 1834dcd0538fSMark Fasheh handle_t *handle, 1835dcd0538fSMark Fasheh struct ocfs2_path *left_path, 1836dcd0538fSMark Fasheh struct ocfs2_path *right_path, 1837dcd0538fSMark Fasheh int subtree_index) 1838dcd0538fSMark Fasheh { 1839dcd0538fSMark Fasheh int ret, i; 1840dcd0538fSMark Fasheh struct buffer_head *right_leaf_bh; 1841dcd0538fSMark Fasheh struct buffer_head *left_leaf_bh = NULL; 1842dcd0538fSMark Fasheh struct buffer_head *root_bh; 1843dcd0538fSMark Fasheh struct ocfs2_extent_list *right_el, *left_el; 1844dcd0538fSMark Fasheh struct ocfs2_extent_rec move_rec; 1845dcd0538fSMark Fasheh 1846dcd0538fSMark Fasheh left_leaf_bh = path_leaf_bh(left_path); 1847dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 1848dcd0538fSMark Fasheh 1849dcd0538fSMark Fasheh if (left_el->l_next_free_rec != left_el->l_count) { 1850dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1851dcd0538fSMark Fasheh "Inode %llu has non-full interior leaf node %llu" 1852dcd0538fSMark Fasheh "(next free = %u)", 1853dcd0538fSMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 1854dcd0538fSMark Fasheh (unsigned long long)left_leaf_bh->b_blocknr, 1855dcd0538fSMark Fasheh le16_to_cpu(left_el->l_next_free_rec)); 1856dcd0538fSMark Fasheh return -EROFS; 1857dcd0538fSMark Fasheh } 1858dcd0538fSMark Fasheh 1859dcd0538fSMark Fasheh /* 1860dcd0538fSMark Fasheh * This extent block may already have an empty record, so we 1861dcd0538fSMark Fasheh * return early if so. 1862dcd0538fSMark Fasheh */ 1863dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&left_el->l_recs[0])) 1864dcd0538fSMark Fasheh return 0; 1865dcd0538fSMark Fasheh 1866dcd0538fSMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 1867dcd0538fSMark Fasheh BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 1868dcd0538fSMark Fasheh 1869dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, root_bh, 1870dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1871dcd0538fSMark Fasheh if (ret) { 1872dcd0538fSMark Fasheh mlog_errno(ret); 1873dcd0538fSMark Fasheh goto out; 1874dcd0538fSMark Fasheh } 1875dcd0538fSMark Fasheh 1876dcd0538fSMark Fasheh for(i = subtree_index + 1; i < path_num_items(right_path); i++) { 1877dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, 1878dcd0538fSMark Fasheh right_path->p_node[i].bh, 1879dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1880dcd0538fSMark Fasheh if (ret) { 1881dcd0538fSMark Fasheh mlog_errno(ret); 1882dcd0538fSMark Fasheh goto out; 1883dcd0538fSMark Fasheh } 1884dcd0538fSMark Fasheh 1885dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, 1886dcd0538fSMark Fasheh left_path->p_node[i].bh, 1887dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1888dcd0538fSMark Fasheh if (ret) { 1889dcd0538fSMark Fasheh mlog_errno(ret); 1890dcd0538fSMark Fasheh goto out; 1891dcd0538fSMark Fasheh } 1892dcd0538fSMark Fasheh } 1893dcd0538fSMark Fasheh 1894dcd0538fSMark Fasheh right_leaf_bh = path_leaf_bh(right_path); 1895dcd0538fSMark Fasheh right_el = path_leaf_el(right_path); 1896dcd0538fSMark Fasheh 1897dcd0538fSMark Fasheh /* This is a code error, not a disk corruption. */ 1898dcd0538fSMark Fasheh mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails " 1899dcd0538fSMark Fasheh "because rightmost leaf block %llu is empty\n", 1900dcd0538fSMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 1901dcd0538fSMark Fasheh (unsigned long long)right_leaf_bh->b_blocknr); 1902dcd0538fSMark Fasheh 1903dcd0538fSMark Fasheh ocfs2_create_empty_extent(right_el); 1904dcd0538fSMark Fasheh 1905dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, right_leaf_bh); 1906dcd0538fSMark Fasheh if (ret) { 1907dcd0538fSMark Fasheh mlog_errno(ret); 1908dcd0538fSMark Fasheh goto out; 1909dcd0538fSMark Fasheh } 1910dcd0538fSMark Fasheh 1911dcd0538fSMark Fasheh /* Do the copy now. */ 1912dcd0538fSMark Fasheh i = le16_to_cpu(left_el->l_next_free_rec) - 1; 1913dcd0538fSMark Fasheh move_rec = left_el->l_recs[i]; 1914dcd0538fSMark Fasheh right_el->l_recs[0] = move_rec; 1915dcd0538fSMark Fasheh 1916dcd0538fSMark Fasheh /* 1917dcd0538fSMark Fasheh * Clear out the record we just copied and shift everything 1918dcd0538fSMark Fasheh * over, leaving an empty extent in the left leaf. 1919dcd0538fSMark Fasheh * 1920dcd0538fSMark Fasheh * We temporarily subtract from next_free_rec so that the 1921dcd0538fSMark Fasheh * shift will lose the tail record (which is now defunct). 1922dcd0538fSMark Fasheh */ 1923dcd0538fSMark Fasheh le16_add_cpu(&left_el->l_next_free_rec, -1); 1924dcd0538fSMark Fasheh ocfs2_shift_records_right(left_el); 1925dcd0538fSMark Fasheh memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 1926dcd0538fSMark Fasheh le16_add_cpu(&left_el->l_next_free_rec, 1); 1927dcd0538fSMark Fasheh 1928dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, left_leaf_bh); 1929dcd0538fSMark Fasheh if (ret) { 1930dcd0538fSMark Fasheh mlog_errno(ret); 1931dcd0538fSMark Fasheh goto out; 1932dcd0538fSMark Fasheh } 1933dcd0538fSMark Fasheh 1934dcd0538fSMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, right_path, 1935dcd0538fSMark Fasheh subtree_index); 1936dcd0538fSMark Fasheh 1937dcd0538fSMark Fasheh out: 1938dcd0538fSMark Fasheh return ret; 1939dcd0538fSMark Fasheh } 1940dcd0538fSMark Fasheh 1941dcd0538fSMark Fasheh /* 1942dcd0538fSMark Fasheh * Given a full path, determine what cpos value would return us a path 1943dcd0538fSMark Fasheh * containing the leaf immediately to the left of the current one. 1944dcd0538fSMark Fasheh * 1945dcd0538fSMark Fasheh * Will return zero if the path passed in is already the leftmost path. 1946dcd0538fSMark Fasheh */ 1947dcd0538fSMark Fasheh static int ocfs2_find_cpos_for_left_leaf(struct super_block *sb, 1948dcd0538fSMark Fasheh struct ocfs2_path *path, u32 *cpos) 1949dcd0538fSMark Fasheh { 1950dcd0538fSMark Fasheh int i, j, ret = 0; 1951dcd0538fSMark Fasheh u64 blkno; 1952dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 1953dcd0538fSMark Fasheh 1954e48edee2SMark Fasheh BUG_ON(path->p_tree_depth == 0); 1955e48edee2SMark Fasheh 1956dcd0538fSMark Fasheh *cpos = 0; 1957dcd0538fSMark Fasheh 1958dcd0538fSMark Fasheh blkno = path_leaf_bh(path)->b_blocknr; 1959dcd0538fSMark Fasheh 1960dcd0538fSMark Fasheh /* Start at the tree node just above the leaf and work our way up. */ 1961dcd0538fSMark Fasheh i = path->p_tree_depth - 1; 1962dcd0538fSMark Fasheh while (i >= 0) { 1963dcd0538fSMark Fasheh el = path->p_node[i].el; 1964dcd0538fSMark Fasheh 1965dcd0538fSMark Fasheh /* 1966dcd0538fSMark Fasheh * Find the extent record just before the one in our 1967dcd0538fSMark Fasheh * path. 1968dcd0538fSMark Fasheh */ 1969dcd0538fSMark Fasheh for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) { 1970dcd0538fSMark Fasheh if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) { 1971dcd0538fSMark Fasheh if (j == 0) { 1972dcd0538fSMark Fasheh if (i == 0) { 1973dcd0538fSMark Fasheh /* 1974dcd0538fSMark Fasheh * We've determined that the 1975dcd0538fSMark Fasheh * path specified is already 1976dcd0538fSMark Fasheh * the leftmost one - return a 1977dcd0538fSMark Fasheh * cpos of zero. 1978dcd0538fSMark Fasheh */ 1979dcd0538fSMark Fasheh goto out; 1980dcd0538fSMark Fasheh } 1981dcd0538fSMark Fasheh /* 1982dcd0538fSMark Fasheh * The leftmost record points to our 1983dcd0538fSMark Fasheh * leaf - we need to travel up the 1984dcd0538fSMark Fasheh * tree one level. 1985dcd0538fSMark Fasheh */ 1986dcd0538fSMark Fasheh goto next_node; 1987dcd0538fSMark Fasheh } 1988dcd0538fSMark Fasheh 1989dcd0538fSMark Fasheh *cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos); 1990e48edee2SMark Fasheh *cpos = *cpos + ocfs2_rec_clusters(el, 1991e48edee2SMark Fasheh &el->l_recs[j - 1]); 1992e48edee2SMark Fasheh *cpos = *cpos - 1; 1993dcd0538fSMark Fasheh goto out; 1994dcd0538fSMark Fasheh } 1995dcd0538fSMark Fasheh } 1996dcd0538fSMark Fasheh 1997dcd0538fSMark Fasheh /* 1998dcd0538fSMark Fasheh * If we got here, we never found a valid node where 1999dcd0538fSMark Fasheh * the tree indicated one should be. 2000dcd0538fSMark Fasheh */ 2001dcd0538fSMark Fasheh ocfs2_error(sb, 2002dcd0538fSMark Fasheh "Invalid extent tree at extent block %llu\n", 2003dcd0538fSMark Fasheh (unsigned long long)blkno); 2004dcd0538fSMark Fasheh ret = -EROFS; 2005dcd0538fSMark Fasheh goto out; 2006dcd0538fSMark Fasheh 2007dcd0538fSMark Fasheh next_node: 2008dcd0538fSMark Fasheh blkno = path->p_node[i].bh->b_blocknr; 2009dcd0538fSMark Fasheh i--; 2010dcd0538fSMark Fasheh } 2011dcd0538fSMark Fasheh 2012dcd0538fSMark Fasheh out: 2013dcd0538fSMark Fasheh return ret; 2014dcd0538fSMark Fasheh } 2015dcd0538fSMark Fasheh 2016328d5752SMark Fasheh /* 2017328d5752SMark Fasheh * Extend the transaction by enough credits to complete the rotation, 2018328d5752SMark Fasheh * and still leave at least the original number of credits allocated 2019328d5752SMark Fasheh * to this transaction. 2020328d5752SMark Fasheh */ 2021dcd0538fSMark Fasheh static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth, 2022328d5752SMark Fasheh int op_credits, 2023dcd0538fSMark Fasheh struct ocfs2_path *path) 2024dcd0538fSMark Fasheh { 2025328d5752SMark Fasheh int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits; 2026dcd0538fSMark Fasheh 2027dcd0538fSMark Fasheh if (handle->h_buffer_credits < credits) 2028dcd0538fSMark Fasheh return ocfs2_extend_trans(handle, credits); 2029dcd0538fSMark Fasheh 2030dcd0538fSMark Fasheh return 0; 2031dcd0538fSMark Fasheh } 2032dcd0538fSMark Fasheh 2033dcd0538fSMark Fasheh /* 2034dcd0538fSMark Fasheh * Trap the case where we're inserting into the theoretical range past 2035dcd0538fSMark Fasheh * the _actual_ left leaf range. Otherwise, we'll rotate a record 2036dcd0538fSMark Fasheh * whose cpos is less than ours into the right leaf. 2037dcd0538fSMark Fasheh * 2038dcd0538fSMark Fasheh * It's only necessary to look at the rightmost record of the left 2039dcd0538fSMark Fasheh * leaf because the logic that calls us should ensure that the 2040dcd0538fSMark Fasheh * theoretical ranges in the path components above the leaves are 2041dcd0538fSMark Fasheh * correct. 2042dcd0538fSMark Fasheh */ 2043dcd0538fSMark Fasheh static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path, 2044dcd0538fSMark Fasheh u32 insert_cpos) 2045dcd0538fSMark Fasheh { 2046dcd0538fSMark Fasheh struct ocfs2_extent_list *left_el; 2047dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 2048dcd0538fSMark Fasheh int next_free; 2049dcd0538fSMark Fasheh 2050dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 2051dcd0538fSMark Fasheh next_free = le16_to_cpu(left_el->l_next_free_rec); 2052dcd0538fSMark Fasheh rec = &left_el->l_recs[next_free - 1]; 2053dcd0538fSMark Fasheh 2054dcd0538fSMark Fasheh if (insert_cpos > le32_to_cpu(rec->e_cpos)) 2055dcd0538fSMark Fasheh return 1; 2056dcd0538fSMark Fasheh return 0; 2057dcd0538fSMark Fasheh } 2058dcd0538fSMark Fasheh 2059328d5752SMark Fasheh static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos) 2060328d5752SMark Fasheh { 2061328d5752SMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 2062328d5752SMark Fasheh unsigned int range; 2063328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 2064328d5752SMark Fasheh 2065328d5752SMark Fasheh if (next_free == 0) 2066328d5752SMark Fasheh return 0; 2067328d5752SMark Fasheh 2068328d5752SMark Fasheh rec = &el->l_recs[0]; 2069328d5752SMark Fasheh if (ocfs2_is_empty_extent(rec)) { 2070328d5752SMark Fasheh /* Empty list. */ 2071328d5752SMark Fasheh if (next_free == 1) 2072328d5752SMark Fasheh return 0; 2073328d5752SMark Fasheh rec = &el->l_recs[1]; 2074328d5752SMark Fasheh } 2075328d5752SMark Fasheh 2076328d5752SMark Fasheh range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 2077328d5752SMark Fasheh if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range) 2078328d5752SMark Fasheh return 1; 2079328d5752SMark Fasheh return 0; 2080328d5752SMark Fasheh } 2081328d5752SMark Fasheh 2082dcd0538fSMark Fasheh /* 2083dcd0538fSMark Fasheh * Rotate all the records in a btree right one record, starting at insert_cpos. 2084dcd0538fSMark Fasheh * 2085dcd0538fSMark Fasheh * The path to the rightmost leaf should be passed in. 2086dcd0538fSMark Fasheh * 2087dcd0538fSMark Fasheh * The array is assumed to be large enough to hold an entire path (tree depth). 2088dcd0538fSMark Fasheh * 2089dcd0538fSMark Fasheh * Upon succesful return from this function: 2090dcd0538fSMark Fasheh * 2091dcd0538fSMark Fasheh * - The 'right_path' array will contain a path to the leaf block 2092dcd0538fSMark Fasheh * whose range contains e_cpos. 2093dcd0538fSMark Fasheh * - That leaf block will have a single empty extent in list index 0. 2094dcd0538fSMark Fasheh * - In the case that the rotation requires a post-insert update, 2095dcd0538fSMark Fasheh * *ret_left_path will contain a valid path which can be passed to 2096dcd0538fSMark Fasheh * ocfs2_insert_path(). 2097dcd0538fSMark Fasheh */ 2098dcd0538fSMark Fasheh static int ocfs2_rotate_tree_right(struct inode *inode, 2099dcd0538fSMark Fasheh handle_t *handle, 2100328d5752SMark Fasheh enum ocfs2_split_type split, 2101dcd0538fSMark Fasheh u32 insert_cpos, 2102dcd0538fSMark Fasheh struct ocfs2_path *right_path, 2103dcd0538fSMark Fasheh struct ocfs2_path **ret_left_path) 2104dcd0538fSMark Fasheh { 2105328d5752SMark Fasheh int ret, start, orig_credits = handle->h_buffer_credits; 2106dcd0538fSMark Fasheh u32 cpos; 2107dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 2108dcd0538fSMark Fasheh 2109dcd0538fSMark Fasheh *ret_left_path = NULL; 2110dcd0538fSMark Fasheh 2111dcd0538fSMark Fasheh left_path = ocfs2_new_path(path_root_bh(right_path), 2112dcd0538fSMark Fasheh path_root_el(right_path)); 2113dcd0538fSMark Fasheh if (!left_path) { 2114dcd0538fSMark Fasheh ret = -ENOMEM; 2115dcd0538fSMark Fasheh mlog_errno(ret); 2116dcd0538fSMark Fasheh goto out; 2117dcd0538fSMark Fasheh } 2118dcd0538fSMark Fasheh 2119dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, &cpos); 2120dcd0538fSMark Fasheh if (ret) { 2121dcd0538fSMark Fasheh mlog_errno(ret); 2122dcd0538fSMark Fasheh goto out; 2123dcd0538fSMark Fasheh } 2124dcd0538fSMark Fasheh 2125dcd0538fSMark Fasheh mlog(0, "Insert: %u, first left path cpos: %u\n", insert_cpos, cpos); 2126dcd0538fSMark Fasheh 2127dcd0538fSMark Fasheh /* 2128dcd0538fSMark Fasheh * What we want to do here is: 2129dcd0538fSMark Fasheh * 2130dcd0538fSMark Fasheh * 1) Start with the rightmost path. 2131dcd0538fSMark Fasheh * 2132dcd0538fSMark Fasheh * 2) Determine a path to the leaf block directly to the left 2133dcd0538fSMark Fasheh * of that leaf. 2134dcd0538fSMark Fasheh * 2135dcd0538fSMark Fasheh * 3) Determine the 'subtree root' - the lowest level tree node 2136dcd0538fSMark Fasheh * which contains a path to both leaves. 2137dcd0538fSMark Fasheh * 2138dcd0538fSMark Fasheh * 4) Rotate the subtree. 2139dcd0538fSMark Fasheh * 2140dcd0538fSMark Fasheh * 5) Find the next subtree by considering the left path to be 2141dcd0538fSMark Fasheh * the new right path. 2142dcd0538fSMark Fasheh * 2143dcd0538fSMark Fasheh * The check at the top of this while loop also accepts 2144dcd0538fSMark Fasheh * insert_cpos == cpos because cpos is only a _theoretical_ 2145dcd0538fSMark Fasheh * value to get us the left path - insert_cpos might very well 2146dcd0538fSMark Fasheh * be filling that hole. 2147dcd0538fSMark Fasheh * 2148dcd0538fSMark Fasheh * Stop at a cpos of '0' because we either started at the 2149dcd0538fSMark Fasheh * leftmost branch (i.e., a tree with one branch and a 2150dcd0538fSMark Fasheh * rotation inside of it), or we've gone as far as we can in 2151dcd0538fSMark Fasheh * rotating subtrees. 2152dcd0538fSMark Fasheh */ 2153dcd0538fSMark Fasheh while (cpos && insert_cpos <= cpos) { 2154dcd0538fSMark Fasheh mlog(0, "Rotating a tree: ins. cpos: %u, left path cpos: %u\n", 2155dcd0538fSMark Fasheh insert_cpos, cpos); 2156dcd0538fSMark Fasheh 2157dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 2158dcd0538fSMark Fasheh if (ret) { 2159dcd0538fSMark Fasheh mlog_errno(ret); 2160dcd0538fSMark Fasheh goto out; 2161dcd0538fSMark Fasheh } 2162dcd0538fSMark Fasheh 2163dcd0538fSMark Fasheh mlog_bug_on_msg(path_leaf_bh(left_path) == 2164dcd0538fSMark Fasheh path_leaf_bh(right_path), 2165dcd0538fSMark Fasheh "Inode %lu: error during insert of %u " 2166dcd0538fSMark Fasheh "(left path cpos %u) results in two identical " 2167dcd0538fSMark Fasheh "paths ending at %llu\n", 2168dcd0538fSMark Fasheh inode->i_ino, insert_cpos, cpos, 2169dcd0538fSMark Fasheh (unsigned long long) 2170dcd0538fSMark Fasheh path_leaf_bh(left_path)->b_blocknr); 2171dcd0538fSMark Fasheh 2172328d5752SMark Fasheh if (split == SPLIT_NONE && 2173328d5752SMark Fasheh ocfs2_rotate_requires_path_adjustment(left_path, 2174dcd0538fSMark Fasheh insert_cpos)) { 2175dcd0538fSMark Fasheh 2176dcd0538fSMark Fasheh /* 2177dcd0538fSMark Fasheh * We've rotated the tree as much as we 2178dcd0538fSMark Fasheh * should. The rest is up to 2179dcd0538fSMark Fasheh * ocfs2_insert_path() to complete, after the 2180dcd0538fSMark Fasheh * record insertion. We indicate this 2181dcd0538fSMark Fasheh * situation by returning the left path. 2182dcd0538fSMark Fasheh * 2183dcd0538fSMark Fasheh * The reason we don't adjust the records here 2184dcd0538fSMark Fasheh * before the record insert is that an error 2185dcd0538fSMark Fasheh * later might break the rule where a parent 2186dcd0538fSMark Fasheh * record e_cpos will reflect the actual 2187dcd0538fSMark Fasheh * e_cpos of the 1st nonempty record of the 2188dcd0538fSMark Fasheh * child list. 2189dcd0538fSMark Fasheh */ 2190dcd0538fSMark Fasheh *ret_left_path = left_path; 2191dcd0538fSMark Fasheh goto out_ret_path; 2192dcd0538fSMark Fasheh } 2193dcd0538fSMark Fasheh 2194dcd0538fSMark Fasheh start = ocfs2_find_subtree_root(inode, left_path, right_path); 2195dcd0538fSMark Fasheh 2196dcd0538fSMark Fasheh mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n", 2197dcd0538fSMark Fasheh start, 2198dcd0538fSMark Fasheh (unsigned long long) right_path->p_node[start].bh->b_blocknr, 2199dcd0538fSMark Fasheh right_path->p_tree_depth); 2200dcd0538fSMark Fasheh 2201dcd0538fSMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, start, 2202328d5752SMark Fasheh orig_credits, right_path); 2203dcd0538fSMark Fasheh if (ret) { 2204dcd0538fSMark Fasheh mlog_errno(ret); 2205dcd0538fSMark Fasheh goto out; 2206dcd0538fSMark Fasheh } 2207dcd0538fSMark Fasheh 2208dcd0538fSMark Fasheh ret = ocfs2_rotate_subtree_right(inode, handle, left_path, 2209dcd0538fSMark Fasheh right_path, start); 2210dcd0538fSMark Fasheh if (ret) { 2211dcd0538fSMark Fasheh mlog_errno(ret); 2212dcd0538fSMark Fasheh goto out; 2213dcd0538fSMark Fasheh } 2214dcd0538fSMark Fasheh 2215328d5752SMark Fasheh if (split != SPLIT_NONE && 2216328d5752SMark Fasheh ocfs2_leftmost_rec_contains(path_leaf_el(right_path), 2217328d5752SMark Fasheh insert_cpos)) { 2218328d5752SMark Fasheh /* 2219328d5752SMark Fasheh * A rotate moves the rightmost left leaf 2220328d5752SMark Fasheh * record over to the leftmost right leaf 2221328d5752SMark Fasheh * slot. If we're doing an extent split 2222328d5752SMark Fasheh * instead of a real insert, then we have to 2223328d5752SMark Fasheh * check that the extent to be split wasn't 2224328d5752SMark Fasheh * just moved over. If it was, then we can 2225328d5752SMark Fasheh * exit here, passing left_path back - 2226328d5752SMark Fasheh * ocfs2_split_extent() is smart enough to 2227328d5752SMark Fasheh * search both leaves. 2228328d5752SMark Fasheh */ 2229328d5752SMark Fasheh *ret_left_path = left_path; 2230328d5752SMark Fasheh goto out_ret_path; 2231328d5752SMark Fasheh } 2232328d5752SMark Fasheh 2233dcd0538fSMark Fasheh /* 2234dcd0538fSMark Fasheh * There is no need to re-read the next right path 2235dcd0538fSMark Fasheh * as we know that it'll be our current left 2236dcd0538fSMark Fasheh * path. Optimize by copying values instead. 2237dcd0538fSMark Fasheh */ 2238dcd0538fSMark Fasheh ocfs2_mv_path(right_path, left_path); 2239dcd0538fSMark Fasheh 2240dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, 2241dcd0538fSMark Fasheh &cpos); 2242dcd0538fSMark Fasheh if (ret) { 2243dcd0538fSMark Fasheh mlog_errno(ret); 2244dcd0538fSMark Fasheh goto out; 2245dcd0538fSMark Fasheh } 2246dcd0538fSMark Fasheh } 2247dcd0538fSMark Fasheh 2248dcd0538fSMark Fasheh out: 2249dcd0538fSMark Fasheh ocfs2_free_path(left_path); 2250dcd0538fSMark Fasheh 2251dcd0538fSMark Fasheh out_ret_path: 2252dcd0538fSMark Fasheh return ret; 2253dcd0538fSMark Fasheh } 2254dcd0538fSMark Fasheh 2255328d5752SMark Fasheh static void ocfs2_update_edge_lengths(struct inode *inode, handle_t *handle, 2256328d5752SMark Fasheh struct ocfs2_path *path) 2257328d5752SMark Fasheh { 2258328d5752SMark Fasheh int i, idx; 2259328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 2260328d5752SMark Fasheh struct ocfs2_extent_list *el; 2261328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2262328d5752SMark Fasheh u32 range; 2263328d5752SMark Fasheh 2264328d5752SMark Fasheh /* Path should always be rightmost. */ 2265328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 2266328d5752SMark Fasheh BUG_ON(eb->h_next_leaf_blk != 0ULL); 2267328d5752SMark Fasheh 2268328d5752SMark Fasheh el = &eb->h_list; 2269328d5752SMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0); 2270328d5752SMark Fasheh idx = le16_to_cpu(el->l_next_free_rec) - 1; 2271328d5752SMark Fasheh rec = &el->l_recs[idx]; 2272328d5752SMark Fasheh range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 2273328d5752SMark Fasheh 2274328d5752SMark Fasheh for (i = 0; i < path->p_tree_depth; i++) { 2275328d5752SMark Fasheh el = path->p_node[i].el; 2276328d5752SMark Fasheh idx = le16_to_cpu(el->l_next_free_rec) - 1; 2277328d5752SMark Fasheh rec = &el->l_recs[idx]; 2278328d5752SMark Fasheh 2279328d5752SMark Fasheh rec->e_int_clusters = cpu_to_le32(range); 2280328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos)); 2281328d5752SMark Fasheh 2282328d5752SMark Fasheh ocfs2_journal_dirty(handle, path->p_node[i].bh); 2283328d5752SMark Fasheh } 2284328d5752SMark Fasheh } 2285328d5752SMark Fasheh 2286328d5752SMark Fasheh static void ocfs2_unlink_path(struct inode *inode, handle_t *handle, 2287328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2288328d5752SMark Fasheh struct ocfs2_path *path, int unlink_start) 2289328d5752SMark Fasheh { 2290328d5752SMark Fasheh int ret, i; 2291328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2292328d5752SMark Fasheh struct ocfs2_extent_list *el; 2293328d5752SMark Fasheh struct buffer_head *bh; 2294328d5752SMark Fasheh 2295328d5752SMark Fasheh for(i = unlink_start; i < path_num_items(path); i++) { 2296328d5752SMark Fasheh bh = path->p_node[i].bh; 2297328d5752SMark Fasheh 2298328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)bh->b_data; 2299328d5752SMark Fasheh /* 2300328d5752SMark Fasheh * Not all nodes might have had their final count 2301328d5752SMark Fasheh * decremented by the caller - handle this here. 2302328d5752SMark Fasheh */ 2303328d5752SMark Fasheh el = &eb->h_list; 2304328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1) { 2305328d5752SMark Fasheh mlog(ML_ERROR, 2306328d5752SMark Fasheh "Inode %llu, attempted to remove extent block " 2307328d5752SMark Fasheh "%llu with %u records\n", 2308328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 2309328d5752SMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno), 2310328d5752SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 2311328d5752SMark Fasheh 2312328d5752SMark Fasheh ocfs2_journal_dirty(handle, bh); 2313328d5752SMark Fasheh ocfs2_remove_from_cache(inode, bh); 2314328d5752SMark Fasheh continue; 2315328d5752SMark Fasheh } 2316328d5752SMark Fasheh 2317328d5752SMark Fasheh el->l_next_free_rec = 0; 2318328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 2319328d5752SMark Fasheh 2320328d5752SMark Fasheh ocfs2_journal_dirty(handle, bh); 2321328d5752SMark Fasheh 2322328d5752SMark Fasheh ret = ocfs2_cache_extent_block_free(dealloc, eb); 2323328d5752SMark Fasheh if (ret) 2324328d5752SMark Fasheh mlog_errno(ret); 2325328d5752SMark Fasheh 2326328d5752SMark Fasheh ocfs2_remove_from_cache(inode, bh); 2327328d5752SMark Fasheh } 2328328d5752SMark Fasheh } 2329328d5752SMark Fasheh 2330328d5752SMark Fasheh static void ocfs2_unlink_subtree(struct inode *inode, handle_t *handle, 2331328d5752SMark Fasheh struct ocfs2_path *left_path, 2332328d5752SMark Fasheh struct ocfs2_path *right_path, 2333328d5752SMark Fasheh int subtree_index, 2334328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc) 2335328d5752SMark Fasheh { 2336328d5752SMark Fasheh int i; 2337328d5752SMark Fasheh struct buffer_head *root_bh = left_path->p_node[subtree_index].bh; 2338328d5752SMark Fasheh struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el; 2339328d5752SMark Fasheh struct ocfs2_extent_list *el; 2340328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2341328d5752SMark Fasheh 2342328d5752SMark Fasheh el = path_leaf_el(left_path); 2343328d5752SMark Fasheh 2344328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data; 2345328d5752SMark Fasheh 2346328d5752SMark Fasheh for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++) 2347328d5752SMark Fasheh if (root_el->l_recs[i].e_blkno == eb->h_blkno) 2348328d5752SMark Fasheh break; 2349328d5752SMark Fasheh 2350328d5752SMark Fasheh BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec)); 2351328d5752SMark Fasheh 2352328d5752SMark Fasheh memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec)); 2353328d5752SMark Fasheh le16_add_cpu(&root_el->l_next_free_rec, -1); 2354328d5752SMark Fasheh 2355328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 2356328d5752SMark Fasheh eb->h_next_leaf_blk = 0; 2357328d5752SMark Fasheh 2358328d5752SMark Fasheh ocfs2_journal_dirty(handle, root_bh); 2359328d5752SMark Fasheh ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 2360328d5752SMark Fasheh 2361328d5752SMark Fasheh ocfs2_unlink_path(inode, handle, dealloc, right_path, 2362328d5752SMark Fasheh subtree_index + 1); 2363328d5752SMark Fasheh } 2364328d5752SMark Fasheh 2365328d5752SMark Fasheh static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle, 2366328d5752SMark Fasheh struct ocfs2_path *left_path, 2367328d5752SMark Fasheh struct ocfs2_path *right_path, 2368328d5752SMark Fasheh int subtree_index, 2369328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2370e7d4cb6bSTao Ma int *deleted, 2371e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2372328d5752SMark Fasheh { 2373328d5752SMark Fasheh int ret, i, del_right_subtree = 0, right_has_empty = 0; 2374e7d4cb6bSTao Ma struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path); 2375328d5752SMark Fasheh struct ocfs2_extent_list *right_leaf_el, *left_leaf_el; 2376328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2377328d5752SMark Fasheh 2378328d5752SMark Fasheh *deleted = 0; 2379328d5752SMark Fasheh 2380328d5752SMark Fasheh right_leaf_el = path_leaf_el(right_path); 2381328d5752SMark Fasheh left_leaf_el = path_leaf_el(left_path); 2382328d5752SMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 2383328d5752SMark Fasheh BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 2384328d5752SMark Fasheh 2385328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0])) 2386328d5752SMark Fasheh return 0; 2387328d5752SMark Fasheh 2388328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data; 2389328d5752SMark Fasheh if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) { 2390328d5752SMark Fasheh /* 2391328d5752SMark Fasheh * It's legal for us to proceed if the right leaf is 2392328d5752SMark Fasheh * the rightmost one and it has an empty extent. There 2393328d5752SMark Fasheh * are two cases to handle - whether the leaf will be 2394328d5752SMark Fasheh * empty after removal or not. If the leaf isn't empty 2395328d5752SMark Fasheh * then just remove the empty extent up front. The 2396328d5752SMark Fasheh * next block will handle empty leaves by flagging 2397328d5752SMark Fasheh * them for unlink. 2398328d5752SMark Fasheh * 2399328d5752SMark Fasheh * Non rightmost leaves will throw -EAGAIN and the 2400328d5752SMark Fasheh * caller can manually move the subtree and retry. 2401328d5752SMark Fasheh */ 2402328d5752SMark Fasheh 2403328d5752SMark Fasheh if (eb->h_next_leaf_blk != 0ULL) 2404328d5752SMark Fasheh return -EAGAIN; 2405328d5752SMark Fasheh 2406328d5752SMark Fasheh if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) { 2407328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2408328d5752SMark Fasheh path_leaf_bh(right_path), 2409328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2410328d5752SMark Fasheh if (ret) { 2411328d5752SMark Fasheh mlog_errno(ret); 2412328d5752SMark Fasheh goto out; 2413328d5752SMark Fasheh } 2414328d5752SMark Fasheh 2415328d5752SMark Fasheh ocfs2_remove_empty_extent(right_leaf_el); 2416328d5752SMark Fasheh } else 2417328d5752SMark Fasheh right_has_empty = 1; 2418328d5752SMark Fasheh } 2419328d5752SMark Fasheh 2420328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0ULL && 2421328d5752SMark Fasheh le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) { 2422328d5752SMark Fasheh /* 2423328d5752SMark Fasheh * We have to update i_last_eb_blk during the meta 2424328d5752SMark Fasheh * data delete. 2425328d5752SMark Fasheh */ 2426e7d4cb6bSTao Ma ret = ocfs2_journal_access(handle, inode, et_root_bh, 2427328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2428328d5752SMark Fasheh if (ret) { 2429328d5752SMark Fasheh mlog_errno(ret); 2430328d5752SMark Fasheh goto out; 2431328d5752SMark Fasheh } 2432328d5752SMark Fasheh 2433328d5752SMark Fasheh del_right_subtree = 1; 2434328d5752SMark Fasheh } 2435328d5752SMark Fasheh 2436328d5752SMark Fasheh /* 2437328d5752SMark Fasheh * Getting here with an empty extent in the right path implies 2438328d5752SMark Fasheh * that it's the rightmost path and will be deleted. 2439328d5752SMark Fasheh */ 2440328d5752SMark Fasheh BUG_ON(right_has_empty && !del_right_subtree); 2441328d5752SMark Fasheh 2442328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, root_bh, 2443328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2444328d5752SMark Fasheh if (ret) { 2445328d5752SMark Fasheh mlog_errno(ret); 2446328d5752SMark Fasheh goto out; 2447328d5752SMark Fasheh } 2448328d5752SMark Fasheh 2449328d5752SMark Fasheh for(i = subtree_index + 1; i < path_num_items(right_path); i++) { 2450328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2451328d5752SMark Fasheh right_path->p_node[i].bh, 2452328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2453328d5752SMark Fasheh if (ret) { 2454328d5752SMark Fasheh mlog_errno(ret); 2455328d5752SMark Fasheh goto out; 2456328d5752SMark Fasheh } 2457328d5752SMark Fasheh 2458328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2459328d5752SMark Fasheh left_path->p_node[i].bh, 2460328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2461328d5752SMark Fasheh if (ret) { 2462328d5752SMark Fasheh mlog_errno(ret); 2463328d5752SMark Fasheh goto out; 2464328d5752SMark Fasheh } 2465328d5752SMark Fasheh } 2466328d5752SMark Fasheh 2467328d5752SMark Fasheh if (!right_has_empty) { 2468328d5752SMark Fasheh /* 2469328d5752SMark Fasheh * Only do this if we're moving a real 2470328d5752SMark Fasheh * record. Otherwise, the action is delayed until 2471328d5752SMark Fasheh * after removal of the right path in which case we 2472328d5752SMark Fasheh * can do a simple shift to remove the empty extent. 2473328d5752SMark Fasheh */ 2474328d5752SMark Fasheh ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]); 2475328d5752SMark Fasheh memset(&right_leaf_el->l_recs[0], 0, 2476328d5752SMark Fasheh sizeof(struct ocfs2_extent_rec)); 2477328d5752SMark Fasheh } 2478328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0ULL) { 2479328d5752SMark Fasheh /* 2480328d5752SMark Fasheh * Move recs over to get rid of empty extent, decrease 2481328d5752SMark Fasheh * next_free. This is allowed to remove the last 2482328d5752SMark Fasheh * extent in our leaf (setting l_next_free_rec to 2483328d5752SMark Fasheh * zero) - the delete code below won't care. 2484328d5752SMark Fasheh */ 2485328d5752SMark Fasheh ocfs2_remove_empty_extent(right_leaf_el); 2486328d5752SMark Fasheh } 2487328d5752SMark Fasheh 2488328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 2489328d5752SMark Fasheh if (ret) 2490328d5752SMark Fasheh mlog_errno(ret); 2491328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path)); 2492328d5752SMark Fasheh if (ret) 2493328d5752SMark Fasheh mlog_errno(ret); 2494328d5752SMark Fasheh 2495328d5752SMark Fasheh if (del_right_subtree) { 2496328d5752SMark Fasheh ocfs2_unlink_subtree(inode, handle, left_path, right_path, 2497328d5752SMark Fasheh subtree_index, dealloc); 2498328d5752SMark Fasheh ocfs2_update_edge_lengths(inode, handle, left_path); 2499328d5752SMark Fasheh 2500328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 250135dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 2502328d5752SMark Fasheh 2503328d5752SMark Fasheh /* 2504328d5752SMark Fasheh * Removal of the extent in the left leaf was skipped 2505328d5752SMark Fasheh * above so we could delete the right path 2506328d5752SMark Fasheh * 1st. 2507328d5752SMark Fasheh */ 2508328d5752SMark Fasheh if (right_has_empty) 2509328d5752SMark Fasheh ocfs2_remove_empty_extent(left_leaf_el); 2510328d5752SMark Fasheh 2511e7d4cb6bSTao Ma ret = ocfs2_journal_dirty(handle, et_root_bh); 2512328d5752SMark Fasheh if (ret) 2513328d5752SMark Fasheh mlog_errno(ret); 2514328d5752SMark Fasheh 2515328d5752SMark Fasheh *deleted = 1; 2516328d5752SMark Fasheh } else 2517328d5752SMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, right_path, 2518328d5752SMark Fasheh subtree_index); 2519328d5752SMark Fasheh 2520328d5752SMark Fasheh out: 2521328d5752SMark Fasheh return ret; 2522328d5752SMark Fasheh } 2523328d5752SMark Fasheh 2524328d5752SMark Fasheh /* 2525328d5752SMark Fasheh * Given a full path, determine what cpos value would return us a path 2526328d5752SMark Fasheh * containing the leaf immediately to the right of the current one. 2527328d5752SMark Fasheh * 2528328d5752SMark Fasheh * Will return zero if the path passed in is already the rightmost path. 2529328d5752SMark Fasheh * 2530328d5752SMark Fasheh * This looks similar, but is subtly different to 2531328d5752SMark Fasheh * ocfs2_find_cpos_for_left_leaf(). 2532328d5752SMark Fasheh */ 2533328d5752SMark Fasheh static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb, 2534328d5752SMark Fasheh struct ocfs2_path *path, u32 *cpos) 2535328d5752SMark Fasheh { 2536328d5752SMark Fasheh int i, j, ret = 0; 2537328d5752SMark Fasheh u64 blkno; 2538328d5752SMark Fasheh struct ocfs2_extent_list *el; 2539328d5752SMark Fasheh 2540328d5752SMark Fasheh *cpos = 0; 2541328d5752SMark Fasheh 2542328d5752SMark Fasheh if (path->p_tree_depth == 0) 2543328d5752SMark Fasheh return 0; 2544328d5752SMark Fasheh 2545328d5752SMark Fasheh blkno = path_leaf_bh(path)->b_blocknr; 2546328d5752SMark Fasheh 2547328d5752SMark Fasheh /* Start at the tree node just above the leaf and work our way up. */ 2548328d5752SMark Fasheh i = path->p_tree_depth - 1; 2549328d5752SMark Fasheh while (i >= 0) { 2550328d5752SMark Fasheh int next_free; 2551328d5752SMark Fasheh 2552328d5752SMark Fasheh el = path->p_node[i].el; 2553328d5752SMark Fasheh 2554328d5752SMark Fasheh /* 2555328d5752SMark Fasheh * Find the extent record just after the one in our 2556328d5752SMark Fasheh * path. 2557328d5752SMark Fasheh */ 2558328d5752SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 2559328d5752SMark Fasheh for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) { 2560328d5752SMark Fasheh if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) { 2561328d5752SMark Fasheh if (j == (next_free - 1)) { 2562328d5752SMark Fasheh if (i == 0) { 2563328d5752SMark Fasheh /* 2564328d5752SMark Fasheh * We've determined that the 2565328d5752SMark Fasheh * path specified is already 2566328d5752SMark Fasheh * the rightmost one - return a 2567328d5752SMark Fasheh * cpos of zero. 2568328d5752SMark Fasheh */ 2569328d5752SMark Fasheh goto out; 2570328d5752SMark Fasheh } 2571328d5752SMark Fasheh /* 2572328d5752SMark Fasheh * The rightmost record points to our 2573328d5752SMark Fasheh * leaf - we need to travel up the 2574328d5752SMark Fasheh * tree one level. 2575328d5752SMark Fasheh */ 2576328d5752SMark Fasheh goto next_node; 2577328d5752SMark Fasheh } 2578328d5752SMark Fasheh 2579328d5752SMark Fasheh *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos); 2580328d5752SMark Fasheh goto out; 2581328d5752SMark Fasheh } 2582328d5752SMark Fasheh } 2583328d5752SMark Fasheh 2584328d5752SMark Fasheh /* 2585328d5752SMark Fasheh * If we got here, we never found a valid node where 2586328d5752SMark Fasheh * the tree indicated one should be. 2587328d5752SMark Fasheh */ 2588328d5752SMark Fasheh ocfs2_error(sb, 2589328d5752SMark Fasheh "Invalid extent tree at extent block %llu\n", 2590328d5752SMark Fasheh (unsigned long long)blkno); 2591328d5752SMark Fasheh ret = -EROFS; 2592328d5752SMark Fasheh goto out; 2593328d5752SMark Fasheh 2594328d5752SMark Fasheh next_node: 2595328d5752SMark Fasheh blkno = path->p_node[i].bh->b_blocknr; 2596328d5752SMark Fasheh i--; 2597328d5752SMark Fasheh } 2598328d5752SMark Fasheh 2599328d5752SMark Fasheh out: 2600328d5752SMark Fasheh return ret; 2601328d5752SMark Fasheh } 2602328d5752SMark Fasheh 2603328d5752SMark Fasheh static int ocfs2_rotate_rightmost_leaf_left(struct inode *inode, 2604328d5752SMark Fasheh handle_t *handle, 2605328d5752SMark Fasheh struct buffer_head *bh, 2606328d5752SMark Fasheh struct ocfs2_extent_list *el) 2607328d5752SMark Fasheh { 2608328d5752SMark Fasheh int ret; 2609328d5752SMark Fasheh 2610328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&el->l_recs[0])) 2611328d5752SMark Fasheh return 0; 2612328d5752SMark Fasheh 2613328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 2614328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2615328d5752SMark Fasheh if (ret) { 2616328d5752SMark Fasheh mlog_errno(ret); 2617328d5752SMark Fasheh goto out; 2618328d5752SMark Fasheh } 2619328d5752SMark Fasheh 2620328d5752SMark Fasheh ocfs2_remove_empty_extent(el); 2621328d5752SMark Fasheh 2622328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 2623328d5752SMark Fasheh if (ret) 2624328d5752SMark Fasheh mlog_errno(ret); 2625328d5752SMark Fasheh 2626328d5752SMark Fasheh out: 2627328d5752SMark Fasheh return ret; 2628328d5752SMark Fasheh } 2629328d5752SMark Fasheh 2630328d5752SMark Fasheh static int __ocfs2_rotate_tree_left(struct inode *inode, 2631328d5752SMark Fasheh handle_t *handle, int orig_credits, 2632328d5752SMark Fasheh struct ocfs2_path *path, 2633328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2634e7d4cb6bSTao Ma struct ocfs2_path **empty_extent_path, 2635e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2636328d5752SMark Fasheh { 2637328d5752SMark Fasheh int ret, subtree_root, deleted; 2638328d5752SMark Fasheh u32 right_cpos; 2639328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 2640328d5752SMark Fasheh struct ocfs2_path *right_path = NULL; 2641328d5752SMark Fasheh 2642328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0]))); 2643328d5752SMark Fasheh 2644328d5752SMark Fasheh *empty_extent_path = NULL; 2645328d5752SMark Fasheh 2646328d5752SMark Fasheh ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, path, 2647328d5752SMark Fasheh &right_cpos); 2648328d5752SMark Fasheh if (ret) { 2649328d5752SMark Fasheh mlog_errno(ret); 2650328d5752SMark Fasheh goto out; 2651328d5752SMark Fasheh } 2652328d5752SMark Fasheh 2653328d5752SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 2654328d5752SMark Fasheh path_root_el(path)); 2655328d5752SMark Fasheh if (!left_path) { 2656328d5752SMark Fasheh ret = -ENOMEM; 2657328d5752SMark Fasheh mlog_errno(ret); 2658328d5752SMark Fasheh goto out; 2659328d5752SMark Fasheh } 2660328d5752SMark Fasheh 2661328d5752SMark Fasheh ocfs2_cp_path(left_path, path); 2662328d5752SMark Fasheh 2663328d5752SMark Fasheh right_path = ocfs2_new_path(path_root_bh(path), 2664328d5752SMark Fasheh path_root_el(path)); 2665328d5752SMark Fasheh if (!right_path) { 2666328d5752SMark Fasheh ret = -ENOMEM; 2667328d5752SMark Fasheh mlog_errno(ret); 2668328d5752SMark Fasheh goto out; 2669328d5752SMark Fasheh } 2670328d5752SMark Fasheh 2671328d5752SMark Fasheh while (right_cpos) { 2672328d5752SMark Fasheh ret = ocfs2_find_path(inode, right_path, right_cpos); 2673328d5752SMark Fasheh if (ret) { 2674328d5752SMark Fasheh mlog_errno(ret); 2675328d5752SMark Fasheh goto out; 2676328d5752SMark Fasheh } 2677328d5752SMark Fasheh 2678328d5752SMark Fasheh subtree_root = ocfs2_find_subtree_root(inode, left_path, 2679328d5752SMark Fasheh right_path); 2680328d5752SMark Fasheh 2681328d5752SMark Fasheh mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n", 2682328d5752SMark Fasheh subtree_root, 2683328d5752SMark Fasheh (unsigned long long) 2684328d5752SMark Fasheh right_path->p_node[subtree_root].bh->b_blocknr, 2685328d5752SMark Fasheh right_path->p_tree_depth); 2686328d5752SMark Fasheh 2687328d5752SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, subtree_root, 2688328d5752SMark Fasheh orig_credits, left_path); 2689328d5752SMark Fasheh if (ret) { 2690328d5752SMark Fasheh mlog_errno(ret); 2691328d5752SMark Fasheh goto out; 2692328d5752SMark Fasheh } 2693328d5752SMark Fasheh 2694e8aed345SMark Fasheh /* 2695e8aed345SMark Fasheh * Caller might still want to make changes to the 2696e8aed345SMark Fasheh * tree root, so re-add it to the journal here. 2697e8aed345SMark Fasheh */ 2698e8aed345SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2699e8aed345SMark Fasheh path_root_bh(left_path), 2700e8aed345SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2701e8aed345SMark Fasheh if (ret) { 2702e8aed345SMark Fasheh mlog_errno(ret); 2703e8aed345SMark Fasheh goto out; 2704e8aed345SMark Fasheh } 2705e8aed345SMark Fasheh 2706328d5752SMark Fasheh ret = ocfs2_rotate_subtree_left(inode, handle, left_path, 2707328d5752SMark Fasheh right_path, subtree_root, 2708e7d4cb6bSTao Ma dealloc, &deleted, et); 2709328d5752SMark Fasheh if (ret == -EAGAIN) { 2710328d5752SMark Fasheh /* 2711328d5752SMark Fasheh * The rotation has to temporarily stop due to 2712328d5752SMark Fasheh * the right subtree having an empty 2713328d5752SMark Fasheh * extent. Pass it back to the caller for a 2714328d5752SMark Fasheh * fixup. 2715328d5752SMark Fasheh */ 2716328d5752SMark Fasheh *empty_extent_path = right_path; 2717328d5752SMark Fasheh right_path = NULL; 2718328d5752SMark Fasheh goto out; 2719328d5752SMark Fasheh } 2720328d5752SMark Fasheh if (ret) { 2721328d5752SMark Fasheh mlog_errno(ret); 2722328d5752SMark Fasheh goto out; 2723328d5752SMark Fasheh } 2724328d5752SMark Fasheh 2725328d5752SMark Fasheh /* 2726328d5752SMark Fasheh * The subtree rotate might have removed records on 2727328d5752SMark Fasheh * the rightmost edge. If so, then rotation is 2728328d5752SMark Fasheh * complete. 2729328d5752SMark Fasheh */ 2730328d5752SMark Fasheh if (deleted) 2731328d5752SMark Fasheh break; 2732328d5752SMark Fasheh 2733328d5752SMark Fasheh ocfs2_mv_path(left_path, right_path); 2734328d5752SMark Fasheh 2735328d5752SMark Fasheh ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path, 2736328d5752SMark Fasheh &right_cpos); 2737328d5752SMark Fasheh if (ret) { 2738328d5752SMark Fasheh mlog_errno(ret); 2739328d5752SMark Fasheh goto out; 2740328d5752SMark Fasheh } 2741328d5752SMark Fasheh } 2742328d5752SMark Fasheh 2743328d5752SMark Fasheh out: 2744328d5752SMark Fasheh ocfs2_free_path(right_path); 2745328d5752SMark Fasheh ocfs2_free_path(left_path); 2746328d5752SMark Fasheh 2747328d5752SMark Fasheh return ret; 2748328d5752SMark Fasheh } 2749328d5752SMark Fasheh 2750328d5752SMark Fasheh static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle, 2751328d5752SMark Fasheh struct ocfs2_path *path, 2752e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 2753e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2754328d5752SMark Fasheh { 2755328d5752SMark Fasheh int ret, subtree_index; 2756328d5752SMark Fasheh u32 cpos; 2757328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 2758328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2759328d5752SMark Fasheh struct ocfs2_extent_list *el; 2760328d5752SMark Fasheh 2761328d5752SMark Fasheh 276235dc0aa3SJoel Becker ret = ocfs2_et_sanity_check(inode, et); 2763e7d4cb6bSTao Ma if (ret) 2764e7d4cb6bSTao Ma goto out; 2765328d5752SMark Fasheh /* 2766328d5752SMark Fasheh * There's two ways we handle this depending on 2767328d5752SMark Fasheh * whether path is the only existing one. 2768328d5752SMark Fasheh */ 2769328d5752SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, 0, 2770328d5752SMark Fasheh handle->h_buffer_credits, 2771328d5752SMark Fasheh path); 2772328d5752SMark Fasheh if (ret) { 2773328d5752SMark Fasheh mlog_errno(ret); 2774328d5752SMark Fasheh goto out; 2775328d5752SMark Fasheh } 2776328d5752SMark Fasheh 2777328d5752SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, path); 2778328d5752SMark Fasheh if (ret) { 2779328d5752SMark Fasheh mlog_errno(ret); 2780328d5752SMark Fasheh goto out; 2781328d5752SMark Fasheh } 2782328d5752SMark Fasheh 2783328d5752SMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos); 2784328d5752SMark Fasheh if (ret) { 2785328d5752SMark Fasheh mlog_errno(ret); 2786328d5752SMark Fasheh goto out; 2787328d5752SMark Fasheh } 2788328d5752SMark Fasheh 2789328d5752SMark Fasheh if (cpos) { 2790328d5752SMark Fasheh /* 2791328d5752SMark Fasheh * We have a path to the left of this one - it needs 2792328d5752SMark Fasheh * an update too. 2793328d5752SMark Fasheh */ 2794328d5752SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 2795328d5752SMark Fasheh path_root_el(path)); 2796328d5752SMark Fasheh if (!left_path) { 2797328d5752SMark Fasheh ret = -ENOMEM; 2798328d5752SMark Fasheh mlog_errno(ret); 2799328d5752SMark Fasheh goto out; 2800328d5752SMark Fasheh } 2801328d5752SMark Fasheh 2802328d5752SMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 2803328d5752SMark Fasheh if (ret) { 2804328d5752SMark Fasheh mlog_errno(ret); 2805328d5752SMark Fasheh goto out; 2806328d5752SMark Fasheh } 2807328d5752SMark Fasheh 2808328d5752SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 2809328d5752SMark Fasheh if (ret) { 2810328d5752SMark Fasheh mlog_errno(ret); 2811328d5752SMark Fasheh goto out; 2812328d5752SMark Fasheh } 2813328d5752SMark Fasheh 2814328d5752SMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, path); 2815328d5752SMark Fasheh 2816328d5752SMark Fasheh ocfs2_unlink_subtree(inode, handle, left_path, path, 2817328d5752SMark Fasheh subtree_index, dealloc); 2818328d5752SMark Fasheh ocfs2_update_edge_lengths(inode, handle, left_path); 2819328d5752SMark Fasheh 2820328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 282135dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 2822328d5752SMark Fasheh } else { 2823328d5752SMark Fasheh /* 2824328d5752SMark Fasheh * 'path' is also the leftmost path which 2825328d5752SMark Fasheh * means it must be the only one. This gets 2826328d5752SMark Fasheh * handled differently because we want to 2827328d5752SMark Fasheh * revert the inode back to having extents 2828328d5752SMark Fasheh * in-line. 2829328d5752SMark Fasheh */ 2830328d5752SMark Fasheh ocfs2_unlink_path(inode, handle, dealloc, path, 1); 2831328d5752SMark Fasheh 2832ce1d9ea6SJoel Becker el = et->et_root_el; 2833328d5752SMark Fasheh el->l_tree_depth = 0; 2834328d5752SMark Fasheh el->l_next_free_rec = 0; 2835328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 2836328d5752SMark Fasheh 283735dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, 0); 2838328d5752SMark Fasheh } 2839328d5752SMark Fasheh 2840328d5752SMark Fasheh ocfs2_journal_dirty(handle, path_root_bh(path)); 2841328d5752SMark Fasheh 2842328d5752SMark Fasheh out: 2843328d5752SMark Fasheh ocfs2_free_path(left_path); 2844328d5752SMark Fasheh return ret; 2845328d5752SMark Fasheh } 2846328d5752SMark Fasheh 2847328d5752SMark Fasheh /* 2848328d5752SMark Fasheh * Left rotation of btree records. 2849328d5752SMark Fasheh * 2850328d5752SMark Fasheh * In many ways, this is (unsurprisingly) the opposite of right 2851328d5752SMark Fasheh * rotation. We start at some non-rightmost path containing an empty 2852328d5752SMark Fasheh * extent in the leaf block. The code works its way to the rightmost 2853328d5752SMark Fasheh * path by rotating records to the left in every subtree. 2854328d5752SMark Fasheh * 2855328d5752SMark Fasheh * This is used by any code which reduces the number of extent records 2856328d5752SMark Fasheh * in a leaf. After removal, an empty record should be placed in the 2857328d5752SMark Fasheh * leftmost list position. 2858328d5752SMark Fasheh * 2859328d5752SMark Fasheh * This won't handle a length update of the rightmost path records if 2860328d5752SMark Fasheh * the rightmost tree leaf record is removed so the caller is 2861328d5752SMark Fasheh * responsible for detecting and correcting that. 2862328d5752SMark Fasheh */ 2863328d5752SMark Fasheh static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle, 2864328d5752SMark Fasheh struct ocfs2_path *path, 2865e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 2866e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2867328d5752SMark Fasheh { 2868328d5752SMark Fasheh int ret, orig_credits = handle->h_buffer_credits; 2869328d5752SMark Fasheh struct ocfs2_path *tmp_path = NULL, *restart_path = NULL; 2870328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2871328d5752SMark Fasheh struct ocfs2_extent_list *el; 2872328d5752SMark Fasheh 2873328d5752SMark Fasheh el = path_leaf_el(path); 2874328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&el->l_recs[0])) 2875328d5752SMark Fasheh return 0; 2876328d5752SMark Fasheh 2877328d5752SMark Fasheh if (path->p_tree_depth == 0) { 2878328d5752SMark Fasheh rightmost_no_delete: 2879328d5752SMark Fasheh /* 2880e7d4cb6bSTao Ma * Inline extents. This is trivially handled, so do 2881328d5752SMark Fasheh * it up front. 2882328d5752SMark Fasheh */ 2883328d5752SMark Fasheh ret = ocfs2_rotate_rightmost_leaf_left(inode, handle, 2884328d5752SMark Fasheh path_leaf_bh(path), 2885328d5752SMark Fasheh path_leaf_el(path)); 2886328d5752SMark Fasheh if (ret) 2887328d5752SMark Fasheh mlog_errno(ret); 2888328d5752SMark Fasheh goto out; 2889328d5752SMark Fasheh } 2890328d5752SMark Fasheh 2891328d5752SMark Fasheh /* 2892328d5752SMark Fasheh * Handle rightmost branch now. There's several cases: 2893328d5752SMark Fasheh * 1) simple rotation leaving records in there. That's trivial. 2894328d5752SMark Fasheh * 2) rotation requiring a branch delete - there's no more 2895328d5752SMark Fasheh * records left. Two cases of this: 2896328d5752SMark Fasheh * a) There are branches to the left. 2897328d5752SMark Fasheh * b) This is also the leftmost (the only) branch. 2898328d5752SMark Fasheh * 2899328d5752SMark Fasheh * 1) is handled via ocfs2_rotate_rightmost_leaf_left() 2900328d5752SMark Fasheh * 2a) we need the left branch so that we can update it with the unlink 2901328d5752SMark Fasheh * 2b) we need to bring the inode back to inline extents. 2902328d5752SMark Fasheh */ 2903328d5752SMark Fasheh 2904328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 2905328d5752SMark Fasheh el = &eb->h_list; 2906328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0) { 2907328d5752SMark Fasheh /* 2908328d5752SMark Fasheh * This gets a bit tricky if we're going to delete the 2909328d5752SMark Fasheh * rightmost path. Get the other cases out of the way 2910328d5752SMark Fasheh * 1st. 2911328d5752SMark Fasheh */ 2912328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1) 2913328d5752SMark Fasheh goto rightmost_no_delete; 2914328d5752SMark Fasheh 2915328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 2916328d5752SMark Fasheh ret = -EIO; 2917328d5752SMark Fasheh ocfs2_error(inode->i_sb, 2918328d5752SMark Fasheh "Inode %llu has empty extent block at %llu", 2919328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 2920328d5752SMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno)); 2921328d5752SMark Fasheh goto out; 2922328d5752SMark Fasheh } 2923328d5752SMark Fasheh 2924328d5752SMark Fasheh /* 2925328d5752SMark Fasheh * XXX: The caller can not trust "path" any more after 2926328d5752SMark Fasheh * this as it will have been deleted. What do we do? 2927328d5752SMark Fasheh * 2928328d5752SMark Fasheh * In theory the rotate-for-merge code will never get 2929328d5752SMark Fasheh * here because it'll always ask for a rotate in a 2930328d5752SMark Fasheh * nonempty list. 2931328d5752SMark Fasheh */ 2932328d5752SMark Fasheh 2933328d5752SMark Fasheh ret = ocfs2_remove_rightmost_path(inode, handle, path, 2934e7d4cb6bSTao Ma dealloc, et); 2935328d5752SMark Fasheh if (ret) 2936328d5752SMark Fasheh mlog_errno(ret); 2937328d5752SMark Fasheh goto out; 2938328d5752SMark Fasheh } 2939328d5752SMark Fasheh 2940328d5752SMark Fasheh /* 2941328d5752SMark Fasheh * Now we can loop, remembering the path we get from -EAGAIN 2942328d5752SMark Fasheh * and restarting from there. 2943328d5752SMark Fasheh */ 2944328d5752SMark Fasheh try_rotate: 2945328d5752SMark Fasheh ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path, 2946e7d4cb6bSTao Ma dealloc, &restart_path, et); 2947328d5752SMark Fasheh if (ret && ret != -EAGAIN) { 2948328d5752SMark Fasheh mlog_errno(ret); 2949328d5752SMark Fasheh goto out; 2950328d5752SMark Fasheh } 2951328d5752SMark Fasheh 2952328d5752SMark Fasheh while (ret == -EAGAIN) { 2953328d5752SMark Fasheh tmp_path = restart_path; 2954328d5752SMark Fasheh restart_path = NULL; 2955328d5752SMark Fasheh 2956328d5752SMark Fasheh ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, 2957328d5752SMark Fasheh tmp_path, dealloc, 2958e7d4cb6bSTao Ma &restart_path, et); 2959328d5752SMark Fasheh if (ret && ret != -EAGAIN) { 2960328d5752SMark Fasheh mlog_errno(ret); 2961328d5752SMark Fasheh goto out; 2962328d5752SMark Fasheh } 2963328d5752SMark Fasheh 2964328d5752SMark Fasheh ocfs2_free_path(tmp_path); 2965328d5752SMark Fasheh tmp_path = NULL; 2966328d5752SMark Fasheh 2967328d5752SMark Fasheh if (ret == 0) 2968328d5752SMark Fasheh goto try_rotate; 2969328d5752SMark Fasheh } 2970328d5752SMark Fasheh 2971328d5752SMark Fasheh out: 2972328d5752SMark Fasheh ocfs2_free_path(tmp_path); 2973328d5752SMark Fasheh ocfs2_free_path(restart_path); 2974328d5752SMark Fasheh return ret; 2975328d5752SMark Fasheh } 2976328d5752SMark Fasheh 2977328d5752SMark Fasheh static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el, 2978328d5752SMark Fasheh int index) 2979328d5752SMark Fasheh { 2980328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[index]; 2981328d5752SMark Fasheh unsigned int size; 2982328d5752SMark Fasheh 2983328d5752SMark Fasheh if (rec->e_leaf_clusters == 0) { 2984328d5752SMark Fasheh /* 2985328d5752SMark Fasheh * We consumed all of the merged-from record. An empty 2986328d5752SMark Fasheh * extent cannot exist anywhere but the 1st array 2987328d5752SMark Fasheh * position, so move things over if the merged-from 2988328d5752SMark Fasheh * record doesn't occupy that position. 2989328d5752SMark Fasheh * 2990328d5752SMark Fasheh * This creates a new empty extent so the caller 2991328d5752SMark Fasheh * should be smart enough to have removed any existing 2992328d5752SMark Fasheh * ones. 2993328d5752SMark Fasheh */ 2994328d5752SMark Fasheh if (index > 0) { 2995328d5752SMark Fasheh BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0])); 2996328d5752SMark Fasheh size = index * sizeof(struct ocfs2_extent_rec); 2997328d5752SMark Fasheh memmove(&el->l_recs[1], &el->l_recs[0], size); 2998328d5752SMark Fasheh } 2999328d5752SMark Fasheh 3000328d5752SMark Fasheh /* 3001328d5752SMark Fasheh * Always memset - the caller doesn't check whether it 3002328d5752SMark Fasheh * created an empty extent, so there could be junk in 3003328d5752SMark Fasheh * the other fields. 3004328d5752SMark Fasheh */ 3005328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 3006328d5752SMark Fasheh } 3007328d5752SMark Fasheh } 3008328d5752SMark Fasheh 3009677b9752STao Ma static int ocfs2_get_right_path(struct inode *inode, 3010677b9752STao Ma struct ocfs2_path *left_path, 3011677b9752STao Ma struct ocfs2_path **ret_right_path) 3012328d5752SMark Fasheh { 3013328d5752SMark Fasheh int ret; 3014677b9752STao Ma u32 right_cpos; 3015677b9752STao Ma struct ocfs2_path *right_path = NULL; 3016677b9752STao Ma struct ocfs2_extent_list *left_el; 3017677b9752STao Ma 3018677b9752STao Ma *ret_right_path = NULL; 3019677b9752STao Ma 3020677b9752STao Ma /* This function shouldn't be called for non-trees. */ 3021677b9752STao Ma BUG_ON(left_path->p_tree_depth == 0); 3022677b9752STao Ma 3023677b9752STao Ma left_el = path_leaf_el(left_path); 3024677b9752STao Ma BUG_ON(left_el->l_next_free_rec != left_el->l_count); 3025677b9752STao Ma 3026677b9752STao Ma ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path, 3027677b9752STao Ma &right_cpos); 3028677b9752STao Ma if (ret) { 3029677b9752STao Ma mlog_errno(ret); 3030677b9752STao Ma goto out; 3031677b9752STao Ma } 3032677b9752STao Ma 3033677b9752STao Ma /* This function shouldn't be called for the rightmost leaf. */ 3034677b9752STao Ma BUG_ON(right_cpos == 0); 3035677b9752STao Ma 3036677b9752STao Ma right_path = ocfs2_new_path(path_root_bh(left_path), 3037677b9752STao Ma path_root_el(left_path)); 3038677b9752STao Ma if (!right_path) { 3039677b9752STao Ma ret = -ENOMEM; 3040677b9752STao Ma mlog_errno(ret); 3041677b9752STao Ma goto out; 3042677b9752STao Ma } 3043677b9752STao Ma 3044677b9752STao Ma ret = ocfs2_find_path(inode, right_path, right_cpos); 3045677b9752STao Ma if (ret) { 3046677b9752STao Ma mlog_errno(ret); 3047677b9752STao Ma goto out; 3048677b9752STao Ma } 3049677b9752STao Ma 3050677b9752STao Ma *ret_right_path = right_path; 3051677b9752STao Ma out: 3052677b9752STao Ma if (ret) 3053677b9752STao Ma ocfs2_free_path(right_path); 3054677b9752STao Ma return ret; 3055677b9752STao Ma } 3056677b9752STao Ma 3057677b9752STao Ma /* 3058677b9752STao Ma * Remove split_rec clusters from the record at index and merge them 3059677b9752STao Ma * onto the beginning of the record "next" to it. 3060677b9752STao Ma * For index < l_count - 1, the next means the extent rec at index + 1. 3061677b9752STao Ma * For index == l_count - 1, the "next" means the 1st extent rec of the 3062677b9752STao Ma * next extent block. 3063677b9752STao Ma */ 3064677b9752STao Ma static int ocfs2_merge_rec_right(struct inode *inode, 3065677b9752STao Ma struct ocfs2_path *left_path, 3066677b9752STao Ma handle_t *handle, 3067677b9752STao Ma struct ocfs2_extent_rec *split_rec, 3068677b9752STao Ma int index) 3069677b9752STao Ma { 3070677b9752STao Ma int ret, next_free, i; 3071328d5752SMark Fasheh unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters); 3072328d5752SMark Fasheh struct ocfs2_extent_rec *left_rec; 3073328d5752SMark Fasheh struct ocfs2_extent_rec *right_rec; 3074677b9752STao Ma struct ocfs2_extent_list *right_el; 3075677b9752STao Ma struct ocfs2_path *right_path = NULL; 3076677b9752STao Ma int subtree_index = 0; 3077677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(left_path); 3078677b9752STao Ma struct buffer_head *bh = path_leaf_bh(left_path); 3079677b9752STao Ma struct buffer_head *root_bh = NULL; 3080328d5752SMark Fasheh 3081328d5752SMark Fasheh BUG_ON(index >= le16_to_cpu(el->l_next_free_rec)); 3082328d5752SMark Fasheh left_rec = &el->l_recs[index]; 3083677b9752STao Ma 30849d8df6aaSAl Viro if (index == le16_to_cpu(el->l_next_free_rec) - 1 && 3085677b9752STao Ma le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) { 3086677b9752STao Ma /* we meet with a cross extent block merge. */ 3087677b9752STao Ma ret = ocfs2_get_right_path(inode, left_path, &right_path); 3088677b9752STao Ma if (ret) { 3089677b9752STao Ma mlog_errno(ret); 3090677b9752STao Ma goto out; 3091677b9752STao Ma } 3092677b9752STao Ma 3093677b9752STao Ma right_el = path_leaf_el(right_path); 3094677b9752STao Ma next_free = le16_to_cpu(right_el->l_next_free_rec); 3095677b9752STao Ma BUG_ON(next_free <= 0); 3096677b9752STao Ma right_rec = &right_el->l_recs[0]; 3097677b9752STao Ma if (ocfs2_is_empty_extent(right_rec)) { 30989d8df6aaSAl Viro BUG_ON(next_free <= 1); 3099677b9752STao Ma right_rec = &right_el->l_recs[1]; 3100677b9752STao Ma } 3101677b9752STao Ma 3102677b9752STao Ma BUG_ON(le32_to_cpu(left_rec->e_cpos) + 3103677b9752STao Ma le16_to_cpu(left_rec->e_leaf_clusters) != 3104677b9752STao Ma le32_to_cpu(right_rec->e_cpos)); 3105677b9752STao Ma 3106677b9752STao Ma subtree_index = ocfs2_find_subtree_root(inode, 3107677b9752STao Ma left_path, right_path); 3108677b9752STao Ma 3109677b9752STao Ma ret = ocfs2_extend_rotate_transaction(handle, subtree_index, 3110677b9752STao Ma handle->h_buffer_credits, 3111677b9752STao Ma right_path); 3112677b9752STao Ma if (ret) { 3113677b9752STao Ma mlog_errno(ret); 3114677b9752STao Ma goto out; 3115677b9752STao Ma } 3116677b9752STao Ma 3117677b9752STao Ma root_bh = left_path->p_node[subtree_index].bh; 3118677b9752STao Ma BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 3119677b9752STao Ma 3120677b9752STao Ma ret = ocfs2_journal_access(handle, inode, root_bh, 3121677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3122677b9752STao Ma if (ret) { 3123677b9752STao Ma mlog_errno(ret); 3124677b9752STao Ma goto out; 3125677b9752STao Ma } 3126677b9752STao Ma 3127677b9752STao Ma for (i = subtree_index + 1; 3128677b9752STao Ma i < path_num_items(right_path); i++) { 3129677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3130677b9752STao Ma right_path->p_node[i].bh, 3131677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3132677b9752STao Ma if (ret) { 3133677b9752STao Ma mlog_errno(ret); 3134677b9752STao Ma goto out; 3135677b9752STao Ma } 3136677b9752STao Ma 3137677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3138677b9752STao Ma left_path->p_node[i].bh, 3139677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3140677b9752STao Ma if (ret) { 3141677b9752STao Ma mlog_errno(ret); 3142677b9752STao Ma goto out; 3143677b9752STao Ma } 3144677b9752STao Ma } 3145677b9752STao Ma 3146677b9752STao Ma } else { 3147677b9752STao Ma BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1); 3148328d5752SMark Fasheh right_rec = &el->l_recs[index + 1]; 3149677b9752STao Ma } 3150328d5752SMark Fasheh 3151328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 3152328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3153328d5752SMark Fasheh if (ret) { 3154328d5752SMark Fasheh mlog_errno(ret); 3155328d5752SMark Fasheh goto out; 3156328d5752SMark Fasheh } 3157328d5752SMark Fasheh 3158328d5752SMark Fasheh le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters); 3159328d5752SMark Fasheh 3160328d5752SMark Fasheh le32_add_cpu(&right_rec->e_cpos, -split_clusters); 3161328d5752SMark Fasheh le64_add_cpu(&right_rec->e_blkno, 3162328d5752SMark Fasheh -ocfs2_clusters_to_blocks(inode->i_sb, split_clusters)); 3163328d5752SMark Fasheh le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters); 3164328d5752SMark Fasheh 3165328d5752SMark Fasheh ocfs2_cleanup_merge(el, index); 3166328d5752SMark Fasheh 3167328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3168328d5752SMark Fasheh if (ret) 3169328d5752SMark Fasheh mlog_errno(ret); 3170328d5752SMark Fasheh 3171677b9752STao Ma if (right_path) { 3172677b9752STao Ma ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path)); 3173677b9752STao Ma if (ret) 3174677b9752STao Ma mlog_errno(ret); 3175677b9752STao Ma 3176677b9752STao Ma ocfs2_complete_edge_insert(inode, handle, left_path, 3177677b9752STao Ma right_path, subtree_index); 3178677b9752STao Ma } 3179328d5752SMark Fasheh out: 3180677b9752STao Ma if (right_path) 3181677b9752STao Ma ocfs2_free_path(right_path); 3182677b9752STao Ma return ret; 3183677b9752STao Ma } 3184677b9752STao Ma 3185677b9752STao Ma static int ocfs2_get_left_path(struct inode *inode, 3186677b9752STao Ma struct ocfs2_path *right_path, 3187677b9752STao Ma struct ocfs2_path **ret_left_path) 3188677b9752STao Ma { 3189677b9752STao Ma int ret; 3190677b9752STao Ma u32 left_cpos; 3191677b9752STao Ma struct ocfs2_path *left_path = NULL; 3192677b9752STao Ma 3193677b9752STao Ma *ret_left_path = NULL; 3194677b9752STao Ma 3195677b9752STao Ma /* This function shouldn't be called for non-trees. */ 3196677b9752STao Ma BUG_ON(right_path->p_tree_depth == 0); 3197677b9752STao Ma 3198677b9752STao Ma ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, 3199677b9752STao Ma right_path, &left_cpos); 3200677b9752STao Ma if (ret) { 3201677b9752STao Ma mlog_errno(ret); 3202677b9752STao Ma goto out; 3203677b9752STao Ma } 3204677b9752STao Ma 3205677b9752STao Ma /* This function shouldn't be called for the leftmost leaf. */ 3206677b9752STao Ma BUG_ON(left_cpos == 0); 3207677b9752STao Ma 3208677b9752STao Ma left_path = ocfs2_new_path(path_root_bh(right_path), 3209677b9752STao Ma path_root_el(right_path)); 3210677b9752STao Ma if (!left_path) { 3211677b9752STao Ma ret = -ENOMEM; 3212677b9752STao Ma mlog_errno(ret); 3213677b9752STao Ma goto out; 3214677b9752STao Ma } 3215677b9752STao Ma 3216677b9752STao Ma ret = ocfs2_find_path(inode, left_path, left_cpos); 3217677b9752STao Ma if (ret) { 3218677b9752STao Ma mlog_errno(ret); 3219677b9752STao Ma goto out; 3220677b9752STao Ma } 3221677b9752STao Ma 3222677b9752STao Ma *ret_left_path = left_path; 3223677b9752STao Ma out: 3224677b9752STao Ma if (ret) 3225677b9752STao Ma ocfs2_free_path(left_path); 3226328d5752SMark Fasheh return ret; 3227328d5752SMark Fasheh } 3228328d5752SMark Fasheh 3229328d5752SMark Fasheh /* 3230328d5752SMark Fasheh * Remove split_rec clusters from the record at index and merge them 3231677b9752STao Ma * onto the tail of the record "before" it. 3232677b9752STao Ma * For index > 0, the "before" means the extent rec at index - 1. 3233677b9752STao Ma * 3234677b9752STao Ma * For index == 0, the "before" means the last record of the previous 3235677b9752STao Ma * extent block. And there is also a situation that we may need to 3236677b9752STao Ma * remove the rightmost leaf extent block in the right_path and change 3237677b9752STao Ma * the right path to indicate the new rightmost path. 3238328d5752SMark Fasheh */ 3239677b9752STao Ma static int ocfs2_merge_rec_left(struct inode *inode, 3240677b9752STao Ma struct ocfs2_path *right_path, 3241328d5752SMark Fasheh handle_t *handle, 3242328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3243677b9752STao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 3244e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 3245677b9752STao Ma int index) 3246328d5752SMark Fasheh { 3247677b9752STao Ma int ret, i, subtree_index = 0, has_empty_extent = 0; 3248328d5752SMark Fasheh unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters); 3249328d5752SMark Fasheh struct ocfs2_extent_rec *left_rec; 3250328d5752SMark Fasheh struct ocfs2_extent_rec *right_rec; 3251677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(right_path); 3252677b9752STao Ma struct buffer_head *bh = path_leaf_bh(right_path); 3253677b9752STao Ma struct buffer_head *root_bh = NULL; 3254677b9752STao Ma struct ocfs2_path *left_path = NULL; 3255677b9752STao Ma struct ocfs2_extent_list *left_el; 3256328d5752SMark Fasheh 3257677b9752STao Ma BUG_ON(index < 0); 3258328d5752SMark Fasheh 3259328d5752SMark Fasheh right_rec = &el->l_recs[index]; 3260677b9752STao Ma if (index == 0) { 3261677b9752STao Ma /* we meet with a cross extent block merge. */ 3262677b9752STao Ma ret = ocfs2_get_left_path(inode, right_path, &left_path); 3263677b9752STao Ma if (ret) { 3264677b9752STao Ma mlog_errno(ret); 3265677b9752STao Ma goto out; 3266677b9752STao Ma } 3267677b9752STao Ma 3268677b9752STao Ma left_el = path_leaf_el(left_path); 3269677b9752STao Ma BUG_ON(le16_to_cpu(left_el->l_next_free_rec) != 3270677b9752STao Ma le16_to_cpu(left_el->l_count)); 3271677b9752STao Ma 3272677b9752STao Ma left_rec = &left_el->l_recs[ 3273677b9752STao Ma le16_to_cpu(left_el->l_next_free_rec) - 1]; 3274677b9752STao Ma BUG_ON(le32_to_cpu(left_rec->e_cpos) + 3275677b9752STao Ma le16_to_cpu(left_rec->e_leaf_clusters) != 3276677b9752STao Ma le32_to_cpu(split_rec->e_cpos)); 3277677b9752STao Ma 3278677b9752STao Ma subtree_index = ocfs2_find_subtree_root(inode, 3279677b9752STao Ma left_path, right_path); 3280677b9752STao Ma 3281677b9752STao Ma ret = ocfs2_extend_rotate_transaction(handle, subtree_index, 3282677b9752STao Ma handle->h_buffer_credits, 3283677b9752STao Ma left_path); 3284677b9752STao Ma if (ret) { 3285677b9752STao Ma mlog_errno(ret); 3286677b9752STao Ma goto out; 3287677b9752STao Ma } 3288677b9752STao Ma 3289677b9752STao Ma root_bh = left_path->p_node[subtree_index].bh; 3290677b9752STao Ma BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 3291677b9752STao Ma 3292677b9752STao Ma ret = ocfs2_journal_access(handle, inode, root_bh, 3293677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3294677b9752STao Ma if (ret) { 3295677b9752STao Ma mlog_errno(ret); 3296677b9752STao Ma goto out; 3297677b9752STao Ma } 3298677b9752STao Ma 3299677b9752STao Ma for (i = subtree_index + 1; 3300677b9752STao Ma i < path_num_items(right_path); i++) { 3301677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3302677b9752STao Ma right_path->p_node[i].bh, 3303677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3304677b9752STao Ma if (ret) { 3305677b9752STao Ma mlog_errno(ret); 3306677b9752STao Ma goto out; 3307677b9752STao Ma } 3308677b9752STao Ma 3309677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3310677b9752STao Ma left_path->p_node[i].bh, 3311677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3312677b9752STao Ma if (ret) { 3313677b9752STao Ma mlog_errno(ret); 3314677b9752STao Ma goto out; 3315677b9752STao Ma } 3316677b9752STao Ma } 3317677b9752STao Ma } else { 3318677b9752STao Ma left_rec = &el->l_recs[index - 1]; 3319328d5752SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) 3320328d5752SMark Fasheh has_empty_extent = 1; 3321677b9752STao Ma } 3322328d5752SMark Fasheh 3323328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 3324328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3325328d5752SMark Fasheh if (ret) { 3326328d5752SMark Fasheh mlog_errno(ret); 3327328d5752SMark Fasheh goto out; 3328328d5752SMark Fasheh } 3329328d5752SMark Fasheh 3330328d5752SMark Fasheh if (has_empty_extent && index == 1) { 3331328d5752SMark Fasheh /* 3332328d5752SMark Fasheh * The easy case - we can just plop the record right in. 3333328d5752SMark Fasheh */ 3334328d5752SMark Fasheh *left_rec = *split_rec; 3335328d5752SMark Fasheh 3336328d5752SMark Fasheh has_empty_extent = 0; 3337677b9752STao Ma } else 3338328d5752SMark Fasheh le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters); 3339328d5752SMark Fasheh 3340328d5752SMark Fasheh le32_add_cpu(&right_rec->e_cpos, split_clusters); 3341328d5752SMark Fasheh le64_add_cpu(&right_rec->e_blkno, 3342328d5752SMark Fasheh ocfs2_clusters_to_blocks(inode->i_sb, split_clusters)); 3343328d5752SMark Fasheh le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters); 3344328d5752SMark Fasheh 3345328d5752SMark Fasheh ocfs2_cleanup_merge(el, index); 3346328d5752SMark Fasheh 3347328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3348328d5752SMark Fasheh if (ret) 3349328d5752SMark Fasheh mlog_errno(ret); 3350328d5752SMark Fasheh 3351677b9752STao Ma if (left_path) { 3352677b9752STao Ma ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 3353677b9752STao Ma if (ret) 3354677b9752STao Ma mlog_errno(ret); 3355677b9752STao Ma 3356677b9752STao Ma /* 3357677b9752STao Ma * In the situation that the right_rec is empty and the extent 3358677b9752STao Ma * block is empty also, ocfs2_complete_edge_insert can't handle 3359677b9752STao Ma * it and we need to delete the right extent block. 3360677b9752STao Ma */ 3361677b9752STao Ma if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 && 3362677b9752STao Ma le16_to_cpu(el->l_next_free_rec) == 1) { 3363677b9752STao Ma 3364677b9752STao Ma ret = ocfs2_remove_rightmost_path(inode, handle, 3365e7d4cb6bSTao Ma right_path, 3366e7d4cb6bSTao Ma dealloc, et); 3367677b9752STao Ma if (ret) { 3368677b9752STao Ma mlog_errno(ret); 3369677b9752STao Ma goto out; 3370677b9752STao Ma } 3371677b9752STao Ma 3372677b9752STao Ma /* Now the rightmost extent block has been deleted. 3373677b9752STao Ma * So we use the new rightmost path. 3374677b9752STao Ma */ 3375677b9752STao Ma ocfs2_mv_path(right_path, left_path); 3376677b9752STao Ma left_path = NULL; 3377677b9752STao Ma } else 3378677b9752STao Ma ocfs2_complete_edge_insert(inode, handle, left_path, 3379677b9752STao Ma right_path, subtree_index); 3380677b9752STao Ma } 3381328d5752SMark Fasheh out: 3382677b9752STao Ma if (left_path) 3383677b9752STao Ma ocfs2_free_path(left_path); 3384328d5752SMark Fasheh return ret; 3385328d5752SMark Fasheh } 3386328d5752SMark Fasheh 3387328d5752SMark Fasheh static int ocfs2_try_to_merge_extent(struct inode *inode, 3388328d5752SMark Fasheh handle_t *handle, 3389677b9752STao Ma struct ocfs2_path *path, 3390328d5752SMark Fasheh int split_index, 3391328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3392328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 3393e7d4cb6bSTao Ma struct ocfs2_merge_ctxt *ctxt, 3394e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 3395328d5752SMark Fasheh 3396328d5752SMark Fasheh { 3397518d7269STao Mao int ret = 0; 3398677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(path); 3399328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[split_index]; 3400328d5752SMark Fasheh 3401328d5752SMark Fasheh BUG_ON(ctxt->c_contig_type == CONTIG_NONE); 3402328d5752SMark Fasheh 3403518d7269STao Mao if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) { 3404328d5752SMark Fasheh /* 3405328d5752SMark Fasheh * The merge code will need to create an empty 3406328d5752SMark Fasheh * extent to take the place of the newly 3407328d5752SMark Fasheh * emptied slot. Remove any pre-existing empty 3408328d5752SMark Fasheh * extents - having more than one in a leaf is 3409328d5752SMark Fasheh * illegal. 3410328d5752SMark Fasheh */ 3411677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3412e7d4cb6bSTao Ma dealloc, et); 3413328d5752SMark Fasheh if (ret) { 3414328d5752SMark Fasheh mlog_errno(ret); 3415328d5752SMark Fasheh goto out; 3416328d5752SMark Fasheh } 3417328d5752SMark Fasheh split_index--; 3418328d5752SMark Fasheh rec = &el->l_recs[split_index]; 3419328d5752SMark Fasheh } 3420328d5752SMark Fasheh 3421328d5752SMark Fasheh if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) { 3422328d5752SMark Fasheh /* 3423328d5752SMark Fasheh * Left-right contig implies this. 3424328d5752SMark Fasheh */ 3425328d5752SMark Fasheh BUG_ON(!ctxt->c_split_covers_rec); 3426328d5752SMark Fasheh 3427328d5752SMark Fasheh /* 3428328d5752SMark Fasheh * Since the leftright insert always covers the entire 3429328d5752SMark Fasheh * extent, this call will delete the insert record 3430328d5752SMark Fasheh * entirely, resulting in an empty extent record added to 3431328d5752SMark Fasheh * the extent block. 3432328d5752SMark Fasheh * 3433328d5752SMark Fasheh * Since the adding of an empty extent shifts 3434328d5752SMark Fasheh * everything back to the right, there's no need to 3435328d5752SMark Fasheh * update split_index here. 3436677b9752STao Ma * 3437677b9752STao Ma * When the split_index is zero, we need to merge it to the 3438677b9752STao Ma * prevoius extent block. It is more efficient and easier 3439677b9752STao Ma * if we do merge_right first and merge_left later. 3440328d5752SMark Fasheh */ 3441677b9752STao Ma ret = ocfs2_merge_rec_right(inode, path, 3442677b9752STao Ma handle, split_rec, 3443677b9752STao Ma split_index); 3444328d5752SMark Fasheh if (ret) { 3445328d5752SMark Fasheh mlog_errno(ret); 3446328d5752SMark Fasheh goto out; 3447328d5752SMark Fasheh } 3448328d5752SMark Fasheh 3449328d5752SMark Fasheh /* 3450328d5752SMark Fasheh * We can only get this from logic error above. 3451328d5752SMark Fasheh */ 3452328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0])); 3453328d5752SMark Fasheh 3454677b9752STao Ma /* The merge left us with an empty extent, remove it. */ 3455e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3456e7d4cb6bSTao Ma dealloc, et); 3457328d5752SMark Fasheh if (ret) { 3458328d5752SMark Fasheh mlog_errno(ret); 3459328d5752SMark Fasheh goto out; 3460328d5752SMark Fasheh } 3461677b9752STao Ma 3462328d5752SMark Fasheh rec = &el->l_recs[split_index]; 3463328d5752SMark Fasheh 3464328d5752SMark Fasheh /* 3465328d5752SMark Fasheh * Note that we don't pass split_rec here on purpose - 3466677b9752STao Ma * we've merged it into the rec already. 3467328d5752SMark Fasheh */ 3468677b9752STao Ma ret = ocfs2_merge_rec_left(inode, path, 3469677b9752STao Ma handle, rec, 3470e7d4cb6bSTao Ma dealloc, et, 3471677b9752STao Ma split_index); 3472677b9752STao Ma 3473328d5752SMark Fasheh if (ret) { 3474328d5752SMark Fasheh mlog_errno(ret); 3475328d5752SMark Fasheh goto out; 3476328d5752SMark Fasheh } 3477328d5752SMark Fasheh 3478677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3479e7d4cb6bSTao Ma dealloc, et); 3480328d5752SMark Fasheh /* 3481328d5752SMark Fasheh * Error from this last rotate is not critical, so 3482328d5752SMark Fasheh * print but don't bubble it up. 3483328d5752SMark Fasheh */ 3484328d5752SMark Fasheh if (ret) 3485328d5752SMark Fasheh mlog_errno(ret); 3486328d5752SMark Fasheh ret = 0; 3487328d5752SMark Fasheh } else { 3488328d5752SMark Fasheh /* 3489328d5752SMark Fasheh * Merge a record to the left or right. 3490328d5752SMark Fasheh * 3491328d5752SMark Fasheh * 'contig_type' is relative to the existing record, 3492328d5752SMark Fasheh * so for example, if we're "right contig", it's to 3493328d5752SMark Fasheh * the record on the left (hence the left merge). 3494328d5752SMark Fasheh */ 3495328d5752SMark Fasheh if (ctxt->c_contig_type == CONTIG_RIGHT) { 3496328d5752SMark Fasheh ret = ocfs2_merge_rec_left(inode, 3497677b9752STao Ma path, 3498677b9752STao Ma handle, split_rec, 3499e7d4cb6bSTao Ma dealloc, et, 3500328d5752SMark Fasheh split_index); 3501328d5752SMark Fasheh if (ret) { 3502328d5752SMark Fasheh mlog_errno(ret); 3503328d5752SMark Fasheh goto out; 3504328d5752SMark Fasheh } 3505328d5752SMark Fasheh } else { 3506328d5752SMark Fasheh ret = ocfs2_merge_rec_right(inode, 3507677b9752STao Ma path, 3508677b9752STao Ma handle, split_rec, 3509328d5752SMark Fasheh split_index); 3510328d5752SMark Fasheh if (ret) { 3511328d5752SMark Fasheh mlog_errno(ret); 3512328d5752SMark Fasheh goto out; 3513328d5752SMark Fasheh } 3514328d5752SMark Fasheh } 3515328d5752SMark Fasheh 3516328d5752SMark Fasheh if (ctxt->c_split_covers_rec) { 3517328d5752SMark Fasheh /* 3518328d5752SMark Fasheh * The merge may have left an empty extent in 3519328d5752SMark Fasheh * our leaf. Try to rotate it away. 3520328d5752SMark Fasheh */ 3521677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3522e7d4cb6bSTao Ma dealloc, et); 3523328d5752SMark Fasheh if (ret) 3524328d5752SMark Fasheh mlog_errno(ret); 3525328d5752SMark Fasheh ret = 0; 3526328d5752SMark Fasheh } 3527328d5752SMark Fasheh } 3528328d5752SMark Fasheh 3529328d5752SMark Fasheh out: 3530328d5752SMark Fasheh return ret; 3531328d5752SMark Fasheh } 3532328d5752SMark Fasheh 3533328d5752SMark Fasheh static void ocfs2_subtract_from_rec(struct super_block *sb, 3534328d5752SMark Fasheh enum ocfs2_split_type split, 3535328d5752SMark Fasheh struct ocfs2_extent_rec *rec, 3536328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec) 3537328d5752SMark Fasheh { 3538328d5752SMark Fasheh u64 len_blocks; 3539328d5752SMark Fasheh 3540328d5752SMark Fasheh len_blocks = ocfs2_clusters_to_blocks(sb, 3541328d5752SMark Fasheh le16_to_cpu(split_rec->e_leaf_clusters)); 3542328d5752SMark Fasheh 3543328d5752SMark Fasheh if (split == SPLIT_LEFT) { 3544328d5752SMark Fasheh /* 3545328d5752SMark Fasheh * Region is on the left edge of the existing 3546328d5752SMark Fasheh * record. 3547328d5752SMark Fasheh */ 3548328d5752SMark Fasheh le32_add_cpu(&rec->e_cpos, 3549328d5752SMark Fasheh le16_to_cpu(split_rec->e_leaf_clusters)); 3550328d5752SMark Fasheh le64_add_cpu(&rec->e_blkno, len_blocks); 3551328d5752SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3552328d5752SMark Fasheh -le16_to_cpu(split_rec->e_leaf_clusters)); 3553328d5752SMark Fasheh } else { 3554328d5752SMark Fasheh /* 3555328d5752SMark Fasheh * Region is on the right edge of the existing 3556328d5752SMark Fasheh * record. 3557328d5752SMark Fasheh */ 3558328d5752SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3559328d5752SMark Fasheh -le16_to_cpu(split_rec->e_leaf_clusters)); 3560328d5752SMark Fasheh } 3561328d5752SMark Fasheh } 3562328d5752SMark Fasheh 3563dcd0538fSMark Fasheh /* 3564dcd0538fSMark Fasheh * Do the final bits of extent record insertion at the target leaf 3565dcd0538fSMark Fasheh * list. If this leaf is part of an allocation tree, it is assumed 3566dcd0538fSMark Fasheh * that the tree above has been prepared. 3567dcd0538fSMark Fasheh */ 3568dcd0538fSMark Fasheh static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec, 3569dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 3570dcd0538fSMark Fasheh struct ocfs2_insert_type *insert, 3571dcd0538fSMark Fasheh struct inode *inode) 3572dcd0538fSMark Fasheh { 3573dcd0538fSMark Fasheh int i = insert->ins_contig_index; 3574dcd0538fSMark Fasheh unsigned int range; 3575dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 3576dcd0538fSMark Fasheh 3577e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 3578dcd0538fSMark Fasheh 3579328d5752SMark Fasheh if (insert->ins_split != SPLIT_NONE) { 3580328d5752SMark Fasheh i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos)); 3581328d5752SMark Fasheh BUG_ON(i == -1); 3582328d5752SMark Fasheh rec = &el->l_recs[i]; 3583328d5752SMark Fasheh ocfs2_subtract_from_rec(inode->i_sb, insert->ins_split, rec, 3584328d5752SMark Fasheh insert_rec); 3585328d5752SMark Fasheh goto rotate; 3586328d5752SMark Fasheh } 3587328d5752SMark Fasheh 3588dcd0538fSMark Fasheh /* 3589dcd0538fSMark Fasheh * Contiguous insert - either left or right. 3590dcd0538fSMark Fasheh */ 3591dcd0538fSMark Fasheh if (insert->ins_contig != CONTIG_NONE) { 3592dcd0538fSMark Fasheh rec = &el->l_recs[i]; 3593dcd0538fSMark Fasheh if (insert->ins_contig == CONTIG_LEFT) { 3594dcd0538fSMark Fasheh rec->e_blkno = insert_rec->e_blkno; 3595dcd0538fSMark Fasheh rec->e_cpos = insert_rec->e_cpos; 3596dcd0538fSMark Fasheh } 3597e48edee2SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3598e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3599dcd0538fSMark Fasheh return; 3600dcd0538fSMark Fasheh } 3601dcd0538fSMark Fasheh 3602dcd0538fSMark Fasheh /* 3603dcd0538fSMark Fasheh * Handle insert into an empty leaf. 3604dcd0538fSMark Fasheh */ 3605dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0 || 3606dcd0538fSMark Fasheh ((le16_to_cpu(el->l_next_free_rec) == 1) && 3607dcd0538fSMark Fasheh ocfs2_is_empty_extent(&el->l_recs[0]))) { 3608dcd0538fSMark Fasheh el->l_recs[0] = *insert_rec; 3609dcd0538fSMark Fasheh el->l_next_free_rec = cpu_to_le16(1); 3610dcd0538fSMark Fasheh return; 3611dcd0538fSMark Fasheh } 3612dcd0538fSMark Fasheh 3613dcd0538fSMark Fasheh /* 3614dcd0538fSMark Fasheh * Appending insert. 3615dcd0538fSMark Fasheh */ 3616dcd0538fSMark Fasheh if (insert->ins_appending == APPEND_TAIL) { 3617dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 3618dcd0538fSMark Fasheh rec = &el->l_recs[i]; 3619e48edee2SMark Fasheh range = le32_to_cpu(rec->e_cpos) 3620e48edee2SMark Fasheh + le16_to_cpu(rec->e_leaf_clusters); 3621dcd0538fSMark Fasheh BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range); 3622dcd0538fSMark Fasheh 3623dcd0538fSMark Fasheh mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >= 3624dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 3625dcd0538fSMark Fasheh "inode %lu, depth %u, count %u, next free %u, " 3626dcd0538fSMark Fasheh "rec.cpos %u, rec.clusters %u, " 3627dcd0538fSMark Fasheh "insert.cpos %u, insert.clusters %u\n", 3628dcd0538fSMark Fasheh inode->i_ino, 3629dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth), 3630dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 3631dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec), 3632dcd0538fSMark Fasheh le32_to_cpu(el->l_recs[i].e_cpos), 3633e48edee2SMark Fasheh le16_to_cpu(el->l_recs[i].e_leaf_clusters), 3634dcd0538fSMark Fasheh le32_to_cpu(insert_rec->e_cpos), 3635e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3636dcd0538fSMark Fasheh i++; 3637dcd0538fSMark Fasheh el->l_recs[i] = *insert_rec; 3638dcd0538fSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 3639dcd0538fSMark Fasheh return; 3640dcd0538fSMark Fasheh } 3641dcd0538fSMark Fasheh 3642328d5752SMark Fasheh rotate: 3643dcd0538fSMark Fasheh /* 3644dcd0538fSMark Fasheh * Ok, we have to rotate. 3645dcd0538fSMark Fasheh * 3646dcd0538fSMark Fasheh * At this point, it is safe to assume that inserting into an 3647dcd0538fSMark Fasheh * empty leaf and appending to a leaf have both been handled 3648dcd0538fSMark Fasheh * above. 3649dcd0538fSMark Fasheh * 3650dcd0538fSMark Fasheh * This leaf needs to have space, either by the empty 1st 3651dcd0538fSMark Fasheh * extent record, or by virtue of an l_next_rec < l_count. 3652dcd0538fSMark Fasheh */ 3653dcd0538fSMark Fasheh ocfs2_rotate_leaf(el, insert_rec); 3654dcd0538fSMark Fasheh } 3655dcd0538fSMark Fasheh 3656328d5752SMark Fasheh static void ocfs2_adjust_rightmost_records(struct inode *inode, 3657328d5752SMark Fasheh handle_t *handle, 3658328d5752SMark Fasheh struct ocfs2_path *path, 3659328d5752SMark Fasheh struct ocfs2_extent_rec *insert_rec) 3660328d5752SMark Fasheh { 3661328d5752SMark Fasheh int ret, i, next_free; 3662328d5752SMark Fasheh struct buffer_head *bh; 3663328d5752SMark Fasheh struct ocfs2_extent_list *el; 3664328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 3665328d5752SMark Fasheh 3666328d5752SMark Fasheh /* 3667328d5752SMark Fasheh * Update everything except the leaf block. 3668328d5752SMark Fasheh */ 3669328d5752SMark Fasheh for (i = 0; i < path->p_tree_depth; i++) { 3670328d5752SMark Fasheh bh = path->p_node[i].bh; 3671328d5752SMark Fasheh el = path->p_node[i].el; 3672328d5752SMark Fasheh 3673328d5752SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 3674328d5752SMark Fasheh if (next_free == 0) { 3675328d5752SMark Fasheh ocfs2_error(inode->i_sb, 3676328d5752SMark Fasheh "Dinode %llu has a bad extent list", 3677328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 3678328d5752SMark Fasheh ret = -EIO; 3679328d5752SMark Fasheh return; 3680328d5752SMark Fasheh } 3681328d5752SMark Fasheh 3682328d5752SMark Fasheh rec = &el->l_recs[next_free - 1]; 3683328d5752SMark Fasheh 3684328d5752SMark Fasheh rec->e_int_clusters = insert_rec->e_cpos; 3685328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 3686328d5752SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3687328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 3688328d5752SMark Fasheh -le32_to_cpu(rec->e_cpos)); 3689328d5752SMark Fasheh 3690328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3691328d5752SMark Fasheh if (ret) 3692328d5752SMark Fasheh mlog_errno(ret); 3693328d5752SMark Fasheh 3694328d5752SMark Fasheh } 3695328d5752SMark Fasheh } 3696328d5752SMark Fasheh 3697dcd0538fSMark Fasheh static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle, 3698dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3699dcd0538fSMark Fasheh struct ocfs2_path *right_path, 3700dcd0538fSMark Fasheh struct ocfs2_path **ret_left_path) 3701dcd0538fSMark Fasheh { 3702328d5752SMark Fasheh int ret, next_free; 3703dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 3704dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 3705dcd0538fSMark Fasheh 3706dcd0538fSMark Fasheh *ret_left_path = NULL; 3707dcd0538fSMark Fasheh 3708dcd0538fSMark Fasheh /* 3709e48edee2SMark Fasheh * This shouldn't happen for non-trees. The extent rec cluster 3710e48edee2SMark Fasheh * count manipulation below only works for interior nodes. 3711e48edee2SMark Fasheh */ 3712e48edee2SMark Fasheh BUG_ON(right_path->p_tree_depth == 0); 3713e48edee2SMark Fasheh 3714e48edee2SMark Fasheh /* 3715dcd0538fSMark Fasheh * If our appending insert is at the leftmost edge of a leaf, 3716dcd0538fSMark Fasheh * then we might need to update the rightmost records of the 3717dcd0538fSMark Fasheh * neighboring path. 3718dcd0538fSMark Fasheh */ 3719dcd0538fSMark Fasheh el = path_leaf_el(right_path); 3720dcd0538fSMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 3721dcd0538fSMark Fasheh if (next_free == 0 || 3722dcd0538fSMark Fasheh (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) { 3723dcd0538fSMark Fasheh u32 left_cpos; 3724dcd0538fSMark Fasheh 3725dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, 3726dcd0538fSMark Fasheh &left_cpos); 3727dcd0538fSMark Fasheh if (ret) { 3728dcd0538fSMark Fasheh mlog_errno(ret); 3729dcd0538fSMark Fasheh goto out; 3730dcd0538fSMark Fasheh } 3731dcd0538fSMark Fasheh 3732dcd0538fSMark Fasheh mlog(0, "Append may need a left path update. cpos: %u, " 3733dcd0538fSMark Fasheh "left_cpos: %u\n", le32_to_cpu(insert_rec->e_cpos), 3734dcd0538fSMark Fasheh left_cpos); 3735dcd0538fSMark Fasheh 3736dcd0538fSMark Fasheh /* 3737dcd0538fSMark Fasheh * No need to worry if the append is already in the 3738dcd0538fSMark Fasheh * leftmost leaf. 3739dcd0538fSMark Fasheh */ 3740dcd0538fSMark Fasheh if (left_cpos) { 3741dcd0538fSMark Fasheh left_path = ocfs2_new_path(path_root_bh(right_path), 3742dcd0538fSMark Fasheh path_root_el(right_path)); 3743dcd0538fSMark Fasheh if (!left_path) { 3744dcd0538fSMark Fasheh ret = -ENOMEM; 3745dcd0538fSMark Fasheh mlog_errno(ret); 3746dcd0538fSMark Fasheh goto out; 3747dcd0538fSMark Fasheh } 3748dcd0538fSMark Fasheh 3749dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, left_path, left_cpos); 3750dcd0538fSMark Fasheh if (ret) { 3751dcd0538fSMark Fasheh mlog_errno(ret); 3752dcd0538fSMark Fasheh goto out; 3753dcd0538fSMark Fasheh } 3754dcd0538fSMark Fasheh 3755dcd0538fSMark Fasheh /* 3756dcd0538fSMark Fasheh * ocfs2_insert_path() will pass the left_path to the 3757dcd0538fSMark Fasheh * journal for us. 3758dcd0538fSMark Fasheh */ 3759dcd0538fSMark Fasheh } 3760dcd0538fSMark Fasheh } 3761dcd0538fSMark Fasheh 3762dcd0538fSMark Fasheh ret = ocfs2_journal_access_path(inode, handle, right_path); 3763dcd0538fSMark Fasheh if (ret) { 3764dcd0538fSMark Fasheh mlog_errno(ret); 3765dcd0538fSMark Fasheh goto out; 3766dcd0538fSMark Fasheh } 3767dcd0538fSMark Fasheh 3768328d5752SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, right_path, insert_rec); 3769dcd0538fSMark Fasheh 3770dcd0538fSMark Fasheh *ret_left_path = left_path; 3771dcd0538fSMark Fasheh ret = 0; 3772dcd0538fSMark Fasheh out: 3773dcd0538fSMark Fasheh if (ret != 0) 3774dcd0538fSMark Fasheh ocfs2_free_path(left_path); 3775dcd0538fSMark Fasheh 3776dcd0538fSMark Fasheh return ret; 3777dcd0538fSMark Fasheh } 3778dcd0538fSMark Fasheh 3779328d5752SMark Fasheh static void ocfs2_split_record(struct inode *inode, 3780328d5752SMark Fasheh struct ocfs2_path *left_path, 3781328d5752SMark Fasheh struct ocfs2_path *right_path, 3782328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3783328d5752SMark Fasheh enum ocfs2_split_type split) 3784328d5752SMark Fasheh { 3785328d5752SMark Fasheh int index; 3786328d5752SMark Fasheh u32 cpos = le32_to_cpu(split_rec->e_cpos); 3787328d5752SMark Fasheh struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el; 3788328d5752SMark Fasheh struct ocfs2_extent_rec *rec, *tmprec; 3789328d5752SMark Fasheh 3790328d5752SMark Fasheh right_el = path_leaf_el(right_path);; 3791328d5752SMark Fasheh if (left_path) 3792328d5752SMark Fasheh left_el = path_leaf_el(left_path); 3793328d5752SMark Fasheh 3794328d5752SMark Fasheh el = right_el; 3795328d5752SMark Fasheh insert_el = right_el; 3796328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 3797328d5752SMark Fasheh if (index != -1) { 3798328d5752SMark Fasheh if (index == 0 && left_path) { 3799328d5752SMark Fasheh BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0])); 3800328d5752SMark Fasheh 3801328d5752SMark Fasheh /* 3802328d5752SMark Fasheh * This typically means that the record 3803328d5752SMark Fasheh * started in the left path but moved to the 3804328d5752SMark Fasheh * right as a result of rotation. We either 3805328d5752SMark Fasheh * move the existing record to the left, or we 3806328d5752SMark Fasheh * do the later insert there. 3807328d5752SMark Fasheh * 3808328d5752SMark Fasheh * In this case, the left path should always 3809328d5752SMark Fasheh * exist as the rotate code will have passed 3810328d5752SMark Fasheh * it back for a post-insert update. 3811328d5752SMark Fasheh */ 3812328d5752SMark Fasheh 3813328d5752SMark Fasheh if (split == SPLIT_LEFT) { 3814328d5752SMark Fasheh /* 3815328d5752SMark Fasheh * It's a left split. Since we know 3816328d5752SMark Fasheh * that the rotate code gave us an 3817328d5752SMark Fasheh * empty extent in the left path, we 3818328d5752SMark Fasheh * can just do the insert there. 3819328d5752SMark Fasheh */ 3820328d5752SMark Fasheh insert_el = left_el; 3821328d5752SMark Fasheh } else { 3822328d5752SMark Fasheh /* 3823328d5752SMark Fasheh * Right split - we have to move the 3824328d5752SMark Fasheh * existing record over to the left 3825328d5752SMark Fasheh * leaf. The insert will be into the 3826328d5752SMark Fasheh * newly created empty extent in the 3827328d5752SMark Fasheh * right leaf. 3828328d5752SMark Fasheh */ 3829328d5752SMark Fasheh tmprec = &right_el->l_recs[index]; 3830328d5752SMark Fasheh ocfs2_rotate_leaf(left_el, tmprec); 3831328d5752SMark Fasheh el = left_el; 3832328d5752SMark Fasheh 3833328d5752SMark Fasheh memset(tmprec, 0, sizeof(*tmprec)); 3834328d5752SMark Fasheh index = ocfs2_search_extent_list(left_el, cpos); 3835328d5752SMark Fasheh BUG_ON(index == -1); 3836328d5752SMark Fasheh } 3837328d5752SMark Fasheh } 3838328d5752SMark Fasheh } else { 3839328d5752SMark Fasheh BUG_ON(!left_path); 3840328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0])); 3841328d5752SMark Fasheh /* 3842328d5752SMark Fasheh * Left path is easy - we can just allow the insert to 3843328d5752SMark Fasheh * happen. 3844328d5752SMark Fasheh */ 3845328d5752SMark Fasheh el = left_el; 3846328d5752SMark Fasheh insert_el = left_el; 3847328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 3848328d5752SMark Fasheh BUG_ON(index == -1); 3849328d5752SMark Fasheh } 3850328d5752SMark Fasheh 3851328d5752SMark Fasheh rec = &el->l_recs[index]; 3852328d5752SMark Fasheh ocfs2_subtract_from_rec(inode->i_sb, split, rec, split_rec); 3853328d5752SMark Fasheh ocfs2_rotate_leaf(insert_el, split_rec); 3854328d5752SMark Fasheh } 3855328d5752SMark Fasheh 3856dcd0538fSMark Fasheh /* 3857e7d4cb6bSTao Ma * This function only does inserts on an allocation b-tree. For tree 3858e7d4cb6bSTao Ma * depth = 0, ocfs2_insert_at_leaf() is called directly. 3859dcd0538fSMark Fasheh * 3860dcd0538fSMark Fasheh * right_path is the path we want to do the actual insert 3861dcd0538fSMark Fasheh * in. left_path should only be passed in if we need to update that 3862dcd0538fSMark Fasheh * portion of the tree after an edge insert. 3863dcd0538fSMark Fasheh */ 3864dcd0538fSMark Fasheh static int ocfs2_insert_path(struct inode *inode, 3865dcd0538fSMark Fasheh handle_t *handle, 3866dcd0538fSMark Fasheh struct ocfs2_path *left_path, 3867dcd0538fSMark Fasheh struct ocfs2_path *right_path, 3868dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3869dcd0538fSMark Fasheh struct ocfs2_insert_type *insert) 3870dcd0538fSMark Fasheh { 3871dcd0538fSMark Fasheh int ret, subtree_index; 3872dcd0538fSMark Fasheh struct buffer_head *leaf_bh = path_leaf_bh(right_path); 3873dcd0538fSMark Fasheh 3874dcd0538fSMark Fasheh if (left_path) { 3875dcd0538fSMark Fasheh int credits = handle->h_buffer_credits; 3876dcd0538fSMark Fasheh 3877dcd0538fSMark Fasheh /* 3878dcd0538fSMark Fasheh * There's a chance that left_path got passed back to 3879dcd0538fSMark Fasheh * us without being accounted for in the 3880dcd0538fSMark Fasheh * journal. Extend our transaction here to be sure we 3881dcd0538fSMark Fasheh * can change those blocks. 3882dcd0538fSMark Fasheh */ 3883dcd0538fSMark Fasheh credits += left_path->p_tree_depth; 3884dcd0538fSMark Fasheh 3885dcd0538fSMark Fasheh ret = ocfs2_extend_trans(handle, credits); 3886dcd0538fSMark Fasheh if (ret < 0) { 3887dcd0538fSMark Fasheh mlog_errno(ret); 3888dcd0538fSMark Fasheh goto out; 3889dcd0538fSMark Fasheh } 3890dcd0538fSMark Fasheh 3891dcd0538fSMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 3892dcd0538fSMark Fasheh if (ret < 0) { 3893dcd0538fSMark Fasheh mlog_errno(ret); 3894dcd0538fSMark Fasheh goto out; 3895dcd0538fSMark Fasheh } 3896dcd0538fSMark Fasheh } 3897dcd0538fSMark Fasheh 3898e8aed345SMark Fasheh /* 3899e8aed345SMark Fasheh * Pass both paths to the journal. The majority of inserts 3900e8aed345SMark Fasheh * will be touching all components anyway. 3901e8aed345SMark Fasheh */ 3902e8aed345SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, right_path); 3903e8aed345SMark Fasheh if (ret < 0) { 3904e8aed345SMark Fasheh mlog_errno(ret); 3905e8aed345SMark Fasheh goto out; 3906e8aed345SMark Fasheh } 3907e8aed345SMark Fasheh 3908328d5752SMark Fasheh if (insert->ins_split != SPLIT_NONE) { 3909328d5752SMark Fasheh /* 3910328d5752SMark Fasheh * We could call ocfs2_insert_at_leaf() for some types 3911c78bad11SJoe Perches * of splits, but it's easier to just let one separate 3912328d5752SMark Fasheh * function sort it all out. 3913328d5752SMark Fasheh */ 3914328d5752SMark Fasheh ocfs2_split_record(inode, left_path, right_path, 3915328d5752SMark Fasheh insert_rec, insert->ins_split); 3916e8aed345SMark Fasheh 3917e8aed345SMark Fasheh /* 3918e8aed345SMark Fasheh * Split might have modified either leaf and we don't 3919e8aed345SMark Fasheh * have a guarantee that the later edge insert will 3920e8aed345SMark Fasheh * dirty this for us. 3921e8aed345SMark Fasheh */ 3922e8aed345SMark Fasheh if (left_path) 3923e8aed345SMark Fasheh ret = ocfs2_journal_dirty(handle, 3924e8aed345SMark Fasheh path_leaf_bh(left_path)); 3925e8aed345SMark Fasheh if (ret) 3926e8aed345SMark Fasheh mlog_errno(ret); 3927328d5752SMark Fasheh } else 3928328d5752SMark Fasheh ocfs2_insert_at_leaf(insert_rec, path_leaf_el(right_path), 3929328d5752SMark Fasheh insert, inode); 3930dcd0538fSMark Fasheh 3931dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, leaf_bh); 3932dcd0538fSMark Fasheh if (ret) 3933dcd0538fSMark Fasheh mlog_errno(ret); 3934dcd0538fSMark Fasheh 3935dcd0538fSMark Fasheh if (left_path) { 3936dcd0538fSMark Fasheh /* 3937dcd0538fSMark Fasheh * The rotate code has indicated that we need to fix 3938dcd0538fSMark Fasheh * up portions of the tree after the insert. 3939dcd0538fSMark Fasheh * 3940dcd0538fSMark Fasheh * XXX: Should we extend the transaction here? 3941dcd0538fSMark Fasheh */ 3942dcd0538fSMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, 3943dcd0538fSMark Fasheh right_path); 3944dcd0538fSMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, 3945dcd0538fSMark Fasheh right_path, subtree_index); 3946dcd0538fSMark Fasheh } 3947dcd0538fSMark Fasheh 3948dcd0538fSMark Fasheh ret = 0; 3949dcd0538fSMark Fasheh out: 3950dcd0538fSMark Fasheh return ret; 3951dcd0538fSMark Fasheh } 3952dcd0538fSMark Fasheh 3953dcd0538fSMark Fasheh static int ocfs2_do_insert_extent(struct inode *inode, 3954dcd0538fSMark Fasheh handle_t *handle, 3955e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 3956dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3957dcd0538fSMark Fasheh struct ocfs2_insert_type *type) 3958dcd0538fSMark Fasheh { 3959dcd0538fSMark Fasheh int ret, rotate = 0; 3960dcd0538fSMark Fasheh u32 cpos; 3961dcd0538fSMark Fasheh struct ocfs2_path *right_path = NULL; 3962dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 3963dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 3964dcd0538fSMark Fasheh 3965ce1d9ea6SJoel Becker el = et->et_root_el; 3966dcd0538fSMark Fasheh 3967ce1d9ea6SJoel Becker ret = ocfs2_journal_access(handle, inode, et->et_root_bh, 3968dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3969dcd0538fSMark Fasheh if (ret) { 3970dcd0538fSMark Fasheh mlog_errno(ret); 3971dcd0538fSMark Fasheh goto out; 3972dcd0538fSMark Fasheh } 3973dcd0538fSMark Fasheh 3974dcd0538fSMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 3975dcd0538fSMark Fasheh ocfs2_insert_at_leaf(insert_rec, el, type, inode); 3976dcd0538fSMark Fasheh goto out_update_clusters; 3977dcd0538fSMark Fasheh } 3978dcd0538fSMark Fasheh 3979ce1d9ea6SJoel Becker right_path = ocfs2_new_path(et->et_root_bh, et->et_root_el); 3980dcd0538fSMark Fasheh if (!right_path) { 3981dcd0538fSMark Fasheh ret = -ENOMEM; 3982dcd0538fSMark Fasheh mlog_errno(ret); 3983dcd0538fSMark Fasheh goto out; 3984dcd0538fSMark Fasheh } 3985dcd0538fSMark Fasheh 3986dcd0538fSMark Fasheh /* 3987dcd0538fSMark Fasheh * Determine the path to start with. Rotations need the 3988dcd0538fSMark Fasheh * rightmost path, everything else can go directly to the 3989dcd0538fSMark Fasheh * target leaf. 3990dcd0538fSMark Fasheh */ 3991dcd0538fSMark Fasheh cpos = le32_to_cpu(insert_rec->e_cpos); 3992dcd0538fSMark Fasheh if (type->ins_appending == APPEND_NONE && 3993dcd0538fSMark Fasheh type->ins_contig == CONTIG_NONE) { 3994dcd0538fSMark Fasheh rotate = 1; 3995dcd0538fSMark Fasheh cpos = UINT_MAX; 3996dcd0538fSMark Fasheh } 3997dcd0538fSMark Fasheh 3998dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, right_path, cpos); 3999dcd0538fSMark Fasheh if (ret) { 4000dcd0538fSMark Fasheh mlog_errno(ret); 4001dcd0538fSMark Fasheh goto out; 4002dcd0538fSMark Fasheh } 4003dcd0538fSMark Fasheh 4004dcd0538fSMark Fasheh /* 4005dcd0538fSMark Fasheh * Rotations and appends need special treatment - they modify 4006dcd0538fSMark Fasheh * parts of the tree's above them. 4007dcd0538fSMark Fasheh * 4008dcd0538fSMark Fasheh * Both might pass back a path immediate to the left of the 4009dcd0538fSMark Fasheh * one being inserted to. This will be cause 4010dcd0538fSMark Fasheh * ocfs2_insert_path() to modify the rightmost records of 4011dcd0538fSMark Fasheh * left_path to account for an edge insert. 4012dcd0538fSMark Fasheh * 4013dcd0538fSMark Fasheh * XXX: When modifying this code, keep in mind that an insert 4014dcd0538fSMark Fasheh * can wind up skipping both of these two special cases... 4015dcd0538fSMark Fasheh */ 4016dcd0538fSMark Fasheh if (rotate) { 4017328d5752SMark Fasheh ret = ocfs2_rotate_tree_right(inode, handle, type->ins_split, 4018dcd0538fSMark Fasheh le32_to_cpu(insert_rec->e_cpos), 4019dcd0538fSMark Fasheh right_path, &left_path); 4020dcd0538fSMark Fasheh if (ret) { 4021dcd0538fSMark Fasheh mlog_errno(ret); 4022dcd0538fSMark Fasheh goto out; 4023dcd0538fSMark Fasheh } 4024e8aed345SMark Fasheh 4025e8aed345SMark Fasheh /* 4026e8aed345SMark Fasheh * ocfs2_rotate_tree_right() might have extended the 4027e8aed345SMark Fasheh * transaction without re-journaling our tree root. 4028e8aed345SMark Fasheh */ 4029ce1d9ea6SJoel Becker ret = ocfs2_journal_access(handle, inode, et->et_root_bh, 4030e8aed345SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 4031e8aed345SMark Fasheh if (ret) { 4032e8aed345SMark Fasheh mlog_errno(ret); 4033e8aed345SMark Fasheh goto out; 4034e8aed345SMark Fasheh } 4035dcd0538fSMark Fasheh } else if (type->ins_appending == APPEND_TAIL 4036dcd0538fSMark Fasheh && type->ins_contig != CONTIG_LEFT) { 4037dcd0538fSMark Fasheh ret = ocfs2_append_rec_to_path(inode, handle, insert_rec, 4038dcd0538fSMark Fasheh right_path, &left_path); 4039dcd0538fSMark Fasheh if (ret) { 4040dcd0538fSMark Fasheh mlog_errno(ret); 4041dcd0538fSMark Fasheh goto out; 4042dcd0538fSMark Fasheh } 4043dcd0538fSMark Fasheh } 4044dcd0538fSMark Fasheh 4045dcd0538fSMark Fasheh ret = ocfs2_insert_path(inode, handle, left_path, right_path, 4046dcd0538fSMark Fasheh insert_rec, type); 4047dcd0538fSMark Fasheh if (ret) { 4048dcd0538fSMark Fasheh mlog_errno(ret); 4049dcd0538fSMark Fasheh goto out; 4050dcd0538fSMark Fasheh } 4051dcd0538fSMark Fasheh 4052dcd0538fSMark Fasheh out_update_clusters: 4053328d5752SMark Fasheh if (type->ins_split == SPLIT_NONE) 405435dc0aa3SJoel Becker ocfs2_et_update_clusters(inode, et, 4055e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 4056dcd0538fSMark Fasheh 4057ce1d9ea6SJoel Becker ret = ocfs2_journal_dirty(handle, et->et_root_bh); 4058dcd0538fSMark Fasheh if (ret) 4059dcd0538fSMark Fasheh mlog_errno(ret); 4060dcd0538fSMark Fasheh 4061dcd0538fSMark Fasheh out: 4062dcd0538fSMark Fasheh ocfs2_free_path(left_path); 4063dcd0538fSMark Fasheh ocfs2_free_path(right_path); 4064dcd0538fSMark Fasheh 4065dcd0538fSMark Fasheh return ret; 4066dcd0538fSMark Fasheh } 4067dcd0538fSMark Fasheh 4068328d5752SMark Fasheh static enum ocfs2_contig_type 4069ad5a4d70STao Ma ocfs2_figure_merge_contig_type(struct inode *inode, struct ocfs2_path *path, 4070328d5752SMark Fasheh struct ocfs2_extent_list *el, int index, 4071328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec) 4072328d5752SMark Fasheh { 4073ad5a4d70STao Ma int status; 4074328d5752SMark Fasheh enum ocfs2_contig_type ret = CONTIG_NONE; 4075ad5a4d70STao Ma u32 left_cpos, right_cpos; 4076ad5a4d70STao Ma struct ocfs2_extent_rec *rec = NULL; 4077ad5a4d70STao Ma struct ocfs2_extent_list *new_el; 4078ad5a4d70STao Ma struct ocfs2_path *left_path = NULL, *right_path = NULL; 4079ad5a4d70STao Ma struct buffer_head *bh; 4080ad5a4d70STao Ma struct ocfs2_extent_block *eb; 4081ad5a4d70STao Ma 4082ad5a4d70STao Ma if (index > 0) { 4083ad5a4d70STao Ma rec = &el->l_recs[index - 1]; 4084ad5a4d70STao Ma } else if (path->p_tree_depth > 0) { 4085ad5a4d70STao Ma status = ocfs2_find_cpos_for_left_leaf(inode->i_sb, 4086ad5a4d70STao Ma path, &left_cpos); 4087ad5a4d70STao Ma if (status) 4088ad5a4d70STao Ma goto out; 4089ad5a4d70STao Ma 4090ad5a4d70STao Ma if (left_cpos != 0) { 4091ad5a4d70STao Ma left_path = ocfs2_new_path(path_root_bh(path), 4092ad5a4d70STao Ma path_root_el(path)); 4093ad5a4d70STao Ma if (!left_path) 4094ad5a4d70STao Ma goto out; 4095ad5a4d70STao Ma 4096ad5a4d70STao Ma status = ocfs2_find_path(inode, left_path, left_cpos); 4097ad5a4d70STao Ma if (status) 4098ad5a4d70STao Ma goto out; 4099ad5a4d70STao Ma 4100ad5a4d70STao Ma new_el = path_leaf_el(left_path); 4101ad5a4d70STao Ma 4102ad5a4d70STao Ma if (le16_to_cpu(new_el->l_next_free_rec) != 4103ad5a4d70STao Ma le16_to_cpu(new_el->l_count)) { 4104ad5a4d70STao Ma bh = path_leaf_bh(left_path); 4105ad5a4d70STao Ma eb = (struct ocfs2_extent_block *)bh->b_data; 4106ad5a4d70STao Ma OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, 4107ad5a4d70STao Ma eb); 4108ad5a4d70STao Ma goto out; 4109ad5a4d70STao Ma } 4110ad5a4d70STao Ma rec = &new_el->l_recs[ 4111ad5a4d70STao Ma le16_to_cpu(new_el->l_next_free_rec) - 1]; 4112ad5a4d70STao Ma } 4113ad5a4d70STao Ma } 4114328d5752SMark Fasheh 4115328d5752SMark Fasheh /* 4116328d5752SMark Fasheh * We're careful to check for an empty extent record here - 4117328d5752SMark Fasheh * the merge code will know what to do if it sees one. 4118328d5752SMark Fasheh */ 4119ad5a4d70STao Ma if (rec) { 4120328d5752SMark Fasheh if (index == 1 && ocfs2_is_empty_extent(rec)) { 4121328d5752SMark Fasheh if (split_rec->e_cpos == el->l_recs[index].e_cpos) 4122328d5752SMark Fasheh ret = CONTIG_RIGHT; 4123328d5752SMark Fasheh } else { 4124328d5752SMark Fasheh ret = ocfs2_extent_contig(inode, rec, split_rec); 4125328d5752SMark Fasheh } 4126328d5752SMark Fasheh } 4127328d5752SMark Fasheh 4128ad5a4d70STao Ma rec = NULL; 4129ad5a4d70STao Ma if (index < (le16_to_cpu(el->l_next_free_rec) - 1)) 4130ad5a4d70STao Ma rec = &el->l_recs[index + 1]; 4131ad5a4d70STao Ma else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) && 4132ad5a4d70STao Ma path->p_tree_depth > 0) { 4133ad5a4d70STao Ma status = ocfs2_find_cpos_for_right_leaf(inode->i_sb, 4134ad5a4d70STao Ma path, &right_cpos); 4135ad5a4d70STao Ma if (status) 4136ad5a4d70STao Ma goto out; 4137ad5a4d70STao Ma 4138ad5a4d70STao Ma if (right_cpos == 0) 4139ad5a4d70STao Ma goto out; 4140ad5a4d70STao Ma 4141ad5a4d70STao Ma right_path = ocfs2_new_path(path_root_bh(path), 4142ad5a4d70STao Ma path_root_el(path)); 4143ad5a4d70STao Ma if (!right_path) 4144ad5a4d70STao Ma goto out; 4145ad5a4d70STao Ma 4146ad5a4d70STao Ma status = ocfs2_find_path(inode, right_path, right_cpos); 4147ad5a4d70STao Ma if (status) 4148ad5a4d70STao Ma goto out; 4149ad5a4d70STao Ma 4150ad5a4d70STao Ma new_el = path_leaf_el(right_path); 4151ad5a4d70STao Ma rec = &new_el->l_recs[0]; 4152ad5a4d70STao Ma if (ocfs2_is_empty_extent(rec)) { 4153ad5a4d70STao Ma if (le16_to_cpu(new_el->l_next_free_rec) <= 1) { 4154ad5a4d70STao Ma bh = path_leaf_bh(right_path); 4155ad5a4d70STao Ma eb = (struct ocfs2_extent_block *)bh->b_data; 4156ad5a4d70STao Ma OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, 4157ad5a4d70STao Ma eb); 4158ad5a4d70STao Ma goto out; 4159ad5a4d70STao Ma } 4160ad5a4d70STao Ma rec = &new_el->l_recs[1]; 4161ad5a4d70STao Ma } 4162ad5a4d70STao Ma } 4163ad5a4d70STao Ma 4164ad5a4d70STao Ma if (rec) { 4165328d5752SMark Fasheh enum ocfs2_contig_type contig_type; 4166328d5752SMark Fasheh 4167328d5752SMark Fasheh contig_type = ocfs2_extent_contig(inode, rec, split_rec); 4168328d5752SMark Fasheh 4169328d5752SMark Fasheh if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT) 4170328d5752SMark Fasheh ret = CONTIG_LEFTRIGHT; 4171328d5752SMark Fasheh else if (ret == CONTIG_NONE) 4172328d5752SMark Fasheh ret = contig_type; 4173328d5752SMark Fasheh } 4174328d5752SMark Fasheh 4175ad5a4d70STao Ma out: 4176ad5a4d70STao Ma if (left_path) 4177ad5a4d70STao Ma ocfs2_free_path(left_path); 4178ad5a4d70STao Ma if (right_path) 4179ad5a4d70STao Ma ocfs2_free_path(right_path); 4180ad5a4d70STao Ma 4181328d5752SMark Fasheh return ret; 4182328d5752SMark Fasheh } 4183328d5752SMark Fasheh 4184dcd0538fSMark Fasheh static void ocfs2_figure_contig_type(struct inode *inode, 4185dcd0538fSMark Fasheh struct ocfs2_insert_type *insert, 4186dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 4187ca12b7c4STao Ma struct ocfs2_extent_rec *insert_rec, 4188ca12b7c4STao Ma struct ocfs2_extent_tree *et) 4189dcd0538fSMark Fasheh { 4190dcd0538fSMark Fasheh int i; 4191dcd0538fSMark Fasheh enum ocfs2_contig_type contig_type = CONTIG_NONE; 4192dcd0538fSMark Fasheh 4193e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 4194e48edee2SMark Fasheh 4195dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 4196dcd0538fSMark Fasheh contig_type = ocfs2_extent_contig(inode, &el->l_recs[i], 4197dcd0538fSMark Fasheh insert_rec); 4198dcd0538fSMark Fasheh if (contig_type != CONTIG_NONE) { 4199dcd0538fSMark Fasheh insert->ins_contig_index = i; 4200dcd0538fSMark Fasheh break; 4201dcd0538fSMark Fasheh } 4202dcd0538fSMark Fasheh } 4203dcd0538fSMark Fasheh insert->ins_contig = contig_type; 4204ca12b7c4STao Ma 4205ca12b7c4STao Ma if (insert->ins_contig != CONTIG_NONE) { 4206ca12b7c4STao Ma struct ocfs2_extent_rec *rec = 4207ca12b7c4STao Ma &el->l_recs[insert->ins_contig_index]; 4208ca12b7c4STao Ma unsigned int len = le16_to_cpu(rec->e_leaf_clusters) + 4209ca12b7c4STao Ma le16_to_cpu(insert_rec->e_leaf_clusters); 4210ca12b7c4STao Ma 4211ca12b7c4STao Ma /* 4212ca12b7c4STao Ma * Caller might want us to limit the size of extents, don't 4213ca12b7c4STao Ma * calculate contiguousness if we might exceed that limit. 4214ca12b7c4STao Ma */ 4215ce1d9ea6SJoel Becker if (et->et_max_leaf_clusters && 4216ce1d9ea6SJoel Becker (len > et->et_max_leaf_clusters)) 4217ca12b7c4STao Ma insert->ins_contig = CONTIG_NONE; 4218ca12b7c4STao Ma } 4219dcd0538fSMark Fasheh } 4220dcd0538fSMark Fasheh 4221dcd0538fSMark Fasheh /* 4222dcd0538fSMark Fasheh * This should only be called against the righmost leaf extent list. 4223dcd0538fSMark Fasheh * 4224dcd0538fSMark Fasheh * ocfs2_figure_appending_type() will figure out whether we'll have to 4225dcd0538fSMark Fasheh * insert at the tail of the rightmost leaf. 4226dcd0538fSMark Fasheh * 4227e7d4cb6bSTao Ma * This should also work against the root extent list for tree's with 0 4228e7d4cb6bSTao Ma * depth. If we consider the root extent list to be the rightmost leaf node 4229dcd0538fSMark Fasheh * then the logic here makes sense. 4230dcd0538fSMark Fasheh */ 4231dcd0538fSMark Fasheh static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert, 4232dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 4233dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 4234dcd0538fSMark Fasheh { 4235dcd0538fSMark Fasheh int i; 4236dcd0538fSMark Fasheh u32 cpos = le32_to_cpu(insert_rec->e_cpos); 4237dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 4238dcd0538fSMark Fasheh 4239dcd0538fSMark Fasheh insert->ins_appending = APPEND_NONE; 4240dcd0538fSMark Fasheh 4241e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 4242dcd0538fSMark Fasheh 4243dcd0538fSMark Fasheh if (!el->l_next_free_rec) 4244dcd0538fSMark Fasheh goto set_tail_append; 4245dcd0538fSMark Fasheh 4246dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 4247dcd0538fSMark Fasheh /* Were all records empty? */ 4248dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 1) 4249dcd0538fSMark Fasheh goto set_tail_append; 4250dcd0538fSMark Fasheh } 4251dcd0538fSMark Fasheh 4252dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 4253dcd0538fSMark Fasheh rec = &el->l_recs[i]; 4254dcd0538fSMark Fasheh 4255e48edee2SMark Fasheh if (cpos >= 4256e48edee2SMark Fasheh (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters))) 4257dcd0538fSMark Fasheh goto set_tail_append; 4258dcd0538fSMark Fasheh 4259dcd0538fSMark Fasheh return; 4260dcd0538fSMark Fasheh 4261dcd0538fSMark Fasheh set_tail_append: 4262dcd0538fSMark Fasheh insert->ins_appending = APPEND_TAIL; 4263dcd0538fSMark Fasheh } 4264dcd0538fSMark Fasheh 4265dcd0538fSMark Fasheh /* 4266dcd0538fSMark Fasheh * Helper function called at the begining of an insert. 4267dcd0538fSMark Fasheh * 4268dcd0538fSMark Fasheh * This computes a few things that are commonly used in the process of 4269dcd0538fSMark Fasheh * inserting into the btree: 4270dcd0538fSMark Fasheh * - Whether the new extent is contiguous with an existing one. 4271dcd0538fSMark Fasheh * - The current tree depth. 4272dcd0538fSMark Fasheh * - Whether the insert is an appending one. 4273dcd0538fSMark Fasheh * - The total # of free records in the tree. 4274dcd0538fSMark Fasheh * 4275dcd0538fSMark Fasheh * All of the information is stored on the ocfs2_insert_type 4276dcd0538fSMark Fasheh * structure. 4277dcd0538fSMark Fasheh */ 4278dcd0538fSMark Fasheh static int ocfs2_figure_insert_type(struct inode *inode, 4279e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4280dcd0538fSMark Fasheh struct buffer_head **last_eb_bh, 4281dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 4282c77534f6STao Mao int *free_records, 4283dcd0538fSMark Fasheh struct ocfs2_insert_type *insert) 4284dcd0538fSMark Fasheh { 4285dcd0538fSMark Fasheh int ret; 4286dcd0538fSMark Fasheh struct ocfs2_extent_block *eb; 4287dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 4288dcd0538fSMark Fasheh struct ocfs2_path *path = NULL; 4289dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 4290dcd0538fSMark Fasheh 4291328d5752SMark Fasheh insert->ins_split = SPLIT_NONE; 4292328d5752SMark Fasheh 4293ce1d9ea6SJoel Becker el = et->et_root_el; 4294dcd0538fSMark Fasheh insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth); 4295dcd0538fSMark Fasheh 4296dcd0538fSMark Fasheh if (el->l_tree_depth) { 4297dcd0538fSMark Fasheh /* 4298dcd0538fSMark Fasheh * If we have tree depth, we read in the 4299dcd0538fSMark Fasheh * rightmost extent block ahead of time as 4300dcd0538fSMark Fasheh * ocfs2_figure_insert_type() and ocfs2_add_branch() 4301dcd0538fSMark Fasheh * may want it later. 4302dcd0538fSMark Fasheh */ 4303dcd0538fSMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 430435dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), &bh, 4305dcd0538fSMark Fasheh OCFS2_BH_CACHED, inode); 4306dcd0538fSMark Fasheh if (ret) { 4307dcd0538fSMark Fasheh mlog_exit(ret); 4308dcd0538fSMark Fasheh goto out; 4309dcd0538fSMark Fasheh } 4310dcd0538fSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 4311dcd0538fSMark Fasheh el = &eb->h_list; 4312dcd0538fSMark Fasheh } 4313dcd0538fSMark Fasheh 4314dcd0538fSMark Fasheh /* 4315dcd0538fSMark Fasheh * Unless we have a contiguous insert, we'll need to know if 4316dcd0538fSMark Fasheh * there is room left in our allocation tree for another 4317dcd0538fSMark Fasheh * extent record. 4318dcd0538fSMark Fasheh * 4319dcd0538fSMark Fasheh * XXX: This test is simplistic, we can search for empty 4320dcd0538fSMark Fasheh * extent records too. 4321dcd0538fSMark Fasheh */ 4322c77534f6STao Mao *free_records = le16_to_cpu(el->l_count) - 4323dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec); 4324dcd0538fSMark Fasheh 4325dcd0538fSMark Fasheh if (!insert->ins_tree_depth) { 4326ca12b7c4STao Ma ocfs2_figure_contig_type(inode, insert, el, insert_rec, et); 4327dcd0538fSMark Fasheh ocfs2_figure_appending_type(insert, el, insert_rec); 4328dcd0538fSMark Fasheh return 0; 4329dcd0538fSMark Fasheh } 4330dcd0538fSMark Fasheh 4331ce1d9ea6SJoel Becker path = ocfs2_new_path(et->et_root_bh, et->et_root_el); 4332dcd0538fSMark Fasheh if (!path) { 4333dcd0538fSMark Fasheh ret = -ENOMEM; 4334dcd0538fSMark Fasheh mlog_errno(ret); 4335dcd0538fSMark Fasheh goto out; 4336dcd0538fSMark Fasheh } 4337dcd0538fSMark Fasheh 4338dcd0538fSMark Fasheh /* 4339dcd0538fSMark Fasheh * In the case that we're inserting past what the tree 4340dcd0538fSMark Fasheh * currently accounts for, ocfs2_find_path() will return for 4341dcd0538fSMark Fasheh * us the rightmost tree path. This is accounted for below in 4342dcd0538fSMark Fasheh * the appending code. 4343dcd0538fSMark Fasheh */ 4344dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, path, le32_to_cpu(insert_rec->e_cpos)); 4345dcd0538fSMark Fasheh if (ret) { 4346dcd0538fSMark Fasheh mlog_errno(ret); 4347dcd0538fSMark Fasheh goto out; 4348dcd0538fSMark Fasheh } 4349dcd0538fSMark Fasheh 4350dcd0538fSMark Fasheh el = path_leaf_el(path); 4351dcd0538fSMark Fasheh 4352dcd0538fSMark Fasheh /* 4353dcd0538fSMark Fasheh * Now that we have the path, there's two things we want to determine: 4354dcd0538fSMark Fasheh * 1) Contiguousness (also set contig_index if this is so) 4355dcd0538fSMark Fasheh * 4356dcd0538fSMark Fasheh * 2) Are we doing an append? We can trivially break this up 4357dcd0538fSMark Fasheh * into two types of appends: simple record append, or a 4358dcd0538fSMark Fasheh * rotate inside the tail leaf. 4359dcd0538fSMark Fasheh */ 4360ca12b7c4STao Ma ocfs2_figure_contig_type(inode, insert, el, insert_rec, et); 4361dcd0538fSMark Fasheh 4362dcd0538fSMark Fasheh /* 4363dcd0538fSMark Fasheh * The insert code isn't quite ready to deal with all cases of 4364dcd0538fSMark Fasheh * left contiguousness. Specifically, if it's an insert into 4365dcd0538fSMark Fasheh * the 1st record in a leaf, it will require the adjustment of 4366e48edee2SMark Fasheh * cluster count on the last record of the path directly to it's 4367dcd0538fSMark Fasheh * left. For now, just catch that case and fool the layers 4368dcd0538fSMark Fasheh * above us. This works just fine for tree_depth == 0, which 4369dcd0538fSMark Fasheh * is why we allow that above. 4370dcd0538fSMark Fasheh */ 4371dcd0538fSMark Fasheh if (insert->ins_contig == CONTIG_LEFT && 4372dcd0538fSMark Fasheh insert->ins_contig_index == 0) 4373dcd0538fSMark Fasheh insert->ins_contig = CONTIG_NONE; 4374dcd0538fSMark Fasheh 4375dcd0538fSMark Fasheh /* 4376dcd0538fSMark Fasheh * Ok, so we can simply compare against last_eb to figure out 4377dcd0538fSMark Fasheh * whether the path doesn't exist. This will only happen in 4378dcd0538fSMark Fasheh * the case that we're doing a tail append, so maybe we can 4379dcd0538fSMark Fasheh * take advantage of that information somehow. 4380dcd0538fSMark Fasheh */ 438135dc0aa3SJoel Becker if (ocfs2_et_get_last_eb_blk(et) == 4382e7d4cb6bSTao Ma path_leaf_bh(path)->b_blocknr) { 4383dcd0538fSMark Fasheh /* 4384dcd0538fSMark Fasheh * Ok, ocfs2_find_path() returned us the rightmost 4385dcd0538fSMark Fasheh * tree path. This might be an appending insert. There are 4386dcd0538fSMark Fasheh * two cases: 4387dcd0538fSMark Fasheh * 1) We're doing a true append at the tail: 4388dcd0538fSMark Fasheh * -This might even be off the end of the leaf 4389dcd0538fSMark Fasheh * 2) We're "appending" by rotating in the tail 4390dcd0538fSMark Fasheh */ 4391dcd0538fSMark Fasheh ocfs2_figure_appending_type(insert, el, insert_rec); 4392dcd0538fSMark Fasheh } 4393dcd0538fSMark Fasheh 4394dcd0538fSMark Fasheh out: 4395dcd0538fSMark Fasheh ocfs2_free_path(path); 4396dcd0538fSMark Fasheh 4397dcd0538fSMark Fasheh if (ret == 0) 4398dcd0538fSMark Fasheh *last_eb_bh = bh; 4399dcd0538fSMark Fasheh else 4400dcd0538fSMark Fasheh brelse(bh); 4401dcd0538fSMark Fasheh return ret; 4402dcd0538fSMark Fasheh } 4403dcd0538fSMark Fasheh 4404dcd0538fSMark Fasheh /* 4405dcd0538fSMark Fasheh * Insert an extent into an inode btree. 4406dcd0538fSMark Fasheh * 4407dcd0538fSMark Fasheh * The caller needs to update fe->i_clusters 4408dcd0538fSMark Fasheh */ 4409f56654c4STao Ma static int ocfs2_insert_extent(struct ocfs2_super *osb, 44101fabe148SMark Fasheh handle_t *handle, 4411ccd979bdSMark Fasheh struct inode *inode, 4412e7d4cb6bSTao Ma struct buffer_head *root_bh, 4413dcd0538fSMark Fasheh u32 cpos, 4414ccd979bdSMark Fasheh u64 start_blk, 4415ccd979bdSMark Fasheh u32 new_clusters, 44162ae99a60SMark Fasheh u8 flags, 4417e7d4cb6bSTao Ma struct ocfs2_alloc_context *meta_ac, 4418f56654c4STao Ma struct ocfs2_extent_tree *et) 4419ccd979bdSMark Fasheh { 4420c3afcbb3SMark Fasheh int status; 4421c77534f6STao Mao int uninitialized_var(free_records); 4422ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 4423dcd0538fSMark Fasheh struct ocfs2_insert_type insert = {0, }; 4424dcd0538fSMark Fasheh struct ocfs2_extent_rec rec; 4425ccd979bdSMark Fasheh 4426dcd0538fSMark Fasheh mlog(0, "add %u clusters at position %u to inode %llu\n", 4427dcd0538fSMark Fasheh new_clusters, cpos, (unsigned long long)OCFS2_I(inode)->ip_blkno); 4428ccd979bdSMark Fasheh 4429e48edee2SMark Fasheh memset(&rec, 0, sizeof(rec)); 4430dcd0538fSMark Fasheh rec.e_cpos = cpu_to_le32(cpos); 4431dcd0538fSMark Fasheh rec.e_blkno = cpu_to_le64(start_blk); 4432e48edee2SMark Fasheh rec.e_leaf_clusters = cpu_to_le16(new_clusters); 44332ae99a60SMark Fasheh rec.e_flags = flags; 44341e61ee79SJoel Becker status = ocfs2_et_insert_check(inode, et, &rec); 44351e61ee79SJoel Becker if (status) { 44361e61ee79SJoel Becker mlog_errno(status); 44371e61ee79SJoel Becker goto bail; 44381e61ee79SJoel Becker } 4439ccd979bdSMark Fasheh 4440e7d4cb6bSTao Ma status = ocfs2_figure_insert_type(inode, et, &last_eb_bh, &rec, 4441c77534f6STao Mao &free_records, &insert); 4442ccd979bdSMark Fasheh if (status < 0) { 4443dcd0538fSMark Fasheh mlog_errno(status); 4444ccd979bdSMark Fasheh goto bail; 4445ccd979bdSMark Fasheh } 4446ccd979bdSMark Fasheh 4447dcd0538fSMark Fasheh mlog(0, "Insert.appending: %u, Insert.Contig: %u, " 4448dcd0538fSMark Fasheh "Insert.contig_index: %d, Insert.free_records: %d, " 4449dcd0538fSMark Fasheh "Insert.tree_depth: %d\n", 4450dcd0538fSMark Fasheh insert.ins_appending, insert.ins_contig, insert.ins_contig_index, 4451c77534f6STao Mao free_records, insert.ins_tree_depth); 4452dcd0538fSMark Fasheh 4453c77534f6STao Mao if (insert.ins_contig == CONTIG_NONE && free_records == 0) { 4454e7d4cb6bSTao Ma status = ocfs2_grow_tree(inode, handle, et, 4455328d5752SMark Fasheh &insert.ins_tree_depth, &last_eb_bh, 4456ccd979bdSMark Fasheh meta_ac); 4457c3afcbb3SMark Fasheh if (status) { 4458ccd979bdSMark Fasheh mlog_errno(status); 4459ccd979bdSMark Fasheh goto bail; 4460ccd979bdSMark Fasheh } 4461c3afcbb3SMark Fasheh } 4462ccd979bdSMark Fasheh 4463dcd0538fSMark Fasheh /* Finally, we can add clusters. This might rotate the tree for us. */ 4464e7d4cb6bSTao Ma status = ocfs2_do_insert_extent(inode, handle, et, &rec, &insert); 4465ccd979bdSMark Fasheh if (status < 0) 4466ccd979bdSMark Fasheh mlog_errno(status); 4467ce1d9ea6SJoel Becker else if (et->et_type == OCFS2_DINODE_EXTENT) 446883418978SMark Fasheh ocfs2_extent_map_insert_rec(inode, &rec); 4469ccd979bdSMark Fasheh 4470ccd979bdSMark Fasheh bail: 4471ccd979bdSMark Fasheh if (last_eb_bh) 4472ccd979bdSMark Fasheh brelse(last_eb_bh); 4473ccd979bdSMark Fasheh 4474f56654c4STao Ma mlog_exit(status); 4475f56654c4STao Ma return status; 4476f56654c4STao Ma } 4477f56654c4STao Ma 4478f56654c4STao Ma int ocfs2_dinode_insert_extent(struct ocfs2_super *osb, 4479f56654c4STao Ma handle_t *handle, 4480f56654c4STao Ma struct inode *inode, 4481f56654c4STao Ma struct buffer_head *root_bh, 4482f56654c4STao Ma u32 cpos, 4483f56654c4STao Ma u64 start_blk, 4484f56654c4STao Ma u32 new_clusters, 4485f56654c4STao Ma u8 flags, 4486f56654c4STao Ma struct ocfs2_alloc_context *meta_ac) 4487f56654c4STao Ma { 4488f56654c4STao Ma int status; 4489dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4490f56654c4STao Ma 44911a09f556SJoel Becker ocfs2_get_dinode_extent_tree(&et, inode, root_bh); 4492f56654c4STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4493f56654c4STao Ma cpos, start_blk, new_clusters, 4494dc0ce61aSJoel Becker flags, meta_ac, &et); 4495dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4496f56654c4STao Ma 4497f56654c4STao Ma return status; 4498f56654c4STao Ma } 4499f56654c4STao Ma 4500f56654c4STao Ma int ocfs2_xattr_value_insert_extent(struct ocfs2_super *osb, 4501f56654c4STao Ma handle_t *handle, 4502f56654c4STao Ma struct inode *inode, 4503f56654c4STao Ma struct buffer_head *root_bh, 4504f56654c4STao Ma u32 cpos, 4505f56654c4STao Ma u64 start_blk, 4506f56654c4STao Ma u32 new_clusters, 4507f56654c4STao Ma u8 flags, 4508f56654c4STao Ma struct ocfs2_alloc_context *meta_ac, 45091a09f556SJoel Becker struct ocfs2_xattr_value_root *xv) 4510f56654c4STao Ma { 4511f56654c4STao Ma int status; 4512dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4513f56654c4STao Ma 45141a09f556SJoel Becker ocfs2_get_xattr_value_extent_tree(&et, inode, root_bh, xv); 4515f56654c4STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4516f56654c4STao Ma cpos, start_blk, new_clusters, 4517dc0ce61aSJoel Becker flags, meta_ac, &et); 4518dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4519f56654c4STao Ma 4520ccd979bdSMark Fasheh return status; 4521ccd979bdSMark Fasheh } 4522ccd979bdSMark Fasheh 4523ba492615STao Ma int ocfs2_xattr_tree_insert_extent(struct ocfs2_super *osb, 4524ba492615STao Ma handle_t *handle, 4525ba492615STao Ma struct inode *inode, 4526ba492615STao Ma struct buffer_head *root_bh, 4527ba492615STao Ma u32 cpos, 4528ba492615STao Ma u64 start_blk, 4529ba492615STao Ma u32 new_clusters, 4530ba492615STao Ma u8 flags, 4531ba492615STao Ma struct ocfs2_alloc_context *meta_ac) 4532ba492615STao Ma { 4533ba492615STao Ma int status; 4534dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4535ba492615STao Ma 45361a09f556SJoel Becker ocfs2_get_xattr_tree_extent_tree(&et, inode, root_bh); 4537ba492615STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4538ba492615STao Ma cpos, start_blk, new_clusters, 4539dc0ce61aSJoel Becker flags, meta_ac, &et); 4540dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4541ba492615STao Ma 4542ba492615STao Ma return status; 4543ba492615STao Ma } 4544ba492615STao Ma 45450eb8d47eSTao Ma /* 45460eb8d47eSTao Ma * Allcate and add clusters into the extent b-tree. 45470eb8d47eSTao Ma * The new clusters(clusters_to_add) will be inserted at logical_offset. 45480eb8d47eSTao Ma * The extent b-tree's root is root_el and it should be in root_bh, and 45490eb8d47eSTao Ma * it is not limited to the file storage. Any extent tree can use this 45500eb8d47eSTao Ma * function if it implements the proper ocfs2_extent_tree. 45510eb8d47eSTao Ma */ 45520eb8d47eSTao Ma int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb, 45530eb8d47eSTao Ma struct inode *inode, 45540eb8d47eSTao Ma u32 *logical_offset, 45550eb8d47eSTao Ma u32 clusters_to_add, 45560eb8d47eSTao Ma int mark_unwritten, 45570eb8d47eSTao Ma struct buffer_head *root_bh, 45580eb8d47eSTao Ma struct ocfs2_extent_list *root_el, 45590eb8d47eSTao Ma handle_t *handle, 45600eb8d47eSTao Ma struct ocfs2_alloc_context *data_ac, 45610eb8d47eSTao Ma struct ocfs2_alloc_context *meta_ac, 45620eb8d47eSTao Ma enum ocfs2_alloc_restarted *reason_ret, 4563f56654c4STao Ma enum ocfs2_extent_tree_type type, 4564ea5efa15SJoel Becker void *obj) 45650eb8d47eSTao Ma { 45660eb8d47eSTao Ma int status = 0; 45670eb8d47eSTao Ma int free_extents; 45680eb8d47eSTao Ma enum ocfs2_alloc_restarted reason = RESTART_NONE; 45690eb8d47eSTao Ma u32 bit_off, num_bits; 45700eb8d47eSTao Ma u64 block; 45710eb8d47eSTao Ma u8 flags = 0; 45720eb8d47eSTao Ma 45730eb8d47eSTao Ma BUG_ON(!clusters_to_add); 45740eb8d47eSTao Ma 45750eb8d47eSTao Ma if (mark_unwritten) 45760eb8d47eSTao Ma flags = OCFS2_EXT_UNWRITTEN; 45770eb8d47eSTao Ma 4578f56654c4STao Ma free_extents = ocfs2_num_free_extents(osb, inode, root_bh, type, 4579ea5efa15SJoel Becker obj); 45800eb8d47eSTao Ma if (free_extents < 0) { 45810eb8d47eSTao Ma status = free_extents; 45820eb8d47eSTao Ma mlog_errno(status); 45830eb8d47eSTao Ma goto leave; 45840eb8d47eSTao Ma } 45850eb8d47eSTao Ma 45860eb8d47eSTao Ma /* there are two cases which could cause us to EAGAIN in the 45870eb8d47eSTao Ma * we-need-more-metadata case: 45880eb8d47eSTao Ma * 1) we haven't reserved *any* 45890eb8d47eSTao Ma * 2) we are so fragmented, we've needed to add metadata too 45900eb8d47eSTao Ma * many times. */ 45910eb8d47eSTao Ma if (!free_extents && !meta_ac) { 45920eb8d47eSTao Ma mlog(0, "we haven't reserved any metadata!\n"); 45930eb8d47eSTao Ma status = -EAGAIN; 45940eb8d47eSTao Ma reason = RESTART_META; 45950eb8d47eSTao Ma goto leave; 45960eb8d47eSTao Ma } else if ((!free_extents) 45970eb8d47eSTao Ma && (ocfs2_alloc_context_bits_left(meta_ac) 45980eb8d47eSTao Ma < ocfs2_extend_meta_needed(root_el))) { 45990eb8d47eSTao Ma mlog(0, "filesystem is really fragmented...\n"); 46000eb8d47eSTao Ma status = -EAGAIN; 46010eb8d47eSTao Ma reason = RESTART_META; 46020eb8d47eSTao Ma goto leave; 46030eb8d47eSTao Ma } 46040eb8d47eSTao Ma 46050eb8d47eSTao Ma status = __ocfs2_claim_clusters(osb, handle, data_ac, 1, 46060eb8d47eSTao Ma clusters_to_add, &bit_off, &num_bits); 46070eb8d47eSTao Ma if (status < 0) { 46080eb8d47eSTao Ma if (status != -ENOSPC) 46090eb8d47eSTao Ma mlog_errno(status); 46100eb8d47eSTao Ma goto leave; 46110eb8d47eSTao Ma } 46120eb8d47eSTao Ma 46130eb8d47eSTao Ma BUG_ON(num_bits > clusters_to_add); 46140eb8d47eSTao Ma 46150eb8d47eSTao Ma /* reserve our write early -- insert_extent may update the inode */ 46160eb8d47eSTao Ma status = ocfs2_journal_access(handle, inode, root_bh, 46170eb8d47eSTao Ma OCFS2_JOURNAL_ACCESS_WRITE); 46180eb8d47eSTao Ma if (status < 0) { 46190eb8d47eSTao Ma mlog_errno(status); 46200eb8d47eSTao Ma goto leave; 46210eb8d47eSTao Ma } 46220eb8d47eSTao Ma 46230eb8d47eSTao Ma block = ocfs2_clusters_to_blocks(osb->sb, bit_off); 46240eb8d47eSTao Ma mlog(0, "Allocating %u clusters at block %u for inode %llu\n", 46250eb8d47eSTao Ma num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno); 4626f56654c4STao Ma if (type == OCFS2_DINODE_EXTENT) 4627f56654c4STao Ma status = ocfs2_dinode_insert_extent(osb, handle, inode, root_bh, 4628f56654c4STao Ma *logical_offset, block, 4629f56654c4STao Ma num_bits, flags, meta_ac); 4630ba492615STao Ma else if (type == OCFS2_XATTR_TREE_EXTENT) 4631ba492615STao Ma status = ocfs2_xattr_tree_insert_extent(osb, handle, 4632ba492615STao Ma inode, root_bh, 4633ba492615STao Ma *logical_offset, 4634ba492615STao Ma block, num_bits, flags, 4635ba492615STao Ma meta_ac); 4636f56654c4STao Ma else 4637f56654c4STao Ma status = ocfs2_xattr_value_insert_extent(osb, handle, 4638f56654c4STao Ma inode, root_bh, 4639f56654c4STao Ma *logical_offset, 4640f56654c4STao Ma block, num_bits, flags, 4641ea5efa15SJoel Becker meta_ac, obj); 46420eb8d47eSTao Ma if (status < 0) { 46430eb8d47eSTao Ma mlog_errno(status); 46440eb8d47eSTao Ma goto leave; 46450eb8d47eSTao Ma } 46460eb8d47eSTao Ma 46470eb8d47eSTao Ma status = ocfs2_journal_dirty(handle, root_bh); 46480eb8d47eSTao Ma if (status < 0) { 46490eb8d47eSTao Ma mlog_errno(status); 46500eb8d47eSTao Ma goto leave; 46510eb8d47eSTao Ma } 46520eb8d47eSTao Ma 46530eb8d47eSTao Ma clusters_to_add -= num_bits; 46540eb8d47eSTao Ma *logical_offset += num_bits; 46550eb8d47eSTao Ma 46560eb8d47eSTao Ma if (clusters_to_add) { 46570eb8d47eSTao Ma mlog(0, "need to alloc once more, wanted = %u\n", 46580eb8d47eSTao Ma clusters_to_add); 46590eb8d47eSTao Ma status = -EAGAIN; 46600eb8d47eSTao Ma reason = RESTART_TRANS; 46610eb8d47eSTao Ma } 46620eb8d47eSTao Ma 46630eb8d47eSTao Ma leave: 46640eb8d47eSTao Ma mlog_exit(status); 46650eb8d47eSTao Ma if (reason_ret) 46660eb8d47eSTao Ma *reason_ret = reason; 46670eb8d47eSTao Ma return status; 46680eb8d47eSTao Ma } 46690eb8d47eSTao Ma 4670328d5752SMark Fasheh static void ocfs2_make_right_split_rec(struct super_block *sb, 4671328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 4672328d5752SMark Fasheh u32 cpos, 4673328d5752SMark Fasheh struct ocfs2_extent_rec *rec) 4674328d5752SMark Fasheh { 4675328d5752SMark Fasheh u32 rec_cpos = le32_to_cpu(rec->e_cpos); 4676328d5752SMark Fasheh u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters); 4677328d5752SMark Fasheh 4678328d5752SMark Fasheh memset(split_rec, 0, sizeof(struct ocfs2_extent_rec)); 4679328d5752SMark Fasheh 4680328d5752SMark Fasheh split_rec->e_cpos = cpu_to_le32(cpos); 4681328d5752SMark Fasheh split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos); 4682328d5752SMark Fasheh 4683328d5752SMark Fasheh split_rec->e_blkno = rec->e_blkno; 4684328d5752SMark Fasheh le64_add_cpu(&split_rec->e_blkno, 4685328d5752SMark Fasheh ocfs2_clusters_to_blocks(sb, cpos - rec_cpos)); 4686328d5752SMark Fasheh 4687328d5752SMark Fasheh split_rec->e_flags = rec->e_flags; 4688328d5752SMark Fasheh } 4689328d5752SMark Fasheh 4690328d5752SMark Fasheh static int ocfs2_split_and_insert(struct inode *inode, 4691328d5752SMark Fasheh handle_t *handle, 4692328d5752SMark Fasheh struct ocfs2_path *path, 4693e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4694328d5752SMark Fasheh struct buffer_head **last_eb_bh, 4695328d5752SMark Fasheh int split_index, 4696328d5752SMark Fasheh struct ocfs2_extent_rec *orig_split_rec, 4697328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac) 4698328d5752SMark Fasheh { 4699328d5752SMark Fasheh int ret = 0, depth; 4700328d5752SMark Fasheh unsigned int insert_range, rec_range, do_leftright = 0; 4701328d5752SMark Fasheh struct ocfs2_extent_rec tmprec; 4702328d5752SMark Fasheh struct ocfs2_extent_list *rightmost_el; 4703328d5752SMark Fasheh struct ocfs2_extent_rec rec; 4704328d5752SMark Fasheh struct ocfs2_extent_rec split_rec = *orig_split_rec; 4705328d5752SMark Fasheh struct ocfs2_insert_type insert; 4706328d5752SMark Fasheh struct ocfs2_extent_block *eb; 4707328d5752SMark Fasheh 4708328d5752SMark Fasheh leftright: 4709328d5752SMark Fasheh /* 4710328d5752SMark Fasheh * Store a copy of the record on the stack - it might move 4711328d5752SMark Fasheh * around as the tree is manipulated below. 4712328d5752SMark Fasheh */ 4713328d5752SMark Fasheh rec = path_leaf_el(path)->l_recs[split_index]; 4714328d5752SMark Fasheh 4715ce1d9ea6SJoel Becker rightmost_el = et->et_root_el; 4716328d5752SMark Fasheh 4717328d5752SMark Fasheh depth = le16_to_cpu(rightmost_el->l_tree_depth); 4718328d5752SMark Fasheh if (depth) { 4719328d5752SMark Fasheh BUG_ON(!(*last_eb_bh)); 4720328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data; 4721328d5752SMark Fasheh rightmost_el = &eb->h_list; 4722328d5752SMark Fasheh } 4723328d5752SMark Fasheh 4724328d5752SMark Fasheh if (le16_to_cpu(rightmost_el->l_next_free_rec) == 4725328d5752SMark Fasheh le16_to_cpu(rightmost_el->l_count)) { 4726e7d4cb6bSTao Ma ret = ocfs2_grow_tree(inode, handle, et, 4727e7d4cb6bSTao Ma &depth, last_eb_bh, meta_ac); 4728328d5752SMark Fasheh if (ret) { 4729328d5752SMark Fasheh mlog_errno(ret); 4730328d5752SMark Fasheh goto out; 4731328d5752SMark Fasheh } 4732328d5752SMark Fasheh } 4733328d5752SMark Fasheh 4734328d5752SMark Fasheh memset(&insert, 0, sizeof(struct ocfs2_insert_type)); 4735328d5752SMark Fasheh insert.ins_appending = APPEND_NONE; 4736328d5752SMark Fasheh insert.ins_contig = CONTIG_NONE; 4737328d5752SMark Fasheh insert.ins_tree_depth = depth; 4738328d5752SMark Fasheh 4739328d5752SMark Fasheh insert_range = le32_to_cpu(split_rec.e_cpos) + 4740328d5752SMark Fasheh le16_to_cpu(split_rec.e_leaf_clusters); 4741328d5752SMark Fasheh rec_range = le32_to_cpu(rec.e_cpos) + 4742328d5752SMark Fasheh le16_to_cpu(rec.e_leaf_clusters); 4743328d5752SMark Fasheh 4744328d5752SMark Fasheh if (split_rec.e_cpos == rec.e_cpos) { 4745328d5752SMark Fasheh insert.ins_split = SPLIT_LEFT; 4746328d5752SMark Fasheh } else if (insert_range == rec_range) { 4747328d5752SMark Fasheh insert.ins_split = SPLIT_RIGHT; 4748328d5752SMark Fasheh } else { 4749328d5752SMark Fasheh /* 4750328d5752SMark Fasheh * Left/right split. We fake this as a right split 4751328d5752SMark Fasheh * first and then make a second pass as a left split. 4752328d5752SMark Fasheh */ 4753328d5752SMark Fasheh insert.ins_split = SPLIT_RIGHT; 4754328d5752SMark Fasheh 4755328d5752SMark Fasheh ocfs2_make_right_split_rec(inode->i_sb, &tmprec, insert_range, 4756328d5752SMark Fasheh &rec); 4757328d5752SMark Fasheh 4758328d5752SMark Fasheh split_rec = tmprec; 4759328d5752SMark Fasheh 4760328d5752SMark Fasheh BUG_ON(do_leftright); 4761328d5752SMark Fasheh do_leftright = 1; 4762328d5752SMark Fasheh } 4763328d5752SMark Fasheh 4764e7d4cb6bSTao Ma ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert); 4765328d5752SMark Fasheh if (ret) { 4766328d5752SMark Fasheh mlog_errno(ret); 4767328d5752SMark Fasheh goto out; 4768328d5752SMark Fasheh } 4769328d5752SMark Fasheh 4770328d5752SMark Fasheh if (do_leftright == 1) { 4771328d5752SMark Fasheh u32 cpos; 4772328d5752SMark Fasheh struct ocfs2_extent_list *el; 4773328d5752SMark Fasheh 4774328d5752SMark Fasheh do_leftright++; 4775328d5752SMark Fasheh split_rec = *orig_split_rec; 4776328d5752SMark Fasheh 4777328d5752SMark Fasheh ocfs2_reinit_path(path, 1); 4778328d5752SMark Fasheh 4779328d5752SMark Fasheh cpos = le32_to_cpu(split_rec.e_cpos); 4780328d5752SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 4781328d5752SMark Fasheh if (ret) { 4782328d5752SMark Fasheh mlog_errno(ret); 4783328d5752SMark Fasheh goto out; 4784328d5752SMark Fasheh } 4785328d5752SMark Fasheh 4786328d5752SMark Fasheh el = path_leaf_el(path); 4787328d5752SMark Fasheh split_index = ocfs2_search_extent_list(el, cpos); 4788328d5752SMark Fasheh goto leftright; 4789328d5752SMark Fasheh } 4790328d5752SMark Fasheh out: 4791328d5752SMark Fasheh 4792328d5752SMark Fasheh return ret; 4793328d5752SMark Fasheh } 4794328d5752SMark Fasheh 4795328d5752SMark Fasheh /* 4796328d5752SMark Fasheh * Mark part or all of the extent record at split_index in the leaf 4797328d5752SMark Fasheh * pointed to by path as written. This removes the unwritten 4798328d5752SMark Fasheh * extent flag. 4799328d5752SMark Fasheh * 4800328d5752SMark Fasheh * Care is taken to handle contiguousness so as to not grow the tree. 4801328d5752SMark Fasheh * 4802328d5752SMark Fasheh * meta_ac is not strictly necessary - we only truly need it if growth 4803328d5752SMark Fasheh * of the tree is required. All other cases will degrade into a less 4804328d5752SMark Fasheh * optimal tree layout. 4805328d5752SMark Fasheh * 4806e7d4cb6bSTao Ma * last_eb_bh should be the rightmost leaf block for any extent 4807e7d4cb6bSTao Ma * btree. Since a split may grow the tree or a merge might shrink it, 4808e7d4cb6bSTao Ma * the caller cannot trust the contents of that buffer after this call. 4809328d5752SMark Fasheh * 4810328d5752SMark Fasheh * This code is optimized for readability - several passes might be 4811328d5752SMark Fasheh * made over certain portions of the tree. All of those blocks will 4812328d5752SMark Fasheh * have been brought into cache (and pinned via the journal), so the 4813328d5752SMark Fasheh * extra overhead is not expressed in terms of disk reads. 4814328d5752SMark Fasheh */ 4815328d5752SMark Fasheh static int __ocfs2_mark_extent_written(struct inode *inode, 4816e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4817328d5752SMark Fasheh handle_t *handle, 4818328d5752SMark Fasheh struct ocfs2_path *path, 4819328d5752SMark Fasheh int split_index, 4820328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 4821328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac, 4822328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc) 4823328d5752SMark Fasheh { 4824328d5752SMark Fasheh int ret = 0; 4825328d5752SMark Fasheh struct ocfs2_extent_list *el = path_leaf_el(path); 4826e8aed345SMark Fasheh struct buffer_head *last_eb_bh = NULL; 4827328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[split_index]; 4828328d5752SMark Fasheh struct ocfs2_merge_ctxt ctxt; 4829328d5752SMark Fasheh struct ocfs2_extent_list *rightmost_el; 4830328d5752SMark Fasheh 48313cf0c507SRoel Kluin if (!(rec->e_flags & OCFS2_EXT_UNWRITTEN)) { 4832328d5752SMark Fasheh ret = -EIO; 4833328d5752SMark Fasheh mlog_errno(ret); 4834328d5752SMark Fasheh goto out; 4835328d5752SMark Fasheh } 4836328d5752SMark Fasheh 4837328d5752SMark Fasheh if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) || 4838328d5752SMark Fasheh ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) < 4839328d5752SMark Fasheh (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) { 4840328d5752SMark Fasheh ret = -EIO; 4841328d5752SMark Fasheh mlog_errno(ret); 4842328d5752SMark Fasheh goto out; 4843328d5752SMark Fasheh } 4844328d5752SMark Fasheh 4845ad5a4d70STao Ma ctxt.c_contig_type = ocfs2_figure_merge_contig_type(inode, path, el, 4846328d5752SMark Fasheh split_index, 4847328d5752SMark Fasheh split_rec); 4848328d5752SMark Fasheh 4849328d5752SMark Fasheh /* 4850328d5752SMark Fasheh * The core merge / split code wants to know how much room is 4851328d5752SMark Fasheh * left in this inodes allocation tree, so we pass the 4852328d5752SMark Fasheh * rightmost extent list. 4853328d5752SMark Fasheh */ 4854328d5752SMark Fasheh if (path->p_tree_depth) { 4855328d5752SMark Fasheh struct ocfs2_extent_block *eb; 4856328d5752SMark Fasheh 4857328d5752SMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 485835dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), 4859328d5752SMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 4860328d5752SMark Fasheh if (ret) { 4861328d5752SMark Fasheh mlog_exit(ret); 4862328d5752SMark Fasheh goto out; 4863328d5752SMark Fasheh } 4864328d5752SMark Fasheh 4865328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 4866328d5752SMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 4867328d5752SMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 4868328d5752SMark Fasheh ret = -EROFS; 4869328d5752SMark Fasheh goto out; 4870328d5752SMark Fasheh } 4871328d5752SMark Fasheh 4872328d5752SMark Fasheh rightmost_el = &eb->h_list; 4873328d5752SMark Fasheh } else 4874328d5752SMark Fasheh rightmost_el = path_root_el(path); 4875328d5752SMark Fasheh 4876328d5752SMark Fasheh if (rec->e_cpos == split_rec->e_cpos && 4877328d5752SMark Fasheh rec->e_leaf_clusters == split_rec->e_leaf_clusters) 4878328d5752SMark Fasheh ctxt.c_split_covers_rec = 1; 4879328d5752SMark Fasheh else 4880328d5752SMark Fasheh ctxt.c_split_covers_rec = 0; 4881328d5752SMark Fasheh 4882328d5752SMark Fasheh ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]); 4883328d5752SMark Fasheh 4884015452b1SMark Fasheh mlog(0, "index: %d, contig: %u, has_empty: %u, split_covers: %u\n", 4885015452b1SMark Fasheh split_index, ctxt.c_contig_type, ctxt.c_has_empty_extent, 4886015452b1SMark Fasheh ctxt.c_split_covers_rec); 4887328d5752SMark Fasheh 4888328d5752SMark Fasheh if (ctxt.c_contig_type == CONTIG_NONE) { 4889328d5752SMark Fasheh if (ctxt.c_split_covers_rec) 4890328d5752SMark Fasheh el->l_recs[split_index] = *split_rec; 4891328d5752SMark Fasheh else 4892e7d4cb6bSTao Ma ret = ocfs2_split_and_insert(inode, handle, path, et, 4893328d5752SMark Fasheh &last_eb_bh, split_index, 4894328d5752SMark Fasheh split_rec, meta_ac); 4895328d5752SMark Fasheh if (ret) 4896328d5752SMark Fasheh mlog_errno(ret); 4897328d5752SMark Fasheh } else { 4898328d5752SMark Fasheh ret = ocfs2_try_to_merge_extent(inode, handle, path, 4899328d5752SMark Fasheh split_index, split_rec, 4900e7d4cb6bSTao Ma dealloc, &ctxt, et); 4901328d5752SMark Fasheh if (ret) 4902328d5752SMark Fasheh mlog_errno(ret); 4903328d5752SMark Fasheh } 4904328d5752SMark Fasheh 4905328d5752SMark Fasheh out: 4906328d5752SMark Fasheh brelse(last_eb_bh); 4907328d5752SMark Fasheh return ret; 4908328d5752SMark Fasheh } 4909328d5752SMark Fasheh 4910328d5752SMark Fasheh /* 4911328d5752SMark Fasheh * Mark the already-existing extent at cpos as written for len clusters. 4912328d5752SMark Fasheh * 4913328d5752SMark Fasheh * If the existing extent is larger than the request, initiate a 4914328d5752SMark Fasheh * split. An attempt will be made at merging with adjacent extents. 4915328d5752SMark Fasheh * 4916328d5752SMark Fasheh * The caller is responsible for passing down meta_ac if we'll need it. 4917328d5752SMark Fasheh */ 4918e7d4cb6bSTao Ma int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *root_bh, 4919328d5752SMark Fasheh handle_t *handle, u32 cpos, u32 len, u32 phys, 4920328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac, 4921e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 4922f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 4923ea5efa15SJoel Becker void *obj) 4924328d5752SMark Fasheh { 4925328d5752SMark Fasheh int ret, index; 4926328d5752SMark Fasheh u64 start_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys); 4927328d5752SMark Fasheh struct ocfs2_extent_rec split_rec; 4928328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 4929328d5752SMark Fasheh struct ocfs2_extent_list *el; 4930dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4931328d5752SMark Fasheh 4932328d5752SMark Fasheh mlog(0, "Inode %lu cpos %u, len %u, phys %u (%llu)\n", 4933328d5752SMark Fasheh inode->i_ino, cpos, len, phys, (unsigned long long)start_blkno); 4934328d5752SMark Fasheh 4935ea5efa15SJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, et_type, obj); 4936dc0ce61aSJoel Becker 4937328d5752SMark Fasheh if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) { 4938328d5752SMark Fasheh ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents " 4939328d5752SMark Fasheh "that are being written to, but the feature bit " 4940328d5752SMark Fasheh "is not set in the super block.", 4941328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 4942328d5752SMark Fasheh ret = -EROFS; 4943328d5752SMark Fasheh goto out; 4944328d5752SMark Fasheh } 4945328d5752SMark Fasheh 4946328d5752SMark Fasheh /* 4947328d5752SMark Fasheh * XXX: This should be fixed up so that we just re-insert the 4948328d5752SMark Fasheh * next extent records. 4949328d5752SMark Fasheh */ 4950e7d4cb6bSTao Ma if (et_type == OCFS2_DINODE_EXTENT) 4951328d5752SMark Fasheh ocfs2_extent_map_trunc(inode, 0); 4952328d5752SMark Fasheh 4953dc0ce61aSJoel Becker left_path = ocfs2_new_path(et.et_root_bh, et.et_root_el); 4954328d5752SMark Fasheh if (!left_path) { 4955328d5752SMark Fasheh ret = -ENOMEM; 4956328d5752SMark Fasheh mlog_errno(ret); 4957328d5752SMark Fasheh goto out; 4958328d5752SMark Fasheh } 4959328d5752SMark Fasheh 4960328d5752SMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 4961328d5752SMark Fasheh if (ret) { 4962328d5752SMark Fasheh mlog_errno(ret); 4963328d5752SMark Fasheh goto out; 4964328d5752SMark Fasheh } 4965328d5752SMark Fasheh el = path_leaf_el(left_path); 4966328d5752SMark Fasheh 4967328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 4968328d5752SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 4969328d5752SMark Fasheh ocfs2_error(inode->i_sb, 4970328d5752SMark Fasheh "Inode %llu has an extent at cpos %u which can no " 4971328d5752SMark Fasheh "longer be found.\n", 4972328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos); 4973328d5752SMark Fasheh ret = -EROFS; 4974328d5752SMark Fasheh goto out; 4975328d5752SMark Fasheh } 4976328d5752SMark Fasheh 4977328d5752SMark Fasheh memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec)); 4978328d5752SMark Fasheh split_rec.e_cpos = cpu_to_le32(cpos); 4979328d5752SMark Fasheh split_rec.e_leaf_clusters = cpu_to_le16(len); 4980328d5752SMark Fasheh split_rec.e_blkno = cpu_to_le64(start_blkno); 4981328d5752SMark Fasheh split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags; 4982328d5752SMark Fasheh split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN; 4983328d5752SMark Fasheh 4984dc0ce61aSJoel Becker ret = __ocfs2_mark_extent_written(inode, &et, handle, left_path, 4985e7d4cb6bSTao Ma index, &split_rec, meta_ac, 4986e7d4cb6bSTao Ma dealloc); 4987328d5752SMark Fasheh if (ret) 4988328d5752SMark Fasheh mlog_errno(ret); 4989328d5752SMark Fasheh 4990328d5752SMark Fasheh out: 4991328d5752SMark Fasheh ocfs2_free_path(left_path); 4992dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4993328d5752SMark Fasheh return ret; 4994328d5752SMark Fasheh } 4995328d5752SMark Fasheh 4996e7d4cb6bSTao Ma static int ocfs2_split_tree(struct inode *inode, struct ocfs2_extent_tree *et, 4997d0c7d708SMark Fasheh handle_t *handle, struct ocfs2_path *path, 4998d0c7d708SMark Fasheh int index, u32 new_range, 4999d0c7d708SMark Fasheh struct ocfs2_alloc_context *meta_ac) 5000d0c7d708SMark Fasheh { 5001d0c7d708SMark Fasheh int ret, depth, credits = handle->h_buffer_credits; 5002d0c7d708SMark Fasheh struct buffer_head *last_eb_bh = NULL; 5003d0c7d708SMark Fasheh struct ocfs2_extent_block *eb; 5004d0c7d708SMark Fasheh struct ocfs2_extent_list *rightmost_el, *el; 5005d0c7d708SMark Fasheh struct ocfs2_extent_rec split_rec; 5006d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 5007d0c7d708SMark Fasheh struct ocfs2_insert_type insert; 5008d0c7d708SMark Fasheh 5009d0c7d708SMark Fasheh /* 5010d0c7d708SMark Fasheh * Setup the record to split before we grow the tree. 5011d0c7d708SMark Fasheh */ 5012d0c7d708SMark Fasheh el = path_leaf_el(path); 5013d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5014d0c7d708SMark Fasheh ocfs2_make_right_split_rec(inode->i_sb, &split_rec, new_range, rec); 5015d0c7d708SMark Fasheh 5016d0c7d708SMark Fasheh depth = path->p_tree_depth; 5017d0c7d708SMark Fasheh if (depth > 0) { 5018d0c7d708SMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 501935dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), 5020d0c7d708SMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 5021d0c7d708SMark Fasheh if (ret < 0) { 5022d0c7d708SMark Fasheh mlog_errno(ret); 5023d0c7d708SMark Fasheh goto out; 5024d0c7d708SMark Fasheh } 5025d0c7d708SMark Fasheh 5026d0c7d708SMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 5027d0c7d708SMark Fasheh rightmost_el = &eb->h_list; 5028d0c7d708SMark Fasheh } else 5029d0c7d708SMark Fasheh rightmost_el = path_leaf_el(path); 5030d0c7d708SMark Fasheh 5031811f933dSTao Ma credits += path->p_tree_depth + 5032ce1d9ea6SJoel Becker ocfs2_extend_meta_needed(et->et_root_el); 5033d0c7d708SMark Fasheh ret = ocfs2_extend_trans(handle, credits); 5034d0c7d708SMark Fasheh if (ret) { 5035d0c7d708SMark Fasheh mlog_errno(ret); 5036d0c7d708SMark Fasheh goto out; 5037d0c7d708SMark Fasheh } 5038d0c7d708SMark Fasheh 5039d0c7d708SMark Fasheh if (le16_to_cpu(rightmost_el->l_next_free_rec) == 5040d0c7d708SMark Fasheh le16_to_cpu(rightmost_el->l_count)) { 5041e7d4cb6bSTao Ma ret = ocfs2_grow_tree(inode, handle, et, &depth, &last_eb_bh, 5042d0c7d708SMark Fasheh meta_ac); 5043d0c7d708SMark Fasheh if (ret) { 5044d0c7d708SMark Fasheh mlog_errno(ret); 5045d0c7d708SMark Fasheh goto out; 5046d0c7d708SMark Fasheh } 5047d0c7d708SMark Fasheh } 5048d0c7d708SMark Fasheh 5049d0c7d708SMark Fasheh memset(&insert, 0, sizeof(struct ocfs2_insert_type)); 5050d0c7d708SMark Fasheh insert.ins_appending = APPEND_NONE; 5051d0c7d708SMark Fasheh insert.ins_contig = CONTIG_NONE; 5052d0c7d708SMark Fasheh insert.ins_split = SPLIT_RIGHT; 5053d0c7d708SMark Fasheh insert.ins_tree_depth = depth; 5054d0c7d708SMark Fasheh 5055e7d4cb6bSTao Ma ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert); 5056d0c7d708SMark Fasheh if (ret) 5057d0c7d708SMark Fasheh mlog_errno(ret); 5058d0c7d708SMark Fasheh 5059d0c7d708SMark Fasheh out: 5060d0c7d708SMark Fasheh brelse(last_eb_bh); 5061d0c7d708SMark Fasheh return ret; 5062d0c7d708SMark Fasheh } 5063d0c7d708SMark Fasheh 5064d0c7d708SMark Fasheh static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle, 5065d0c7d708SMark Fasheh struct ocfs2_path *path, int index, 5066d0c7d708SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 5067e7d4cb6bSTao Ma u32 cpos, u32 len, 5068e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 5069d0c7d708SMark Fasheh { 5070d0c7d708SMark Fasheh int ret; 5071d0c7d708SMark Fasheh u32 left_cpos, rec_range, trunc_range; 5072d0c7d708SMark Fasheh int wants_rotate = 0, is_rightmost_tree_rec = 0; 5073d0c7d708SMark Fasheh struct super_block *sb = inode->i_sb; 5074d0c7d708SMark Fasheh struct ocfs2_path *left_path = NULL; 5075d0c7d708SMark Fasheh struct ocfs2_extent_list *el = path_leaf_el(path); 5076d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 5077d0c7d708SMark Fasheh struct ocfs2_extent_block *eb; 5078d0c7d708SMark Fasheh 5079d0c7d708SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) { 5080e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et); 5081d0c7d708SMark Fasheh if (ret) { 5082d0c7d708SMark Fasheh mlog_errno(ret); 5083d0c7d708SMark Fasheh goto out; 5084d0c7d708SMark Fasheh } 5085d0c7d708SMark Fasheh 5086d0c7d708SMark Fasheh index--; 5087d0c7d708SMark Fasheh } 5088d0c7d708SMark Fasheh 5089d0c7d708SMark Fasheh if (index == (le16_to_cpu(el->l_next_free_rec) - 1) && 5090d0c7d708SMark Fasheh path->p_tree_depth) { 5091d0c7d708SMark Fasheh /* 5092d0c7d708SMark Fasheh * Check whether this is the rightmost tree record. If 5093d0c7d708SMark Fasheh * we remove all of this record or part of its right 5094d0c7d708SMark Fasheh * edge then an update of the record lengths above it 5095d0c7d708SMark Fasheh * will be required. 5096d0c7d708SMark Fasheh */ 5097d0c7d708SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 5098d0c7d708SMark Fasheh if (eb->h_next_leaf_blk == 0) 5099d0c7d708SMark Fasheh is_rightmost_tree_rec = 1; 5100d0c7d708SMark Fasheh } 5101d0c7d708SMark Fasheh 5102d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5103d0c7d708SMark Fasheh if (index == 0 && path->p_tree_depth && 5104d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos) == cpos) { 5105d0c7d708SMark Fasheh /* 5106d0c7d708SMark Fasheh * Changing the leftmost offset (via partial or whole 5107d0c7d708SMark Fasheh * record truncate) of an interior (or rightmost) path 5108d0c7d708SMark Fasheh * means we have to update the subtree that is formed 5109d0c7d708SMark Fasheh * by this leaf and the one to it's left. 5110d0c7d708SMark Fasheh * 5111d0c7d708SMark Fasheh * There are two cases we can skip: 5112d0c7d708SMark Fasheh * 1) Path is the leftmost one in our inode tree. 5113d0c7d708SMark Fasheh * 2) The leaf is rightmost and will be empty after 5114d0c7d708SMark Fasheh * we remove the extent record - the rotate code 5115d0c7d708SMark Fasheh * knows how to update the newly formed edge. 5116d0c7d708SMark Fasheh */ 5117d0c7d708SMark Fasheh 5118d0c7d708SMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, 5119d0c7d708SMark Fasheh &left_cpos); 5120d0c7d708SMark Fasheh if (ret) { 5121d0c7d708SMark Fasheh mlog_errno(ret); 5122d0c7d708SMark Fasheh goto out; 5123d0c7d708SMark Fasheh } 5124d0c7d708SMark Fasheh 5125d0c7d708SMark Fasheh if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) { 5126d0c7d708SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 5127d0c7d708SMark Fasheh path_root_el(path)); 5128d0c7d708SMark Fasheh if (!left_path) { 5129d0c7d708SMark Fasheh ret = -ENOMEM; 5130d0c7d708SMark Fasheh mlog_errno(ret); 5131d0c7d708SMark Fasheh goto out; 5132d0c7d708SMark Fasheh } 5133d0c7d708SMark Fasheh 5134d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, left_path, left_cpos); 5135d0c7d708SMark Fasheh if (ret) { 5136d0c7d708SMark Fasheh mlog_errno(ret); 5137d0c7d708SMark Fasheh goto out; 5138d0c7d708SMark Fasheh } 5139d0c7d708SMark Fasheh } 5140d0c7d708SMark Fasheh } 5141d0c7d708SMark Fasheh 5142d0c7d708SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, 0, 5143d0c7d708SMark Fasheh handle->h_buffer_credits, 5144d0c7d708SMark Fasheh path); 5145d0c7d708SMark Fasheh if (ret) { 5146d0c7d708SMark Fasheh mlog_errno(ret); 5147d0c7d708SMark Fasheh goto out; 5148d0c7d708SMark Fasheh } 5149d0c7d708SMark Fasheh 5150d0c7d708SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, path); 5151d0c7d708SMark Fasheh if (ret) { 5152d0c7d708SMark Fasheh mlog_errno(ret); 5153d0c7d708SMark Fasheh goto out; 5154d0c7d708SMark Fasheh } 5155d0c7d708SMark Fasheh 5156d0c7d708SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 5157d0c7d708SMark Fasheh if (ret) { 5158d0c7d708SMark Fasheh mlog_errno(ret); 5159d0c7d708SMark Fasheh goto out; 5160d0c7d708SMark Fasheh } 5161d0c7d708SMark Fasheh 5162d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 5163d0c7d708SMark Fasheh trunc_range = cpos + len; 5164d0c7d708SMark Fasheh 5165d0c7d708SMark Fasheh if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) { 5166d0c7d708SMark Fasheh int next_free; 5167d0c7d708SMark Fasheh 5168d0c7d708SMark Fasheh memset(rec, 0, sizeof(*rec)); 5169d0c7d708SMark Fasheh ocfs2_cleanup_merge(el, index); 5170d0c7d708SMark Fasheh wants_rotate = 1; 5171d0c7d708SMark Fasheh 5172d0c7d708SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 5173d0c7d708SMark Fasheh if (is_rightmost_tree_rec && next_free > 1) { 5174d0c7d708SMark Fasheh /* 5175d0c7d708SMark Fasheh * We skip the edge update if this path will 5176d0c7d708SMark Fasheh * be deleted by the rotate code. 5177d0c7d708SMark Fasheh */ 5178d0c7d708SMark Fasheh rec = &el->l_recs[next_free - 1]; 5179d0c7d708SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, path, 5180d0c7d708SMark Fasheh rec); 5181d0c7d708SMark Fasheh } 5182d0c7d708SMark Fasheh } else if (le32_to_cpu(rec->e_cpos) == cpos) { 5183d0c7d708SMark Fasheh /* Remove leftmost portion of the record. */ 5184d0c7d708SMark Fasheh le32_add_cpu(&rec->e_cpos, len); 5185d0c7d708SMark Fasheh le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len)); 5186d0c7d708SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -len); 5187d0c7d708SMark Fasheh } else if (rec_range == trunc_range) { 5188d0c7d708SMark Fasheh /* Remove rightmost portion of the record */ 5189d0c7d708SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -len); 5190d0c7d708SMark Fasheh if (is_rightmost_tree_rec) 5191d0c7d708SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, path, rec); 5192d0c7d708SMark Fasheh } else { 5193d0c7d708SMark Fasheh /* Caller should have trapped this. */ 5194d0c7d708SMark Fasheh mlog(ML_ERROR, "Inode %llu: Invalid record truncate: (%u, %u) " 5195d0c7d708SMark Fasheh "(%u, %u)\n", (unsigned long long)OCFS2_I(inode)->ip_blkno, 5196d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos), 5197d0c7d708SMark Fasheh le16_to_cpu(rec->e_leaf_clusters), cpos, len); 5198d0c7d708SMark Fasheh BUG(); 5199d0c7d708SMark Fasheh } 5200d0c7d708SMark Fasheh 5201d0c7d708SMark Fasheh if (left_path) { 5202d0c7d708SMark Fasheh int subtree_index; 5203d0c7d708SMark Fasheh 5204d0c7d708SMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, path); 5205d0c7d708SMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, path, 5206d0c7d708SMark Fasheh subtree_index); 5207d0c7d708SMark Fasheh } 5208d0c7d708SMark Fasheh 5209d0c7d708SMark Fasheh ocfs2_journal_dirty(handle, path_leaf_bh(path)); 5210d0c7d708SMark Fasheh 5211e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et); 5212d0c7d708SMark Fasheh if (ret) { 5213d0c7d708SMark Fasheh mlog_errno(ret); 5214d0c7d708SMark Fasheh goto out; 5215d0c7d708SMark Fasheh } 5216d0c7d708SMark Fasheh 5217d0c7d708SMark Fasheh out: 5218d0c7d708SMark Fasheh ocfs2_free_path(left_path); 5219d0c7d708SMark Fasheh return ret; 5220d0c7d708SMark Fasheh } 5221d0c7d708SMark Fasheh 5222e7d4cb6bSTao Ma int ocfs2_remove_extent(struct inode *inode, struct buffer_head *root_bh, 5223d0c7d708SMark Fasheh u32 cpos, u32 len, handle_t *handle, 5224d0c7d708SMark Fasheh struct ocfs2_alloc_context *meta_ac, 5225e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 5226f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 5227ea5efa15SJoel Becker void *obj) 5228d0c7d708SMark Fasheh { 5229d0c7d708SMark Fasheh int ret, index; 5230d0c7d708SMark Fasheh u32 rec_range, trunc_range; 5231d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 5232d0c7d708SMark Fasheh struct ocfs2_extent_list *el; 5233e7d4cb6bSTao Ma struct ocfs2_path *path = NULL; 5234dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 5235e7d4cb6bSTao Ma 5236ea5efa15SJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, et_type, obj); 5237d0c7d708SMark Fasheh 5238d0c7d708SMark Fasheh ocfs2_extent_map_trunc(inode, 0); 5239d0c7d708SMark Fasheh 5240dc0ce61aSJoel Becker path = ocfs2_new_path(et.et_root_bh, et.et_root_el); 5241d0c7d708SMark Fasheh if (!path) { 5242d0c7d708SMark Fasheh ret = -ENOMEM; 5243d0c7d708SMark Fasheh mlog_errno(ret); 5244d0c7d708SMark Fasheh goto out; 5245d0c7d708SMark Fasheh } 5246d0c7d708SMark Fasheh 5247d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 5248d0c7d708SMark Fasheh if (ret) { 5249d0c7d708SMark Fasheh mlog_errno(ret); 5250d0c7d708SMark Fasheh goto out; 5251d0c7d708SMark Fasheh } 5252d0c7d708SMark Fasheh 5253d0c7d708SMark Fasheh el = path_leaf_el(path); 5254d0c7d708SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 5255d0c7d708SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 5256d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5257d0c7d708SMark Fasheh "Inode %llu has an extent at cpos %u which can no " 5258d0c7d708SMark Fasheh "longer be found.\n", 5259d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos); 5260d0c7d708SMark Fasheh ret = -EROFS; 5261d0c7d708SMark Fasheh goto out; 5262d0c7d708SMark Fasheh } 5263d0c7d708SMark Fasheh 5264d0c7d708SMark Fasheh /* 5265d0c7d708SMark Fasheh * We have 3 cases of extent removal: 5266d0c7d708SMark Fasheh * 1) Range covers the entire extent rec 5267d0c7d708SMark Fasheh * 2) Range begins or ends on one edge of the extent rec 5268d0c7d708SMark Fasheh * 3) Range is in the middle of the extent rec (no shared edges) 5269d0c7d708SMark Fasheh * 5270d0c7d708SMark Fasheh * For case 1 we remove the extent rec and left rotate to 5271d0c7d708SMark Fasheh * fill the hole. 5272d0c7d708SMark Fasheh * 5273d0c7d708SMark Fasheh * For case 2 we just shrink the existing extent rec, with a 5274d0c7d708SMark Fasheh * tree update if the shrinking edge is also the edge of an 5275d0c7d708SMark Fasheh * extent block. 5276d0c7d708SMark Fasheh * 5277d0c7d708SMark Fasheh * For case 3 we do a right split to turn the extent rec into 5278d0c7d708SMark Fasheh * something case 2 can handle. 5279d0c7d708SMark Fasheh */ 5280d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5281d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 5282d0c7d708SMark Fasheh trunc_range = cpos + len; 5283d0c7d708SMark Fasheh 5284d0c7d708SMark Fasheh BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range); 5285d0c7d708SMark Fasheh 5286d0c7d708SMark Fasheh mlog(0, "Inode %llu, remove (cpos %u, len %u). Existing index %d " 5287d0c7d708SMark Fasheh "(cpos %u, len %u)\n", 5288d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, len, index, 5289d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec)); 5290d0c7d708SMark Fasheh 5291d0c7d708SMark Fasheh if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) { 5292d0c7d708SMark Fasheh ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc, 5293dc0ce61aSJoel Becker cpos, len, &et); 5294d0c7d708SMark Fasheh if (ret) { 5295d0c7d708SMark Fasheh mlog_errno(ret); 5296d0c7d708SMark Fasheh goto out; 5297d0c7d708SMark Fasheh } 5298d0c7d708SMark Fasheh } else { 5299dc0ce61aSJoel Becker ret = ocfs2_split_tree(inode, &et, handle, path, index, 5300d0c7d708SMark Fasheh trunc_range, meta_ac); 5301d0c7d708SMark Fasheh if (ret) { 5302d0c7d708SMark Fasheh mlog_errno(ret); 5303d0c7d708SMark Fasheh goto out; 5304d0c7d708SMark Fasheh } 5305d0c7d708SMark Fasheh 5306d0c7d708SMark Fasheh /* 5307d0c7d708SMark Fasheh * The split could have manipulated the tree enough to 5308d0c7d708SMark Fasheh * move the record location, so we have to look for it again. 5309d0c7d708SMark Fasheh */ 5310d0c7d708SMark Fasheh ocfs2_reinit_path(path, 1); 5311d0c7d708SMark Fasheh 5312d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 5313d0c7d708SMark Fasheh if (ret) { 5314d0c7d708SMark Fasheh mlog_errno(ret); 5315d0c7d708SMark Fasheh goto out; 5316d0c7d708SMark Fasheh } 5317d0c7d708SMark Fasheh 5318d0c7d708SMark Fasheh el = path_leaf_el(path); 5319d0c7d708SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 5320d0c7d708SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 5321d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5322d0c7d708SMark Fasheh "Inode %llu: split at cpos %u lost record.", 5323d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 5324d0c7d708SMark Fasheh cpos); 5325d0c7d708SMark Fasheh ret = -EROFS; 5326d0c7d708SMark Fasheh goto out; 5327d0c7d708SMark Fasheh } 5328d0c7d708SMark Fasheh 5329d0c7d708SMark Fasheh /* 5330d0c7d708SMark Fasheh * Double check our values here. If anything is fishy, 5331d0c7d708SMark Fasheh * it's easier to catch it at the top level. 5332d0c7d708SMark Fasheh */ 5333d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5334d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + 5335d0c7d708SMark Fasheh ocfs2_rec_clusters(el, rec); 5336d0c7d708SMark Fasheh if (rec_range != trunc_range) { 5337d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5338d0c7d708SMark Fasheh "Inode %llu: error after split at cpos %u" 5339d0c7d708SMark Fasheh "trunc len %u, existing record is (%u,%u)", 5340d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 5341d0c7d708SMark Fasheh cpos, len, le32_to_cpu(rec->e_cpos), 5342d0c7d708SMark Fasheh ocfs2_rec_clusters(el, rec)); 5343d0c7d708SMark Fasheh ret = -EROFS; 5344d0c7d708SMark Fasheh goto out; 5345d0c7d708SMark Fasheh } 5346d0c7d708SMark Fasheh 5347d0c7d708SMark Fasheh ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc, 5348dc0ce61aSJoel Becker cpos, len, &et); 5349d0c7d708SMark Fasheh if (ret) { 5350d0c7d708SMark Fasheh mlog_errno(ret); 5351d0c7d708SMark Fasheh goto out; 5352d0c7d708SMark Fasheh } 5353d0c7d708SMark Fasheh } 5354d0c7d708SMark Fasheh 5355d0c7d708SMark Fasheh out: 5356d0c7d708SMark Fasheh ocfs2_free_path(path); 5357dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 5358d0c7d708SMark Fasheh return ret; 5359d0c7d708SMark Fasheh } 5360d0c7d708SMark Fasheh 5361063c4561SMark Fasheh int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb) 5362ccd979bdSMark Fasheh { 5363ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5364ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5365ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5366ccd979bdSMark Fasheh 5367ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5368ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5369ccd979bdSMark Fasheh 5370ccd979bdSMark Fasheh mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count), 5371ccd979bdSMark Fasheh "slot %d, invalid truncate log parameters: used = " 5372ccd979bdSMark Fasheh "%u, count = %u\n", osb->slot_num, 5373ccd979bdSMark Fasheh le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count)); 5374ccd979bdSMark Fasheh return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count); 5375ccd979bdSMark Fasheh } 5376ccd979bdSMark Fasheh 5377ccd979bdSMark Fasheh static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl, 5378ccd979bdSMark Fasheh unsigned int new_start) 5379ccd979bdSMark Fasheh { 5380ccd979bdSMark Fasheh unsigned int tail_index; 5381ccd979bdSMark Fasheh unsigned int current_tail; 5382ccd979bdSMark Fasheh 5383ccd979bdSMark Fasheh /* No records, nothing to coalesce */ 5384ccd979bdSMark Fasheh if (!le16_to_cpu(tl->tl_used)) 5385ccd979bdSMark Fasheh return 0; 5386ccd979bdSMark Fasheh 5387ccd979bdSMark Fasheh tail_index = le16_to_cpu(tl->tl_used) - 1; 5388ccd979bdSMark Fasheh current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start); 5389ccd979bdSMark Fasheh current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters); 5390ccd979bdSMark Fasheh 5391ccd979bdSMark Fasheh return current_tail == new_start; 5392ccd979bdSMark Fasheh } 5393ccd979bdSMark Fasheh 5394063c4561SMark Fasheh int ocfs2_truncate_log_append(struct ocfs2_super *osb, 53951fabe148SMark Fasheh handle_t *handle, 5396ccd979bdSMark Fasheh u64 start_blk, 5397ccd979bdSMark Fasheh unsigned int num_clusters) 5398ccd979bdSMark Fasheh { 5399ccd979bdSMark Fasheh int status, index; 5400ccd979bdSMark Fasheh unsigned int start_cluster, tl_count; 5401ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5402ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5403ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5404ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5405ccd979bdSMark Fasheh 5406b0697053SMark Fasheh mlog_entry("start_blk = %llu, num_clusters = %u\n", 5407b0697053SMark Fasheh (unsigned long long)start_blk, num_clusters); 5408ccd979bdSMark Fasheh 54091b1dcc1bSJes Sorensen BUG_ON(mutex_trylock(&tl_inode->i_mutex)); 5410ccd979bdSMark Fasheh 5411ccd979bdSMark Fasheh start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk); 5412ccd979bdSMark Fasheh 5413ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5414ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5415ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5416ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(osb->sb, di); 5417ccd979bdSMark Fasheh status = -EIO; 5418ccd979bdSMark Fasheh goto bail; 5419ccd979bdSMark Fasheh } 5420ccd979bdSMark Fasheh 5421ccd979bdSMark Fasheh tl_count = le16_to_cpu(tl->tl_count); 5422ccd979bdSMark Fasheh mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) || 5423ccd979bdSMark Fasheh tl_count == 0, 5424b0697053SMark Fasheh "Truncate record count on #%llu invalid " 5425b0697053SMark Fasheh "wanted %u, actual %u\n", 5426b0697053SMark Fasheh (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, 5427ccd979bdSMark Fasheh ocfs2_truncate_recs_per_inode(osb->sb), 5428ccd979bdSMark Fasheh le16_to_cpu(tl->tl_count)); 5429ccd979bdSMark Fasheh 5430ccd979bdSMark Fasheh /* Caller should have known to flush before calling us. */ 5431ccd979bdSMark Fasheh index = le16_to_cpu(tl->tl_used); 5432ccd979bdSMark Fasheh if (index >= tl_count) { 5433ccd979bdSMark Fasheh status = -ENOSPC; 5434ccd979bdSMark Fasheh mlog_errno(status); 5435ccd979bdSMark Fasheh goto bail; 5436ccd979bdSMark Fasheh } 5437ccd979bdSMark Fasheh 5438ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, tl_inode, tl_bh, 5439ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 5440ccd979bdSMark Fasheh if (status < 0) { 5441ccd979bdSMark Fasheh mlog_errno(status); 5442ccd979bdSMark Fasheh goto bail; 5443ccd979bdSMark Fasheh } 5444ccd979bdSMark Fasheh 5445ccd979bdSMark Fasheh mlog(0, "Log truncate of %u clusters starting at cluster %u to " 5446b0697053SMark Fasheh "%llu (index = %d)\n", num_clusters, start_cluster, 5447b0697053SMark Fasheh (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index); 5448ccd979bdSMark Fasheh 5449ccd979bdSMark Fasheh if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) { 5450ccd979bdSMark Fasheh /* 5451ccd979bdSMark Fasheh * Move index back to the record we are coalescing with. 5452ccd979bdSMark Fasheh * ocfs2_truncate_log_can_coalesce() guarantees nonzero 5453ccd979bdSMark Fasheh */ 5454ccd979bdSMark Fasheh index--; 5455ccd979bdSMark Fasheh 5456ccd979bdSMark Fasheh num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters); 5457ccd979bdSMark Fasheh mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n", 5458ccd979bdSMark Fasheh index, le32_to_cpu(tl->tl_recs[index].t_start), 5459ccd979bdSMark Fasheh num_clusters); 5460ccd979bdSMark Fasheh } else { 5461ccd979bdSMark Fasheh tl->tl_recs[index].t_start = cpu_to_le32(start_cluster); 5462ccd979bdSMark Fasheh tl->tl_used = cpu_to_le16(index + 1); 5463ccd979bdSMark Fasheh } 5464ccd979bdSMark Fasheh tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters); 5465ccd979bdSMark Fasheh 5466ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, tl_bh); 5467ccd979bdSMark Fasheh if (status < 0) { 5468ccd979bdSMark Fasheh mlog_errno(status); 5469ccd979bdSMark Fasheh goto bail; 5470ccd979bdSMark Fasheh } 5471ccd979bdSMark Fasheh 5472ccd979bdSMark Fasheh bail: 5473ccd979bdSMark Fasheh mlog_exit(status); 5474ccd979bdSMark Fasheh return status; 5475ccd979bdSMark Fasheh } 5476ccd979bdSMark Fasheh 5477ccd979bdSMark Fasheh static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, 54781fabe148SMark Fasheh handle_t *handle, 5479ccd979bdSMark Fasheh struct inode *data_alloc_inode, 5480ccd979bdSMark Fasheh struct buffer_head *data_alloc_bh) 5481ccd979bdSMark Fasheh { 5482ccd979bdSMark Fasheh int status = 0; 5483ccd979bdSMark Fasheh int i; 5484ccd979bdSMark Fasheh unsigned int num_clusters; 5485ccd979bdSMark Fasheh u64 start_blk; 5486ccd979bdSMark Fasheh struct ocfs2_truncate_rec rec; 5487ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5488ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5489ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5490ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5491ccd979bdSMark Fasheh 5492ccd979bdSMark Fasheh mlog_entry_void(); 5493ccd979bdSMark Fasheh 5494ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5495ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5496ccd979bdSMark Fasheh i = le16_to_cpu(tl->tl_used) - 1; 5497ccd979bdSMark Fasheh while (i >= 0) { 5498ccd979bdSMark Fasheh /* Caller has given us at least enough credits to 5499ccd979bdSMark Fasheh * update the truncate log dinode */ 5500ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, tl_inode, tl_bh, 5501ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 5502ccd979bdSMark Fasheh if (status < 0) { 5503ccd979bdSMark Fasheh mlog_errno(status); 5504ccd979bdSMark Fasheh goto bail; 5505ccd979bdSMark Fasheh } 5506ccd979bdSMark Fasheh 5507ccd979bdSMark Fasheh tl->tl_used = cpu_to_le16(i); 5508ccd979bdSMark Fasheh 5509ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, tl_bh); 5510ccd979bdSMark Fasheh if (status < 0) { 5511ccd979bdSMark Fasheh mlog_errno(status); 5512ccd979bdSMark Fasheh goto bail; 5513ccd979bdSMark Fasheh } 5514ccd979bdSMark Fasheh 5515ccd979bdSMark Fasheh /* TODO: Perhaps we can calculate the bulk of the 5516ccd979bdSMark Fasheh * credits up front rather than extending like 5517ccd979bdSMark Fasheh * this. */ 5518ccd979bdSMark Fasheh status = ocfs2_extend_trans(handle, 5519ccd979bdSMark Fasheh OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC); 5520ccd979bdSMark Fasheh if (status < 0) { 5521ccd979bdSMark Fasheh mlog_errno(status); 5522ccd979bdSMark Fasheh goto bail; 5523ccd979bdSMark Fasheh } 5524ccd979bdSMark Fasheh 5525ccd979bdSMark Fasheh rec = tl->tl_recs[i]; 5526ccd979bdSMark Fasheh start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb, 5527ccd979bdSMark Fasheh le32_to_cpu(rec.t_start)); 5528ccd979bdSMark Fasheh num_clusters = le32_to_cpu(rec.t_clusters); 5529ccd979bdSMark Fasheh 5530ccd979bdSMark Fasheh /* if start_blk is not set, we ignore the record as 5531ccd979bdSMark Fasheh * invalid. */ 5532ccd979bdSMark Fasheh if (start_blk) { 5533ccd979bdSMark Fasheh mlog(0, "free record %d, start = %u, clusters = %u\n", 5534ccd979bdSMark Fasheh i, le32_to_cpu(rec.t_start), num_clusters); 5535ccd979bdSMark Fasheh 5536ccd979bdSMark Fasheh status = ocfs2_free_clusters(handle, data_alloc_inode, 5537ccd979bdSMark Fasheh data_alloc_bh, start_blk, 5538ccd979bdSMark Fasheh num_clusters); 5539ccd979bdSMark Fasheh if (status < 0) { 5540ccd979bdSMark Fasheh mlog_errno(status); 5541ccd979bdSMark Fasheh goto bail; 5542ccd979bdSMark Fasheh } 5543ccd979bdSMark Fasheh } 5544ccd979bdSMark Fasheh i--; 5545ccd979bdSMark Fasheh } 5546ccd979bdSMark Fasheh 5547ccd979bdSMark Fasheh bail: 5548ccd979bdSMark Fasheh mlog_exit(status); 5549ccd979bdSMark Fasheh return status; 5550ccd979bdSMark Fasheh } 5551ccd979bdSMark Fasheh 55521b1dcc1bSJes Sorensen /* Expects you to already be holding tl_inode->i_mutex */ 5553063c4561SMark Fasheh int __ocfs2_flush_truncate_log(struct ocfs2_super *osb) 5554ccd979bdSMark Fasheh { 5555ccd979bdSMark Fasheh int status; 5556ccd979bdSMark Fasheh unsigned int num_to_flush; 55571fabe148SMark Fasheh handle_t *handle; 5558ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5559ccd979bdSMark Fasheh struct inode *data_alloc_inode = NULL; 5560ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5561ccd979bdSMark Fasheh struct buffer_head *data_alloc_bh = NULL; 5562ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5563ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5564ccd979bdSMark Fasheh 5565ccd979bdSMark Fasheh mlog_entry_void(); 5566ccd979bdSMark Fasheh 55671b1dcc1bSJes Sorensen BUG_ON(mutex_trylock(&tl_inode->i_mutex)); 5568ccd979bdSMark Fasheh 5569ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5570ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5571ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5572ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(osb->sb, di); 5573ccd979bdSMark Fasheh status = -EIO; 5574e08dc8b9SMark Fasheh goto out; 5575ccd979bdSMark Fasheh } 5576ccd979bdSMark Fasheh 5577ccd979bdSMark Fasheh num_to_flush = le16_to_cpu(tl->tl_used); 5578b0697053SMark Fasheh mlog(0, "Flush %u records from truncate log #%llu\n", 5579b0697053SMark Fasheh num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno); 5580ccd979bdSMark Fasheh if (!num_to_flush) { 5581ccd979bdSMark Fasheh status = 0; 5582e08dc8b9SMark Fasheh goto out; 5583ccd979bdSMark Fasheh } 5584ccd979bdSMark Fasheh 5585ccd979bdSMark Fasheh data_alloc_inode = ocfs2_get_system_file_inode(osb, 5586ccd979bdSMark Fasheh GLOBAL_BITMAP_SYSTEM_INODE, 5587ccd979bdSMark Fasheh OCFS2_INVALID_SLOT); 5588ccd979bdSMark Fasheh if (!data_alloc_inode) { 5589ccd979bdSMark Fasheh status = -EINVAL; 5590ccd979bdSMark Fasheh mlog(ML_ERROR, "Could not get bitmap inode!\n"); 5591e08dc8b9SMark Fasheh goto out; 5592ccd979bdSMark Fasheh } 5593ccd979bdSMark Fasheh 5594e08dc8b9SMark Fasheh mutex_lock(&data_alloc_inode->i_mutex); 5595e08dc8b9SMark Fasheh 5596e63aecb6SMark Fasheh status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1); 5597ccd979bdSMark Fasheh if (status < 0) { 5598ccd979bdSMark Fasheh mlog_errno(status); 5599e08dc8b9SMark Fasheh goto out_mutex; 5600ccd979bdSMark Fasheh } 5601ccd979bdSMark Fasheh 560265eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE); 5603ccd979bdSMark Fasheh if (IS_ERR(handle)) { 5604ccd979bdSMark Fasheh status = PTR_ERR(handle); 5605ccd979bdSMark Fasheh mlog_errno(status); 5606e08dc8b9SMark Fasheh goto out_unlock; 5607ccd979bdSMark Fasheh } 5608ccd979bdSMark Fasheh 5609ccd979bdSMark Fasheh status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode, 5610ccd979bdSMark Fasheh data_alloc_bh); 5611e08dc8b9SMark Fasheh if (status < 0) 5612ccd979bdSMark Fasheh mlog_errno(status); 5613ccd979bdSMark Fasheh 561402dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 5615ccd979bdSMark Fasheh 5616e08dc8b9SMark Fasheh out_unlock: 5617e08dc8b9SMark Fasheh brelse(data_alloc_bh); 5618e63aecb6SMark Fasheh ocfs2_inode_unlock(data_alloc_inode, 1); 5619e08dc8b9SMark Fasheh 5620e08dc8b9SMark Fasheh out_mutex: 5621e08dc8b9SMark Fasheh mutex_unlock(&data_alloc_inode->i_mutex); 5622ccd979bdSMark Fasheh iput(data_alloc_inode); 5623ccd979bdSMark Fasheh 5624e08dc8b9SMark Fasheh out: 5625ccd979bdSMark Fasheh mlog_exit(status); 5626ccd979bdSMark Fasheh return status; 5627ccd979bdSMark Fasheh } 5628ccd979bdSMark Fasheh 5629ccd979bdSMark Fasheh int ocfs2_flush_truncate_log(struct ocfs2_super *osb) 5630ccd979bdSMark Fasheh { 5631ccd979bdSMark Fasheh int status; 5632ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5633ccd979bdSMark Fasheh 56341b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 5635ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 56361b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 5637ccd979bdSMark Fasheh 5638ccd979bdSMark Fasheh return status; 5639ccd979bdSMark Fasheh } 5640ccd979bdSMark Fasheh 5641c4028958SDavid Howells static void ocfs2_truncate_log_worker(struct work_struct *work) 5642ccd979bdSMark Fasheh { 5643ccd979bdSMark Fasheh int status; 5644c4028958SDavid Howells struct ocfs2_super *osb = 5645c4028958SDavid Howells container_of(work, struct ocfs2_super, 5646c4028958SDavid Howells osb_truncate_log_wq.work); 5647ccd979bdSMark Fasheh 5648ccd979bdSMark Fasheh mlog_entry_void(); 5649ccd979bdSMark Fasheh 5650ccd979bdSMark Fasheh status = ocfs2_flush_truncate_log(osb); 5651ccd979bdSMark Fasheh if (status < 0) 5652ccd979bdSMark Fasheh mlog_errno(status); 56534d0ddb2cSTao Ma else 56544d0ddb2cSTao Ma ocfs2_init_inode_steal_slot(osb); 5655ccd979bdSMark Fasheh 5656ccd979bdSMark Fasheh mlog_exit(status); 5657ccd979bdSMark Fasheh } 5658ccd979bdSMark Fasheh 5659ccd979bdSMark Fasheh #define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ) 5660ccd979bdSMark Fasheh void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb, 5661ccd979bdSMark Fasheh int cancel) 5662ccd979bdSMark Fasheh { 5663ccd979bdSMark Fasheh if (osb->osb_tl_inode) { 5664ccd979bdSMark Fasheh /* We want to push off log flushes while truncates are 5665ccd979bdSMark Fasheh * still running. */ 5666ccd979bdSMark Fasheh if (cancel) 5667ccd979bdSMark Fasheh cancel_delayed_work(&osb->osb_truncate_log_wq); 5668ccd979bdSMark Fasheh 5669ccd979bdSMark Fasheh queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq, 5670ccd979bdSMark Fasheh OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL); 5671ccd979bdSMark Fasheh } 5672ccd979bdSMark Fasheh } 5673ccd979bdSMark Fasheh 5674ccd979bdSMark Fasheh static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb, 5675ccd979bdSMark Fasheh int slot_num, 5676ccd979bdSMark Fasheh struct inode **tl_inode, 5677ccd979bdSMark Fasheh struct buffer_head **tl_bh) 5678ccd979bdSMark Fasheh { 5679ccd979bdSMark Fasheh int status; 5680ccd979bdSMark Fasheh struct inode *inode = NULL; 5681ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 5682ccd979bdSMark Fasheh 5683ccd979bdSMark Fasheh inode = ocfs2_get_system_file_inode(osb, 5684ccd979bdSMark Fasheh TRUNCATE_LOG_SYSTEM_INODE, 5685ccd979bdSMark Fasheh slot_num); 5686ccd979bdSMark Fasheh if (!inode) { 5687ccd979bdSMark Fasheh status = -EINVAL; 5688ccd979bdSMark Fasheh mlog(ML_ERROR, "Could not get load truncate log inode!\n"); 5689ccd979bdSMark Fasheh goto bail; 5690ccd979bdSMark Fasheh } 5691ccd979bdSMark Fasheh 5692ccd979bdSMark Fasheh status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh, 5693ccd979bdSMark Fasheh OCFS2_BH_CACHED, inode); 5694ccd979bdSMark Fasheh if (status < 0) { 5695ccd979bdSMark Fasheh iput(inode); 5696ccd979bdSMark Fasheh mlog_errno(status); 5697ccd979bdSMark Fasheh goto bail; 5698ccd979bdSMark Fasheh } 5699ccd979bdSMark Fasheh 5700ccd979bdSMark Fasheh *tl_inode = inode; 5701ccd979bdSMark Fasheh *tl_bh = bh; 5702ccd979bdSMark Fasheh bail: 5703ccd979bdSMark Fasheh mlog_exit(status); 5704ccd979bdSMark Fasheh return status; 5705ccd979bdSMark Fasheh } 5706ccd979bdSMark Fasheh 5707ccd979bdSMark Fasheh /* called during the 1st stage of node recovery. we stamp a clean 5708ccd979bdSMark Fasheh * truncate log and pass back a copy for processing later. if the 5709ccd979bdSMark Fasheh * truncate log does not require processing, a *tl_copy is set to 5710ccd979bdSMark Fasheh * NULL. */ 5711ccd979bdSMark Fasheh int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb, 5712ccd979bdSMark Fasheh int slot_num, 5713ccd979bdSMark Fasheh struct ocfs2_dinode **tl_copy) 5714ccd979bdSMark Fasheh { 5715ccd979bdSMark Fasheh int status; 5716ccd979bdSMark Fasheh struct inode *tl_inode = NULL; 5717ccd979bdSMark Fasheh struct buffer_head *tl_bh = NULL; 5718ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5719ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5720ccd979bdSMark Fasheh 5721ccd979bdSMark Fasheh *tl_copy = NULL; 5722ccd979bdSMark Fasheh 5723ccd979bdSMark Fasheh mlog(0, "recover truncate log from slot %d\n", slot_num); 5724ccd979bdSMark Fasheh 5725ccd979bdSMark Fasheh status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh); 5726ccd979bdSMark Fasheh if (status < 0) { 5727ccd979bdSMark Fasheh mlog_errno(status); 5728ccd979bdSMark Fasheh goto bail; 5729ccd979bdSMark Fasheh } 5730ccd979bdSMark Fasheh 5731ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5732ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5733ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5734ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(tl_inode->i_sb, di); 5735ccd979bdSMark Fasheh status = -EIO; 5736ccd979bdSMark Fasheh goto bail; 5737ccd979bdSMark Fasheh } 5738ccd979bdSMark Fasheh 5739ccd979bdSMark Fasheh if (le16_to_cpu(tl->tl_used)) { 5740ccd979bdSMark Fasheh mlog(0, "We'll have %u logs to recover\n", 5741ccd979bdSMark Fasheh le16_to_cpu(tl->tl_used)); 5742ccd979bdSMark Fasheh 5743ccd979bdSMark Fasheh *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL); 5744ccd979bdSMark Fasheh if (!(*tl_copy)) { 5745ccd979bdSMark Fasheh status = -ENOMEM; 5746ccd979bdSMark Fasheh mlog_errno(status); 5747ccd979bdSMark Fasheh goto bail; 5748ccd979bdSMark Fasheh } 5749ccd979bdSMark Fasheh 5750ccd979bdSMark Fasheh /* Assuming the write-out below goes well, this copy 5751ccd979bdSMark Fasheh * will be passed back to recovery for processing. */ 5752ccd979bdSMark Fasheh memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size); 5753ccd979bdSMark Fasheh 5754ccd979bdSMark Fasheh /* All we need to do to clear the truncate log is set 5755ccd979bdSMark Fasheh * tl_used. */ 5756ccd979bdSMark Fasheh tl->tl_used = 0; 5757ccd979bdSMark Fasheh 5758ccd979bdSMark Fasheh status = ocfs2_write_block(osb, tl_bh, tl_inode); 5759ccd979bdSMark Fasheh if (status < 0) { 5760ccd979bdSMark Fasheh mlog_errno(status); 5761ccd979bdSMark Fasheh goto bail; 5762ccd979bdSMark Fasheh } 5763ccd979bdSMark Fasheh } 5764ccd979bdSMark Fasheh 5765ccd979bdSMark Fasheh bail: 5766ccd979bdSMark Fasheh if (tl_inode) 5767ccd979bdSMark Fasheh iput(tl_inode); 5768ccd979bdSMark Fasheh if (tl_bh) 5769ccd979bdSMark Fasheh brelse(tl_bh); 5770ccd979bdSMark Fasheh 5771ccd979bdSMark Fasheh if (status < 0 && (*tl_copy)) { 5772ccd979bdSMark Fasheh kfree(*tl_copy); 5773ccd979bdSMark Fasheh *tl_copy = NULL; 5774ccd979bdSMark Fasheh } 5775ccd979bdSMark Fasheh 5776ccd979bdSMark Fasheh mlog_exit(status); 5777ccd979bdSMark Fasheh return status; 5778ccd979bdSMark Fasheh } 5779ccd979bdSMark Fasheh 5780ccd979bdSMark Fasheh int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb, 5781ccd979bdSMark Fasheh struct ocfs2_dinode *tl_copy) 5782ccd979bdSMark Fasheh { 5783ccd979bdSMark Fasheh int status = 0; 5784ccd979bdSMark Fasheh int i; 5785ccd979bdSMark Fasheh unsigned int clusters, num_recs, start_cluster; 5786ccd979bdSMark Fasheh u64 start_blk; 57871fabe148SMark Fasheh handle_t *handle; 5788ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5789ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5790ccd979bdSMark Fasheh 5791ccd979bdSMark Fasheh mlog_entry_void(); 5792ccd979bdSMark Fasheh 5793ccd979bdSMark Fasheh if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) { 5794ccd979bdSMark Fasheh mlog(ML_ERROR, "Asked to recover my own truncate log!\n"); 5795ccd979bdSMark Fasheh return -EINVAL; 5796ccd979bdSMark Fasheh } 5797ccd979bdSMark Fasheh 5798ccd979bdSMark Fasheh tl = &tl_copy->id2.i_dealloc; 5799ccd979bdSMark Fasheh num_recs = le16_to_cpu(tl->tl_used); 5800b0697053SMark Fasheh mlog(0, "cleanup %u records from %llu\n", num_recs, 58011ca1a111SMark Fasheh (unsigned long long)le64_to_cpu(tl_copy->i_blkno)); 5802ccd979bdSMark Fasheh 58031b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 5804ccd979bdSMark Fasheh for(i = 0; i < num_recs; i++) { 5805ccd979bdSMark Fasheh if (ocfs2_truncate_log_needs_flush(osb)) { 5806ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 5807ccd979bdSMark Fasheh if (status < 0) { 5808ccd979bdSMark Fasheh mlog_errno(status); 5809ccd979bdSMark Fasheh goto bail_up; 5810ccd979bdSMark Fasheh } 5811ccd979bdSMark Fasheh } 5812ccd979bdSMark Fasheh 581365eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE); 5814ccd979bdSMark Fasheh if (IS_ERR(handle)) { 5815ccd979bdSMark Fasheh status = PTR_ERR(handle); 5816ccd979bdSMark Fasheh mlog_errno(status); 5817ccd979bdSMark Fasheh goto bail_up; 5818ccd979bdSMark Fasheh } 5819ccd979bdSMark Fasheh 5820ccd979bdSMark Fasheh clusters = le32_to_cpu(tl->tl_recs[i].t_clusters); 5821ccd979bdSMark Fasheh start_cluster = le32_to_cpu(tl->tl_recs[i].t_start); 5822ccd979bdSMark Fasheh start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster); 5823ccd979bdSMark Fasheh 5824ccd979bdSMark Fasheh status = ocfs2_truncate_log_append(osb, handle, 5825ccd979bdSMark Fasheh start_blk, clusters); 582602dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 5827ccd979bdSMark Fasheh if (status < 0) { 5828ccd979bdSMark Fasheh mlog_errno(status); 5829ccd979bdSMark Fasheh goto bail_up; 5830ccd979bdSMark Fasheh } 5831ccd979bdSMark Fasheh } 5832ccd979bdSMark Fasheh 5833ccd979bdSMark Fasheh bail_up: 58341b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 5835ccd979bdSMark Fasheh 5836ccd979bdSMark Fasheh mlog_exit(status); 5837ccd979bdSMark Fasheh return status; 5838ccd979bdSMark Fasheh } 5839ccd979bdSMark Fasheh 5840ccd979bdSMark Fasheh void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb) 5841ccd979bdSMark Fasheh { 5842ccd979bdSMark Fasheh int status; 5843ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5844ccd979bdSMark Fasheh 5845ccd979bdSMark Fasheh mlog_entry_void(); 5846ccd979bdSMark Fasheh 5847ccd979bdSMark Fasheh if (tl_inode) { 5848ccd979bdSMark Fasheh cancel_delayed_work(&osb->osb_truncate_log_wq); 5849ccd979bdSMark Fasheh flush_workqueue(ocfs2_wq); 5850ccd979bdSMark Fasheh 5851ccd979bdSMark Fasheh status = ocfs2_flush_truncate_log(osb); 5852ccd979bdSMark Fasheh if (status < 0) 5853ccd979bdSMark Fasheh mlog_errno(status); 5854ccd979bdSMark Fasheh 5855ccd979bdSMark Fasheh brelse(osb->osb_tl_bh); 5856ccd979bdSMark Fasheh iput(osb->osb_tl_inode); 5857ccd979bdSMark Fasheh } 5858ccd979bdSMark Fasheh 5859ccd979bdSMark Fasheh mlog_exit_void(); 5860ccd979bdSMark Fasheh } 5861ccd979bdSMark Fasheh 5862ccd979bdSMark Fasheh int ocfs2_truncate_log_init(struct ocfs2_super *osb) 5863ccd979bdSMark Fasheh { 5864ccd979bdSMark Fasheh int status; 5865ccd979bdSMark Fasheh struct inode *tl_inode = NULL; 5866ccd979bdSMark Fasheh struct buffer_head *tl_bh = NULL; 5867ccd979bdSMark Fasheh 5868ccd979bdSMark Fasheh mlog_entry_void(); 5869ccd979bdSMark Fasheh 5870ccd979bdSMark Fasheh status = ocfs2_get_truncate_log_info(osb, 5871ccd979bdSMark Fasheh osb->slot_num, 5872ccd979bdSMark Fasheh &tl_inode, 5873ccd979bdSMark Fasheh &tl_bh); 5874ccd979bdSMark Fasheh if (status < 0) 5875ccd979bdSMark Fasheh mlog_errno(status); 5876ccd979bdSMark Fasheh 5877ccd979bdSMark Fasheh /* ocfs2_truncate_log_shutdown keys on the existence of 5878ccd979bdSMark Fasheh * osb->osb_tl_inode so we don't set any of the osb variables 5879ccd979bdSMark Fasheh * until we're sure all is well. */ 5880c4028958SDavid Howells INIT_DELAYED_WORK(&osb->osb_truncate_log_wq, 5881c4028958SDavid Howells ocfs2_truncate_log_worker); 5882ccd979bdSMark Fasheh osb->osb_tl_bh = tl_bh; 5883ccd979bdSMark Fasheh osb->osb_tl_inode = tl_inode; 5884ccd979bdSMark Fasheh 5885ccd979bdSMark Fasheh mlog_exit(status); 5886ccd979bdSMark Fasheh return status; 5887ccd979bdSMark Fasheh } 5888ccd979bdSMark Fasheh 58892b604351SMark Fasheh /* 58902b604351SMark Fasheh * Delayed de-allocation of suballocator blocks. 58912b604351SMark Fasheh * 58922b604351SMark Fasheh * Some sets of block de-allocations might involve multiple suballocator inodes. 58932b604351SMark Fasheh * 58942b604351SMark Fasheh * The locking for this can get extremely complicated, especially when 58952b604351SMark Fasheh * the suballocator inodes to delete from aren't known until deep 58962b604351SMark Fasheh * within an unrelated codepath. 58972b604351SMark Fasheh * 58982b604351SMark Fasheh * ocfs2_extent_block structures are a good example of this - an inode 58992b604351SMark Fasheh * btree could have been grown by any number of nodes each allocating 59002b604351SMark Fasheh * out of their own suballoc inode. 59012b604351SMark Fasheh * 59022b604351SMark Fasheh * These structures allow the delay of block de-allocation until a 59032b604351SMark Fasheh * later time, when locking of multiple cluster inodes won't cause 59042b604351SMark Fasheh * deadlock. 59052b604351SMark Fasheh */ 59062b604351SMark Fasheh 59072b604351SMark Fasheh /* 59082b604351SMark Fasheh * Describes a single block free from a suballocator 59092b604351SMark Fasheh */ 59102b604351SMark Fasheh struct ocfs2_cached_block_free { 59112b604351SMark Fasheh struct ocfs2_cached_block_free *free_next; 59122b604351SMark Fasheh u64 free_blk; 59132b604351SMark Fasheh unsigned int free_bit; 59142b604351SMark Fasheh }; 59152b604351SMark Fasheh 59162b604351SMark Fasheh struct ocfs2_per_slot_free_list { 59172b604351SMark Fasheh struct ocfs2_per_slot_free_list *f_next_suballocator; 59182b604351SMark Fasheh int f_inode_type; 59192b604351SMark Fasheh int f_slot; 59202b604351SMark Fasheh struct ocfs2_cached_block_free *f_first; 59212b604351SMark Fasheh }; 59222b604351SMark Fasheh 59232b604351SMark Fasheh static int ocfs2_free_cached_items(struct ocfs2_super *osb, 59242b604351SMark Fasheh int sysfile_type, 59252b604351SMark Fasheh int slot, 59262b604351SMark Fasheh struct ocfs2_cached_block_free *head) 59272b604351SMark Fasheh { 59282b604351SMark Fasheh int ret; 59292b604351SMark Fasheh u64 bg_blkno; 59302b604351SMark Fasheh handle_t *handle; 59312b604351SMark Fasheh struct inode *inode; 59322b604351SMark Fasheh struct buffer_head *di_bh = NULL; 59332b604351SMark Fasheh struct ocfs2_cached_block_free *tmp; 59342b604351SMark Fasheh 59352b604351SMark Fasheh inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot); 59362b604351SMark Fasheh if (!inode) { 59372b604351SMark Fasheh ret = -EINVAL; 59382b604351SMark Fasheh mlog_errno(ret); 59392b604351SMark Fasheh goto out; 59402b604351SMark Fasheh } 59412b604351SMark Fasheh 59422b604351SMark Fasheh mutex_lock(&inode->i_mutex); 59432b604351SMark Fasheh 5944e63aecb6SMark Fasheh ret = ocfs2_inode_lock(inode, &di_bh, 1); 59452b604351SMark Fasheh if (ret) { 59462b604351SMark Fasheh mlog_errno(ret); 59472b604351SMark Fasheh goto out_mutex; 59482b604351SMark Fasheh } 59492b604351SMark Fasheh 59502b604351SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE); 59512b604351SMark Fasheh if (IS_ERR(handle)) { 59522b604351SMark Fasheh ret = PTR_ERR(handle); 59532b604351SMark Fasheh mlog_errno(ret); 59542b604351SMark Fasheh goto out_unlock; 59552b604351SMark Fasheh } 59562b604351SMark Fasheh 59572b604351SMark Fasheh while (head) { 59582b604351SMark Fasheh bg_blkno = ocfs2_which_suballoc_group(head->free_blk, 59592b604351SMark Fasheh head->free_bit); 59602b604351SMark Fasheh mlog(0, "Free bit: (bit %u, blkno %llu)\n", 59612b604351SMark Fasheh head->free_bit, (unsigned long long)head->free_blk); 59622b604351SMark Fasheh 59632b604351SMark Fasheh ret = ocfs2_free_suballoc_bits(handle, inode, di_bh, 59642b604351SMark Fasheh head->free_bit, bg_blkno, 1); 59652b604351SMark Fasheh if (ret) { 59662b604351SMark Fasheh mlog_errno(ret); 59672b604351SMark Fasheh goto out_journal; 59682b604351SMark Fasheh } 59692b604351SMark Fasheh 59702b604351SMark Fasheh ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE); 59712b604351SMark Fasheh if (ret) { 59722b604351SMark Fasheh mlog_errno(ret); 59732b604351SMark Fasheh goto out_journal; 59742b604351SMark Fasheh } 59752b604351SMark Fasheh 59762b604351SMark Fasheh tmp = head; 59772b604351SMark Fasheh head = head->free_next; 59782b604351SMark Fasheh kfree(tmp); 59792b604351SMark Fasheh } 59802b604351SMark Fasheh 59812b604351SMark Fasheh out_journal: 59822b604351SMark Fasheh ocfs2_commit_trans(osb, handle); 59832b604351SMark Fasheh 59842b604351SMark Fasheh out_unlock: 5985e63aecb6SMark Fasheh ocfs2_inode_unlock(inode, 1); 59862b604351SMark Fasheh brelse(di_bh); 59872b604351SMark Fasheh out_mutex: 59882b604351SMark Fasheh mutex_unlock(&inode->i_mutex); 59892b604351SMark Fasheh iput(inode); 59902b604351SMark Fasheh out: 59912b604351SMark Fasheh while(head) { 59922b604351SMark Fasheh /* Premature exit may have left some dangling items. */ 59932b604351SMark Fasheh tmp = head; 59942b604351SMark Fasheh head = head->free_next; 59952b604351SMark Fasheh kfree(tmp); 59962b604351SMark Fasheh } 59972b604351SMark Fasheh 59982b604351SMark Fasheh return ret; 59992b604351SMark Fasheh } 60002b604351SMark Fasheh 60012b604351SMark Fasheh int ocfs2_run_deallocs(struct ocfs2_super *osb, 60022b604351SMark Fasheh struct ocfs2_cached_dealloc_ctxt *ctxt) 60032b604351SMark Fasheh { 60042b604351SMark Fasheh int ret = 0, ret2; 60052b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl; 60062b604351SMark Fasheh 60072b604351SMark Fasheh if (!ctxt) 60082b604351SMark Fasheh return 0; 60092b604351SMark Fasheh 60102b604351SMark Fasheh while (ctxt->c_first_suballocator) { 60112b604351SMark Fasheh fl = ctxt->c_first_suballocator; 60122b604351SMark Fasheh 60132b604351SMark Fasheh if (fl->f_first) { 60142b604351SMark Fasheh mlog(0, "Free items: (type %u, slot %d)\n", 60152b604351SMark Fasheh fl->f_inode_type, fl->f_slot); 60162b604351SMark Fasheh ret2 = ocfs2_free_cached_items(osb, fl->f_inode_type, 60172b604351SMark Fasheh fl->f_slot, fl->f_first); 60182b604351SMark Fasheh if (ret2) 60192b604351SMark Fasheh mlog_errno(ret2); 60202b604351SMark Fasheh if (!ret) 60212b604351SMark Fasheh ret = ret2; 60222b604351SMark Fasheh } 60232b604351SMark Fasheh 60242b604351SMark Fasheh ctxt->c_first_suballocator = fl->f_next_suballocator; 60252b604351SMark Fasheh kfree(fl); 60262b604351SMark Fasheh } 60272b604351SMark Fasheh 60282b604351SMark Fasheh return ret; 60292b604351SMark Fasheh } 60302b604351SMark Fasheh 60312b604351SMark Fasheh static struct ocfs2_per_slot_free_list * 60322b604351SMark Fasheh ocfs2_find_per_slot_free_list(int type, 60332b604351SMark Fasheh int slot, 60342b604351SMark Fasheh struct ocfs2_cached_dealloc_ctxt *ctxt) 60352b604351SMark Fasheh { 60362b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator; 60372b604351SMark Fasheh 60382b604351SMark Fasheh while (fl) { 60392b604351SMark Fasheh if (fl->f_inode_type == type && fl->f_slot == slot) 60402b604351SMark Fasheh return fl; 60412b604351SMark Fasheh 60422b604351SMark Fasheh fl = fl->f_next_suballocator; 60432b604351SMark Fasheh } 60442b604351SMark Fasheh 60452b604351SMark Fasheh fl = kmalloc(sizeof(*fl), GFP_NOFS); 60462b604351SMark Fasheh if (fl) { 60472b604351SMark Fasheh fl->f_inode_type = type; 60482b604351SMark Fasheh fl->f_slot = slot; 60492b604351SMark Fasheh fl->f_first = NULL; 60502b604351SMark Fasheh fl->f_next_suballocator = ctxt->c_first_suballocator; 60512b604351SMark Fasheh 60522b604351SMark Fasheh ctxt->c_first_suballocator = fl; 60532b604351SMark Fasheh } 60542b604351SMark Fasheh return fl; 60552b604351SMark Fasheh } 60562b604351SMark Fasheh 60572b604351SMark Fasheh static int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt, 60582b604351SMark Fasheh int type, int slot, u64 blkno, 60592b604351SMark Fasheh unsigned int bit) 60602b604351SMark Fasheh { 60612b604351SMark Fasheh int ret; 60622b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl; 60632b604351SMark Fasheh struct ocfs2_cached_block_free *item; 60642b604351SMark Fasheh 60652b604351SMark Fasheh fl = ocfs2_find_per_slot_free_list(type, slot, ctxt); 60662b604351SMark Fasheh if (fl == NULL) { 60672b604351SMark Fasheh ret = -ENOMEM; 60682b604351SMark Fasheh mlog_errno(ret); 60692b604351SMark Fasheh goto out; 60702b604351SMark Fasheh } 60712b604351SMark Fasheh 60722b604351SMark Fasheh item = kmalloc(sizeof(*item), GFP_NOFS); 60732b604351SMark Fasheh if (item == NULL) { 60742b604351SMark Fasheh ret = -ENOMEM; 60752b604351SMark Fasheh mlog_errno(ret); 60762b604351SMark Fasheh goto out; 60772b604351SMark Fasheh } 60782b604351SMark Fasheh 60792b604351SMark Fasheh mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n", 60802b604351SMark Fasheh type, slot, bit, (unsigned long long)blkno); 60812b604351SMark Fasheh 60822b604351SMark Fasheh item->free_blk = blkno; 60832b604351SMark Fasheh item->free_bit = bit; 60842b604351SMark Fasheh item->free_next = fl->f_first; 60852b604351SMark Fasheh 60862b604351SMark Fasheh fl->f_first = item; 60872b604351SMark Fasheh 60882b604351SMark Fasheh ret = 0; 60892b604351SMark Fasheh out: 60902b604351SMark Fasheh return ret; 60912b604351SMark Fasheh } 60922b604351SMark Fasheh 609359a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, 609459a5e416SMark Fasheh struct ocfs2_extent_block *eb) 609559a5e416SMark Fasheh { 609659a5e416SMark Fasheh return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE, 609759a5e416SMark Fasheh le16_to_cpu(eb->h_suballoc_slot), 609859a5e416SMark Fasheh le64_to_cpu(eb->h_blkno), 609959a5e416SMark Fasheh le16_to_cpu(eb->h_suballoc_bit)); 610059a5e416SMark Fasheh } 610159a5e416SMark Fasheh 6102ccd979bdSMark Fasheh /* This function will figure out whether the currently last extent 6103ccd979bdSMark Fasheh * block will be deleted, and if it will, what the new last extent 6104ccd979bdSMark Fasheh * block will be so we can update his h_next_leaf_blk field, as well 6105ccd979bdSMark Fasheh * as the dinodes i_last_eb_blk */ 6106dcd0538fSMark Fasheh static int ocfs2_find_new_last_ext_blk(struct inode *inode, 61073a0782d0SMark Fasheh unsigned int clusters_to_del, 6108dcd0538fSMark Fasheh struct ocfs2_path *path, 6109ccd979bdSMark Fasheh struct buffer_head **new_last_eb) 6110ccd979bdSMark Fasheh { 61113a0782d0SMark Fasheh int next_free, ret = 0; 6112dcd0538fSMark Fasheh u32 cpos; 61133a0782d0SMark Fasheh struct ocfs2_extent_rec *rec; 6114ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 6115ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 6116ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 6117ccd979bdSMark Fasheh 6118ccd979bdSMark Fasheh *new_last_eb = NULL; 6119ccd979bdSMark Fasheh 6120ccd979bdSMark Fasheh /* we have no tree, so of course, no last_eb. */ 6121dcd0538fSMark Fasheh if (!path->p_tree_depth) 6122dcd0538fSMark Fasheh goto out; 6123ccd979bdSMark Fasheh 6124ccd979bdSMark Fasheh /* trunc to zero special case - this makes tree_depth = 0 6125ccd979bdSMark Fasheh * regardless of what it is. */ 61263a0782d0SMark Fasheh if (OCFS2_I(inode)->ip_clusters == clusters_to_del) 6127dcd0538fSMark Fasheh goto out; 6128ccd979bdSMark Fasheh 6129dcd0538fSMark Fasheh el = path_leaf_el(path); 6130ccd979bdSMark Fasheh BUG_ON(!el->l_next_free_rec); 6131ccd979bdSMark Fasheh 61323a0782d0SMark Fasheh /* 61333a0782d0SMark Fasheh * Make sure that this extent list will actually be empty 61343a0782d0SMark Fasheh * after we clear away the data. We can shortcut out if 61353a0782d0SMark Fasheh * there's more than one non-empty extent in the 61363a0782d0SMark Fasheh * list. Otherwise, a check of the remaining extent is 61373a0782d0SMark Fasheh * necessary. 61383a0782d0SMark Fasheh */ 61393a0782d0SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 61403a0782d0SMark Fasheh rec = NULL; 6141dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 61423a0782d0SMark Fasheh if (next_free > 2) 6143dcd0538fSMark Fasheh goto out; 61443a0782d0SMark Fasheh 61453a0782d0SMark Fasheh /* We may have a valid extent in index 1, check it. */ 61463a0782d0SMark Fasheh if (next_free == 2) 61473a0782d0SMark Fasheh rec = &el->l_recs[1]; 61483a0782d0SMark Fasheh 61493a0782d0SMark Fasheh /* 61503a0782d0SMark Fasheh * Fall through - no more nonempty extents, so we want 61513a0782d0SMark Fasheh * to delete this leaf. 61523a0782d0SMark Fasheh */ 61533a0782d0SMark Fasheh } else { 61543a0782d0SMark Fasheh if (next_free > 1) 6155dcd0538fSMark Fasheh goto out; 6156ccd979bdSMark Fasheh 61573a0782d0SMark Fasheh rec = &el->l_recs[0]; 61583a0782d0SMark Fasheh } 61593a0782d0SMark Fasheh 61603a0782d0SMark Fasheh if (rec) { 61613a0782d0SMark Fasheh /* 61623a0782d0SMark Fasheh * Check it we'll only be trimming off the end of this 61633a0782d0SMark Fasheh * cluster. 61643a0782d0SMark Fasheh */ 6165e48edee2SMark Fasheh if (le16_to_cpu(rec->e_leaf_clusters) > clusters_to_del) 61663a0782d0SMark Fasheh goto out; 61673a0782d0SMark Fasheh } 61683a0782d0SMark Fasheh 6169dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos); 6170dcd0538fSMark Fasheh if (ret) { 6171dcd0538fSMark Fasheh mlog_errno(ret); 6172dcd0538fSMark Fasheh goto out; 6173ccd979bdSMark Fasheh } 6174ccd979bdSMark Fasheh 6175dcd0538fSMark Fasheh ret = ocfs2_find_leaf(inode, path_root_el(path), cpos, &bh); 6176dcd0538fSMark Fasheh if (ret) { 6177dcd0538fSMark Fasheh mlog_errno(ret); 6178dcd0538fSMark Fasheh goto out; 6179ccd979bdSMark Fasheh } 6180dcd0538fSMark Fasheh 6181ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 6182ccd979bdSMark Fasheh el = &eb->h_list; 6183ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 6184ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 6185dcd0538fSMark Fasheh ret = -EROFS; 6186dcd0538fSMark Fasheh goto out; 6187ccd979bdSMark Fasheh } 6188ccd979bdSMark Fasheh 6189ccd979bdSMark Fasheh *new_last_eb = bh; 6190ccd979bdSMark Fasheh get_bh(*new_last_eb); 6191dcd0538fSMark Fasheh mlog(0, "returning block %llu, (cpos: %u)\n", 6192dcd0538fSMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno), cpos); 6193dcd0538fSMark Fasheh out: 6194ccd979bdSMark Fasheh brelse(bh); 6195ccd979bdSMark Fasheh 6196dcd0538fSMark Fasheh return ret; 6197ccd979bdSMark Fasheh } 6198ccd979bdSMark Fasheh 61993a0782d0SMark Fasheh /* 62003a0782d0SMark Fasheh * Trim some clusters off the rightmost edge of a tree. Only called 62013a0782d0SMark Fasheh * during truncate. 62023a0782d0SMark Fasheh * 62033a0782d0SMark Fasheh * The caller needs to: 62043a0782d0SMark Fasheh * - start journaling of each path component. 62053a0782d0SMark Fasheh * - compute and fully set up any new last ext block 62063a0782d0SMark Fasheh */ 62073a0782d0SMark Fasheh static int ocfs2_trim_tree(struct inode *inode, struct ocfs2_path *path, 62083a0782d0SMark Fasheh handle_t *handle, struct ocfs2_truncate_context *tc, 62093a0782d0SMark Fasheh u32 clusters_to_del, u64 *delete_start) 62103a0782d0SMark Fasheh { 62113a0782d0SMark Fasheh int ret, i, index = path->p_tree_depth; 62123a0782d0SMark Fasheh u32 new_edge = 0; 62133a0782d0SMark Fasheh u64 deleted_eb = 0; 62143a0782d0SMark Fasheh struct buffer_head *bh; 62153a0782d0SMark Fasheh struct ocfs2_extent_list *el; 62163a0782d0SMark Fasheh struct ocfs2_extent_rec *rec; 62173a0782d0SMark Fasheh 62183a0782d0SMark Fasheh *delete_start = 0; 62193a0782d0SMark Fasheh 62203a0782d0SMark Fasheh while (index >= 0) { 62213a0782d0SMark Fasheh bh = path->p_node[index].bh; 62223a0782d0SMark Fasheh el = path->p_node[index].el; 62233a0782d0SMark Fasheh 62243a0782d0SMark Fasheh mlog(0, "traveling tree (index = %d, block = %llu)\n", 62253a0782d0SMark Fasheh index, (unsigned long long)bh->b_blocknr); 62263a0782d0SMark Fasheh 62273a0782d0SMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0); 62283a0782d0SMark Fasheh 62293a0782d0SMark Fasheh if (index != 62303a0782d0SMark Fasheh (path->p_tree_depth - le16_to_cpu(el->l_tree_depth))) { 62313a0782d0SMark Fasheh ocfs2_error(inode->i_sb, 62323a0782d0SMark Fasheh "Inode %lu has invalid ext. block %llu", 62333a0782d0SMark Fasheh inode->i_ino, 62343a0782d0SMark Fasheh (unsigned long long)bh->b_blocknr); 62353a0782d0SMark Fasheh ret = -EROFS; 62363a0782d0SMark Fasheh goto out; 62373a0782d0SMark Fasheh } 62383a0782d0SMark Fasheh 62393a0782d0SMark Fasheh find_tail_record: 62403a0782d0SMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 62413a0782d0SMark Fasheh rec = &el->l_recs[i]; 62423a0782d0SMark Fasheh 62433a0782d0SMark Fasheh mlog(0, "Extent list before: record %d: (%u, %u, %llu), " 62443a0782d0SMark Fasheh "next = %u\n", i, le32_to_cpu(rec->e_cpos), 6245e48edee2SMark Fasheh ocfs2_rec_clusters(el, rec), 62463a0782d0SMark Fasheh (unsigned long long)le64_to_cpu(rec->e_blkno), 62473a0782d0SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 62483a0782d0SMark Fasheh 6249e48edee2SMark Fasheh BUG_ON(ocfs2_rec_clusters(el, rec) < clusters_to_del); 62503a0782d0SMark Fasheh 62513a0782d0SMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 62523a0782d0SMark Fasheh /* 62533a0782d0SMark Fasheh * If the leaf block contains a single empty 62543a0782d0SMark Fasheh * extent and no records, we can just remove 62553a0782d0SMark Fasheh * the block. 62563a0782d0SMark Fasheh */ 62573a0782d0SMark Fasheh if (i == 0 && ocfs2_is_empty_extent(rec)) { 62583a0782d0SMark Fasheh memset(rec, 0, 62593a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 62603a0782d0SMark Fasheh el->l_next_free_rec = cpu_to_le16(0); 62613a0782d0SMark Fasheh 62623a0782d0SMark Fasheh goto delete; 62633a0782d0SMark Fasheh } 62643a0782d0SMark Fasheh 62653a0782d0SMark Fasheh /* 62663a0782d0SMark Fasheh * Remove any empty extents by shifting things 62673a0782d0SMark Fasheh * left. That should make life much easier on 62683a0782d0SMark Fasheh * the code below. This condition is rare 62693a0782d0SMark Fasheh * enough that we shouldn't see a performance 62703a0782d0SMark Fasheh * hit. 62713a0782d0SMark Fasheh */ 62723a0782d0SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 62733a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 62743a0782d0SMark Fasheh 62753a0782d0SMark Fasheh for(i = 0; 62763a0782d0SMark Fasheh i < le16_to_cpu(el->l_next_free_rec); i++) 62773a0782d0SMark Fasheh el->l_recs[i] = el->l_recs[i + 1]; 62783a0782d0SMark Fasheh 62793a0782d0SMark Fasheh memset(&el->l_recs[i], 0, 62803a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 62813a0782d0SMark Fasheh 62823a0782d0SMark Fasheh /* 62833a0782d0SMark Fasheh * We've modified our extent list. The 62843a0782d0SMark Fasheh * simplest way to handle this change 62853a0782d0SMark Fasheh * is to being the search from the 62863a0782d0SMark Fasheh * start again. 62873a0782d0SMark Fasheh */ 62883a0782d0SMark Fasheh goto find_tail_record; 62893a0782d0SMark Fasheh } 62903a0782d0SMark Fasheh 6291e48edee2SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -clusters_to_del); 62923a0782d0SMark Fasheh 62933a0782d0SMark Fasheh /* 62943a0782d0SMark Fasheh * We'll use "new_edge" on our way back up the 62953a0782d0SMark Fasheh * tree to know what our rightmost cpos is. 62963a0782d0SMark Fasheh */ 6297e48edee2SMark Fasheh new_edge = le16_to_cpu(rec->e_leaf_clusters); 62983a0782d0SMark Fasheh new_edge += le32_to_cpu(rec->e_cpos); 62993a0782d0SMark Fasheh 63003a0782d0SMark Fasheh /* 63013a0782d0SMark Fasheh * The caller will use this to delete data blocks. 63023a0782d0SMark Fasheh */ 63033a0782d0SMark Fasheh *delete_start = le64_to_cpu(rec->e_blkno) 63043a0782d0SMark Fasheh + ocfs2_clusters_to_blocks(inode->i_sb, 6305e48edee2SMark Fasheh le16_to_cpu(rec->e_leaf_clusters)); 63063a0782d0SMark Fasheh 63073a0782d0SMark Fasheh /* 63083a0782d0SMark Fasheh * If it's now empty, remove this record. 63093a0782d0SMark Fasheh */ 6310e48edee2SMark Fasheh if (le16_to_cpu(rec->e_leaf_clusters) == 0) { 63113a0782d0SMark Fasheh memset(rec, 0, 63123a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 63133a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 63143a0782d0SMark Fasheh } 63153a0782d0SMark Fasheh } else { 63163a0782d0SMark Fasheh if (le64_to_cpu(rec->e_blkno) == deleted_eb) { 63173a0782d0SMark Fasheh memset(rec, 0, 63183a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 63193a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 63203a0782d0SMark Fasheh 63213a0782d0SMark Fasheh goto delete; 63223a0782d0SMark Fasheh } 63233a0782d0SMark Fasheh 63243a0782d0SMark Fasheh /* Can this actually happen? */ 63253a0782d0SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) 63263a0782d0SMark Fasheh goto delete; 63273a0782d0SMark Fasheh 63283a0782d0SMark Fasheh /* 63293a0782d0SMark Fasheh * We never actually deleted any clusters 63303a0782d0SMark Fasheh * because our leaf was empty. There's no 63313a0782d0SMark Fasheh * reason to adjust the rightmost edge then. 63323a0782d0SMark Fasheh */ 63333a0782d0SMark Fasheh if (new_edge == 0) 63343a0782d0SMark Fasheh goto delete; 63353a0782d0SMark Fasheh 6336e48edee2SMark Fasheh rec->e_int_clusters = cpu_to_le32(new_edge); 6337e48edee2SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 63383a0782d0SMark Fasheh -le32_to_cpu(rec->e_cpos)); 63393a0782d0SMark Fasheh 63403a0782d0SMark Fasheh /* 63413a0782d0SMark Fasheh * A deleted child record should have been 63423a0782d0SMark Fasheh * caught above. 63433a0782d0SMark Fasheh */ 6344e48edee2SMark Fasheh BUG_ON(le32_to_cpu(rec->e_int_clusters) == 0); 63453a0782d0SMark Fasheh } 63463a0782d0SMark Fasheh 63473a0782d0SMark Fasheh delete: 63483a0782d0SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 63493a0782d0SMark Fasheh if (ret) { 63503a0782d0SMark Fasheh mlog_errno(ret); 63513a0782d0SMark Fasheh goto out; 63523a0782d0SMark Fasheh } 63533a0782d0SMark Fasheh 63543a0782d0SMark Fasheh mlog(0, "extent list container %llu, after: record %d: " 63553a0782d0SMark Fasheh "(%u, %u, %llu), next = %u.\n", 63563a0782d0SMark Fasheh (unsigned long long)bh->b_blocknr, i, 6357e48edee2SMark Fasheh le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec), 63583a0782d0SMark Fasheh (unsigned long long)le64_to_cpu(rec->e_blkno), 63593a0782d0SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 63603a0782d0SMark Fasheh 63613a0782d0SMark Fasheh /* 63623a0782d0SMark Fasheh * We must be careful to only attempt delete of an 63633a0782d0SMark Fasheh * extent block (and not the root inode block). 63643a0782d0SMark Fasheh */ 63653a0782d0SMark Fasheh if (index > 0 && le16_to_cpu(el->l_next_free_rec) == 0) { 63663a0782d0SMark Fasheh struct ocfs2_extent_block *eb = 63673a0782d0SMark Fasheh (struct ocfs2_extent_block *)bh->b_data; 63683a0782d0SMark Fasheh 63693a0782d0SMark Fasheh /* 63703a0782d0SMark Fasheh * Save this for use when processing the 63713a0782d0SMark Fasheh * parent block. 63723a0782d0SMark Fasheh */ 63733a0782d0SMark Fasheh deleted_eb = le64_to_cpu(eb->h_blkno); 63743a0782d0SMark Fasheh 63753a0782d0SMark Fasheh mlog(0, "deleting this extent block.\n"); 63763a0782d0SMark Fasheh 63773a0782d0SMark Fasheh ocfs2_remove_from_cache(inode, bh); 63783a0782d0SMark Fasheh 6379e48edee2SMark Fasheh BUG_ON(ocfs2_rec_clusters(el, &el->l_recs[0])); 63803a0782d0SMark Fasheh BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos)); 63813a0782d0SMark Fasheh BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno)); 63823a0782d0SMark Fasheh 638359a5e416SMark Fasheh ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb); 63843a0782d0SMark Fasheh /* An error here is not fatal. */ 63853a0782d0SMark Fasheh if (ret < 0) 63863a0782d0SMark Fasheh mlog_errno(ret); 63873a0782d0SMark Fasheh } else { 63883a0782d0SMark Fasheh deleted_eb = 0; 63893a0782d0SMark Fasheh } 63903a0782d0SMark Fasheh 63913a0782d0SMark Fasheh index--; 63923a0782d0SMark Fasheh } 63933a0782d0SMark Fasheh 63943a0782d0SMark Fasheh ret = 0; 63953a0782d0SMark Fasheh out: 63963a0782d0SMark Fasheh return ret; 63973a0782d0SMark Fasheh } 63983a0782d0SMark Fasheh 6399ccd979bdSMark Fasheh static int ocfs2_do_truncate(struct ocfs2_super *osb, 6400ccd979bdSMark Fasheh unsigned int clusters_to_del, 6401ccd979bdSMark Fasheh struct inode *inode, 6402ccd979bdSMark Fasheh struct buffer_head *fe_bh, 64031fabe148SMark Fasheh handle_t *handle, 6404dcd0538fSMark Fasheh struct ocfs2_truncate_context *tc, 6405dcd0538fSMark Fasheh struct ocfs2_path *path) 6406ccd979bdSMark Fasheh { 64073a0782d0SMark Fasheh int status; 6408ccd979bdSMark Fasheh struct ocfs2_dinode *fe; 6409ccd979bdSMark Fasheh struct ocfs2_extent_block *last_eb = NULL; 6410ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 6411ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 6412ccd979bdSMark Fasheh u64 delete_blk = 0; 6413ccd979bdSMark Fasheh 6414ccd979bdSMark Fasheh fe = (struct ocfs2_dinode *) fe_bh->b_data; 6415ccd979bdSMark Fasheh 64163a0782d0SMark Fasheh status = ocfs2_find_new_last_ext_blk(inode, clusters_to_del, 6417dcd0538fSMark Fasheh path, &last_eb_bh); 6418ccd979bdSMark Fasheh if (status < 0) { 6419ccd979bdSMark Fasheh mlog_errno(status); 6420ccd979bdSMark Fasheh goto bail; 6421ccd979bdSMark Fasheh } 6422ccd979bdSMark Fasheh 6423dcd0538fSMark Fasheh /* 6424dcd0538fSMark Fasheh * Each component will be touched, so we might as well journal 6425dcd0538fSMark Fasheh * here to avoid having to handle errors later. 6426dcd0538fSMark Fasheh */ 64273a0782d0SMark Fasheh status = ocfs2_journal_access_path(inode, handle, path); 6428ccd979bdSMark Fasheh if (status < 0) { 6429ccd979bdSMark Fasheh mlog_errno(status); 6430ccd979bdSMark Fasheh goto bail; 6431ccd979bdSMark Fasheh } 6432dcd0538fSMark Fasheh 6433dcd0538fSMark Fasheh if (last_eb_bh) { 6434dcd0538fSMark Fasheh status = ocfs2_journal_access(handle, inode, last_eb_bh, 6435dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 6436dcd0538fSMark Fasheh if (status < 0) { 6437dcd0538fSMark Fasheh mlog_errno(status); 6438dcd0538fSMark Fasheh goto bail; 6439dcd0538fSMark Fasheh } 6440dcd0538fSMark Fasheh 6441dcd0538fSMark Fasheh last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 6442dcd0538fSMark Fasheh } 6443dcd0538fSMark Fasheh 6444ccd979bdSMark Fasheh el = &(fe->id2.i_list); 6445ccd979bdSMark Fasheh 6446dcd0538fSMark Fasheh /* 6447dcd0538fSMark Fasheh * Lower levels depend on this never happening, but it's best 6448dcd0538fSMark Fasheh * to check it up here before changing the tree. 6449dcd0538fSMark Fasheh */ 6450e48edee2SMark Fasheh if (el->l_tree_depth && el->l_recs[0].e_int_clusters == 0) { 6451dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 6452dcd0538fSMark Fasheh "Inode %lu has an empty extent record, depth %u\n", 6453dcd0538fSMark Fasheh inode->i_ino, le16_to_cpu(el->l_tree_depth)); 64543a0782d0SMark Fasheh status = -EROFS; 6455dcd0538fSMark Fasheh goto bail; 6456dcd0538fSMark Fasheh } 6457dcd0538fSMark Fasheh 6458ccd979bdSMark Fasheh spin_lock(&OCFS2_I(inode)->ip_lock); 6459ccd979bdSMark Fasheh OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) - 6460ccd979bdSMark Fasheh clusters_to_del; 6461ccd979bdSMark Fasheh spin_unlock(&OCFS2_I(inode)->ip_lock); 6462ccd979bdSMark Fasheh le32_add_cpu(&fe->i_clusters, -clusters_to_del); 6463e535e2efSMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 6464ccd979bdSMark Fasheh 64653a0782d0SMark Fasheh status = ocfs2_trim_tree(inode, path, handle, tc, 64663a0782d0SMark Fasheh clusters_to_del, &delete_blk); 64673a0782d0SMark Fasheh if (status) { 64683a0782d0SMark Fasheh mlog_errno(status); 64693a0782d0SMark Fasheh goto bail; 6470ccd979bdSMark Fasheh } 6471ccd979bdSMark Fasheh 6472dcd0538fSMark Fasheh if (le32_to_cpu(fe->i_clusters) == 0) { 6473ccd979bdSMark Fasheh /* trunc to zero is a special case. */ 6474ccd979bdSMark Fasheh el->l_tree_depth = 0; 6475ccd979bdSMark Fasheh fe->i_last_eb_blk = 0; 6476ccd979bdSMark Fasheh } else if (last_eb) 6477ccd979bdSMark Fasheh fe->i_last_eb_blk = last_eb->h_blkno; 6478ccd979bdSMark Fasheh 6479ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, fe_bh); 6480ccd979bdSMark Fasheh if (status < 0) { 6481ccd979bdSMark Fasheh mlog_errno(status); 6482ccd979bdSMark Fasheh goto bail; 6483ccd979bdSMark Fasheh } 6484ccd979bdSMark Fasheh 6485ccd979bdSMark Fasheh if (last_eb) { 6486ccd979bdSMark Fasheh /* If there will be a new last extent block, then by 6487ccd979bdSMark Fasheh * definition, there cannot be any leaves to the right of 6488ccd979bdSMark Fasheh * him. */ 6489ccd979bdSMark Fasheh last_eb->h_next_leaf_blk = 0; 6490ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, last_eb_bh); 6491ccd979bdSMark Fasheh if (status < 0) { 6492ccd979bdSMark Fasheh mlog_errno(status); 6493ccd979bdSMark Fasheh goto bail; 6494ccd979bdSMark Fasheh } 6495ccd979bdSMark Fasheh } 6496ccd979bdSMark Fasheh 64973a0782d0SMark Fasheh if (delete_blk) { 6498ccd979bdSMark Fasheh status = ocfs2_truncate_log_append(osb, handle, delete_blk, 6499ccd979bdSMark Fasheh clusters_to_del); 6500ccd979bdSMark Fasheh if (status < 0) { 6501ccd979bdSMark Fasheh mlog_errno(status); 6502ccd979bdSMark Fasheh goto bail; 6503ccd979bdSMark Fasheh } 65043a0782d0SMark Fasheh } 6505ccd979bdSMark Fasheh status = 0; 6506ccd979bdSMark Fasheh bail: 6507dcd0538fSMark Fasheh 6508ccd979bdSMark Fasheh mlog_exit(status); 6509ccd979bdSMark Fasheh return status; 6510ccd979bdSMark Fasheh } 6511ccd979bdSMark Fasheh 651260b11392SMark Fasheh static int ocfs2_writeback_zero_func(handle_t *handle, struct buffer_head *bh) 651360b11392SMark Fasheh { 651460b11392SMark Fasheh set_buffer_uptodate(bh); 651560b11392SMark Fasheh mark_buffer_dirty(bh); 651660b11392SMark Fasheh return 0; 651760b11392SMark Fasheh } 651860b11392SMark Fasheh 651960b11392SMark Fasheh static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh) 652060b11392SMark Fasheh { 652160b11392SMark Fasheh set_buffer_uptodate(bh); 652260b11392SMark Fasheh mark_buffer_dirty(bh); 652360b11392SMark Fasheh return ocfs2_journal_dirty_data(handle, bh); 652460b11392SMark Fasheh } 652560b11392SMark Fasheh 65261d410a6eSMark Fasheh static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle, 65271d410a6eSMark Fasheh unsigned int from, unsigned int to, 65281d410a6eSMark Fasheh struct page *page, int zero, u64 *phys) 652960b11392SMark Fasheh { 65301d410a6eSMark Fasheh int ret, partial = 0; 653160b11392SMark Fasheh 65321d410a6eSMark Fasheh ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0); 653360b11392SMark Fasheh if (ret) 653460b11392SMark Fasheh mlog_errno(ret); 653560b11392SMark Fasheh 65361d410a6eSMark Fasheh if (zero) 6537eebd2aa3SChristoph Lameter zero_user_segment(page, from, to); 653860b11392SMark Fasheh 653960b11392SMark Fasheh /* 654060b11392SMark Fasheh * Need to set the buffers we zero'd into uptodate 654160b11392SMark Fasheh * here if they aren't - ocfs2_map_page_blocks() 654260b11392SMark Fasheh * might've skipped some 654360b11392SMark Fasheh */ 654460b11392SMark Fasheh if (ocfs2_should_order_data(inode)) { 654560b11392SMark Fasheh ret = walk_page_buffers(handle, 654660b11392SMark Fasheh page_buffers(page), 654760b11392SMark Fasheh from, to, &partial, 654860b11392SMark Fasheh ocfs2_ordered_zero_func); 654960b11392SMark Fasheh if (ret < 0) 655060b11392SMark Fasheh mlog_errno(ret); 655160b11392SMark Fasheh } else { 655260b11392SMark Fasheh ret = walk_page_buffers(handle, page_buffers(page), 655360b11392SMark Fasheh from, to, &partial, 655460b11392SMark Fasheh ocfs2_writeback_zero_func); 655560b11392SMark Fasheh if (ret < 0) 655660b11392SMark Fasheh mlog_errno(ret); 655760b11392SMark Fasheh } 655860b11392SMark Fasheh 655960b11392SMark Fasheh if (!partial) 656060b11392SMark Fasheh SetPageUptodate(page); 656160b11392SMark Fasheh 656260b11392SMark Fasheh flush_dcache_page(page); 65631d410a6eSMark Fasheh } 65641d410a6eSMark Fasheh 65651d410a6eSMark Fasheh static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start, 65661d410a6eSMark Fasheh loff_t end, struct page **pages, 65671d410a6eSMark Fasheh int numpages, u64 phys, handle_t *handle) 65681d410a6eSMark Fasheh { 65691d410a6eSMark Fasheh int i; 65701d410a6eSMark Fasheh struct page *page; 65711d410a6eSMark Fasheh unsigned int from, to = PAGE_CACHE_SIZE; 65721d410a6eSMark Fasheh struct super_block *sb = inode->i_sb; 65731d410a6eSMark Fasheh 65741d410a6eSMark Fasheh BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb))); 65751d410a6eSMark Fasheh 65761d410a6eSMark Fasheh if (numpages == 0) 65771d410a6eSMark Fasheh goto out; 65781d410a6eSMark Fasheh 65791d410a6eSMark Fasheh to = PAGE_CACHE_SIZE; 65801d410a6eSMark Fasheh for(i = 0; i < numpages; i++) { 65811d410a6eSMark Fasheh page = pages[i]; 65821d410a6eSMark Fasheh 65831d410a6eSMark Fasheh from = start & (PAGE_CACHE_SIZE - 1); 65841d410a6eSMark Fasheh if ((end >> PAGE_CACHE_SHIFT) == page->index) 65851d410a6eSMark Fasheh to = end & (PAGE_CACHE_SIZE - 1); 65861d410a6eSMark Fasheh 65871d410a6eSMark Fasheh BUG_ON(from > PAGE_CACHE_SIZE); 65881d410a6eSMark Fasheh BUG_ON(to > PAGE_CACHE_SIZE); 65891d410a6eSMark Fasheh 65901d410a6eSMark Fasheh ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1, 65911d410a6eSMark Fasheh &phys); 659260b11392SMark Fasheh 659335edec1dSMark Fasheh start = (page->index + 1) << PAGE_CACHE_SHIFT; 659460b11392SMark Fasheh } 659560b11392SMark Fasheh out: 65961d410a6eSMark Fasheh if (pages) 65971d410a6eSMark Fasheh ocfs2_unlock_and_free_pages(pages, numpages); 659860b11392SMark Fasheh } 659960b11392SMark Fasheh 660035edec1dSMark Fasheh static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end, 66011d410a6eSMark Fasheh struct page **pages, int *num) 660260b11392SMark Fasheh { 66031d410a6eSMark Fasheh int numpages, ret = 0; 660460b11392SMark Fasheh struct super_block *sb = inode->i_sb; 660560b11392SMark Fasheh struct address_space *mapping = inode->i_mapping; 660660b11392SMark Fasheh unsigned long index; 660735edec1dSMark Fasheh loff_t last_page_bytes; 660860b11392SMark Fasheh 660935edec1dSMark Fasheh BUG_ON(start > end); 661060b11392SMark Fasheh 661135edec1dSMark Fasheh BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits != 661235edec1dSMark Fasheh (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits); 661335edec1dSMark Fasheh 66141d410a6eSMark Fasheh numpages = 0; 661535edec1dSMark Fasheh last_page_bytes = PAGE_ALIGN(end); 661635edec1dSMark Fasheh index = start >> PAGE_CACHE_SHIFT; 661760b11392SMark Fasheh do { 661860b11392SMark Fasheh pages[numpages] = grab_cache_page(mapping, index); 661960b11392SMark Fasheh if (!pages[numpages]) { 662060b11392SMark Fasheh ret = -ENOMEM; 662160b11392SMark Fasheh mlog_errno(ret); 662260b11392SMark Fasheh goto out; 662360b11392SMark Fasheh } 662460b11392SMark Fasheh 662560b11392SMark Fasheh numpages++; 662660b11392SMark Fasheh index++; 662735edec1dSMark Fasheh } while (index < (last_page_bytes >> PAGE_CACHE_SHIFT)); 662860b11392SMark Fasheh 662960b11392SMark Fasheh out: 663060b11392SMark Fasheh if (ret != 0) { 66311d410a6eSMark Fasheh if (pages) 66321d410a6eSMark Fasheh ocfs2_unlock_and_free_pages(pages, numpages); 663360b11392SMark Fasheh numpages = 0; 663460b11392SMark Fasheh } 663560b11392SMark Fasheh 663660b11392SMark Fasheh *num = numpages; 663760b11392SMark Fasheh 663860b11392SMark Fasheh return ret; 663960b11392SMark Fasheh } 664060b11392SMark Fasheh 664160b11392SMark Fasheh /* 664260b11392SMark Fasheh * Zero the area past i_size but still within an allocated 664360b11392SMark Fasheh * cluster. This avoids exposing nonzero data on subsequent file 664460b11392SMark Fasheh * extends. 664560b11392SMark Fasheh * 664660b11392SMark Fasheh * We need to call this before i_size is updated on the inode because 664760b11392SMark Fasheh * otherwise block_write_full_page() will skip writeout of pages past 664860b11392SMark Fasheh * i_size. The new_i_size parameter is passed for this reason. 664960b11392SMark Fasheh */ 665035edec1dSMark Fasheh int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle, 665135edec1dSMark Fasheh u64 range_start, u64 range_end) 665260b11392SMark Fasheh { 66531d410a6eSMark Fasheh int ret = 0, numpages; 665460b11392SMark Fasheh struct page **pages = NULL; 665560b11392SMark Fasheh u64 phys; 66561d410a6eSMark Fasheh unsigned int ext_flags; 66571d410a6eSMark Fasheh struct super_block *sb = inode->i_sb; 665860b11392SMark Fasheh 665960b11392SMark Fasheh /* 666060b11392SMark Fasheh * File systems which don't support sparse files zero on every 666160b11392SMark Fasheh * extend. 666260b11392SMark Fasheh */ 66631d410a6eSMark Fasheh if (!ocfs2_sparse_alloc(OCFS2_SB(sb))) 666460b11392SMark Fasheh return 0; 666560b11392SMark Fasheh 66661d410a6eSMark Fasheh pages = kcalloc(ocfs2_pages_per_cluster(sb), 666760b11392SMark Fasheh sizeof(struct page *), GFP_NOFS); 666860b11392SMark Fasheh if (pages == NULL) { 666960b11392SMark Fasheh ret = -ENOMEM; 667060b11392SMark Fasheh mlog_errno(ret); 667160b11392SMark Fasheh goto out; 667260b11392SMark Fasheh } 667360b11392SMark Fasheh 66741d410a6eSMark Fasheh if (range_start == range_end) 66751d410a6eSMark Fasheh goto out; 66761d410a6eSMark Fasheh 66771d410a6eSMark Fasheh ret = ocfs2_extent_map_get_blocks(inode, 66781d410a6eSMark Fasheh range_start >> sb->s_blocksize_bits, 66791d410a6eSMark Fasheh &phys, NULL, &ext_flags); 668060b11392SMark Fasheh if (ret) { 668160b11392SMark Fasheh mlog_errno(ret); 668260b11392SMark Fasheh goto out; 668360b11392SMark Fasheh } 668460b11392SMark Fasheh 66851d410a6eSMark Fasheh /* 66861d410a6eSMark Fasheh * Tail is a hole, or is marked unwritten. In either case, we 66871d410a6eSMark Fasheh * can count on read and write to return/push zero's. 66881d410a6eSMark Fasheh */ 66891d410a6eSMark Fasheh if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN) 669060b11392SMark Fasheh goto out; 669160b11392SMark Fasheh 66921d410a6eSMark Fasheh ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages, 66931d410a6eSMark Fasheh &numpages); 66941d410a6eSMark Fasheh if (ret) { 66951d410a6eSMark Fasheh mlog_errno(ret); 66961d410a6eSMark Fasheh goto out; 66971d410a6eSMark Fasheh } 66981d410a6eSMark Fasheh 669935edec1dSMark Fasheh ocfs2_zero_cluster_pages(inode, range_start, range_end, pages, 670035edec1dSMark Fasheh numpages, phys, handle); 670160b11392SMark Fasheh 670260b11392SMark Fasheh /* 670360b11392SMark Fasheh * Initiate writeout of the pages we zero'd here. We don't 670460b11392SMark Fasheh * wait on them - the truncate_inode_pages() call later will 670560b11392SMark Fasheh * do that for us. 670660b11392SMark Fasheh */ 670735edec1dSMark Fasheh ret = do_sync_mapping_range(inode->i_mapping, range_start, 670835edec1dSMark Fasheh range_end - 1, SYNC_FILE_RANGE_WRITE); 670960b11392SMark Fasheh if (ret) 671060b11392SMark Fasheh mlog_errno(ret); 671160b11392SMark Fasheh 671260b11392SMark Fasheh out: 671360b11392SMark Fasheh if (pages) 671460b11392SMark Fasheh kfree(pages); 671560b11392SMark Fasheh 671660b11392SMark Fasheh return ret; 671760b11392SMark Fasheh } 671860b11392SMark Fasheh 6719fdd77704STiger Yang static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode, 6720fdd77704STiger Yang struct ocfs2_dinode *di) 67211afc32b9SMark Fasheh { 67221afc32b9SMark Fasheh unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits; 6723fdd77704STiger Yang unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size); 67241afc32b9SMark Fasheh 6725fdd77704STiger Yang if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL) 6726fdd77704STiger Yang memset(&di->id2, 0, blocksize - 6727fdd77704STiger Yang offsetof(struct ocfs2_dinode, id2) - 6728fdd77704STiger Yang xattrsize); 6729fdd77704STiger Yang else 6730fdd77704STiger Yang memset(&di->id2, 0, blocksize - 6731fdd77704STiger Yang offsetof(struct ocfs2_dinode, id2)); 67321afc32b9SMark Fasheh } 67331afc32b9SMark Fasheh 67345b6a3a2bSMark Fasheh void ocfs2_dinode_new_extent_list(struct inode *inode, 67355b6a3a2bSMark Fasheh struct ocfs2_dinode *di) 67365b6a3a2bSMark Fasheh { 6737fdd77704STiger Yang ocfs2_zero_dinode_id2_with_xattr(inode, di); 67385b6a3a2bSMark Fasheh di->id2.i_list.l_tree_depth = 0; 67395b6a3a2bSMark Fasheh di->id2.i_list.l_next_free_rec = 0; 6740fdd77704STiger Yang di->id2.i_list.l_count = cpu_to_le16( 6741fdd77704STiger Yang ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di)); 67425b6a3a2bSMark Fasheh } 67435b6a3a2bSMark Fasheh 67441afc32b9SMark Fasheh void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di) 67451afc32b9SMark Fasheh { 67461afc32b9SMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 67471afc32b9SMark Fasheh struct ocfs2_inline_data *idata = &di->id2.i_data; 67481afc32b9SMark Fasheh 67491afc32b9SMark Fasheh spin_lock(&oi->ip_lock); 67501afc32b9SMark Fasheh oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL; 67511afc32b9SMark Fasheh di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 67521afc32b9SMark Fasheh spin_unlock(&oi->ip_lock); 67531afc32b9SMark Fasheh 67541afc32b9SMark Fasheh /* 67551afc32b9SMark Fasheh * We clear the entire i_data structure here so that all 67561afc32b9SMark Fasheh * fields can be properly initialized. 67571afc32b9SMark Fasheh */ 6758fdd77704STiger Yang ocfs2_zero_dinode_id2_with_xattr(inode, di); 67591afc32b9SMark Fasheh 6760fdd77704STiger Yang idata->id_count = cpu_to_le16( 6761fdd77704STiger Yang ocfs2_max_inline_data_with_xattr(inode->i_sb, di)); 67621afc32b9SMark Fasheh } 67631afc32b9SMark Fasheh 67641afc32b9SMark Fasheh int ocfs2_convert_inline_data_to_extents(struct inode *inode, 67651afc32b9SMark Fasheh struct buffer_head *di_bh) 67661afc32b9SMark Fasheh { 67671afc32b9SMark Fasheh int ret, i, has_data, num_pages = 0; 67681afc32b9SMark Fasheh handle_t *handle; 67691afc32b9SMark Fasheh u64 uninitialized_var(block); 67701afc32b9SMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 67711afc32b9SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 67721afc32b9SMark Fasheh struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 67731afc32b9SMark Fasheh struct ocfs2_alloc_context *data_ac = NULL; 67741afc32b9SMark Fasheh struct page **pages = NULL; 67751afc32b9SMark Fasheh loff_t end = osb->s_clustersize; 67761afc32b9SMark Fasheh 67771afc32b9SMark Fasheh has_data = i_size_read(inode) ? 1 : 0; 67781afc32b9SMark Fasheh 67791afc32b9SMark Fasheh if (has_data) { 67801afc32b9SMark Fasheh pages = kcalloc(ocfs2_pages_per_cluster(osb->sb), 67811afc32b9SMark Fasheh sizeof(struct page *), GFP_NOFS); 67821afc32b9SMark Fasheh if (pages == NULL) { 67831afc32b9SMark Fasheh ret = -ENOMEM; 67841afc32b9SMark Fasheh mlog_errno(ret); 67851afc32b9SMark Fasheh goto out; 67861afc32b9SMark Fasheh } 67871afc32b9SMark Fasheh 67881afc32b9SMark Fasheh ret = ocfs2_reserve_clusters(osb, 1, &data_ac); 67891afc32b9SMark Fasheh if (ret) { 67901afc32b9SMark Fasheh mlog_errno(ret); 67911afc32b9SMark Fasheh goto out; 67921afc32b9SMark Fasheh } 67931afc32b9SMark Fasheh } 67941afc32b9SMark Fasheh 67951afc32b9SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_INLINE_TO_EXTENTS_CREDITS); 67961afc32b9SMark Fasheh if (IS_ERR(handle)) { 67971afc32b9SMark Fasheh ret = PTR_ERR(handle); 67981afc32b9SMark Fasheh mlog_errno(ret); 67991afc32b9SMark Fasheh goto out_unlock; 68001afc32b9SMark Fasheh } 68011afc32b9SMark Fasheh 68021afc32b9SMark Fasheh ret = ocfs2_journal_access(handle, inode, di_bh, 68031afc32b9SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 68041afc32b9SMark Fasheh if (ret) { 68051afc32b9SMark Fasheh mlog_errno(ret); 68061afc32b9SMark Fasheh goto out_commit; 68071afc32b9SMark Fasheh } 68081afc32b9SMark Fasheh 68091afc32b9SMark Fasheh if (has_data) { 68101afc32b9SMark Fasheh u32 bit_off, num; 68111afc32b9SMark Fasheh unsigned int page_end; 68121afc32b9SMark Fasheh u64 phys; 68131afc32b9SMark Fasheh 68141afc32b9SMark Fasheh ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, 68151afc32b9SMark Fasheh &num); 68161afc32b9SMark Fasheh if (ret) { 68171afc32b9SMark Fasheh mlog_errno(ret); 68181afc32b9SMark Fasheh goto out_commit; 68191afc32b9SMark Fasheh } 68201afc32b9SMark Fasheh 68211afc32b9SMark Fasheh /* 68221afc32b9SMark Fasheh * Save two copies, one for insert, and one that can 68231afc32b9SMark Fasheh * be changed by ocfs2_map_and_dirty_page() below. 68241afc32b9SMark Fasheh */ 68251afc32b9SMark Fasheh block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); 68261afc32b9SMark Fasheh 68271afc32b9SMark Fasheh /* 68281afc32b9SMark Fasheh * Non sparse file systems zero on extend, so no need 68291afc32b9SMark Fasheh * to do that now. 68301afc32b9SMark Fasheh */ 68311afc32b9SMark Fasheh if (!ocfs2_sparse_alloc(osb) && 68321afc32b9SMark Fasheh PAGE_CACHE_SIZE < osb->s_clustersize) 68331afc32b9SMark Fasheh end = PAGE_CACHE_SIZE; 68341afc32b9SMark Fasheh 68351afc32b9SMark Fasheh ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages); 68361afc32b9SMark Fasheh if (ret) { 68371afc32b9SMark Fasheh mlog_errno(ret); 68381afc32b9SMark Fasheh goto out_commit; 68391afc32b9SMark Fasheh } 68401afc32b9SMark Fasheh 68411afc32b9SMark Fasheh /* 68421afc32b9SMark Fasheh * This should populate the 1st page for us and mark 68431afc32b9SMark Fasheh * it up to date. 68441afc32b9SMark Fasheh */ 68451afc32b9SMark Fasheh ret = ocfs2_read_inline_data(inode, pages[0], di_bh); 68461afc32b9SMark Fasheh if (ret) { 68471afc32b9SMark Fasheh mlog_errno(ret); 68481afc32b9SMark Fasheh goto out_commit; 68491afc32b9SMark Fasheh } 68501afc32b9SMark Fasheh 68511afc32b9SMark Fasheh page_end = PAGE_CACHE_SIZE; 68521afc32b9SMark Fasheh if (PAGE_CACHE_SIZE > osb->s_clustersize) 68531afc32b9SMark Fasheh page_end = osb->s_clustersize; 68541afc32b9SMark Fasheh 68551afc32b9SMark Fasheh for (i = 0; i < num_pages; i++) 68561afc32b9SMark Fasheh ocfs2_map_and_dirty_page(inode, handle, 0, page_end, 68571afc32b9SMark Fasheh pages[i], i > 0, &phys); 68581afc32b9SMark Fasheh } 68591afc32b9SMark Fasheh 68601afc32b9SMark Fasheh spin_lock(&oi->ip_lock); 68611afc32b9SMark Fasheh oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL; 68621afc32b9SMark Fasheh di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 68631afc32b9SMark Fasheh spin_unlock(&oi->ip_lock); 68641afc32b9SMark Fasheh 68655b6a3a2bSMark Fasheh ocfs2_dinode_new_extent_list(inode, di); 68661afc32b9SMark Fasheh 68671afc32b9SMark Fasheh ocfs2_journal_dirty(handle, di_bh); 68681afc32b9SMark Fasheh 68691afc32b9SMark Fasheh if (has_data) { 68701afc32b9SMark Fasheh /* 68711afc32b9SMark Fasheh * An error at this point should be extremely rare. If 68721afc32b9SMark Fasheh * this proves to be false, we could always re-build 68731afc32b9SMark Fasheh * the in-inode data from our pages. 68741afc32b9SMark Fasheh */ 6875f56654c4STao Ma ret = ocfs2_dinode_insert_extent(osb, handle, inode, di_bh, 6876f56654c4STao Ma 0, block, 1, 0, NULL); 68771afc32b9SMark Fasheh if (ret) { 68781afc32b9SMark Fasheh mlog_errno(ret); 68791afc32b9SMark Fasheh goto out_commit; 68801afc32b9SMark Fasheh } 68811afc32b9SMark Fasheh 68821afc32b9SMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 68831afc32b9SMark Fasheh } 68841afc32b9SMark Fasheh 68851afc32b9SMark Fasheh out_commit: 68861afc32b9SMark Fasheh ocfs2_commit_trans(osb, handle); 68871afc32b9SMark Fasheh 68881afc32b9SMark Fasheh out_unlock: 68891afc32b9SMark Fasheh if (data_ac) 68901afc32b9SMark Fasheh ocfs2_free_alloc_context(data_ac); 68911afc32b9SMark Fasheh 68921afc32b9SMark Fasheh out: 68931afc32b9SMark Fasheh if (pages) { 68941afc32b9SMark Fasheh ocfs2_unlock_and_free_pages(pages, num_pages); 68951afc32b9SMark Fasheh kfree(pages); 68961afc32b9SMark Fasheh } 68971afc32b9SMark Fasheh 68981afc32b9SMark Fasheh return ret; 68991afc32b9SMark Fasheh } 69001afc32b9SMark Fasheh 6901ccd979bdSMark Fasheh /* 6902ccd979bdSMark Fasheh * It is expected, that by the time you call this function, 6903ccd979bdSMark Fasheh * inode->i_size and fe->i_size have been adjusted. 6904ccd979bdSMark Fasheh * 6905ccd979bdSMark Fasheh * WARNING: This will kfree the truncate context 6906ccd979bdSMark Fasheh */ 6907ccd979bdSMark Fasheh int ocfs2_commit_truncate(struct ocfs2_super *osb, 6908ccd979bdSMark Fasheh struct inode *inode, 6909ccd979bdSMark Fasheh struct buffer_head *fe_bh, 6910ccd979bdSMark Fasheh struct ocfs2_truncate_context *tc) 6911ccd979bdSMark Fasheh { 6912ccd979bdSMark Fasheh int status, i, credits, tl_sem = 0; 6913dcd0538fSMark Fasheh u32 clusters_to_del, new_highest_cpos, range; 6914ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 69151fabe148SMark Fasheh handle_t *handle = NULL; 6916ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 6917dcd0538fSMark Fasheh struct ocfs2_path *path = NULL; 6918e7d4cb6bSTao Ma struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data; 6919ccd979bdSMark Fasheh 6920ccd979bdSMark Fasheh mlog_entry_void(); 6921ccd979bdSMark Fasheh 6922dcd0538fSMark Fasheh new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb, 6923ccd979bdSMark Fasheh i_size_read(inode)); 6924ccd979bdSMark Fasheh 6925e7d4cb6bSTao Ma path = ocfs2_new_path(fe_bh, &di->id2.i_list); 6926dcd0538fSMark Fasheh if (!path) { 6927dcd0538fSMark Fasheh status = -ENOMEM; 6928ccd979bdSMark Fasheh mlog_errno(status); 6929ccd979bdSMark Fasheh goto bail; 6930ccd979bdSMark Fasheh } 693183418978SMark Fasheh 693283418978SMark Fasheh ocfs2_extent_map_trunc(inode, new_highest_cpos); 693383418978SMark Fasheh 6934dcd0538fSMark Fasheh start: 6935dcd0538fSMark Fasheh /* 69363a0782d0SMark Fasheh * Check that we still have allocation to delete. 69373a0782d0SMark Fasheh */ 69383a0782d0SMark Fasheh if (OCFS2_I(inode)->ip_clusters == 0) { 69393a0782d0SMark Fasheh status = 0; 69403a0782d0SMark Fasheh goto bail; 69413a0782d0SMark Fasheh } 69423a0782d0SMark Fasheh 69433a0782d0SMark Fasheh /* 6944dcd0538fSMark Fasheh * Truncate always works against the rightmost tree branch. 6945dcd0538fSMark Fasheh */ 6946dcd0538fSMark Fasheh status = ocfs2_find_path(inode, path, UINT_MAX); 6947dcd0538fSMark Fasheh if (status) { 6948dcd0538fSMark Fasheh mlog_errno(status); 6949ccd979bdSMark Fasheh goto bail; 6950ccd979bdSMark Fasheh } 6951ccd979bdSMark Fasheh 6952dcd0538fSMark Fasheh mlog(0, "inode->ip_clusters = %u, tree_depth = %u\n", 6953dcd0538fSMark Fasheh OCFS2_I(inode)->ip_clusters, path->p_tree_depth); 6954dcd0538fSMark Fasheh 6955dcd0538fSMark Fasheh /* 6956dcd0538fSMark Fasheh * By now, el will point to the extent list on the bottom most 6957dcd0538fSMark Fasheh * portion of this tree. Only the tail record is considered in 6958dcd0538fSMark Fasheh * each pass. 6959dcd0538fSMark Fasheh * 6960dcd0538fSMark Fasheh * We handle the following cases, in order: 6961dcd0538fSMark Fasheh * - empty extent: delete the remaining branch 6962dcd0538fSMark Fasheh * - remove the entire record 6963dcd0538fSMark Fasheh * - remove a partial record 6964dcd0538fSMark Fasheh * - no record needs to be removed (truncate has completed) 6965dcd0538fSMark Fasheh */ 6966dcd0538fSMark Fasheh el = path_leaf_el(path); 69673a0782d0SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 69683a0782d0SMark Fasheh ocfs2_error(inode->i_sb, 69693a0782d0SMark Fasheh "Inode %llu has empty extent block at %llu\n", 69703a0782d0SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 69713a0782d0SMark Fasheh (unsigned long long)path_leaf_bh(path)->b_blocknr); 69723a0782d0SMark Fasheh status = -EROFS; 69733a0782d0SMark Fasheh goto bail; 69743a0782d0SMark Fasheh } 69753a0782d0SMark Fasheh 6976ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 6977dcd0538fSMark Fasheh range = le32_to_cpu(el->l_recs[i].e_cpos) + 6978e48edee2SMark Fasheh ocfs2_rec_clusters(el, &el->l_recs[i]); 6979dcd0538fSMark Fasheh if (i == 0 && ocfs2_is_empty_extent(&el->l_recs[i])) { 6980dcd0538fSMark Fasheh clusters_to_del = 0; 6981dcd0538fSMark Fasheh } else if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_highest_cpos) { 6982e48edee2SMark Fasheh clusters_to_del = ocfs2_rec_clusters(el, &el->l_recs[i]); 6983dcd0538fSMark Fasheh } else if (range > new_highest_cpos) { 6984e48edee2SMark Fasheh clusters_to_del = (ocfs2_rec_clusters(el, &el->l_recs[i]) + 6985ccd979bdSMark Fasheh le32_to_cpu(el->l_recs[i].e_cpos)) - 6986dcd0538fSMark Fasheh new_highest_cpos; 6987dcd0538fSMark Fasheh } else { 6988dcd0538fSMark Fasheh status = 0; 6989dcd0538fSMark Fasheh goto bail; 6990dcd0538fSMark Fasheh } 6991ccd979bdSMark Fasheh 6992dcd0538fSMark Fasheh mlog(0, "clusters_to_del = %u in this pass, tail blk=%llu\n", 6993dcd0538fSMark Fasheh clusters_to_del, (unsigned long long)path_leaf_bh(path)->b_blocknr); 6994dcd0538fSMark Fasheh 69951b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 6996ccd979bdSMark Fasheh tl_sem = 1; 6997ccd979bdSMark Fasheh /* ocfs2_truncate_log_needs_flush guarantees us at least one 6998ccd979bdSMark Fasheh * record is free for use. If there isn't any, we flush to get 6999ccd979bdSMark Fasheh * an empty truncate log. */ 7000ccd979bdSMark Fasheh if (ocfs2_truncate_log_needs_flush(osb)) { 7001ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 7002ccd979bdSMark Fasheh if (status < 0) { 7003ccd979bdSMark Fasheh mlog_errno(status); 7004ccd979bdSMark Fasheh goto bail; 7005ccd979bdSMark Fasheh } 7006ccd979bdSMark Fasheh } 7007ccd979bdSMark Fasheh 7008ccd979bdSMark Fasheh credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del, 7009dcd0538fSMark Fasheh (struct ocfs2_dinode *)fe_bh->b_data, 7010dcd0538fSMark Fasheh el); 701165eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, credits); 7012ccd979bdSMark Fasheh if (IS_ERR(handle)) { 7013ccd979bdSMark Fasheh status = PTR_ERR(handle); 7014ccd979bdSMark Fasheh handle = NULL; 7015ccd979bdSMark Fasheh mlog_errno(status); 7016ccd979bdSMark Fasheh goto bail; 7017ccd979bdSMark Fasheh } 7018ccd979bdSMark Fasheh 7019dcd0538fSMark Fasheh status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh, handle, 7020dcd0538fSMark Fasheh tc, path); 7021ccd979bdSMark Fasheh if (status < 0) { 7022ccd979bdSMark Fasheh mlog_errno(status); 7023ccd979bdSMark Fasheh goto bail; 7024ccd979bdSMark Fasheh } 7025ccd979bdSMark Fasheh 70261b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 7027ccd979bdSMark Fasheh tl_sem = 0; 7028ccd979bdSMark Fasheh 702902dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 7030ccd979bdSMark Fasheh handle = NULL; 7031ccd979bdSMark Fasheh 7032dcd0538fSMark Fasheh ocfs2_reinit_path(path, 1); 7033dcd0538fSMark Fasheh 7034dcd0538fSMark Fasheh /* 70353a0782d0SMark Fasheh * The check above will catch the case where we've truncated 70363a0782d0SMark Fasheh * away all allocation. 7037dcd0538fSMark Fasheh */ 7038ccd979bdSMark Fasheh goto start; 70393a0782d0SMark Fasheh 7040ccd979bdSMark Fasheh bail: 7041ccd979bdSMark Fasheh 7042ccd979bdSMark Fasheh ocfs2_schedule_truncate_log_flush(osb, 1); 7043ccd979bdSMark Fasheh 7044ccd979bdSMark Fasheh if (tl_sem) 70451b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 7046ccd979bdSMark Fasheh 7047ccd979bdSMark Fasheh if (handle) 704802dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 7049ccd979bdSMark Fasheh 705059a5e416SMark Fasheh ocfs2_run_deallocs(osb, &tc->tc_dealloc); 705159a5e416SMark Fasheh 7052dcd0538fSMark Fasheh ocfs2_free_path(path); 7053ccd979bdSMark Fasheh 7054ccd979bdSMark Fasheh /* This will drop the ext_alloc cluster lock for us */ 7055ccd979bdSMark Fasheh ocfs2_free_truncate_context(tc); 7056ccd979bdSMark Fasheh 7057ccd979bdSMark Fasheh mlog_exit(status); 7058ccd979bdSMark Fasheh return status; 7059ccd979bdSMark Fasheh } 7060ccd979bdSMark Fasheh 7061ccd979bdSMark Fasheh /* 706259a5e416SMark Fasheh * Expects the inode to already be locked. 7063ccd979bdSMark Fasheh */ 7064ccd979bdSMark Fasheh int ocfs2_prepare_truncate(struct ocfs2_super *osb, 7065ccd979bdSMark Fasheh struct inode *inode, 7066ccd979bdSMark Fasheh struct buffer_head *fe_bh, 7067ccd979bdSMark Fasheh struct ocfs2_truncate_context **tc) 7068ccd979bdSMark Fasheh { 706959a5e416SMark Fasheh int status; 7070ccd979bdSMark Fasheh unsigned int new_i_clusters; 7071ccd979bdSMark Fasheh struct ocfs2_dinode *fe; 7072ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 7073ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 7074ccd979bdSMark Fasheh 7075ccd979bdSMark Fasheh mlog_entry_void(); 7076ccd979bdSMark Fasheh 7077ccd979bdSMark Fasheh *tc = NULL; 7078ccd979bdSMark Fasheh 7079ccd979bdSMark Fasheh new_i_clusters = ocfs2_clusters_for_bytes(osb->sb, 7080ccd979bdSMark Fasheh i_size_read(inode)); 7081ccd979bdSMark Fasheh fe = (struct ocfs2_dinode *) fe_bh->b_data; 7082ccd979bdSMark Fasheh 7083ccd979bdSMark Fasheh mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size =" 70841ca1a111SMark Fasheh "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters, 70851ca1a111SMark Fasheh (unsigned long long)le64_to_cpu(fe->i_size)); 7086ccd979bdSMark Fasheh 7087cd861280SRobert P. J. Day *tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL); 7088ccd979bdSMark Fasheh if (!(*tc)) { 7089ccd979bdSMark Fasheh status = -ENOMEM; 7090ccd979bdSMark Fasheh mlog_errno(status); 7091ccd979bdSMark Fasheh goto bail; 7092ccd979bdSMark Fasheh } 709359a5e416SMark Fasheh ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc); 7094ccd979bdSMark Fasheh 7095ccd979bdSMark Fasheh if (fe->id2.i_list.l_tree_depth) { 7096ccd979bdSMark Fasheh status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk), 7097ccd979bdSMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 7098ccd979bdSMark Fasheh if (status < 0) { 7099ccd979bdSMark Fasheh mlog_errno(status); 7100ccd979bdSMark Fasheh goto bail; 7101ccd979bdSMark Fasheh } 7102ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 7103ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 7104ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 7105ccd979bdSMark Fasheh 7106ccd979bdSMark Fasheh brelse(last_eb_bh); 7107ccd979bdSMark Fasheh status = -EIO; 7108ccd979bdSMark Fasheh goto bail; 7109ccd979bdSMark Fasheh } 7110ccd979bdSMark Fasheh } 7111ccd979bdSMark Fasheh 7112ccd979bdSMark Fasheh (*tc)->tc_last_eb_bh = last_eb_bh; 7113ccd979bdSMark Fasheh 7114ccd979bdSMark Fasheh status = 0; 7115ccd979bdSMark Fasheh bail: 7116ccd979bdSMark Fasheh if (status < 0) { 7117ccd979bdSMark Fasheh if (*tc) 7118ccd979bdSMark Fasheh ocfs2_free_truncate_context(*tc); 7119ccd979bdSMark Fasheh *tc = NULL; 7120ccd979bdSMark Fasheh } 7121ccd979bdSMark Fasheh mlog_exit_void(); 7122ccd979bdSMark Fasheh return status; 7123ccd979bdSMark Fasheh } 7124ccd979bdSMark Fasheh 71251afc32b9SMark Fasheh /* 71261afc32b9SMark Fasheh * 'start' is inclusive, 'end' is not. 71271afc32b9SMark Fasheh */ 71281afc32b9SMark Fasheh int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh, 71291afc32b9SMark Fasheh unsigned int start, unsigned int end, int trunc) 71301afc32b9SMark Fasheh { 71311afc32b9SMark Fasheh int ret; 71321afc32b9SMark Fasheh unsigned int numbytes; 71331afc32b9SMark Fasheh handle_t *handle; 71341afc32b9SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 71351afc32b9SMark Fasheh struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 71361afc32b9SMark Fasheh struct ocfs2_inline_data *idata = &di->id2.i_data; 71371afc32b9SMark Fasheh 71381afc32b9SMark Fasheh if (end > i_size_read(inode)) 71391afc32b9SMark Fasheh end = i_size_read(inode); 71401afc32b9SMark Fasheh 71411afc32b9SMark Fasheh BUG_ON(start >= end); 71421afc32b9SMark Fasheh 71431afc32b9SMark Fasheh if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) || 71441afc32b9SMark Fasheh !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) || 71451afc32b9SMark Fasheh !ocfs2_supports_inline_data(osb)) { 71461afc32b9SMark Fasheh ocfs2_error(inode->i_sb, 71471afc32b9SMark Fasheh "Inline data flags for inode %llu don't agree! " 71481afc32b9SMark Fasheh "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n", 71491afc32b9SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 71501afc32b9SMark Fasheh le16_to_cpu(di->i_dyn_features), 71511afc32b9SMark Fasheh OCFS2_I(inode)->ip_dyn_features, 71521afc32b9SMark Fasheh osb->s_feature_incompat); 71531afc32b9SMark Fasheh ret = -EROFS; 71541afc32b9SMark Fasheh goto out; 71551afc32b9SMark Fasheh } 71561afc32b9SMark Fasheh 71571afc32b9SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 71581afc32b9SMark Fasheh if (IS_ERR(handle)) { 71591afc32b9SMark Fasheh ret = PTR_ERR(handle); 71601afc32b9SMark Fasheh mlog_errno(ret); 71611afc32b9SMark Fasheh goto out; 71621afc32b9SMark Fasheh } 71631afc32b9SMark Fasheh 71641afc32b9SMark Fasheh ret = ocfs2_journal_access(handle, inode, di_bh, 71651afc32b9SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 71661afc32b9SMark Fasheh if (ret) { 71671afc32b9SMark Fasheh mlog_errno(ret); 71681afc32b9SMark Fasheh goto out_commit; 71691afc32b9SMark Fasheh } 71701afc32b9SMark Fasheh 71711afc32b9SMark Fasheh numbytes = end - start; 71721afc32b9SMark Fasheh memset(idata->id_data + start, 0, numbytes); 71731afc32b9SMark Fasheh 71741afc32b9SMark Fasheh /* 71751afc32b9SMark Fasheh * No need to worry about the data page here - it's been 71761afc32b9SMark Fasheh * truncated already and inline data doesn't need it for 71771afc32b9SMark Fasheh * pushing zero's to disk, so we'll let readpage pick it up 71781afc32b9SMark Fasheh * later. 71791afc32b9SMark Fasheh */ 71801afc32b9SMark Fasheh if (trunc) { 71811afc32b9SMark Fasheh i_size_write(inode, start); 71821afc32b9SMark Fasheh di->i_size = cpu_to_le64(start); 71831afc32b9SMark Fasheh } 71841afc32b9SMark Fasheh 71851afc32b9SMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 71861afc32b9SMark Fasheh inode->i_ctime = inode->i_mtime = CURRENT_TIME; 71871afc32b9SMark Fasheh 71881afc32b9SMark Fasheh di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec); 71891afc32b9SMark Fasheh di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 71901afc32b9SMark Fasheh 71911afc32b9SMark Fasheh ocfs2_journal_dirty(handle, di_bh); 71921afc32b9SMark Fasheh 71931afc32b9SMark Fasheh out_commit: 71941afc32b9SMark Fasheh ocfs2_commit_trans(osb, handle); 71951afc32b9SMark Fasheh 71961afc32b9SMark Fasheh out: 71971afc32b9SMark Fasheh return ret; 71981afc32b9SMark Fasheh } 71991afc32b9SMark Fasheh 7200ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc) 7201ccd979bdSMark Fasheh { 720259a5e416SMark Fasheh /* 720359a5e416SMark Fasheh * The caller is responsible for completing deallocation 720459a5e416SMark Fasheh * before freeing the context. 720559a5e416SMark Fasheh */ 720659a5e416SMark Fasheh if (tc->tc_dealloc.c_first_suballocator != NULL) 720759a5e416SMark Fasheh mlog(ML_NOTICE, 720859a5e416SMark Fasheh "Truncate completion has non-empty dealloc context\n"); 7209ccd979bdSMark Fasheh 7210ccd979bdSMark Fasheh if (tc->tc_last_eb_bh) 7211ccd979bdSMark Fasheh brelse(tc->tc_last_eb_bh); 7212ccd979bdSMark Fasheh 7213ccd979bdSMark Fasheh kfree(tc); 7214ccd979bdSMark Fasheh } 7215