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); 7435dc0aa3SJoel Becker int (*eo_sanity_check)(struct inode *inode, struct ocfs2_extent_tree *et); 75e7d4cb6bSTao Ma }; 76e7d4cb6bSTao Ma 77e7d4cb6bSTao Ma struct ocfs2_extent_tree { 78ce1d9ea6SJoel Becker enum ocfs2_extent_tree_type et_type; 79ce1d9ea6SJoel Becker struct ocfs2_extent_tree_operations *et_ops; 80ce1d9ea6SJoel Becker struct buffer_head *et_root_bh; 81ce1d9ea6SJoel Becker struct ocfs2_extent_list *et_root_el; 82ce1d9ea6SJoel Becker void *et_private; 83ce1d9ea6SJoel Becker unsigned int et_max_leaf_clusters; 84e7d4cb6bSTao Ma }; 85e7d4cb6bSTao Ma 86e7d4cb6bSTao Ma static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et, 87e7d4cb6bSTao Ma u64 blkno) 88e7d4cb6bSTao Ma { 89ce1d9ea6SJoel Becker struct ocfs2_dinode *di = 90ce1d9ea6SJoel Becker (struct ocfs2_dinode *)et->et_root_bh->b_data; 91e7d4cb6bSTao Ma 92ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 93e7d4cb6bSTao Ma di->i_last_eb_blk = cpu_to_le64(blkno); 94e7d4cb6bSTao Ma } 95e7d4cb6bSTao Ma 96e7d4cb6bSTao Ma static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et) 97e7d4cb6bSTao Ma { 98ce1d9ea6SJoel Becker struct ocfs2_dinode *di = 99ce1d9ea6SJoel Becker (struct ocfs2_dinode *)et->et_root_bh->b_data; 100e7d4cb6bSTao Ma 101ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 102e7d4cb6bSTao Ma return le64_to_cpu(di->i_last_eb_blk); 103e7d4cb6bSTao Ma } 104e7d4cb6bSTao Ma 105e7d4cb6bSTao Ma static void ocfs2_dinode_update_clusters(struct inode *inode, 106e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 107e7d4cb6bSTao Ma u32 clusters) 108e7d4cb6bSTao Ma { 109e7d4cb6bSTao Ma struct ocfs2_dinode *di = 110ce1d9ea6SJoel Becker (struct ocfs2_dinode *)et->et_root_bh->b_data; 111e7d4cb6bSTao Ma 112e7d4cb6bSTao Ma le32_add_cpu(&di->i_clusters, clusters); 113e7d4cb6bSTao Ma spin_lock(&OCFS2_I(inode)->ip_lock); 114e7d4cb6bSTao Ma OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters); 115e7d4cb6bSTao Ma spin_unlock(&OCFS2_I(inode)->ip_lock); 116e7d4cb6bSTao Ma } 117e7d4cb6bSTao Ma 118e7d4cb6bSTao Ma static int ocfs2_dinode_sanity_check(struct inode *inode, 119e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 120e7d4cb6bSTao Ma { 121e7d4cb6bSTao Ma int ret = 0; 122e7d4cb6bSTao Ma struct ocfs2_dinode *di; 123e7d4cb6bSTao Ma 124ce1d9ea6SJoel Becker BUG_ON(et->et_type != OCFS2_DINODE_EXTENT); 125e7d4cb6bSTao Ma 126ce1d9ea6SJoel Becker di = (struct ocfs2_dinode *)et->et_root_bh->b_data; 127e7d4cb6bSTao Ma if (!OCFS2_IS_VALID_DINODE(di)) { 128e7d4cb6bSTao Ma ret = -EIO; 129e7d4cb6bSTao Ma ocfs2_error(inode->i_sb, 130e7d4cb6bSTao Ma "Inode %llu has invalid path root", 131e7d4cb6bSTao Ma (unsigned long long)OCFS2_I(inode)->ip_blkno); 132e7d4cb6bSTao Ma } 133e7d4cb6bSTao Ma 134e7d4cb6bSTao Ma return ret; 135e7d4cb6bSTao Ma } 136e7d4cb6bSTao Ma 137e7d4cb6bSTao Ma static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = { 13835dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk, 13935dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk, 14035dc0aa3SJoel Becker .eo_update_clusters = ocfs2_dinode_update_clusters, 14135dc0aa3SJoel Becker .eo_sanity_check = ocfs2_dinode_sanity_check, 142e7d4cb6bSTao Ma }; 143e7d4cb6bSTao Ma 144f56654c4STao Ma static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et, 145f56654c4STao Ma u64 blkno) 146f56654c4STao Ma { 147f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 148ce1d9ea6SJoel Becker (struct ocfs2_xattr_value_root *)et->et_private; 149f56654c4STao Ma 150f56654c4STao Ma xv->xr_last_eb_blk = cpu_to_le64(blkno); 151f56654c4STao Ma } 152f56654c4STao Ma 153f56654c4STao Ma static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et) 154f56654c4STao Ma { 155f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 156ce1d9ea6SJoel Becker (struct ocfs2_xattr_value_root *) et->et_private; 157f56654c4STao Ma 158f56654c4STao Ma return le64_to_cpu(xv->xr_last_eb_blk); 159f56654c4STao Ma } 160f56654c4STao Ma 161f56654c4STao Ma static void ocfs2_xattr_value_update_clusters(struct inode *inode, 162f56654c4STao Ma struct ocfs2_extent_tree *et, 163f56654c4STao Ma u32 clusters) 164f56654c4STao Ma { 165f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 166ce1d9ea6SJoel Becker (struct ocfs2_xattr_value_root *)et->et_private; 167f56654c4STao Ma 168f56654c4STao Ma le32_add_cpu(&xv->xr_clusters, clusters); 169f56654c4STao Ma } 170f56654c4STao Ma 171f56654c4STao Ma static int ocfs2_xattr_value_sanity_check(struct inode *inode, 172f56654c4STao Ma struct ocfs2_extent_tree *et) 173f56654c4STao Ma { 174f56654c4STao Ma return 0; 175f56654c4STao Ma } 176f56654c4STao Ma 177f56654c4STao Ma static struct ocfs2_extent_tree_operations ocfs2_xattr_et_ops = { 17835dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk, 17935dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk, 18035dc0aa3SJoel Becker .eo_update_clusters = ocfs2_xattr_value_update_clusters, 18135dc0aa3SJoel Becker .eo_sanity_check = ocfs2_xattr_value_sanity_check, 182f56654c4STao Ma }; 183f56654c4STao Ma 184ba492615STao Ma static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et, 185ba492615STao Ma u64 blkno) 186ba492615STao Ma { 187ba492615STao Ma struct ocfs2_xattr_block *xb = 188ce1d9ea6SJoel Becker (struct ocfs2_xattr_block *) et->et_root_bh->b_data; 189ba492615STao Ma struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root; 190ba492615STao Ma 191ba492615STao Ma xt->xt_last_eb_blk = cpu_to_le64(blkno); 192ba492615STao Ma } 193ba492615STao Ma 194ba492615STao Ma static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et) 195ba492615STao Ma { 196ba492615STao Ma struct ocfs2_xattr_block *xb = 197ce1d9ea6SJoel Becker (struct ocfs2_xattr_block *) et->et_root_bh->b_data; 198ba492615STao Ma struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root; 199ba492615STao Ma 200ba492615STao Ma return le64_to_cpu(xt->xt_last_eb_blk); 201ba492615STao Ma } 202ba492615STao Ma 203ba492615STao Ma static void ocfs2_xattr_tree_update_clusters(struct inode *inode, 204ba492615STao Ma struct ocfs2_extent_tree *et, 205ba492615STao Ma u32 clusters) 206ba492615STao Ma { 207ba492615STao Ma struct ocfs2_xattr_block *xb = 208ce1d9ea6SJoel Becker (struct ocfs2_xattr_block *)et->et_root_bh->b_data; 209ba492615STao Ma 210ba492615STao Ma le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters); 211ba492615STao Ma } 212ba492615STao Ma 213ba492615STao Ma static int ocfs2_xattr_tree_sanity_check(struct inode *inode, 214ba492615STao Ma struct ocfs2_extent_tree *et) 215ba492615STao Ma { 216ba492615STao Ma return 0; 217ba492615STao Ma } 218ba492615STao Ma 219ba492615STao Ma static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = { 22035dc0aa3SJoel Becker .eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk, 22135dc0aa3SJoel Becker .eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk, 22235dc0aa3SJoel Becker .eo_update_clusters = ocfs2_xattr_tree_update_clusters, 22335dc0aa3SJoel Becker .eo_sanity_check = ocfs2_xattr_tree_sanity_check, 224ba492615STao Ma }; 225ba492615STao Ma 226dc0ce61aSJoel Becker static void ocfs2_get_extent_tree(struct ocfs2_extent_tree *et, 227dc0ce61aSJoel Becker struct inode *inode, 228ca12b7c4STao Ma struct buffer_head *bh, 229f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 230f56654c4STao Ma void *private) 231e7d4cb6bSTao Ma { 232ce1d9ea6SJoel Becker et->et_type = et_type; 233e7d4cb6bSTao Ma get_bh(bh); 234ce1d9ea6SJoel Becker et->et_root_bh = bh; 235ce1d9ea6SJoel Becker et->et_private = private; 236dc0ce61aSJoel Becker et->et_max_leaf_clusters = 0; 237e7d4cb6bSTao Ma 238e7d4cb6bSTao Ma if (et_type == OCFS2_DINODE_EXTENT) { 239ce1d9ea6SJoel Becker et->et_root_el = 240ce1d9ea6SJoel Becker &((struct ocfs2_dinode *)bh->b_data)->id2.i_list; 241ce1d9ea6SJoel Becker et->et_ops = &ocfs2_dinode_et_ops; 242f56654c4STao Ma } else if (et_type == OCFS2_XATTR_VALUE_EXTENT) { 243f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 244f56654c4STao Ma (struct ocfs2_xattr_value_root *) private; 245ce1d9ea6SJoel Becker et->et_root_el = &xv->xr_list; 246ce1d9ea6SJoel Becker et->et_ops = &ocfs2_xattr_et_ops; 247ba492615STao Ma } else if (et_type == OCFS2_XATTR_TREE_EXTENT) { 248ba492615STao Ma struct ocfs2_xattr_block *xb = 249ba492615STao Ma (struct ocfs2_xattr_block *)bh->b_data; 250ce1d9ea6SJoel Becker et->et_root_el = &xb->xb_attrs.xb_root.xt_list; 251ce1d9ea6SJoel Becker et->et_ops = &ocfs2_xattr_tree_et_ops; 252ce1d9ea6SJoel Becker et->et_max_leaf_clusters = ocfs2_clusters_for_bytes(inode->i_sb, 253ca12b7c4STao Ma OCFS2_MAX_XATTR_TREE_LEAF_SIZE); 254e7d4cb6bSTao Ma } 255e7d4cb6bSTao Ma } 256e7d4cb6bSTao Ma 257dc0ce61aSJoel Becker static void ocfs2_put_extent_tree(struct ocfs2_extent_tree *et) 258e7d4cb6bSTao Ma { 259ce1d9ea6SJoel Becker brelse(et->et_root_bh); 260e7d4cb6bSTao Ma } 261e7d4cb6bSTao Ma 26235dc0aa3SJoel Becker static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et, 263e7d4cb6bSTao Ma u64 new_last_eb_blk) 264e7d4cb6bSTao Ma { 265ce1d9ea6SJoel Becker et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk); 266e7d4cb6bSTao Ma } 267e7d4cb6bSTao Ma 26835dc0aa3SJoel Becker static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et) 269e7d4cb6bSTao Ma { 270ce1d9ea6SJoel Becker return et->et_ops->eo_get_last_eb_blk(et); 271e7d4cb6bSTao Ma } 272e7d4cb6bSTao Ma 27335dc0aa3SJoel Becker static inline void ocfs2_et_update_clusters(struct inode *inode, 274e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 275e7d4cb6bSTao Ma u32 clusters) 276e7d4cb6bSTao Ma { 277ce1d9ea6SJoel Becker et->et_ops->eo_update_clusters(inode, et, clusters); 27835dc0aa3SJoel Becker } 27935dc0aa3SJoel Becker 28035dc0aa3SJoel Becker static inline int ocfs2_et_sanity_check(struct inode *inode, 28135dc0aa3SJoel Becker struct ocfs2_extent_tree *et) 28235dc0aa3SJoel Becker { 283ce1d9ea6SJoel Becker return et->et_ops->eo_sanity_check(inode, et); 284e7d4cb6bSTao Ma } 285e7d4cb6bSTao Ma 286ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc); 28759a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, 28859a5e416SMark Fasheh struct ocfs2_extent_block *eb); 289ccd979bdSMark Fasheh 290dcd0538fSMark Fasheh /* 291dcd0538fSMark Fasheh * Structures which describe a path through a btree, and functions to 292dcd0538fSMark Fasheh * manipulate them. 293dcd0538fSMark Fasheh * 294dcd0538fSMark Fasheh * The idea here is to be as generic as possible with the tree 295dcd0538fSMark Fasheh * manipulation code. 296dcd0538fSMark Fasheh */ 297dcd0538fSMark Fasheh struct ocfs2_path_item { 298dcd0538fSMark Fasheh struct buffer_head *bh; 299dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 300dcd0538fSMark Fasheh }; 301dcd0538fSMark Fasheh 302dcd0538fSMark Fasheh #define OCFS2_MAX_PATH_DEPTH 5 303dcd0538fSMark Fasheh 304dcd0538fSMark Fasheh struct ocfs2_path { 305dcd0538fSMark Fasheh int p_tree_depth; 306dcd0538fSMark Fasheh struct ocfs2_path_item p_node[OCFS2_MAX_PATH_DEPTH]; 307dcd0538fSMark Fasheh }; 308dcd0538fSMark Fasheh 309dcd0538fSMark Fasheh #define path_root_bh(_path) ((_path)->p_node[0].bh) 310dcd0538fSMark Fasheh #define path_root_el(_path) ((_path)->p_node[0].el) 311dcd0538fSMark Fasheh #define path_leaf_bh(_path) ((_path)->p_node[(_path)->p_tree_depth].bh) 312dcd0538fSMark Fasheh #define path_leaf_el(_path) ((_path)->p_node[(_path)->p_tree_depth].el) 313dcd0538fSMark Fasheh #define path_num_items(_path) ((_path)->p_tree_depth + 1) 314dcd0538fSMark Fasheh 315dcd0538fSMark Fasheh /* 316dcd0538fSMark Fasheh * Reset the actual path elements so that we can re-use the structure 317dcd0538fSMark Fasheh * to build another path. Generally, this involves freeing the buffer 318dcd0538fSMark Fasheh * heads. 319dcd0538fSMark Fasheh */ 320dcd0538fSMark Fasheh static void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root) 321dcd0538fSMark Fasheh { 322dcd0538fSMark Fasheh int i, start = 0, depth = 0; 323dcd0538fSMark Fasheh struct ocfs2_path_item *node; 324dcd0538fSMark Fasheh 325dcd0538fSMark Fasheh if (keep_root) 326dcd0538fSMark Fasheh start = 1; 327dcd0538fSMark Fasheh 328dcd0538fSMark Fasheh for(i = start; i < path_num_items(path); i++) { 329dcd0538fSMark Fasheh node = &path->p_node[i]; 330dcd0538fSMark Fasheh 331dcd0538fSMark Fasheh brelse(node->bh); 332dcd0538fSMark Fasheh node->bh = NULL; 333dcd0538fSMark Fasheh node->el = NULL; 334dcd0538fSMark Fasheh } 335dcd0538fSMark Fasheh 336dcd0538fSMark Fasheh /* 337dcd0538fSMark Fasheh * Tree depth may change during truncate, or insert. If we're 338dcd0538fSMark Fasheh * keeping the root extent list, then make sure that our path 339dcd0538fSMark Fasheh * structure reflects the proper depth. 340dcd0538fSMark Fasheh */ 341dcd0538fSMark Fasheh if (keep_root) 342dcd0538fSMark Fasheh depth = le16_to_cpu(path_root_el(path)->l_tree_depth); 343dcd0538fSMark Fasheh 344dcd0538fSMark Fasheh path->p_tree_depth = depth; 345dcd0538fSMark Fasheh } 346dcd0538fSMark Fasheh 347dcd0538fSMark Fasheh static void ocfs2_free_path(struct ocfs2_path *path) 348dcd0538fSMark Fasheh { 349dcd0538fSMark Fasheh if (path) { 350dcd0538fSMark Fasheh ocfs2_reinit_path(path, 0); 351dcd0538fSMark Fasheh kfree(path); 352dcd0538fSMark Fasheh } 353dcd0538fSMark Fasheh } 354dcd0538fSMark Fasheh 355dcd0538fSMark Fasheh /* 356328d5752SMark Fasheh * All the elements of src into dest. After this call, src could be freed 357328d5752SMark Fasheh * without affecting dest. 358328d5752SMark Fasheh * 359328d5752SMark Fasheh * Both paths should have the same root. Any non-root elements of dest 360328d5752SMark Fasheh * will be freed. 361328d5752SMark Fasheh */ 362328d5752SMark Fasheh static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src) 363328d5752SMark Fasheh { 364328d5752SMark Fasheh int i; 365328d5752SMark Fasheh 366328d5752SMark Fasheh BUG_ON(path_root_bh(dest) != path_root_bh(src)); 367328d5752SMark Fasheh BUG_ON(path_root_el(dest) != path_root_el(src)); 368328d5752SMark Fasheh 369328d5752SMark Fasheh ocfs2_reinit_path(dest, 1); 370328d5752SMark Fasheh 371328d5752SMark Fasheh for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) { 372328d5752SMark Fasheh dest->p_node[i].bh = src->p_node[i].bh; 373328d5752SMark Fasheh dest->p_node[i].el = src->p_node[i].el; 374328d5752SMark Fasheh 375328d5752SMark Fasheh if (dest->p_node[i].bh) 376328d5752SMark Fasheh get_bh(dest->p_node[i].bh); 377328d5752SMark Fasheh } 378328d5752SMark Fasheh } 379328d5752SMark Fasheh 380328d5752SMark Fasheh /* 381dcd0538fSMark Fasheh * Make the *dest path the same as src and re-initialize src path to 382dcd0538fSMark Fasheh * have a root only. 383dcd0538fSMark Fasheh */ 384dcd0538fSMark Fasheh static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src) 385dcd0538fSMark Fasheh { 386dcd0538fSMark Fasheh int i; 387dcd0538fSMark Fasheh 388dcd0538fSMark Fasheh BUG_ON(path_root_bh(dest) != path_root_bh(src)); 389dcd0538fSMark Fasheh 390dcd0538fSMark Fasheh for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) { 391dcd0538fSMark Fasheh brelse(dest->p_node[i].bh); 392dcd0538fSMark Fasheh 393dcd0538fSMark Fasheh dest->p_node[i].bh = src->p_node[i].bh; 394dcd0538fSMark Fasheh dest->p_node[i].el = src->p_node[i].el; 395dcd0538fSMark Fasheh 396dcd0538fSMark Fasheh src->p_node[i].bh = NULL; 397dcd0538fSMark Fasheh src->p_node[i].el = NULL; 398dcd0538fSMark Fasheh } 399dcd0538fSMark Fasheh } 400dcd0538fSMark Fasheh 401dcd0538fSMark Fasheh /* 402dcd0538fSMark Fasheh * Insert an extent block at given index. 403dcd0538fSMark Fasheh * 404dcd0538fSMark Fasheh * This will not take an additional reference on eb_bh. 405dcd0538fSMark Fasheh */ 406dcd0538fSMark Fasheh static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index, 407dcd0538fSMark Fasheh struct buffer_head *eb_bh) 408dcd0538fSMark Fasheh { 409dcd0538fSMark Fasheh struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data; 410dcd0538fSMark Fasheh 411dcd0538fSMark Fasheh /* 412dcd0538fSMark Fasheh * Right now, no root bh is an extent block, so this helps 413dcd0538fSMark Fasheh * catch code errors with dinode trees. The assertion can be 414dcd0538fSMark Fasheh * safely removed if we ever need to insert extent block 415dcd0538fSMark Fasheh * structures at the root. 416dcd0538fSMark Fasheh */ 417dcd0538fSMark Fasheh BUG_ON(index == 0); 418dcd0538fSMark Fasheh 419dcd0538fSMark Fasheh path->p_node[index].bh = eb_bh; 420dcd0538fSMark Fasheh path->p_node[index].el = &eb->h_list; 421dcd0538fSMark Fasheh } 422dcd0538fSMark Fasheh 423dcd0538fSMark Fasheh static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh, 424dcd0538fSMark Fasheh struct ocfs2_extent_list *root_el) 425dcd0538fSMark Fasheh { 426dcd0538fSMark Fasheh struct ocfs2_path *path; 427dcd0538fSMark Fasheh 428dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH); 429dcd0538fSMark Fasheh 430dcd0538fSMark Fasheh path = kzalloc(sizeof(*path), GFP_NOFS); 431dcd0538fSMark Fasheh if (path) { 432dcd0538fSMark Fasheh path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth); 433dcd0538fSMark Fasheh get_bh(root_bh); 434dcd0538fSMark Fasheh path_root_bh(path) = root_bh; 435dcd0538fSMark Fasheh path_root_el(path) = root_el; 436dcd0538fSMark Fasheh } 437dcd0538fSMark Fasheh 438dcd0538fSMark Fasheh return path; 439dcd0538fSMark Fasheh } 440dcd0538fSMark Fasheh 441dcd0538fSMark Fasheh /* 442dcd0538fSMark Fasheh * Convenience function to journal all components in a path. 443dcd0538fSMark Fasheh */ 444dcd0538fSMark Fasheh static int ocfs2_journal_access_path(struct inode *inode, handle_t *handle, 445dcd0538fSMark Fasheh struct ocfs2_path *path) 446dcd0538fSMark Fasheh { 447dcd0538fSMark Fasheh int i, ret = 0; 448dcd0538fSMark Fasheh 449dcd0538fSMark Fasheh if (!path) 450dcd0538fSMark Fasheh goto out; 451dcd0538fSMark Fasheh 452dcd0538fSMark Fasheh for(i = 0; i < path_num_items(path); i++) { 453dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, path->p_node[i].bh, 454dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 455dcd0538fSMark Fasheh if (ret < 0) { 456dcd0538fSMark Fasheh mlog_errno(ret); 457dcd0538fSMark Fasheh goto out; 458dcd0538fSMark Fasheh } 459dcd0538fSMark Fasheh } 460dcd0538fSMark Fasheh 461dcd0538fSMark Fasheh out: 462dcd0538fSMark Fasheh return ret; 463dcd0538fSMark Fasheh } 464dcd0538fSMark Fasheh 465328d5752SMark Fasheh /* 466328d5752SMark Fasheh * Return the index of the extent record which contains cluster #v_cluster. 467328d5752SMark Fasheh * -1 is returned if it was not found. 468328d5752SMark Fasheh * 469328d5752SMark Fasheh * Should work fine on interior and exterior nodes. 470328d5752SMark Fasheh */ 471328d5752SMark Fasheh int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster) 472328d5752SMark Fasheh { 473328d5752SMark Fasheh int ret = -1; 474328d5752SMark Fasheh int i; 475328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 476328d5752SMark Fasheh u32 rec_end, rec_start, clusters; 477328d5752SMark Fasheh 478328d5752SMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 479328d5752SMark Fasheh rec = &el->l_recs[i]; 480328d5752SMark Fasheh 481328d5752SMark Fasheh rec_start = le32_to_cpu(rec->e_cpos); 482328d5752SMark Fasheh clusters = ocfs2_rec_clusters(el, rec); 483328d5752SMark Fasheh 484328d5752SMark Fasheh rec_end = rec_start + clusters; 485328d5752SMark Fasheh 486328d5752SMark Fasheh if (v_cluster >= rec_start && v_cluster < rec_end) { 487328d5752SMark Fasheh ret = i; 488328d5752SMark Fasheh break; 489328d5752SMark Fasheh } 490328d5752SMark Fasheh } 491328d5752SMark Fasheh 492328d5752SMark Fasheh return ret; 493328d5752SMark Fasheh } 494328d5752SMark Fasheh 495dcd0538fSMark Fasheh enum ocfs2_contig_type { 496dcd0538fSMark Fasheh CONTIG_NONE = 0, 497dcd0538fSMark Fasheh CONTIG_LEFT, 498328d5752SMark Fasheh CONTIG_RIGHT, 499328d5752SMark Fasheh CONTIG_LEFTRIGHT, 500dcd0538fSMark Fasheh }; 501dcd0538fSMark Fasheh 502e48edee2SMark Fasheh 503e48edee2SMark Fasheh /* 504e48edee2SMark Fasheh * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and 505e48edee2SMark Fasheh * ocfs2_extent_contig only work properly against leaf nodes! 506e48edee2SMark Fasheh */ 507dcd0538fSMark Fasheh static int ocfs2_block_extent_contig(struct super_block *sb, 508ccd979bdSMark Fasheh struct ocfs2_extent_rec *ext, 509ccd979bdSMark Fasheh u64 blkno) 510ccd979bdSMark Fasheh { 511e48edee2SMark Fasheh u64 blk_end = le64_to_cpu(ext->e_blkno); 512e48edee2SMark Fasheh 513e48edee2SMark Fasheh blk_end += ocfs2_clusters_to_blocks(sb, 514e48edee2SMark Fasheh le16_to_cpu(ext->e_leaf_clusters)); 515e48edee2SMark Fasheh 516e48edee2SMark Fasheh return blkno == blk_end; 517ccd979bdSMark Fasheh } 518ccd979bdSMark Fasheh 519dcd0538fSMark Fasheh static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left, 520dcd0538fSMark Fasheh struct ocfs2_extent_rec *right) 521dcd0538fSMark Fasheh { 522e48edee2SMark Fasheh u32 left_range; 523e48edee2SMark Fasheh 524e48edee2SMark Fasheh left_range = le32_to_cpu(left->e_cpos) + 525e48edee2SMark Fasheh le16_to_cpu(left->e_leaf_clusters); 526e48edee2SMark Fasheh 527e48edee2SMark Fasheh return (left_range == le32_to_cpu(right->e_cpos)); 528dcd0538fSMark Fasheh } 529dcd0538fSMark Fasheh 530dcd0538fSMark Fasheh static enum ocfs2_contig_type 531dcd0538fSMark Fasheh ocfs2_extent_contig(struct inode *inode, 532dcd0538fSMark Fasheh struct ocfs2_extent_rec *ext, 533dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 534dcd0538fSMark Fasheh { 535dcd0538fSMark Fasheh u64 blkno = le64_to_cpu(insert_rec->e_blkno); 536dcd0538fSMark Fasheh 537328d5752SMark Fasheh /* 538328d5752SMark Fasheh * Refuse to coalesce extent records with different flag 539328d5752SMark Fasheh * fields - we don't want to mix unwritten extents with user 540328d5752SMark Fasheh * data. 541328d5752SMark Fasheh */ 542328d5752SMark Fasheh if (ext->e_flags != insert_rec->e_flags) 543328d5752SMark Fasheh return CONTIG_NONE; 544328d5752SMark Fasheh 545dcd0538fSMark Fasheh if (ocfs2_extents_adjacent(ext, insert_rec) && 546dcd0538fSMark Fasheh ocfs2_block_extent_contig(inode->i_sb, ext, blkno)) 547dcd0538fSMark Fasheh return CONTIG_RIGHT; 548dcd0538fSMark Fasheh 549dcd0538fSMark Fasheh blkno = le64_to_cpu(ext->e_blkno); 550dcd0538fSMark Fasheh if (ocfs2_extents_adjacent(insert_rec, ext) && 551dcd0538fSMark Fasheh ocfs2_block_extent_contig(inode->i_sb, insert_rec, blkno)) 552dcd0538fSMark Fasheh return CONTIG_LEFT; 553dcd0538fSMark Fasheh 554dcd0538fSMark Fasheh return CONTIG_NONE; 555dcd0538fSMark Fasheh } 556dcd0538fSMark Fasheh 557dcd0538fSMark Fasheh /* 558dcd0538fSMark Fasheh * NOTE: We can have pretty much any combination of contiguousness and 559dcd0538fSMark Fasheh * appending. 560dcd0538fSMark Fasheh * 561dcd0538fSMark Fasheh * The usefulness of APPEND_TAIL is more in that it lets us know that 562dcd0538fSMark Fasheh * we'll have to update the path to that leaf. 563dcd0538fSMark Fasheh */ 564dcd0538fSMark Fasheh enum ocfs2_append_type { 565dcd0538fSMark Fasheh APPEND_NONE = 0, 566dcd0538fSMark Fasheh APPEND_TAIL, 567dcd0538fSMark Fasheh }; 568dcd0538fSMark Fasheh 569328d5752SMark Fasheh enum ocfs2_split_type { 570328d5752SMark Fasheh SPLIT_NONE = 0, 571328d5752SMark Fasheh SPLIT_LEFT, 572328d5752SMark Fasheh SPLIT_RIGHT, 573328d5752SMark Fasheh }; 574328d5752SMark Fasheh 575dcd0538fSMark Fasheh struct ocfs2_insert_type { 576328d5752SMark Fasheh enum ocfs2_split_type ins_split; 577dcd0538fSMark Fasheh enum ocfs2_append_type ins_appending; 578dcd0538fSMark Fasheh enum ocfs2_contig_type ins_contig; 579dcd0538fSMark Fasheh int ins_contig_index; 580dcd0538fSMark Fasheh int ins_tree_depth; 581dcd0538fSMark Fasheh }; 582dcd0538fSMark Fasheh 583328d5752SMark Fasheh struct ocfs2_merge_ctxt { 584328d5752SMark Fasheh enum ocfs2_contig_type c_contig_type; 585328d5752SMark Fasheh int c_has_empty_extent; 586328d5752SMark Fasheh int c_split_covers_rec; 587328d5752SMark Fasheh }; 588328d5752SMark Fasheh 589ccd979bdSMark Fasheh /* 590ccd979bdSMark Fasheh * How many free extents have we got before we need more meta data? 591ccd979bdSMark Fasheh */ 592ccd979bdSMark Fasheh int ocfs2_num_free_extents(struct ocfs2_super *osb, 593ccd979bdSMark Fasheh struct inode *inode, 594e7d4cb6bSTao Ma struct buffer_head *root_bh, 595f56654c4STao Ma enum ocfs2_extent_tree_type type, 596f56654c4STao Ma void *private) 597ccd979bdSMark Fasheh { 598ccd979bdSMark Fasheh int retval; 599e7d4cb6bSTao Ma struct ocfs2_extent_list *el = NULL; 600ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 601ccd979bdSMark Fasheh struct buffer_head *eb_bh = NULL; 602e7d4cb6bSTao Ma u64 last_eb_blk = 0; 603ccd979bdSMark Fasheh 604ccd979bdSMark Fasheh mlog_entry_void(); 605ccd979bdSMark Fasheh 606e7d4cb6bSTao Ma if (type == OCFS2_DINODE_EXTENT) { 607e7d4cb6bSTao Ma struct ocfs2_dinode *fe = 608e7d4cb6bSTao Ma (struct ocfs2_dinode *)root_bh->b_data; 609ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(fe)) { 610ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe); 611ccd979bdSMark Fasheh retval = -EIO; 612ccd979bdSMark Fasheh goto bail; 613ccd979bdSMark Fasheh } 614ccd979bdSMark Fasheh 615e7d4cb6bSTao Ma if (fe->i_last_eb_blk) 616e7d4cb6bSTao Ma last_eb_blk = le64_to_cpu(fe->i_last_eb_blk); 617e7d4cb6bSTao Ma el = &fe->id2.i_list; 618f56654c4STao Ma } else if (type == OCFS2_XATTR_VALUE_EXTENT) { 619f56654c4STao Ma struct ocfs2_xattr_value_root *xv = 620f56654c4STao Ma (struct ocfs2_xattr_value_root *) private; 621f56654c4STao Ma 622f56654c4STao Ma last_eb_blk = le64_to_cpu(xv->xr_last_eb_blk); 623f56654c4STao Ma el = &xv->xr_list; 624ba492615STao Ma } else if (type == OCFS2_XATTR_TREE_EXTENT) { 625ba492615STao Ma struct ocfs2_xattr_block *xb = 626ba492615STao Ma (struct ocfs2_xattr_block *)root_bh->b_data; 627ba492615STao Ma 628ba492615STao Ma last_eb_blk = le64_to_cpu(xb->xb_attrs.xb_root.xt_last_eb_blk); 629ba492615STao Ma el = &xb->xb_attrs.xb_root.xt_list; 630e7d4cb6bSTao Ma } 631e7d4cb6bSTao Ma 632e7d4cb6bSTao Ma if (last_eb_blk) { 633e7d4cb6bSTao Ma retval = ocfs2_read_block(osb, last_eb_blk, 634ccd979bdSMark Fasheh &eb_bh, OCFS2_BH_CACHED, inode); 635ccd979bdSMark Fasheh if (retval < 0) { 636ccd979bdSMark Fasheh mlog_errno(retval); 637ccd979bdSMark Fasheh goto bail; 638ccd979bdSMark Fasheh } 639ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) eb_bh->b_data; 640ccd979bdSMark Fasheh el = &eb->h_list; 641e7d4cb6bSTao Ma } 642ccd979bdSMark Fasheh 643ccd979bdSMark Fasheh BUG_ON(el->l_tree_depth != 0); 644ccd979bdSMark Fasheh 645ccd979bdSMark Fasheh retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec); 646ccd979bdSMark Fasheh bail: 647ccd979bdSMark Fasheh if (eb_bh) 648ccd979bdSMark Fasheh brelse(eb_bh); 649ccd979bdSMark Fasheh 650ccd979bdSMark Fasheh mlog_exit(retval); 651ccd979bdSMark Fasheh return retval; 652ccd979bdSMark Fasheh } 653ccd979bdSMark Fasheh 654ccd979bdSMark Fasheh /* expects array to already be allocated 655ccd979bdSMark Fasheh * 656ccd979bdSMark Fasheh * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and 657ccd979bdSMark Fasheh * l_count for you 658ccd979bdSMark Fasheh */ 659ccd979bdSMark Fasheh static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb, 6601fabe148SMark Fasheh handle_t *handle, 661ccd979bdSMark Fasheh struct inode *inode, 662ccd979bdSMark Fasheh int wanted, 663ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac, 664ccd979bdSMark Fasheh struct buffer_head *bhs[]) 665ccd979bdSMark Fasheh { 666ccd979bdSMark Fasheh int count, status, i; 667ccd979bdSMark Fasheh u16 suballoc_bit_start; 668ccd979bdSMark Fasheh u32 num_got; 669ccd979bdSMark Fasheh u64 first_blkno; 670ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 671ccd979bdSMark Fasheh 672ccd979bdSMark Fasheh mlog_entry_void(); 673ccd979bdSMark Fasheh 674ccd979bdSMark Fasheh count = 0; 675ccd979bdSMark Fasheh while (count < wanted) { 676ccd979bdSMark Fasheh status = ocfs2_claim_metadata(osb, 677ccd979bdSMark Fasheh handle, 678ccd979bdSMark Fasheh meta_ac, 679ccd979bdSMark Fasheh wanted - count, 680ccd979bdSMark Fasheh &suballoc_bit_start, 681ccd979bdSMark Fasheh &num_got, 682ccd979bdSMark Fasheh &first_blkno); 683ccd979bdSMark Fasheh if (status < 0) { 684ccd979bdSMark Fasheh mlog_errno(status); 685ccd979bdSMark Fasheh goto bail; 686ccd979bdSMark Fasheh } 687ccd979bdSMark Fasheh 688ccd979bdSMark Fasheh for(i = count; i < (num_got + count); i++) { 689ccd979bdSMark Fasheh bhs[i] = sb_getblk(osb->sb, first_blkno); 690ccd979bdSMark Fasheh if (bhs[i] == NULL) { 691ccd979bdSMark Fasheh status = -EIO; 692ccd979bdSMark Fasheh mlog_errno(status); 693ccd979bdSMark Fasheh goto bail; 694ccd979bdSMark Fasheh } 695ccd979bdSMark Fasheh ocfs2_set_new_buffer_uptodate(inode, bhs[i]); 696ccd979bdSMark Fasheh 697ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, bhs[i], 698ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 699ccd979bdSMark Fasheh if (status < 0) { 700ccd979bdSMark Fasheh mlog_errno(status); 701ccd979bdSMark Fasheh goto bail; 702ccd979bdSMark Fasheh } 703ccd979bdSMark Fasheh 704ccd979bdSMark Fasheh memset(bhs[i]->b_data, 0, osb->sb->s_blocksize); 705ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bhs[i]->b_data; 706ccd979bdSMark Fasheh /* Ok, setup the minimal stuff here. */ 707ccd979bdSMark Fasheh strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE); 708ccd979bdSMark Fasheh eb->h_blkno = cpu_to_le64(first_blkno); 709ccd979bdSMark Fasheh eb->h_fs_generation = cpu_to_le32(osb->fs_generation); 710ccd979bdSMark Fasheh eb->h_suballoc_slot = cpu_to_le16(osb->slot_num); 711ccd979bdSMark Fasheh eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start); 712ccd979bdSMark Fasheh eb->h_list.l_count = 713ccd979bdSMark Fasheh cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb)); 714ccd979bdSMark Fasheh 715ccd979bdSMark Fasheh suballoc_bit_start++; 716ccd979bdSMark Fasheh first_blkno++; 717ccd979bdSMark Fasheh 718ccd979bdSMark Fasheh /* We'll also be dirtied by the caller, so 719ccd979bdSMark Fasheh * this isn't absolutely necessary. */ 720ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, bhs[i]); 721ccd979bdSMark Fasheh if (status < 0) { 722ccd979bdSMark Fasheh mlog_errno(status); 723ccd979bdSMark Fasheh goto bail; 724ccd979bdSMark Fasheh } 725ccd979bdSMark Fasheh } 726ccd979bdSMark Fasheh 727ccd979bdSMark Fasheh count += num_got; 728ccd979bdSMark Fasheh } 729ccd979bdSMark Fasheh 730ccd979bdSMark Fasheh status = 0; 731ccd979bdSMark Fasheh bail: 732ccd979bdSMark Fasheh if (status < 0) { 733ccd979bdSMark Fasheh for(i = 0; i < wanted; i++) { 734ccd979bdSMark Fasheh if (bhs[i]) 735ccd979bdSMark Fasheh brelse(bhs[i]); 736ccd979bdSMark Fasheh bhs[i] = NULL; 737ccd979bdSMark Fasheh } 738ccd979bdSMark Fasheh } 739ccd979bdSMark Fasheh mlog_exit(status); 740ccd979bdSMark Fasheh return status; 741ccd979bdSMark Fasheh } 742ccd979bdSMark Fasheh 743ccd979bdSMark Fasheh /* 744dcd0538fSMark Fasheh * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth(). 745dcd0538fSMark Fasheh * 746dcd0538fSMark Fasheh * Returns the sum of the rightmost extent rec logical offset and 747dcd0538fSMark Fasheh * cluster count. 748dcd0538fSMark Fasheh * 749dcd0538fSMark Fasheh * ocfs2_add_branch() uses this to determine what logical cluster 750dcd0538fSMark Fasheh * value should be populated into the leftmost new branch records. 751dcd0538fSMark Fasheh * 752dcd0538fSMark Fasheh * ocfs2_shift_tree_depth() uses this to determine the # clusters 753dcd0538fSMark Fasheh * value for the new topmost tree record. 754dcd0538fSMark Fasheh */ 755dcd0538fSMark Fasheh static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el) 756dcd0538fSMark Fasheh { 757dcd0538fSMark Fasheh int i; 758dcd0538fSMark Fasheh 759dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 760dcd0538fSMark Fasheh 761dcd0538fSMark Fasheh return le32_to_cpu(el->l_recs[i].e_cpos) + 762e48edee2SMark Fasheh ocfs2_rec_clusters(el, &el->l_recs[i]); 763dcd0538fSMark Fasheh } 764dcd0538fSMark Fasheh 765dcd0538fSMark Fasheh /* 766ccd979bdSMark Fasheh * Add an entire tree branch to our inode. eb_bh is the extent block 767ccd979bdSMark Fasheh * to start at, if we don't want to start the branch at the dinode 768ccd979bdSMark Fasheh * structure. 769ccd979bdSMark Fasheh * 770ccd979bdSMark Fasheh * last_eb_bh is required as we have to update it's next_leaf pointer 771ccd979bdSMark Fasheh * for the new last extent block. 772ccd979bdSMark Fasheh * 773ccd979bdSMark Fasheh * the new branch will be 'empty' in the sense that every block will 774e48edee2SMark Fasheh * contain a single record with cluster count == 0. 775ccd979bdSMark Fasheh */ 776ccd979bdSMark Fasheh static int ocfs2_add_branch(struct ocfs2_super *osb, 7771fabe148SMark Fasheh handle_t *handle, 778ccd979bdSMark Fasheh struct inode *inode, 779e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 780ccd979bdSMark Fasheh struct buffer_head *eb_bh, 781328d5752SMark Fasheh struct buffer_head **last_eb_bh, 782ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac) 783ccd979bdSMark Fasheh { 784ccd979bdSMark Fasheh int status, new_blocks, i; 785ccd979bdSMark Fasheh u64 next_blkno, new_last_eb_blk; 786ccd979bdSMark Fasheh struct buffer_head *bh; 787ccd979bdSMark Fasheh struct buffer_head **new_eb_bhs = NULL; 788ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 789ccd979bdSMark Fasheh struct ocfs2_extent_list *eb_el; 790ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 791dcd0538fSMark Fasheh u32 new_cpos; 792ccd979bdSMark Fasheh 793ccd979bdSMark Fasheh mlog_entry_void(); 794ccd979bdSMark Fasheh 795328d5752SMark Fasheh BUG_ON(!last_eb_bh || !*last_eb_bh); 796ccd979bdSMark Fasheh 797ccd979bdSMark Fasheh if (eb_bh) { 798ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) eb_bh->b_data; 799ccd979bdSMark Fasheh el = &eb->h_list; 800ccd979bdSMark Fasheh } else 801ce1d9ea6SJoel Becker el = et->et_root_el; 802ccd979bdSMark Fasheh 803ccd979bdSMark Fasheh /* we never add a branch to a leaf. */ 804ccd979bdSMark Fasheh BUG_ON(!el->l_tree_depth); 805ccd979bdSMark Fasheh 806ccd979bdSMark Fasheh new_blocks = le16_to_cpu(el->l_tree_depth); 807ccd979bdSMark Fasheh 808ccd979bdSMark Fasheh /* allocate the number of new eb blocks we need */ 809ccd979bdSMark Fasheh new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *), 810ccd979bdSMark Fasheh GFP_KERNEL); 811ccd979bdSMark Fasheh if (!new_eb_bhs) { 812ccd979bdSMark Fasheh status = -ENOMEM; 813ccd979bdSMark Fasheh mlog_errno(status); 814ccd979bdSMark Fasheh goto bail; 815ccd979bdSMark Fasheh } 816ccd979bdSMark Fasheh 817ccd979bdSMark Fasheh status = ocfs2_create_new_meta_bhs(osb, handle, inode, new_blocks, 818ccd979bdSMark Fasheh meta_ac, new_eb_bhs); 819ccd979bdSMark Fasheh if (status < 0) { 820ccd979bdSMark Fasheh mlog_errno(status); 821ccd979bdSMark Fasheh goto bail; 822ccd979bdSMark Fasheh } 823ccd979bdSMark Fasheh 824328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data; 825dcd0538fSMark Fasheh new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list); 826dcd0538fSMark Fasheh 827ccd979bdSMark Fasheh /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be 828ccd979bdSMark Fasheh * linked with the rest of the tree. 829ccd979bdSMark Fasheh * conversly, new_eb_bhs[0] is the new bottommost leaf. 830ccd979bdSMark Fasheh * 831ccd979bdSMark Fasheh * when we leave the loop, new_last_eb_blk will point to the 832ccd979bdSMark Fasheh * newest leaf, and next_blkno will point to the topmost extent 833ccd979bdSMark Fasheh * block. */ 834ccd979bdSMark Fasheh next_blkno = new_last_eb_blk = 0; 835ccd979bdSMark Fasheh for(i = 0; i < new_blocks; i++) { 836ccd979bdSMark Fasheh bh = new_eb_bhs[i]; 837ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 838ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 839ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 840ccd979bdSMark Fasheh status = -EIO; 841ccd979bdSMark Fasheh goto bail; 842ccd979bdSMark Fasheh } 843ccd979bdSMark Fasheh eb_el = &eb->h_list; 844ccd979bdSMark Fasheh 845ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, bh, 846ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 847ccd979bdSMark Fasheh if (status < 0) { 848ccd979bdSMark Fasheh mlog_errno(status); 849ccd979bdSMark Fasheh goto bail; 850ccd979bdSMark Fasheh } 851ccd979bdSMark Fasheh 852ccd979bdSMark Fasheh eb->h_next_leaf_blk = 0; 853ccd979bdSMark Fasheh eb_el->l_tree_depth = cpu_to_le16(i); 854ccd979bdSMark Fasheh eb_el->l_next_free_rec = cpu_to_le16(1); 855dcd0538fSMark Fasheh /* 856dcd0538fSMark Fasheh * This actually counts as an empty extent as 857dcd0538fSMark Fasheh * c_clusters == 0 858dcd0538fSMark Fasheh */ 859dcd0538fSMark Fasheh eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos); 860ccd979bdSMark Fasheh eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno); 861e48edee2SMark Fasheh /* 862e48edee2SMark Fasheh * eb_el isn't always an interior node, but even leaf 863e48edee2SMark Fasheh * nodes want a zero'd flags and reserved field so 864e48edee2SMark Fasheh * this gets the whole 32 bits regardless of use. 865e48edee2SMark Fasheh */ 866e48edee2SMark Fasheh eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0); 867ccd979bdSMark Fasheh if (!eb_el->l_tree_depth) 868ccd979bdSMark Fasheh new_last_eb_blk = le64_to_cpu(eb->h_blkno); 869ccd979bdSMark Fasheh 870ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, bh); 871ccd979bdSMark Fasheh if (status < 0) { 872ccd979bdSMark Fasheh mlog_errno(status); 873ccd979bdSMark Fasheh goto bail; 874ccd979bdSMark Fasheh } 875ccd979bdSMark Fasheh 876ccd979bdSMark Fasheh next_blkno = le64_to_cpu(eb->h_blkno); 877ccd979bdSMark Fasheh } 878ccd979bdSMark Fasheh 879ccd979bdSMark Fasheh /* This is a bit hairy. We want to update up to three blocks 880ccd979bdSMark Fasheh * here without leaving any of them in an inconsistent state 881ccd979bdSMark Fasheh * in case of error. We don't have to worry about 882ccd979bdSMark Fasheh * journal_dirty erroring as it won't unless we've aborted the 883ccd979bdSMark Fasheh * handle (in which case we would never be here) so reserving 884ccd979bdSMark Fasheh * the write with journal_access is all we need to do. */ 885328d5752SMark Fasheh status = ocfs2_journal_access(handle, inode, *last_eb_bh, 886ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 887ccd979bdSMark Fasheh if (status < 0) { 888ccd979bdSMark Fasheh mlog_errno(status); 889ccd979bdSMark Fasheh goto bail; 890ccd979bdSMark Fasheh } 891ce1d9ea6SJoel Becker status = ocfs2_journal_access(handle, inode, et->et_root_bh, 892ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 893ccd979bdSMark Fasheh if (status < 0) { 894ccd979bdSMark Fasheh mlog_errno(status); 895ccd979bdSMark Fasheh goto bail; 896ccd979bdSMark Fasheh } 897ccd979bdSMark Fasheh if (eb_bh) { 898ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, eb_bh, 899ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 900ccd979bdSMark Fasheh if (status < 0) { 901ccd979bdSMark Fasheh mlog_errno(status); 902ccd979bdSMark Fasheh goto bail; 903ccd979bdSMark Fasheh } 904ccd979bdSMark Fasheh } 905ccd979bdSMark Fasheh 906ccd979bdSMark Fasheh /* Link the new branch into the rest of the tree (el will 907e7d4cb6bSTao Ma * either be on the root_bh, or the extent block passed in. */ 908ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec); 909ccd979bdSMark Fasheh el->l_recs[i].e_blkno = cpu_to_le64(next_blkno); 910dcd0538fSMark Fasheh el->l_recs[i].e_cpos = cpu_to_le32(new_cpos); 911e48edee2SMark Fasheh el->l_recs[i].e_int_clusters = 0; 912ccd979bdSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 913ccd979bdSMark Fasheh 914ccd979bdSMark Fasheh /* fe needs a new last extent block pointer, as does the 915ccd979bdSMark Fasheh * next_leaf on the previously last-extent-block. */ 91635dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, new_last_eb_blk); 917ccd979bdSMark Fasheh 918328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data; 919ccd979bdSMark Fasheh eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk); 920ccd979bdSMark Fasheh 921328d5752SMark Fasheh status = ocfs2_journal_dirty(handle, *last_eb_bh); 922ccd979bdSMark Fasheh if (status < 0) 923ccd979bdSMark Fasheh mlog_errno(status); 924ce1d9ea6SJoel Becker status = ocfs2_journal_dirty(handle, et->et_root_bh); 925ccd979bdSMark Fasheh if (status < 0) 926ccd979bdSMark Fasheh mlog_errno(status); 927ccd979bdSMark Fasheh if (eb_bh) { 928ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, eb_bh); 929ccd979bdSMark Fasheh if (status < 0) 930ccd979bdSMark Fasheh mlog_errno(status); 931ccd979bdSMark Fasheh } 932ccd979bdSMark Fasheh 933328d5752SMark Fasheh /* 934328d5752SMark Fasheh * Some callers want to track the rightmost leaf so pass it 935328d5752SMark Fasheh * back here. 936328d5752SMark Fasheh */ 937328d5752SMark Fasheh brelse(*last_eb_bh); 938328d5752SMark Fasheh get_bh(new_eb_bhs[0]); 939328d5752SMark Fasheh *last_eb_bh = new_eb_bhs[0]; 940328d5752SMark Fasheh 941ccd979bdSMark Fasheh status = 0; 942ccd979bdSMark Fasheh bail: 943ccd979bdSMark Fasheh if (new_eb_bhs) { 944ccd979bdSMark Fasheh for (i = 0; i < new_blocks; i++) 945ccd979bdSMark Fasheh if (new_eb_bhs[i]) 946ccd979bdSMark Fasheh brelse(new_eb_bhs[i]); 947ccd979bdSMark Fasheh kfree(new_eb_bhs); 948ccd979bdSMark Fasheh } 949ccd979bdSMark Fasheh 950ccd979bdSMark Fasheh mlog_exit(status); 951ccd979bdSMark Fasheh return status; 952ccd979bdSMark Fasheh } 953ccd979bdSMark Fasheh 954ccd979bdSMark Fasheh /* 955ccd979bdSMark Fasheh * adds another level to the allocation tree. 956ccd979bdSMark Fasheh * returns back the new extent block so you can add a branch to it 957ccd979bdSMark Fasheh * after this call. 958ccd979bdSMark Fasheh */ 959ccd979bdSMark Fasheh static int ocfs2_shift_tree_depth(struct ocfs2_super *osb, 9601fabe148SMark Fasheh handle_t *handle, 961ccd979bdSMark Fasheh struct inode *inode, 962e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 963ccd979bdSMark Fasheh struct ocfs2_alloc_context *meta_ac, 964ccd979bdSMark Fasheh struct buffer_head **ret_new_eb_bh) 965ccd979bdSMark Fasheh { 966ccd979bdSMark Fasheh int status, i; 967dcd0538fSMark Fasheh u32 new_clusters; 968ccd979bdSMark Fasheh struct buffer_head *new_eb_bh = NULL; 969ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 970e7d4cb6bSTao Ma struct ocfs2_extent_list *root_el; 971ccd979bdSMark Fasheh struct ocfs2_extent_list *eb_el; 972ccd979bdSMark Fasheh 973ccd979bdSMark Fasheh mlog_entry_void(); 974ccd979bdSMark Fasheh 975ccd979bdSMark Fasheh status = ocfs2_create_new_meta_bhs(osb, handle, inode, 1, meta_ac, 976ccd979bdSMark Fasheh &new_eb_bh); 977ccd979bdSMark Fasheh if (status < 0) { 978ccd979bdSMark Fasheh mlog_errno(status); 979ccd979bdSMark Fasheh goto bail; 980ccd979bdSMark Fasheh } 981ccd979bdSMark Fasheh 982ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) new_eb_bh->b_data; 983ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 984ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 985ccd979bdSMark Fasheh status = -EIO; 986ccd979bdSMark Fasheh goto bail; 987ccd979bdSMark Fasheh } 988ccd979bdSMark Fasheh 989ccd979bdSMark Fasheh eb_el = &eb->h_list; 990ce1d9ea6SJoel Becker root_el = et->et_root_el; 991ccd979bdSMark Fasheh 992ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, inode, new_eb_bh, 993ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_CREATE); 994ccd979bdSMark Fasheh if (status < 0) { 995ccd979bdSMark Fasheh mlog_errno(status); 996ccd979bdSMark Fasheh goto bail; 997ccd979bdSMark Fasheh } 998ccd979bdSMark Fasheh 999e7d4cb6bSTao Ma /* copy the root extent list data into the new extent block */ 1000e7d4cb6bSTao Ma eb_el->l_tree_depth = root_el->l_tree_depth; 1001e7d4cb6bSTao Ma eb_el->l_next_free_rec = root_el->l_next_free_rec; 1002e7d4cb6bSTao Ma for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++) 1003e7d4cb6bSTao Ma eb_el->l_recs[i] = root_el->l_recs[i]; 1004ccd979bdSMark Fasheh 1005ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, new_eb_bh); 1006ccd979bdSMark Fasheh if (status < 0) { 1007ccd979bdSMark Fasheh mlog_errno(status); 1008ccd979bdSMark Fasheh goto bail; 1009ccd979bdSMark Fasheh } 1010ccd979bdSMark Fasheh 1011ce1d9ea6SJoel Becker status = ocfs2_journal_access(handle, inode, et->et_root_bh, 1012ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1013ccd979bdSMark Fasheh if (status < 0) { 1014ccd979bdSMark Fasheh mlog_errno(status); 1015ccd979bdSMark Fasheh goto bail; 1016ccd979bdSMark Fasheh } 1017ccd979bdSMark Fasheh 1018dcd0538fSMark Fasheh new_clusters = ocfs2_sum_rightmost_rec(eb_el); 1019dcd0538fSMark Fasheh 1020e7d4cb6bSTao Ma /* update root_bh now */ 1021e7d4cb6bSTao Ma le16_add_cpu(&root_el->l_tree_depth, 1); 1022e7d4cb6bSTao Ma root_el->l_recs[0].e_cpos = 0; 1023e7d4cb6bSTao Ma root_el->l_recs[0].e_blkno = eb->h_blkno; 1024e7d4cb6bSTao Ma root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters); 1025e7d4cb6bSTao Ma for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++) 1026e7d4cb6bSTao Ma memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec)); 1027e7d4cb6bSTao Ma root_el->l_next_free_rec = cpu_to_le16(1); 1028ccd979bdSMark Fasheh 1029ccd979bdSMark Fasheh /* If this is our 1st tree depth shift, then last_eb_blk 1030ccd979bdSMark Fasheh * becomes the allocated extent block */ 1031e7d4cb6bSTao Ma if (root_el->l_tree_depth == cpu_to_le16(1)) 103235dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 1033ccd979bdSMark Fasheh 1034ce1d9ea6SJoel Becker status = ocfs2_journal_dirty(handle, et->et_root_bh); 1035ccd979bdSMark Fasheh if (status < 0) { 1036ccd979bdSMark Fasheh mlog_errno(status); 1037ccd979bdSMark Fasheh goto bail; 1038ccd979bdSMark Fasheh } 1039ccd979bdSMark Fasheh 1040ccd979bdSMark Fasheh *ret_new_eb_bh = new_eb_bh; 1041ccd979bdSMark Fasheh new_eb_bh = NULL; 1042ccd979bdSMark Fasheh status = 0; 1043ccd979bdSMark Fasheh bail: 1044ccd979bdSMark Fasheh if (new_eb_bh) 1045ccd979bdSMark Fasheh brelse(new_eb_bh); 1046ccd979bdSMark Fasheh 1047ccd979bdSMark Fasheh mlog_exit(status); 1048ccd979bdSMark Fasheh return status; 1049ccd979bdSMark Fasheh } 1050ccd979bdSMark Fasheh 1051ccd979bdSMark Fasheh /* 1052ccd979bdSMark Fasheh * Should only be called when there is no space left in any of the 1053ccd979bdSMark Fasheh * leaf nodes. What we want to do is find the lowest tree depth 1054ccd979bdSMark Fasheh * non-leaf extent block with room for new records. There are three 1055ccd979bdSMark Fasheh * valid results of this search: 1056ccd979bdSMark Fasheh * 1057ccd979bdSMark Fasheh * 1) a lowest extent block is found, then we pass it back in 1058ccd979bdSMark Fasheh * *lowest_eb_bh and return '0' 1059ccd979bdSMark Fasheh * 1060e7d4cb6bSTao Ma * 2) the search fails to find anything, but the root_el has room. We 1061ccd979bdSMark Fasheh * pass NULL back in *lowest_eb_bh, but still return '0' 1062ccd979bdSMark Fasheh * 1063e7d4cb6bSTao Ma * 3) the search fails to find anything AND the root_el is full, in 1064ccd979bdSMark Fasheh * which case we return > 0 1065ccd979bdSMark Fasheh * 1066ccd979bdSMark Fasheh * return status < 0 indicates an error. 1067ccd979bdSMark Fasheh */ 1068ccd979bdSMark Fasheh static int ocfs2_find_branch_target(struct ocfs2_super *osb, 1069ccd979bdSMark Fasheh struct inode *inode, 1070e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 1071ccd979bdSMark Fasheh struct buffer_head **target_bh) 1072ccd979bdSMark Fasheh { 1073ccd979bdSMark Fasheh int status = 0, i; 1074ccd979bdSMark Fasheh u64 blkno; 1075ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 1076ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 1077ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 1078ccd979bdSMark Fasheh struct buffer_head *lowest_bh = NULL; 1079ccd979bdSMark Fasheh 1080ccd979bdSMark Fasheh mlog_entry_void(); 1081ccd979bdSMark Fasheh 1082ccd979bdSMark Fasheh *target_bh = NULL; 1083ccd979bdSMark Fasheh 1084ce1d9ea6SJoel Becker el = et->et_root_el; 1085ccd979bdSMark Fasheh 1086ccd979bdSMark Fasheh while(le16_to_cpu(el->l_tree_depth) > 1) { 1087ccd979bdSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 1088b0697053SMark Fasheh ocfs2_error(inode->i_sb, "Dinode %llu has empty " 1089ccd979bdSMark Fasheh "extent list (next_free_rec == 0)", 1090b0697053SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 1091ccd979bdSMark Fasheh status = -EIO; 1092ccd979bdSMark Fasheh goto bail; 1093ccd979bdSMark Fasheh } 1094ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 1095ccd979bdSMark Fasheh blkno = le64_to_cpu(el->l_recs[i].e_blkno); 1096ccd979bdSMark Fasheh if (!blkno) { 1097b0697053SMark Fasheh ocfs2_error(inode->i_sb, "Dinode %llu has extent " 1098ccd979bdSMark Fasheh "list where extent # %d has no physical " 1099ccd979bdSMark Fasheh "block start", 1100b0697053SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, i); 1101ccd979bdSMark Fasheh status = -EIO; 1102ccd979bdSMark Fasheh goto bail; 1103ccd979bdSMark Fasheh } 1104ccd979bdSMark Fasheh 1105ccd979bdSMark Fasheh if (bh) { 1106ccd979bdSMark Fasheh brelse(bh); 1107ccd979bdSMark Fasheh bh = NULL; 1108ccd979bdSMark Fasheh } 1109ccd979bdSMark Fasheh 1110ccd979bdSMark Fasheh status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED, 1111ccd979bdSMark Fasheh inode); 1112ccd979bdSMark Fasheh if (status < 0) { 1113ccd979bdSMark Fasheh mlog_errno(status); 1114ccd979bdSMark Fasheh goto bail; 1115ccd979bdSMark Fasheh } 1116ccd979bdSMark Fasheh 1117ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 1118ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 1119ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 1120ccd979bdSMark Fasheh status = -EIO; 1121ccd979bdSMark Fasheh goto bail; 1122ccd979bdSMark Fasheh } 1123ccd979bdSMark Fasheh el = &eb->h_list; 1124ccd979bdSMark Fasheh 1125ccd979bdSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) < 1126ccd979bdSMark Fasheh le16_to_cpu(el->l_count)) { 1127ccd979bdSMark Fasheh if (lowest_bh) 1128ccd979bdSMark Fasheh brelse(lowest_bh); 1129ccd979bdSMark Fasheh lowest_bh = bh; 1130ccd979bdSMark Fasheh get_bh(lowest_bh); 1131ccd979bdSMark Fasheh } 1132ccd979bdSMark Fasheh } 1133ccd979bdSMark Fasheh 1134ccd979bdSMark Fasheh /* If we didn't find one and the fe doesn't have any room, 1135ccd979bdSMark Fasheh * then return '1' */ 1136ce1d9ea6SJoel Becker el = et->et_root_el; 1137e7d4cb6bSTao Ma if (!lowest_bh && (el->l_next_free_rec == el->l_count)) 1138ccd979bdSMark Fasheh status = 1; 1139ccd979bdSMark Fasheh 1140ccd979bdSMark Fasheh *target_bh = lowest_bh; 1141ccd979bdSMark Fasheh bail: 1142ccd979bdSMark Fasheh if (bh) 1143ccd979bdSMark Fasheh brelse(bh); 1144ccd979bdSMark Fasheh 1145ccd979bdSMark Fasheh mlog_exit(status); 1146ccd979bdSMark Fasheh return status; 1147ccd979bdSMark Fasheh } 1148ccd979bdSMark Fasheh 1149e48edee2SMark Fasheh /* 1150c3afcbb3SMark Fasheh * Grow a b-tree so that it has more records. 1151c3afcbb3SMark Fasheh * 1152c3afcbb3SMark Fasheh * We might shift the tree depth in which case existing paths should 1153c3afcbb3SMark Fasheh * be considered invalid. 1154c3afcbb3SMark Fasheh * 1155c3afcbb3SMark Fasheh * Tree depth after the grow is returned via *final_depth. 1156328d5752SMark Fasheh * 1157328d5752SMark Fasheh * *last_eb_bh will be updated by ocfs2_add_branch(). 1158c3afcbb3SMark Fasheh */ 1159c3afcbb3SMark Fasheh static int ocfs2_grow_tree(struct inode *inode, handle_t *handle, 1160e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, int *final_depth, 1161328d5752SMark Fasheh struct buffer_head **last_eb_bh, 1162c3afcbb3SMark Fasheh struct ocfs2_alloc_context *meta_ac) 1163c3afcbb3SMark Fasheh { 1164c3afcbb3SMark Fasheh int ret, shift; 1165ce1d9ea6SJoel Becker struct ocfs2_extent_list *el = et->et_root_el; 1166e7d4cb6bSTao Ma int depth = le16_to_cpu(el->l_tree_depth); 1167c3afcbb3SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1168c3afcbb3SMark Fasheh struct buffer_head *bh = NULL; 1169c3afcbb3SMark Fasheh 1170c3afcbb3SMark Fasheh BUG_ON(meta_ac == NULL); 1171c3afcbb3SMark Fasheh 1172e7d4cb6bSTao Ma shift = ocfs2_find_branch_target(osb, inode, et, &bh); 1173c3afcbb3SMark Fasheh if (shift < 0) { 1174c3afcbb3SMark Fasheh ret = shift; 1175c3afcbb3SMark Fasheh mlog_errno(ret); 1176c3afcbb3SMark Fasheh goto out; 1177c3afcbb3SMark Fasheh } 1178c3afcbb3SMark Fasheh 1179c3afcbb3SMark Fasheh /* We traveled all the way to the bottom of the allocation tree 1180c3afcbb3SMark Fasheh * and didn't find room for any more extents - we need to add 1181c3afcbb3SMark Fasheh * another tree level */ 1182c3afcbb3SMark Fasheh if (shift) { 1183c3afcbb3SMark Fasheh BUG_ON(bh); 1184c3afcbb3SMark Fasheh mlog(0, "need to shift tree depth (current = %d)\n", depth); 1185c3afcbb3SMark Fasheh 1186c3afcbb3SMark Fasheh /* ocfs2_shift_tree_depth will return us a buffer with 1187c3afcbb3SMark Fasheh * the new extent block (so we can pass that to 1188c3afcbb3SMark Fasheh * ocfs2_add_branch). */ 1189e7d4cb6bSTao Ma ret = ocfs2_shift_tree_depth(osb, handle, inode, et, 1190c3afcbb3SMark Fasheh meta_ac, &bh); 1191c3afcbb3SMark Fasheh if (ret < 0) { 1192c3afcbb3SMark Fasheh mlog_errno(ret); 1193c3afcbb3SMark Fasheh goto out; 1194c3afcbb3SMark Fasheh } 1195c3afcbb3SMark Fasheh depth++; 1196328d5752SMark Fasheh if (depth == 1) { 1197328d5752SMark Fasheh /* 1198328d5752SMark Fasheh * Special case: we have room now if we shifted from 1199328d5752SMark Fasheh * tree_depth 0, so no more work needs to be done. 1200328d5752SMark Fasheh * 1201328d5752SMark Fasheh * We won't be calling add_branch, so pass 1202328d5752SMark Fasheh * back *last_eb_bh as the new leaf. At depth 1203328d5752SMark Fasheh * zero, it should always be null so there's 1204328d5752SMark Fasheh * no reason to brelse. 1205328d5752SMark Fasheh */ 1206328d5752SMark Fasheh BUG_ON(*last_eb_bh); 1207328d5752SMark Fasheh get_bh(bh); 1208328d5752SMark Fasheh *last_eb_bh = bh; 1209c3afcbb3SMark Fasheh goto out; 1210c3afcbb3SMark Fasheh } 1211328d5752SMark Fasheh } 1212c3afcbb3SMark Fasheh 1213c3afcbb3SMark Fasheh /* call ocfs2_add_branch to add the final part of the tree with 1214c3afcbb3SMark Fasheh * the new data. */ 1215c3afcbb3SMark Fasheh mlog(0, "add branch. bh = %p\n", bh); 1216e7d4cb6bSTao Ma ret = ocfs2_add_branch(osb, handle, inode, et, bh, last_eb_bh, 1217c3afcbb3SMark Fasheh meta_ac); 1218c3afcbb3SMark Fasheh if (ret < 0) { 1219c3afcbb3SMark Fasheh mlog_errno(ret); 1220c3afcbb3SMark Fasheh goto out; 1221c3afcbb3SMark Fasheh } 1222c3afcbb3SMark Fasheh 1223c3afcbb3SMark Fasheh out: 1224c3afcbb3SMark Fasheh if (final_depth) 1225c3afcbb3SMark Fasheh *final_depth = depth; 1226c3afcbb3SMark Fasheh brelse(bh); 1227c3afcbb3SMark Fasheh return ret; 1228c3afcbb3SMark Fasheh } 1229c3afcbb3SMark Fasheh 1230c3afcbb3SMark Fasheh /* 1231dcd0538fSMark Fasheh * This function will discard the rightmost extent record. 1232dcd0538fSMark Fasheh */ 1233dcd0538fSMark Fasheh static void ocfs2_shift_records_right(struct ocfs2_extent_list *el) 1234dcd0538fSMark Fasheh { 1235dcd0538fSMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 1236dcd0538fSMark Fasheh int count = le16_to_cpu(el->l_count); 1237dcd0538fSMark Fasheh unsigned int num_bytes; 1238dcd0538fSMark Fasheh 1239dcd0538fSMark Fasheh BUG_ON(!next_free); 1240dcd0538fSMark Fasheh /* This will cause us to go off the end of our extent list. */ 1241dcd0538fSMark Fasheh BUG_ON(next_free >= count); 1242dcd0538fSMark Fasheh 1243dcd0538fSMark Fasheh num_bytes = sizeof(struct ocfs2_extent_rec) * next_free; 1244dcd0538fSMark Fasheh 1245dcd0538fSMark Fasheh memmove(&el->l_recs[1], &el->l_recs[0], num_bytes); 1246dcd0538fSMark Fasheh } 1247dcd0538fSMark Fasheh 1248dcd0538fSMark Fasheh static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el, 1249dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 1250dcd0538fSMark Fasheh { 1251dcd0538fSMark Fasheh int i, insert_index, next_free, has_empty, num_bytes; 1252dcd0538fSMark Fasheh u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos); 1253dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 1254dcd0538fSMark Fasheh 1255dcd0538fSMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 1256dcd0538fSMark Fasheh has_empty = ocfs2_is_empty_extent(&el->l_recs[0]); 1257dcd0538fSMark Fasheh 1258dcd0538fSMark Fasheh BUG_ON(!next_free); 1259dcd0538fSMark Fasheh 1260dcd0538fSMark Fasheh /* The tree code before us didn't allow enough room in the leaf. */ 1261b1f3550fSJulia Lawall BUG_ON(el->l_next_free_rec == el->l_count && !has_empty); 1262dcd0538fSMark Fasheh 1263dcd0538fSMark Fasheh /* 1264dcd0538fSMark Fasheh * The easiest way to approach this is to just remove the 1265dcd0538fSMark Fasheh * empty extent and temporarily decrement next_free. 1266dcd0538fSMark Fasheh */ 1267dcd0538fSMark Fasheh if (has_empty) { 1268dcd0538fSMark Fasheh /* 1269dcd0538fSMark Fasheh * If next_free was 1 (only an empty extent), this 1270dcd0538fSMark Fasheh * loop won't execute, which is fine. We still want 1271dcd0538fSMark Fasheh * the decrement above to happen. 1272dcd0538fSMark Fasheh */ 1273dcd0538fSMark Fasheh for(i = 0; i < (next_free - 1); i++) 1274dcd0538fSMark Fasheh el->l_recs[i] = el->l_recs[i+1]; 1275dcd0538fSMark Fasheh 1276dcd0538fSMark Fasheh next_free--; 1277dcd0538fSMark Fasheh } 1278dcd0538fSMark Fasheh 1279dcd0538fSMark Fasheh /* 1280dcd0538fSMark Fasheh * Figure out what the new record index should be. 1281dcd0538fSMark Fasheh */ 1282dcd0538fSMark Fasheh for(i = 0; i < next_free; i++) { 1283dcd0538fSMark Fasheh rec = &el->l_recs[i]; 1284dcd0538fSMark Fasheh 1285dcd0538fSMark Fasheh if (insert_cpos < le32_to_cpu(rec->e_cpos)) 1286dcd0538fSMark Fasheh break; 1287dcd0538fSMark Fasheh } 1288dcd0538fSMark Fasheh insert_index = i; 1289dcd0538fSMark Fasheh 1290dcd0538fSMark Fasheh mlog(0, "ins %u: index %d, has_empty %d, next_free %d, count %d\n", 1291dcd0538fSMark Fasheh insert_cpos, insert_index, has_empty, next_free, le16_to_cpu(el->l_count)); 1292dcd0538fSMark Fasheh 1293dcd0538fSMark Fasheh BUG_ON(insert_index < 0); 1294dcd0538fSMark Fasheh BUG_ON(insert_index >= le16_to_cpu(el->l_count)); 1295dcd0538fSMark Fasheh BUG_ON(insert_index > next_free); 1296dcd0538fSMark Fasheh 1297dcd0538fSMark Fasheh /* 1298dcd0538fSMark Fasheh * No need to memmove if we're just adding to the tail. 1299dcd0538fSMark Fasheh */ 1300dcd0538fSMark Fasheh if (insert_index != next_free) { 1301dcd0538fSMark Fasheh BUG_ON(next_free >= le16_to_cpu(el->l_count)); 1302dcd0538fSMark Fasheh 1303dcd0538fSMark Fasheh num_bytes = next_free - insert_index; 1304dcd0538fSMark Fasheh num_bytes *= sizeof(struct ocfs2_extent_rec); 1305dcd0538fSMark Fasheh memmove(&el->l_recs[insert_index + 1], 1306dcd0538fSMark Fasheh &el->l_recs[insert_index], 1307dcd0538fSMark Fasheh num_bytes); 1308dcd0538fSMark Fasheh } 1309dcd0538fSMark Fasheh 1310dcd0538fSMark Fasheh /* 1311dcd0538fSMark Fasheh * Either we had an empty extent, and need to re-increment or 1312dcd0538fSMark Fasheh * there was no empty extent on a non full rightmost leaf node, 1313dcd0538fSMark Fasheh * in which case we still need to increment. 1314dcd0538fSMark Fasheh */ 1315dcd0538fSMark Fasheh next_free++; 1316dcd0538fSMark Fasheh el->l_next_free_rec = cpu_to_le16(next_free); 1317dcd0538fSMark Fasheh /* 1318dcd0538fSMark Fasheh * Make sure none of the math above just messed up our tree. 1319dcd0538fSMark Fasheh */ 1320dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count)); 1321dcd0538fSMark Fasheh 1322dcd0538fSMark Fasheh el->l_recs[insert_index] = *insert_rec; 1323dcd0538fSMark Fasheh 1324dcd0538fSMark Fasheh } 1325dcd0538fSMark Fasheh 1326328d5752SMark Fasheh static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el) 1327328d5752SMark Fasheh { 1328328d5752SMark Fasheh int size, num_recs = le16_to_cpu(el->l_next_free_rec); 1329328d5752SMark Fasheh 1330328d5752SMark Fasheh BUG_ON(num_recs == 0); 1331328d5752SMark Fasheh 1332328d5752SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 1333328d5752SMark Fasheh num_recs--; 1334328d5752SMark Fasheh size = num_recs * sizeof(struct ocfs2_extent_rec); 1335328d5752SMark Fasheh memmove(&el->l_recs[0], &el->l_recs[1], size); 1336328d5752SMark Fasheh memset(&el->l_recs[num_recs], 0, 1337328d5752SMark Fasheh sizeof(struct ocfs2_extent_rec)); 1338328d5752SMark Fasheh el->l_next_free_rec = cpu_to_le16(num_recs); 1339328d5752SMark Fasheh } 1340328d5752SMark Fasheh } 1341328d5752SMark Fasheh 1342dcd0538fSMark Fasheh /* 1343dcd0538fSMark Fasheh * Create an empty extent record . 1344dcd0538fSMark Fasheh * 1345dcd0538fSMark Fasheh * l_next_free_rec may be updated. 1346dcd0538fSMark Fasheh * 1347dcd0538fSMark Fasheh * If an empty extent already exists do nothing. 1348dcd0538fSMark Fasheh */ 1349dcd0538fSMark Fasheh static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el) 1350dcd0538fSMark Fasheh { 1351dcd0538fSMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 1352dcd0538fSMark Fasheh 1353e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 1354e48edee2SMark Fasheh 1355dcd0538fSMark Fasheh if (next_free == 0) 1356dcd0538fSMark Fasheh goto set_and_inc; 1357dcd0538fSMark Fasheh 1358dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) 1359dcd0538fSMark Fasheh return; 1360dcd0538fSMark Fasheh 1361dcd0538fSMark Fasheh mlog_bug_on_msg(el->l_count == el->l_next_free_rec, 1362dcd0538fSMark Fasheh "Asked to create an empty extent in a full list:\n" 1363dcd0538fSMark Fasheh "count = %u, tree depth = %u", 1364dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 1365dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth)); 1366dcd0538fSMark Fasheh 1367dcd0538fSMark Fasheh ocfs2_shift_records_right(el); 1368dcd0538fSMark Fasheh 1369dcd0538fSMark Fasheh set_and_inc: 1370dcd0538fSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 1371dcd0538fSMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 1372dcd0538fSMark Fasheh } 1373dcd0538fSMark Fasheh 1374dcd0538fSMark Fasheh /* 1375dcd0538fSMark Fasheh * For a rotation which involves two leaf nodes, the "root node" is 1376dcd0538fSMark Fasheh * the lowest level tree node which contains a path to both leafs. This 1377dcd0538fSMark Fasheh * resulting set of information can be used to form a complete "subtree" 1378dcd0538fSMark Fasheh * 1379dcd0538fSMark Fasheh * This function is passed two full paths from the dinode down to a 1380dcd0538fSMark Fasheh * pair of adjacent leaves. It's task is to figure out which path 1381dcd0538fSMark Fasheh * index contains the subtree root - this can be the root index itself 1382dcd0538fSMark Fasheh * in a worst-case rotation. 1383dcd0538fSMark Fasheh * 1384dcd0538fSMark Fasheh * The array index of the subtree root is passed back. 1385dcd0538fSMark Fasheh */ 1386dcd0538fSMark Fasheh static int ocfs2_find_subtree_root(struct inode *inode, 1387dcd0538fSMark Fasheh struct ocfs2_path *left, 1388dcd0538fSMark Fasheh struct ocfs2_path *right) 1389dcd0538fSMark Fasheh { 1390dcd0538fSMark Fasheh int i = 0; 1391dcd0538fSMark Fasheh 1392dcd0538fSMark Fasheh /* 1393dcd0538fSMark Fasheh * Check that the caller passed in two paths from the same tree. 1394dcd0538fSMark Fasheh */ 1395dcd0538fSMark Fasheh BUG_ON(path_root_bh(left) != path_root_bh(right)); 1396dcd0538fSMark Fasheh 1397dcd0538fSMark Fasheh do { 1398dcd0538fSMark Fasheh i++; 1399dcd0538fSMark Fasheh 1400dcd0538fSMark Fasheh /* 1401dcd0538fSMark Fasheh * The caller didn't pass two adjacent paths. 1402dcd0538fSMark Fasheh */ 1403dcd0538fSMark Fasheh mlog_bug_on_msg(i > left->p_tree_depth, 1404dcd0538fSMark Fasheh "Inode %lu, left depth %u, right depth %u\n" 1405dcd0538fSMark Fasheh "left leaf blk %llu, right leaf blk %llu\n", 1406dcd0538fSMark Fasheh inode->i_ino, left->p_tree_depth, 1407dcd0538fSMark Fasheh right->p_tree_depth, 1408dcd0538fSMark Fasheh (unsigned long long)path_leaf_bh(left)->b_blocknr, 1409dcd0538fSMark Fasheh (unsigned long long)path_leaf_bh(right)->b_blocknr); 1410dcd0538fSMark Fasheh } while (left->p_node[i].bh->b_blocknr == 1411dcd0538fSMark Fasheh right->p_node[i].bh->b_blocknr); 1412dcd0538fSMark Fasheh 1413dcd0538fSMark Fasheh return i - 1; 1414dcd0538fSMark Fasheh } 1415dcd0538fSMark Fasheh 1416dcd0538fSMark Fasheh typedef void (path_insert_t)(void *, struct buffer_head *); 1417dcd0538fSMark Fasheh 1418dcd0538fSMark Fasheh /* 1419dcd0538fSMark Fasheh * Traverse a btree path in search of cpos, starting at root_el. 1420dcd0538fSMark Fasheh * 1421dcd0538fSMark Fasheh * This code can be called with a cpos larger than the tree, in which 1422dcd0538fSMark Fasheh * case it will return the rightmost path. 1423dcd0538fSMark Fasheh */ 1424dcd0538fSMark Fasheh static int __ocfs2_find_path(struct inode *inode, 1425dcd0538fSMark Fasheh struct ocfs2_extent_list *root_el, u32 cpos, 1426dcd0538fSMark Fasheh path_insert_t *func, void *data) 1427dcd0538fSMark Fasheh { 1428dcd0538fSMark Fasheh int i, ret = 0; 1429dcd0538fSMark Fasheh u32 range; 1430dcd0538fSMark Fasheh u64 blkno; 1431dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 1432dcd0538fSMark Fasheh struct ocfs2_extent_block *eb; 1433dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 1434dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 1435dcd0538fSMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 1436dcd0538fSMark Fasheh 1437dcd0538fSMark Fasheh el = root_el; 1438dcd0538fSMark Fasheh while (el->l_tree_depth) { 1439dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 1440dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1441dcd0538fSMark Fasheh "Inode %llu has empty extent list at " 1442dcd0538fSMark Fasheh "depth %u\n", 1443dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1444dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth)); 1445dcd0538fSMark Fasheh ret = -EROFS; 1446dcd0538fSMark Fasheh goto out; 1447dcd0538fSMark Fasheh 1448dcd0538fSMark Fasheh } 1449dcd0538fSMark Fasheh 1450dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) { 1451dcd0538fSMark Fasheh rec = &el->l_recs[i]; 1452dcd0538fSMark Fasheh 1453dcd0538fSMark Fasheh /* 1454dcd0538fSMark Fasheh * In the case that cpos is off the allocation 1455dcd0538fSMark Fasheh * tree, this should just wind up returning the 1456dcd0538fSMark Fasheh * rightmost record. 1457dcd0538fSMark Fasheh */ 1458dcd0538fSMark Fasheh range = le32_to_cpu(rec->e_cpos) + 1459e48edee2SMark Fasheh ocfs2_rec_clusters(el, rec); 1460dcd0538fSMark Fasheh if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range) 1461dcd0538fSMark Fasheh break; 1462dcd0538fSMark Fasheh } 1463dcd0538fSMark Fasheh 1464dcd0538fSMark Fasheh blkno = le64_to_cpu(el->l_recs[i].e_blkno); 1465dcd0538fSMark Fasheh if (blkno == 0) { 1466dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1467dcd0538fSMark Fasheh "Inode %llu has bad blkno in extent list " 1468dcd0538fSMark Fasheh "at depth %u (index %d)\n", 1469dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1470dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth), i); 1471dcd0538fSMark Fasheh ret = -EROFS; 1472dcd0538fSMark Fasheh goto out; 1473dcd0538fSMark Fasheh } 1474dcd0538fSMark Fasheh 1475dcd0538fSMark Fasheh brelse(bh); 1476dcd0538fSMark Fasheh bh = NULL; 1477dcd0538fSMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno, 1478dcd0538fSMark Fasheh &bh, OCFS2_BH_CACHED, inode); 1479dcd0538fSMark Fasheh if (ret) { 1480dcd0538fSMark Fasheh mlog_errno(ret); 1481dcd0538fSMark Fasheh goto out; 1482dcd0538fSMark Fasheh } 1483dcd0538fSMark Fasheh 1484dcd0538fSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 1485dcd0538fSMark Fasheh el = &eb->h_list; 1486dcd0538fSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 1487dcd0538fSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 1488dcd0538fSMark Fasheh ret = -EIO; 1489dcd0538fSMark Fasheh goto out; 1490dcd0538fSMark Fasheh } 1491dcd0538fSMark Fasheh 1492dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1493dcd0538fSMark Fasheh le16_to_cpu(el->l_count)) { 1494dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1495dcd0538fSMark Fasheh "Inode %llu has bad count in extent list " 1496dcd0538fSMark Fasheh "at block %llu (next free=%u, count=%u)\n", 1497dcd0538fSMark Fasheh (unsigned long long)oi->ip_blkno, 1498dcd0538fSMark Fasheh (unsigned long long)bh->b_blocknr, 1499dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec), 1500dcd0538fSMark Fasheh le16_to_cpu(el->l_count)); 1501dcd0538fSMark Fasheh ret = -EROFS; 1502dcd0538fSMark Fasheh goto out; 1503dcd0538fSMark Fasheh } 1504dcd0538fSMark Fasheh 1505dcd0538fSMark Fasheh if (func) 1506dcd0538fSMark Fasheh func(data, bh); 1507dcd0538fSMark Fasheh } 1508dcd0538fSMark Fasheh 1509dcd0538fSMark Fasheh out: 1510dcd0538fSMark Fasheh /* 1511dcd0538fSMark Fasheh * Catch any trailing bh that the loop didn't handle. 1512dcd0538fSMark Fasheh */ 1513dcd0538fSMark Fasheh brelse(bh); 1514dcd0538fSMark Fasheh 1515dcd0538fSMark Fasheh return ret; 1516dcd0538fSMark Fasheh } 1517dcd0538fSMark Fasheh 1518dcd0538fSMark Fasheh /* 1519dcd0538fSMark Fasheh * Given an initialized path (that is, it has a valid root extent 1520dcd0538fSMark Fasheh * list), this function will traverse the btree in search of the path 1521dcd0538fSMark Fasheh * which would contain cpos. 1522dcd0538fSMark Fasheh * 1523dcd0538fSMark Fasheh * The path traveled is recorded in the path structure. 1524dcd0538fSMark Fasheh * 1525dcd0538fSMark Fasheh * Note that this will not do any comparisons on leaf node extent 1526dcd0538fSMark Fasheh * records, so it will work fine in the case that we just added a tree 1527dcd0538fSMark Fasheh * branch. 1528dcd0538fSMark Fasheh */ 1529dcd0538fSMark Fasheh struct find_path_data { 1530dcd0538fSMark Fasheh int index; 1531dcd0538fSMark Fasheh struct ocfs2_path *path; 1532dcd0538fSMark Fasheh }; 1533dcd0538fSMark Fasheh static void find_path_ins(void *data, struct buffer_head *bh) 1534dcd0538fSMark Fasheh { 1535dcd0538fSMark Fasheh struct find_path_data *fp = data; 1536dcd0538fSMark Fasheh 1537dcd0538fSMark Fasheh get_bh(bh); 1538dcd0538fSMark Fasheh ocfs2_path_insert_eb(fp->path, fp->index, bh); 1539dcd0538fSMark Fasheh fp->index++; 1540dcd0538fSMark Fasheh } 1541dcd0538fSMark Fasheh static int ocfs2_find_path(struct inode *inode, struct ocfs2_path *path, 1542dcd0538fSMark Fasheh u32 cpos) 1543dcd0538fSMark Fasheh { 1544dcd0538fSMark Fasheh struct find_path_data data; 1545dcd0538fSMark Fasheh 1546dcd0538fSMark Fasheh data.index = 1; 1547dcd0538fSMark Fasheh data.path = path; 1548dcd0538fSMark Fasheh return __ocfs2_find_path(inode, path_root_el(path), cpos, 1549dcd0538fSMark Fasheh find_path_ins, &data); 1550dcd0538fSMark Fasheh } 1551dcd0538fSMark Fasheh 1552dcd0538fSMark Fasheh static void find_leaf_ins(void *data, struct buffer_head *bh) 1553dcd0538fSMark Fasheh { 1554dcd0538fSMark Fasheh struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data; 1555dcd0538fSMark Fasheh struct ocfs2_extent_list *el = &eb->h_list; 1556dcd0538fSMark Fasheh struct buffer_head **ret = data; 1557dcd0538fSMark Fasheh 1558dcd0538fSMark Fasheh /* We want to retain only the leaf block. */ 1559dcd0538fSMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 1560dcd0538fSMark Fasheh get_bh(bh); 1561dcd0538fSMark Fasheh *ret = bh; 1562dcd0538fSMark Fasheh } 1563dcd0538fSMark Fasheh } 1564dcd0538fSMark Fasheh /* 1565dcd0538fSMark Fasheh * Find the leaf block in the tree which would contain cpos. No 1566dcd0538fSMark Fasheh * checking of the actual leaf is done. 1567dcd0538fSMark Fasheh * 1568dcd0538fSMark Fasheh * Some paths want to call this instead of allocating a path structure 1569dcd0538fSMark Fasheh * and calling ocfs2_find_path(). 1570dcd0538fSMark Fasheh * 1571dcd0538fSMark Fasheh * This function doesn't handle non btree extent lists. 1572dcd0538fSMark Fasheh */ 1573363041a5SMark Fasheh int ocfs2_find_leaf(struct inode *inode, struct ocfs2_extent_list *root_el, 1574363041a5SMark Fasheh u32 cpos, struct buffer_head **leaf_bh) 1575dcd0538fSMark Fasheh { 1576dcd0538fSMark Fasheh int ret; 1577dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 1578dcd0538fSMark Fasheh 1579dcd0538fSMark Fasheh ret = __ocfs2_find_path(inode, root_el, cpos, find_leaf_ins, &bh); 1580dcd0538fSMark Fasheh if (ret) { 1581dcd0538fSMark Fasheh mlog_errno(ret); 1582dcd0538fSMark Fasheh goto out; 1583dcd0538fSMark Fasheh } 1584dcd0538fSMark Fasheh 1585dcd0538fSMark Fasheh *leaf_bh = bh; 1586dcd0538fSMark Fasheh out: 1587dcd0538fSMark Fasheh return ret; 1588dcd0538fSMark Fasheh } 1589dcd0538fSMark Fasheh 1590dcd0538fSMark Fasheh /* 1591dcd0538fSMark Fasheh * Adjust the adjacent records (left_rec, right_rec) involved in a rotation. 1592dcd0538fSMark Fasheh * 1593dcd0538fSMark Fasheh * Basically, we've moved stuff around at the bottom of the tree and 1594dcd0538fSMark Fasheh * we need to fix up the extent records above the changes to reflect 1595dcd0538fSMark Fasheh * the new changes. 1596dcd0538fSMark Fasheh * 1597dcd0538fSMark Fasheh * left_rec: the record on the left. 1598dcd0538fSMark Fasheh * left_child_el: is the child list pointed to by left_rec 1599dcd0538fSMark Fasheh * right_rec: the record to the right of left_rec 1600dcd0538fSMark Fasheh * right_child_el: is the child list pointed to by right_rec 1601dcd0538fSMark Fasheh * 1602dcd0538fSMark Fasheh * By definition, this only works on interior nodes. 1603dcd0538fSMark Fasheh */ 1604dcd0538fSMark Fasheh static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec, 1605dcd0538fSMark Fasheh struct ocfs2_extent_list *left_child_el, 1606dcd0538fSMark Fasheh struct ocfs2_extent_rec *right_rec, 1607dcd0538fSMark Fasheh struct ocfs2_extent_list *right_child_el) 1608dcd0538fSMark Fasheh { 1609dcd0538fSMark Fasheh u32 left_clusters, right_end; 1610dcd0538fSMark Fasheh 1611dcd0538fSMark Fasheh /* 1612dcd0538fSMark Fasheh * Interior nodes never have holes. Their cpos is the cpos of 1613dcd0538fSMark Fasheh * the leftmost record in their child list. Their cluster 1614dcd0538fSMark Fasheh * count covers the full theoretical range of their child list 1615dcd0538fSMark Fasheh * - the range between their cpos and the cpos of the record 1616dcd0538fSMark Fasheh * immediately to their right. 1617dcd0538fSMark Fasheh */ 1618dcd0538fSMark Fasheh left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos); 1619328d5752SMark Fasheh if (ocfs2_is_empty_extent(&right_child_el->l_recs[0])) { 1620328d5752SMark Fasheh BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1); 1621328d5752SMark Fasheh left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos); 1622328d5752SMark Fasheh } 1623dcd0538fSMark Fasheh left_clusters -= le32_to_cpu(left_rec->e_cpos); 1624e48edee2SMark Fasheh left_rec->e_int_clusters = cpu_to_le32(left_clusters); 1625dcd0538fSMark Fasheh 1626dcd0538fSMark Fasheh /* 1627dcd0538fSMark Fasheh * Calculate the rightmost cluster count boundary before 1628e48edee2SMark Fasheh * moving cpos - we will need to adjust clusters after 1629dcd0538fSMark Fasheh * updating e_cpos to keep the same highest cluster count. 1630dcd0538fSMark Fasheh */ 1631dcd0538fSMark Fasheh right_end = le32_to_cpu(right_rec->e_cpos); 1632e48edee2SMark Fasheh right_end += le32_to_cpu(right_rec->e_int_clusters); 1633dcd0538fSMark Fasheh 1634dcd0538fSMark Fasheh right_rec->e_cpos = left_rec->e_cpos; 1635dcd0538fSMark Fasheh le32_add_cpu(&right_rec->e_cpos, left_clusters); 1636dcd0538fSMark Fasheh 1637dcd0538fSMark Fasheh right_end -= le32_to_cpu(right_rec->e_cpos); 1638e48edee2SMark Fasheh right_rec->e_int_clusters = cpu_to_le32(right_end); 1639dcd0538fSMark Fasheh } 1640dcd0538fSMark Fasheh 1641dcd0538fSMark Fasheh /* 1642dcd0538fSMark Fasheh * Adjust the adjacent root node records involved in a 1643dcd0538fSMark Fasheh * rotation. left_el_blkno is passed in as a key so that we can easily 1644dcd0538fSMark Fasheh * find it's index in the root list. 1645dcd0538fSMark Fasheh */ 1646dcd0538fSMark Fasheh static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el, 1647dcd0538fSMark Fasheh struct ocfs2_extent_list *left_el, 1648dcd0538fSMark Fasheh struct ocfs2_extent_list *right_el, 1649dcd0538fSMark Fasheh u64 left_el_blkno) 1650dcd0538fSMark Fasheh { 1651dcd0538fSMark Fasheh int i; 1652dcd0538fSMark Fasheh 1653dcd0538fSMark Fasheh BUG_ON(le16_to_cpu(root_el->l_tree_depth) <= 1654dcd0538fSMark Fasheh le16_to_cpu(left_el->l_tree_depth)); 1655dcd0538fSMark Fasheh 1656dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) { 1657dcd0538fSMark Fasheh if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno) 1658dcd0538fSMark Fasheh break; 1659dcd0538fSMark Fasheh } 1660dcd0538fSMark Fasheh 1661dcd0538fSMark Fasheh /* 1662dcd0538fSMark Fasheh * The path walking code should have never returned a root and 1663dcd0538fSMark Fasheh * two paths which are not adjacent. 1664dcd0538fSMark Fasheh */ 1665dcd0538fSMark Fasheh BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1)); 1666dcd0538fSMark Fasheh 1667dcd0538fSMark Fasheh ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el, 1668dcd0538fSMark Fasheh &root_el->l_recs[i + 1], right_el); 1669dcd0538fSMark Fasheh } 1670dcd0538fSMark Fasheh 1671dcd0538fSMark Fasheh /* 1672dcd0538fSMark Fasheh * We've changed a leaf block (in right_path) and need to reflect that 1673dcd0538fSMark Fasheh * change back up the subtree. 1674dcd0538fSMark Fasheh * 1675dcd0538fSMark Fasheh * This happens in multiple places: 1676dcd0538fSMark Fasheh * - When we've moved an extent record from the left path leaf to the right 1677dcd0538fSMark Fasheh * path leaf to make room for an empty extent in the left path leaf. 1678dcd0538fSMark Fasheh * - When our insert into the right path leaf is at the leftmost edge 1679dcd0538fSMark Fasheh * and requires an update of the path immediately to it's left. This 1680dcd0538fSMark Fasheh * can occur at the end of some types of rotation and appending inserts. 1681677b9752STao Ma * - When we've adjusted the last extent record in the left path leaf and the 1682677b9752STao Ma * 1st extent record in the right path leaf during cross extent block merge. 1683dcd0538fSMark Fasheh */ 1684dcd0538fSMark Fasheh static void ocfs2_complete_edge_insert(struct inode *inode, handle_t *handle, 1685dcd0538fSMark Fasheh struct ocfs2_path *left_path, 1686dcd0538fSMark Fasheh struct ocfs2_path *right_path, 1687dcd0538fSMark Fasheh int subtree_index) 1688dcd0538fSMark Fasheh { 1689dcd0538fSMark Fasheh int ret, i, idx; 1690dcd0538fSMark Fasheh struct ocfs2_extent_list *el, *left_el, *right_el; 1691dcd0538fSMark Fasheh struct ocfs2_extent_rec *left_rec, *right_rec; 1692dcd0538fSMark Fasheh struct buffer_head *root_bh = left_path->p_node[subtree_index].bh; 1693dcd0538fSMark Fasheh 1694dcd0538fSMark Fasheh /* 1695dcd0538fSMark Fasheh * Update the counts and position values within all the 1696dcd0538fSMark Fasheh * interior nodes to reflect the leaf rotation we just did. 1697dcd0538fSMark Fasheh * 1698dcd0538fSMark Fasheh * The root node is handled below the loop. 1699dcd0538fSMark Fasheh * 1700dcd0538fSMark Fasheh * We begin the loop with right_el and left_el pointing to the 1701dcd0538fSMark Fasheh * leaf lists and work our way up. 1702dcd0538fSMark Fasheh * 1703dcd0538fSMark Fasheh * NOTE: within this loop, left_el and right_el always refer 1704dcd0538fSMark Fasheh * to the *child* lists. 1705dcd0538fSMark Fasheh */ 1706dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 1707dcd0538fSMark Fasheh right_el = path_leaf_el(right_path); 1708dcd0538fSMark Fasheh for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) { 1709dcd0538fSMark Fasheh mlog(0, "Adjust records at index %u\n", i); 1710dcd0538fSMark Fasheh 1711dcd0538fSMark Fasheh /* 1712dcd0538fSMark Fasheh * One nice property of knowing that all of these 1713dcd0538fSMark Fasheh * nodes are below the root is that we only deal with 1714dcd0538fSMark Fasheh * the leftmost right node record and the rightmost 1715dcd0538fSMark Fasheh * left node record. 1716dcd0538fSMark Fasheh */ 1717dcd0538fSMark Fasheh el = left_path->p_node[i].el; 1718dcd0538fSMark Fasheh idx = le16_to_cpu(left_el->l_next_free_rec) - 1; 1719dcd0538fSMark Fasheh left_rec = &el->l_recs[idx]; 1720dcd0538fSMark Fasheh 1721dcd0538fSMark Fasheh el = right_path->p_node[i].el; 1722dcd0538fSMark Fasheh right_rec = &el->l_recs[0]; 1723dcd0538fSMark Fasheh 1724dcd0538fSMark Fasheh ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec, 1725dcd0538fSMark Fasheh right_el); 1726dcd0538fSMark Fasheh 1727dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, left_path->p_node[i].bh); 1728dcd0538fSMark Fasheh if (ret) 1729dcd0538fSMark Fasheh mlog_errno(ret); 1730dcd0538fSMark Fasheh 1731dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, right_path->p_node[i].bh); 1732dcd0538fSMark Fasheh if (ret) 1733dcd0538fSMark Fasheh mlog_errno(ret); 1734dcd0538fSMark Fasheh 1735dcd0538fSMark Fasheh /* 1736dcd0538fSMark Fasheh * Setup our list pointers now so that the current 1737dcd0538fSMark Fasheh * parents become children in the next iteration. 1738dcd0538fSMark Fasheh */ 1739dcd0538fSMark Fasheh left_el = left_path->p_node[i].el; 1740dcd0538fSMark Fasheh right_el = right_path->p_node[i].el; 1741dcd0538fSMark Fasheh } 1742dcd0538fSMark Fasheh 1743dcd0538fSMark Fasheh /* 1744dcd0538fSMark Fasheh * At the root node, adjust the two adjacent records which 1745dcd0538fSMark Fasheh * begin our path to the leaves. 1746dcd0538fSMark Fasheh */ 1747dcd0538fSMark Fasheh 1748dcd0538fSMark Fasheh el = left_path->p_node[subtree_index].el; 1749dcd0538fSMark Fasheh left_el = left_path->p_node[subtree_index + 1].el; 1750dcd0538fSMark Fasheh right_el = right_path->p_node[subtree_index + 1].el; 1751dcd0538fSMark Fasheh 1752dcd0538fSMark Fasheh ocfs2_adjust_root_records(el, left_el, right_el, 1753dcd0538fSMark Fasheh left_path->p_node[subtree_index + 1].bh->b_blocknr); 1754dcd0538fSMark Fasheh 1755dcd0538fSMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 1756dcd0538fSMark Fasheh 1757dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, root_bh); 1758dcd0538fSMark Fasheh if (ret) 1759dcd0538fSMark Fasheh mlog_errno(ret); 1760dcd0538fSMark Fasheh } 1761dcd0538fSMark Fasheh 1762dcd0538fSMark Fasheh static int ocfs2_rotate_subtree_right(struct inode *inode, 1763dcd0538fSMark Fasheh handle_t *handle, 1764dcd0538fSMark Fasheh struct ocfs2_path *left_path, 1765dcd0538fSMark Fasheh struct ocfs2_path *right_path, 1766dcd0538fSMark Fasheh int subtree_index) 1767dcd0538fSMark Fasheh { 1768dcd0538fSMark Fasheh int ret, i; 1769dcd0538fSMark Fasheh struct buffer_head *right_leaf_bh; 1770dcd0538fSMark Fasheh struct buffer_head *left_leaf_bh = NULL; 1771dcd0538fSMark Fasheh struct buffer_head *root_bh; 1772dcd0538fSMark Fasheh struct ocfs2_extent_list *right_el, *left_el; 1773dcd0538fSMark Fasheh struct ocfs2_extent_rec move_rec; 1774dcd0538fSMark Fasheh 1775dcd0538fSMark Fasheh left_leaf_bh = path_leaf_bh(left_path); 1776dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 1777dcd0538fSMark Fasheh 1778dcd0538fSMark Fasheh if (left_el->l_next_free_rec != left_el->l_count) { 1779dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 1780dcd0538fSMark Fasheh "Inode %llu has non-full interior leaf node %llu" 1781dcd0538fSMark Fasheh "(next free = %u)", 1782dcd0538fSMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 1783dcd0538fSMark Fasheh (unsigned long long)left_leaf_bh->b_blocknr, 1784dcd0538fSMark Fasheh le16_to_cpu(left_el->l_next_free_rec)); 1785dcd0538fSMark Fasheh return -EROFS; 1786dcd0538fSMark Fasheh } 1787dcd0538fSMark Fasheh 1788dcd0538fSMark Fasheh /* 1789dcd0538fSMark Fasheh * This extent block may already have an empty record, so we 1790dcd0538fSMark Fasheh * return early if so. 1791dcd0538fSMark Fasheh */ 1792dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&left_el->l_recs[0])) 1793dcd0538fSMark Fasheh return 0; 1794dcd0538fSMark Fasheh 1795dcd0538fSMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 1796dcd0538fSMark Fasheh BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 1797dcd0538fSMark Fasheh 1798dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, root_bh, 1799dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1800dcd0538fSMark Fasheh if (ret) { 1801dcd0538fSMark Fasheh mlog_errno(ret); 1802dcd0538fSMark Fasheh goto out; 1803dcd0538fSMark Fasheh } 1804dcd0538fSMark Fasheh 1805dcd0538fSMark Fasheh for(i = subtree_index + 1; i < path_num_items(right_path); i++) { 1806dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, 1807dcd0538fSMark Fasheh right_path->p_node[i].bh, 1808dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1809dcd0538fSMark Fasheh if (ret) { 1810dcd0538fSMark Fasheh mlog_errno(ret); 1811dcd0538fSMark Fasheh goto out; 1812dcd0538fSMark Fasheh } 1813dcd0538fSMark Fasheh 1814dcd0538fSMark Fasheh ret = ocfs2_journal_access(handle, inode, 1815dcd0538fSMark Fasheh left_path->p_node[i].bh, 1816dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 1817dcd0538fSMark Fasheh if (ret) { 1818dcd0538fSMark Fasheh mlog_errno(ret); 1819dcd0538fSMark Fasheh goto out; 1820dcd0538fSMark Fasheh } 1821dcd0538fSMark Fasheh } 1822dcd0538fSMark Fasheh 1823dcd0538fSMark Fasheh right_leaf_bh = path_leaf_bh(right_path); 1824dcd0538fSMark Fasheh right_el = path_leaf_el(right_path); 1825dcd0538fSMark Fasheh 1826dcd0538fSMark Fasheh /* This is a code error, not a disk corruption. */ 1827dcd0538fSMark Fasheh mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails " 1828dcd0538fSMark Fasheh "because rightmost leaf block %llu is empty\n", 1829dcd0538fSMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 1830dcd0538fSMark Fasheh (unsigned long long)right_leaf_bh->b_blocknr); 1831dcd0538fSMark Fasheh 1832dcd0538fSMark Fasheh ocfs2_create_empty_extent(right_el); 1833dcd0538fSMark Fasheh 1834dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, right_leaf_bh); 1835dcd0538fSMark Fasheh if (ret) { 1836dcd0538fSMark Fasheh mlog_errno(ret); 1837dcd0538fSMark Fasheh goto out; 1838dcd0538fSMark Fasheh } 1839dcd0538fSMark Fasheh 1840dcd0538fSMark Fasheh /* Do the copy now. */ 1841dcd0538fSMark Fasheh i = le16_to_cpu(left_el->l_next_free_rec) - 1; 1842dcd0538fSMark Fasheh move_rec = left_el->l_recs[i]; 1843dcd0538fSMark Fasheh right_el->l_recs[0] = move_rec; 1844dcd0538fSMark Fasheh 1845dcd0538fSMark Fasheh /* 1846dcd0538fSMark Fasheh * Clear out the record we just copied and shift everything 1847dcd0538fSMark Fasheh * over, leaving an empty extent in the left leaf. 1848dcd0538fSMark Fasheh * 1849dcd0538fSMark Fasheh * We temporarily subtract from next_free_rec so that the 1850dcd0538fSMark Fasheh * shift will lose the tail record (which is now defunct). 1851dcd0538fSMark Fasheh */ 1852dcd0538fSMark Fasheh le16_add_cpu(&left_el->l_next_free_rec, -1); 1853dcd0538fSMark Fasheh ocfs2_shift_records_right(left_el); 1854dcd0538fSMark Fasheh memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 1855dcd0538fSMark Fasheh le16_add_cpu(&left_el->l_next_free_rec, 1); 1856dcd0538fSMark Fasheh 1857dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, left_leaf_bh); 1858dcd0538fSMark Fasheh if (ret) { 1859dcd0538fSMark Fasheh mlog_errno(ret); 1860dcd0538fSMark Fasheh goto out; 1861dcd0538fSMark Fasheh } 1862dcd0538fSMark Fasheh 1863dcd0538fSMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, right_path, 1864dcd0538fSMark Fasheh subtree_index); 1865dcd0538fSMark Fasheh 1866dcd0538fSMark Fasheh out: 1867dcd0538fSMark Fasheh return ret; 1868dcd0538fSMark Fasheh } 1869dcd0538fSMark Fasheh 1870dcd0538fSMark Fasheh /* 1871dcd0538fSMark Fasheh * Given a full path, determine what cpos value would return us a path 1872dcd0538fSMark Fasheh * containing the leaf immediately to the left of the current one. 1873dcd0538fSMark Fasheh * 1874dcd0538fSMark Fasheh * Will return zero if the path passed in is already the leftmost path. 1875dcd0538fSMark Fasheh */ 1876dcd0538fSMark Fasheh static int ocfs2_find_cpos_for_left_leaf(struct super_block *sb, 1877dcd0538fSMark Fasheh struct ocfs2_path *path, u32 *cpos) 1878dcd0538fSMark Fasheh { 1879dcd0538fSMark Fasheh int i, j, ret = 0; 1880dcd0538fSMark Fasheh u64 blkno; 1881dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 1882dcd0538fSMark Fasheh 1883e48edee2SMark Fasheh BUG_ON(path->p_tree_depth == 0); 1884e48edee2SMark Fasheh 1885dcd0538fSMark Fasheh *cpos = 0; 1886dcd0538fSMark Fasheh 1887dcd0538fSMark Fasheh blkno = path_leaf_bh(path)->b_blocknr; 1888dcd0538fSMark Fasheh 1889dcd0538fSMark Fasheh /* Start at the tree node just above the leaf and work our way up. */ 1890dcd0538fSMark Fasheh i = path->p_tree_depth - 1; 1891dcd0538fSMark Fasheh while (i >= 0) { 1892dcd0538fSMark Fasheh el = path->p_node[i].el; 1893dcd0538fSMark Fasheh 1894dcd0538fSMark Fasheh /* 1895dcd0538fSMark Fasheh * Find the extent record just before the one in our 1896dcd0538fSMark Fasheh * path. 1897dcd0538fSMark Fasheh */ 1898dcd0538fSMark Fasheh for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) { 1899dcd0538fSMark Fasheh if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) { 1900dcd0538fSMark Fasheh if (j == 0) { 1901dcd0538fSMark Fasheh if (i == 0) { 1902dcd0538fSMark Fasheh /* 1903dcd0538fSMark Fasheh * We've determined that the 1904dcd0538fSMark Fasheh * path specified is already 1905dcd0538fSMark Fasheh * the leftmost one - return a 1906dcd0538fSMark Fasheh * cpos of zero. 1907dcd0538fSMark Fasheh */ 1908dcd0538fSMark Fasheh goto out; 1909dcd0538fSMark Fasheh } 1910dcd0538fSMark Fasheh /* 1911dcd0538fSMark Fasheh * The leftmost record points to our 1912dcd0538fSMark Fasheh * leaf - we need to travel up the 1913dcd0538fSMark Fasheh * tree one level. 1914dcd0538fSMark Fasheh */ 1915dcd0538fSMark Fasheh goto next_node; 1916dcd0538fSMark Fasheh } 1917dcd0538fSMark Fasheh 1918dcd0538fSMark Fasheh *cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos); 1919e48edee2SMark Fasheh *cpos = *cpos + ocfs2_rec_clusters(el, 1920e48edee2SMark Fasheh &el->l_recs[j - 1]); 1921e48edee2SMark Fasheh *cpos = *cpos - 1; 1922dcd0538fSMark Fasheh goto out; 1923dcd0538fSMark Fasheh } 1924dcd0538fSMark Fasheh } 1925dcd0538fSMark Fasheh 1926dcd0538fSMark Fasheh /* 1927dcd0538fSMark Fasheh * If we got here, we never found a valid node where 1928dcd0538fSMark Fasheh * the tree indicated one should be. 1929dcd0538fSMark Fasheh */ 1930dcd0538fSMark Fasheh ocfs2_error(sb, 1931dcd0538fSMark Fasheh "Invalid extent tree at extent block %llu\n", 1932dcd0538fSMark Fasheh (unsigned long long)blkno); 1933dcd0538fSMark Fasheh ret = -EROFS; 1934dcd0538fSMark Fasheh goto out; 1935dcd0538fSMark Fasheh 1936dcd0538fSMark Fasheh next_node: 1937dcd0538fSMark Fasheh blkno = path->p_node[i].bh->b_blocknr; 1938dcd0538fSMark Fasheh i--; 1939dcd0538fSMark Fasheh } 1940dcd0538fSMark Fasheh 1941dcd0538fSMark Fasheh out: 1942dcd0538fSMark Fasheh return ret; 1943dcd0538fSMark Fasheh } 1944dcd0538fSMark Fasheh 1945328d5752SMark Fasheh /* 1946328d5752SMark Fasheh * Extend the transaction by enough credits to complete the rotation, 1947328d5752SMark Fasheh * and still leave at least the original number of credits allocated 1948328d5752SMark Fasheh * to this transaction. 1949328d5752SMark Fasheh */ 1950dcd0538fSMark Fasheh static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth, 1951328d5752SMark Fasheh int op_credits, 1952dcd0538fSMark Fasheh struct ocfs2_path *path) 1953dcd0538fSMark Fasheh { 1954328d5752SMark Fasheh int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits; 1955dcd0538fSMark Fasheh 1956dcd0538fSMark Fasheh if (handle->h_buffer_credits < credits) 1957dcd0538fSMark Fasheh return ocfs2_extend_trans(handle, credits); 1958dcd0538fSMark Fasheh 1959dcd0538fSMark Fasheh return 0; 1960dcd0538fSMark Fasheh } 1961dcd0538fSMark Fasheh 1962dcd0538fSMark Fasheh /* 1963dcd0538fSMark Fasheh * Trap the case where we're inserting into the theoretical range past 1964dcd0538fSMark Fasheh * the _actual_ left leaf range. Otherwise, we'll rotate a record 1965dcd0538fSMark Fasheh * whose cpos is less than ours into the right leaf. 1966dcd0538fSMark Fasheh * 1967dcd0538fSMark Fasheh * It's only necessary to look at the rightmost record of the left 1968dcd0538fSMark Fasheh * leaf because the logic that calls us should ensure that the 1969dcd0538fSMark Fasheh * theoretical ranges in the path components above the leaves are 1970dcd0538fSMark Fasheh * correct. 1971dcd0538fSMark Fasheh */ 1972dcd0538fSMark Fasheh static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path, 1973dcd0538fSMark Fasheh u32 insert_cpos) 1974dcd0538fSMark Fasheh { 1975dcd0538fSMark Fasheh struct ocfs2_extent_list *left_el; 1976dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 1977dcd0538fSMark Fasheh int next_free; 1978dcd0538fSMark Fasheh 1979dcd0538fSMark Fasheh left_el = path_leaf_el(left_path); 1980dcd0538fSMark Fasheh next_free = le16_to_cpu(left_el->l_next_free_rec); 1981dcd0538fSMark Fasheh rec = &left_el->l_recs[next_free - 1]; 1982dcd0538fSMark Fasheh 1983dcd0538fSMark Fasheh if (insert_cpos > le32_to_cpu(rec->e_cpos)) 1984dcd0538fSMark Fasheh return 1; 1985dcd0538fSMark Fasheh return 0; 1986dcd0538fSMark Fasheh } 1987dcd0538fSMark Fasheh 1988328d5752SMark Fasheh static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos) 1989328d5752SMark Fasheh { 1990328d5752SMark Fasheh int next_free = le16_to_cpu(el->l_next_free_rec); 1991328d5752SMark Fasheh unsigned int range; 1992328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 1993328d5752SMark Fasheh 1994328d5752SMark Fasheh if (next_free == 0) 1995328d5752SMark Fasheh return 0; 1996328d5752SMark Fasheh 1997328d5752SMark Fasheh rec = &el->l_recs[0]; 1998328d5752SMark Fasheh if (ocfs2_is_empty_extent(rec)) { 1999328d5752SMark Fasheh /* Empty list. */ 2000328d5752SMark Fasheh if (next_free == 1) 2001328d5752SMark Fasheh return 0; 2002328d5752SMark Fasheh rec = &el->l_recs[1]; 2003328d5752SMark Fasheh } 2004328d5752SMark Fasheh 2005328d5752SMark Fasheh range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 2006328d5752SMark Fasheh if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range) 2007328d5752SMark Fasheh return 1; 2008328d5752SMark Fasheh return 0; 2009328d5752SMark Fasheh } 2010328d5752SMark Fasheh 2011dcd0538fSMark Fasheh /* 2012dcd0538fSMark Fasheh * Rotate all the records in a btree right one record, starting at insert_cpos. 2013dcd0538fSMark Fasheh * 2014dcd0538fSMark Fasheh * The path to the rightmost leaf should be passed in. 2015dcd0538fSMark Fasheh * 2016dcd0538fSMark Fasheh * The array is assumed to be large enough to hold an entire path (tree depth). 2017dcd0538fSMark Fasheh * 2018dcd0538fSMark Fasheh * Upon succesful return from this function: 2019dcd0538fSMark Fasheh * 2020dcd0538fSMark Fasheh * - The 'right_path' array will contain a path to the leaf block 2021dcd0538fSMark Fasheh * whose range contains e_cpos. 2022dcd0538fSMark Fasheh * - That leaf block will have a single empty extent in list index 0. 2023dcd0538fSMark Fasheh * - In the case that the rotation requires a post-insert update, 2024dcd0538fSMark Fasheh * *ret_left_path will contain a valid path which can be passed to 2025dcd0538fSMark Fasheh * ocfs2_insert_path(). 2026dcd0538fSMark Fasheh */ 2027dcd0538fSMark Fasheh static int ocfs2_rotate_tree_right(struct inode *inode, 2028dcd0538fSMark Fasheh handle_t *handle, 2029328d5752SMark Fasheh enum ocfs2_split_type split, 2030dcd0538fSMark Fasheh u32 insert_cpos, 2031dcd0538fSMark Fasheh struct ocfs2_path *right_path, 2032dcd0538fSMark Fasheh struct ocfs2_path **ret_left_path) 2033dcd0538fSMark Fasheh { 2034328d5752SMark Fasheh int ret, start, orig_credits = handle->h_buffer_credits; 2035dcd0538fSMark Fasheh u32 cpos; 2036dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 2037dcd0538fSMark Fasheh 2038dcd0538fSMark Fasheh *ret_left_path = NULL; 2039dcd0538fSMark Fasheh 2040dcd0538fSMark Fasheh left_path = ocfs2_new_path(path_root_bh(right_path), 2041dcd0538fSMark Fasheh path_root_el(right_path)); 2042dcd0538fSMark Fasheh if (!left_path) { 2043dcd0538fSMark Fasheh ret = -ENOMEM; 2044dcd0538fSMark Fasheh mlog_errno(ret); 2045dcd0538fSMark Fasheh goto out; 2046dcd0538fSMark Fasheh } 2047dcd0538fSMark Fasheh 2048dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, &cpos); 2049dcd0538fSMark Fasheh if (ret) { 2050dcd0538fSMark Fasheh mlog_errno(ret); 2051dcd0538fSMark Fasheh goto out; 2052dcd0538fSMark Fasheh } 2053dcd0538fSMark Fasheh 2054dcd0538fSMark Fasheh mlog(0, "Insert: %u, first left path cpos: %u\n", insert_cpos, cpos); 2055dcd0538fSMark Fasheh 2056dcd0538fSMark Fasheh /* 2057dcd0538fSMark Fasheh * What we want to do here is: 2058dcd0538fSMark Fasheh * 2059dcd0538fSMark Fasheh * 1) Start with the rightmost path. 2060dcd0538fSMark Fasheh * 2061dcd0538fSMark Fasheh * 2) Determine a path to the leaf block directly to the left 2062dcd0538fSMark Fasheh * of that leaf. 2063dcd0538fSMark Fasheh * 2064dcd0538fSMark Fasheh * 3) Determine the 'subtree root' - the lowest level tree node 2065dcd0538fSMark Fasheh * which contains a path to both leaves. 2066dcd0538fSMark Fasheh * 2067dcd0538fSMark Fasheh * 4) Rotate the subtree. 2068dcd0538fSMark Fasheh * 2069dcd0538fSMark Fasheh * 5) Find the next subtree by considering the left path to be 2070dcd0538fSMark Fasheh * the new right path. 2071dcd0538fSMark Fasheh * 2072dcd0538fSMark Fasheh * The check at the top of this while loop also accepts 2073dcd0538fSMark Fasheh * insert_cpos == cpos because cpos is only a _theoretical_ 2074dcd0538fSMark Fasheh * value to get us the left path - insert_cpos might very well 2075dcd0538fSMark Fasheh * be filling that hole. 2076dcd0538fSMark Fasheh * 2077dcd0538fSMark Fasheh * Stop at a cpos of '0' because we either started at the 2078dcd0538fSMark Fasheh * leftmost branch (i.e., a tree with one branch and a 2079dcd0538fSMark Fasheh * rotation inside of it), or we've gone as far as we can in 2080dcd0538fSMark Fasheh * rotating subtrees. 2081dcd0538fSMark Fasheh */ 2082dcd0538fSMark Fasheh while (cpos && insert_cpos <= cpos) { 2083dcd0538fSMark Fasheh mlog(0, "Rotating a tree: ins. cpos: %u, left path cpos: %u\n", 2084dcd0538fSMark Fasheh insert_cpos, cpos); 2085dcd0538fSMark Fasheh 2086dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 2087dcd0538fSMark Fasheh if (ret) { 2088dcd0538fSMark Fasheh mlog_errno(ret); 2089dcd0538fSMark Fasheh goto out; 2090dcd0538fSMark Fasheh } 2091dcd0538fSMark Fasheh 2092dcd0538fSMark Fasheh mlog_bug_on_msg(path_leaf_bh(left_path) == 2093dcd0538fSMark Fasheh path_leaf_bh(right_path), 2094dcd0538fSMark Fasheh "Inode %lu: error during insert of %u " 2095dcd0538fSMark Fasheh "(left path cpos %u) results in two identical " 2096dcd0538fSMark Fasheh "paths ending at %llu\n", 2097dcd0538fSMark Fasheh inode->i_ino, insert_cpos, cpos, 2098dcd0538fSMark Fasheh (unsigned long long) 2099dcd0538fSMark Fasheh path_leaf_bh(left_path)->b_blocknr); 2100dcd0538fSMark Fasheh 2101328d5752SMark Fasheh if (split == SPLIT_NONE && 2102328d5752SMark Fasheh ocfs2_rotate_requires_path_adjustment(left_path, 2103dcd0538fSMark Fasheh insert_cpos)) { 2104dcd0538fSMark Fasheh 2105dcd0538fSMark Fasheh /* 2106dcd0538fSMark Fasheh * We've rotated the tree as much as we 2107dcd0538fSMark Fasheh * should. The rest is up to 2108dcd0538fSMark Fasheh * ocfs2_insert_path() to complete, after the 2109dcd0538fSMark Fasheh * record insertion. We indicate this 2110dcd0538fSMark Fasheh * situation by returning the left path. 2111dcd0538fSMark Fasheh * 2112dcd0538fSMark Fasheh * The reason we don't adjust the records here 2113dcd0538fSMark Fasheh * before the record insert is that an error 2114dcd0538fSMark Fasheh * later might break the rule where a parent 2115dcd0538fSMark Fasheh * record e_cpos will reflect the actual 2116dcd0538fSMark Fasheh * e_cpos of the 1st nonempty record of the 2117dcd0538fSMark Fasheh * child list. 2118dcd0538fSMark Fasheh */ 2119dcd0538fSMark Fasheh *ret_left_path = left_path; 2120dcd0538fSMark Fasheh goto out_ret_path; 2121dcd0538fSMark Fasheh } 2122dcd0538fSMark Fasheh 2123dcd0538fSMark Fasheh start = ocfs2_find_subtree_root(inode, left_path, right_path); 2124dcd0538fSMark Fasheh 2125dcd0538fSMark Fasheh mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n", 2126dcd0538fSMark Fasheh start, 2127dcd0538fSMark Fasheh (unsigned long long) right_path->p_node[start].bh->b_blocknr, 2128dcd0538fSMark Fasheh right_path->p_tree_depth); 2129dcd0538fSMark Fasheh 2130dcd0538fSMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, start, 2131328d5752SMark Fasheh orig_credits, right_path); 2132dcd0538fSMark Fasheh if (ret) { 2133dcd0538fSMark Fasheh mlog_errno(ret); 2134dcd0538fSMark Fasheh goto out; 2135dcd0538fSMark Fasheh } 2136dcd0538fSMark Fasheh 2137dcd0538fSMark Fasheh ret = ocfs2_rotate_subtree_right(inode, handle, left_path, 2138dcd0538fSMark Fasheh right_path, start); 2139dcd0538fSMark Fasheh if (ret) { 2140dcd0538fSMark Fasheh mlog_errno(ret); 2141dcd0538fSMark Fasheh goto out; 2142dcd0538fSMark Fasheh } 2143dcd0538fSMark Fasheh 2144328d5752SMark Fasheh if (split != SPLIT_NONE && 2145328d5752SMark Fasheh ocfs2_leftmost_rec_contains(path_leaf_el(right_path), 2146328d5752SMark Fasheh insert_cpos)) { 2147328d5752SMark Fasheh /* 2148328d5752SMark Fasheh * A rotate moves the rightmost left leaf 2149328d5752SMark Fasheh * record over to the leftmost right leaf 2150328d5752SMark Fasheh * slot. If we're doing an extent split 2151328d5752SMark Fasheh * instead of a real insert, then we have to 2152328d5752SMark Fasheh * check that the extent to be split wasn't 2153328d5752SMark Fasheh * just moved over. If it was, then we can 2154328d5752SMark Fasheh * exit here, passing left_path back - 2155328d5752SMark Fasheh * ocfs2_split_extent() is smart enough to 2156328d5752SMark Fasheh * search both leaves. 2157328d5752SMark Fasheh */ 2158328d5752SMark Fasheh *ret_left_path = left_path; 2159328d5752SMark Fasheh goto out_ret_path; 2160328d5752SMark Fasheh } 2161328d5752SMark Fasheh 2162dcd0538fSMark Fasheh /* 2163dcd0538fSMark Fasheh * There is no need to re-read the next right path 2164dcd0538fSMark Fasheh * as we know that it'll be our current left 2165dcd0538fSMark Fasheh * path. Optimize by copying values instead. 2166dcd0538fSMark Fasheh */ 2167dcd0538fSMark Fasheh ocfs2_mv_path(right_path, left_path); 2168dcd0538fSMark Fasheh 2169dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, 2170dcd0538fSMark Fasheh &cpos); 2171dcd0538fSMark Fasheh if (ret) { 2172dcd0538fSMark Fasheh mlog_errno(ret); 2173dcd0538fSMark Fasheh goto out; 2174dcd0538fSMark Fasheh } 2175dcd0538fSMark Fasheh } 2176dcd0538fSMark Fasheh 2177dcd0538fSMark Fasheh out: 2178dcd0538fSMark Fasheh ocfs2_free_path(left_path); 2179dcd0538fSMark Fasheh 2180dcd0538fSMark Fasheh out_ret_path: 2181dcd0538fSMark Fasheh return ret; 2182dcd0538fSMark Fasheh } 2183dcd0538fSMark Fasheh 2184328d5752SMark Fasheh static void ocfs2_update_edge_lengths(struct inode *inode, handle_t *handle, 2185328d5752SMark Fasheh struct ocfs2_path *path) 2186328d5752SMark Fasheh { 2187328d5752SMark Fasheh int i, idx; 2188328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 2189328d5752SMark Fasheh struct ocfs2_extent_list *el; 2190328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2191328d5752SMark Fasheh u32 range; 2192328d5752SMark Fasheh 2193328d5752SMark Fasheh /* Path should always be rightmost. */ 2194328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 2195328d5752SMark Fasheh BUG_ON(eb->h_next_leaf_blk != 0ULL); 2196328d5752SMark Fasheh 2197328d5752SMark Fasheh el = &eb->h_list; 2198328d5752SMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0); 2199328d5752SMark Fasheh idx = le16_to_cpu(el->l_next_free_rec) - 1; 2200328d5752SMark Fasheh rec = &el->l_recs[idx]; 2201328d5752SMark Fasheh range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 2202328d5752SMark Fasheh 2203328d5752SMark Fasheh for (i = 0; i < path->p_tree_depth; i++) { 2204328d5752SMark Fasheh el = path->p_node[i].el; 2205328d5752SMark Fasheh idx = le16_to_cpu(el->l_next_free_rec) - 1; 2206328d5752SMark Fasheh rec = &el->l_recs[idx]; 2207328d5752SMark Fasheh 2208328d5752SMark Fasheh rec->e_int_clusters = cpu_to_le32(range); 2209328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos)); 2210328d5752SMark Fasheh 2211328d5752SMark Fasheh ocfs2_journal_dirty(handle, path->p_node[i].bh); 2212328d5752SMark Fasheh } 2213328d5752SMark Fasheh } 2214328d5752SMark Fasheh 2215328d5752SMark Fasheh static void ocfs2_unlink_path(struct inode *inode, handle_t *handle, 2216328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2217328d5752SMark Fasheh struct ocfs2_path *path, int unlink_start) 2218328d5752SMark Fasheh { 2219328d5752SMark Fasheh int ret, i; 2220328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2221328d5752SMark Fasheh struct ocfs2_extent_list *el; 2222328d5752SMark Fasheh struct buffer_head *bh; 2223328d5752SMark Fasheh 2224328d5752SMark Fasheh for(i = unlink_start; i < path_num_items(path); i++) { 2225328d5752SMark Fasheh bh = path->p_node[i].bh; 2226328d5752SMark Fasheh 2227328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)bh->b_data; 2228328d5752SMark Fasheh /* 2229328d5752SMark Fasheh * Not all nodes might have had their final count 2230328d5752SMark Fasheh * decremented by the caller - handle this here. 2231328d5752SMark Fasheh */ 2232328d5752SMark Fasheh el = &eb->h_list; 2233328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1) { 2234328d5752SMark Fasheh mlog(ML_ERROR, 2235328d5752SMark Fasheh "Inode %llu, attempted to remove extent block " 2236328d5752SMark Fasheh "%llu with %u records\n", 2237328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 2238328d5752SMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno), 2239328d5752SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 2240328d5752SMark Fasheh 2241328d5752SMark Fasheh ocfs2_journal_dirty(handle, bh); 2242328d5752SMark Fasheh ocfs2_remove_from_cache(inode, bh); 2243328d5752SMark Fasheh continue; 2244328d5752SMark Fasheh } 2245328d5752SMark Fasheh 2246328d5752SMark Fasheh el->l_next_free_rec = 0; 2247328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 2248328d5752SMark Fasheh 2249328d5752SMark Fasheh ocfs2_journal_dirty(handle, bh); 2250328d5752SMark Fasheh 2251328d5752SMark Fasheh ret = ocfs2_cache_extent_block_free(dealloc, eb); 2252328d5752SMark Fasheh if (ret) 2253328d5752SMark Fasheh mlog_errno(ret); 2254328d5752SMark Fasheh 2255328d5752SMark Fasheh ocfs2_remove_from_cache(inode, bh); 2256328d5752SMark Fasheh } 2257328d5752SMark Fasheh } 2258328d5752SMark Fasheh 2259328d5752SMark Fasheh static void ocfs2_unlink_subtree(struct inode *inode, handle_t *handle, 2260328d5752SMark Fasheh struct ocfs2_path *left_path, 2261328d5752SMark Fasheh struct ocfs2_path *right_path, 2262328d5752SMark Fasheh int subtree_index, 2263328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc) 2264328d5752SMark Fasheh { 2265328d5752SMark Fasheh int i; 2266328d5752SMark Fasheh struct buffer_head *root_bh = left_path->p_node[subtree_index].bh; 2267328d5752SMark Fasheh struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el; 2268328d5752SMark Fasheh struct ocfs2_extent_list *el; 2269328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2270328d5752SMark Fasheh 2271328d5752SMark Fasheh el = path_leaf_el(left_path); 2272328d5752SMark Fasheh 2273328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data; 2274328d5752SMark Fasheh 2275328d5752SMark Fasheh for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++) 2276328d5752SMark Fasheh if (root_el->l_recs[i].e_blkno == eb->h_blkno) 2277328d5752SMark Fasheh break; 2278328d5752SMark Fasheh 2279328d5752SMark Fasheh BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec)); 2280328d5752SMark Fasheh 2281328d5752SMark Fasheh memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec)); 2282328d5752SMark Fasheh le16_add_cpu(&root_el->l_next_free_rec, -1); 2283328d5752SMark Fasheh 2284328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 2285328d5752SMark Fasheh eb->h_next_leaf_blk = 0; 2286328d5752SMark Fasheh 2287328d5752SMark Fasheh ocfs2_journal_dirty(handle, root_bh); 2288328d5752SMark Fasheh ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 2289328d5752SMark Fasheh 2290328d5752SMark Fasheh ocfs2_unlink_path(inode, handle, dealloc, right_path, 2291328d5752SMark Fasheh subtree_index + 1); 2292328d5752SMark Fasheh } 2293328d5752SMark Fasheh 2294328d5752SMark Fasheh static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle, 2295328d5752SMark Fasheh struct ocfs2_path *left_path, 2296328d5752SMark Fasheh struct ocfs2_path *right_path, 2297328d5752SMark Fasheh int subtree_index, 2298328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2299e7d4cb6bSTao Ma int *deleted, 2300e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2301328d5752SMark Fasheh { 2302328d5752SMark Fasheh int ret, i, del_right_subtree = 0, right_has_empty = 0; 2303e7d4cb6bSTao Ma struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path); 2304328d5752SMark Fasheh struct ocfs2_extent_list *right_leaf_el, *left_leaf_el; 2305328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2306328d5752SMark Fasheh 2307328d5752SMark Fasheh *deleted = 0; 2308328d5752SMark Fasheh 2309328d5752SMark Fasheh right_leaf_el = path_leaf_el(right_path); 2310328d5752SMark Fasheh left_leaf_el = path_leaf_el(left_path); 2311328d5752SMark Fasheh root_bh = left_path->p_node[subtree_index].bh; 2312328d5752SMark Fasheh BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 2313328d5752SMark Fasheh 2314328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0])) 2315328d5752SMark Fasheh return 0; 2316328d5752SMark Fasheh 2317328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data; 2318328d5752SMark Fasheh if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) { 2319328d5752SMark Fasheh /* 2320328d5752SMark Fasheh * It's legal for us to proceed if the right leaf is 2321328d5752SMark Fasheh * the rightmost one and it has an empty extent. There 2322328d5752SMark Fasheh * are two cases to handle - whether the leaf will be 2323328d5752SMark Fasheh * empty after removal or not. If the leaf isn't empty 2324328d5752SMark Fasheh * then just remove the empty extent up front. The 2325328d5752SMark Fasheh * next block will handle empty leaves by flagging 2326328d5752SMark Fasheh * them for unlink. 2327328d5752SMark Fasheh * 2328328d5752SMark Fasheh * Non rightmost leaves will throw -EAGAIN and the 2329328d5752SMark Fasheh * caller can manually move the subtree and retry. 2330328d5752SMark Fasheh */ 2331328d5752SMark Fasheh 2332328d5752SMark Fasheh if (eb->h_next_leaf_blk != 0ULL) 2333328d5752SMark Fasheh return -EAGAIN; 2334328d5752SMark Fasheh 2335328d5752SMark Fasheh if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) { 2336328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2337328d5752SMark Fasheh path_leaf_bh(right_path), 2338328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2339328d5752SMark Fasheh if (ret) { 2340328d5752SMark Fasheh mlog_errno(ret); 2341328d5752SMark Fasheh goto out; 2342328d5752SMark Fasheh } 2343328d5752SMark Fasheh 2344328d5752SMark Fasheh ocfs2_remove_empty_extent(right_leaf_el); 2345328d5752SMark Fasheh } else 2346328d5752SMark Fasheh right_has_empty = 1; 2347328d5752SMark Fasheh } 2348328d5752SMark Fasheh 2349328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0ULL && 2350328d5752SMark Fasheh le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) { 2351328d5752SMark Fasheh /* 2352328d5752SMark Fasheh * We have to update i_last_eb_blk during the meta 2353328d5752SMark Fasheh * data delete. 2354328d5752SMark Fasheh */ 2355e7d4cb6bSTao Ma ret = ocfs2_journal_access(handle, inode, et_root_bh, 2356328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2357328d5752SMark Fasheh if (ret) { 2358328d5752SMark Fasheh mlog_errno(ret); 2359328d5752SMark Fasheh goto out; 2360328d5752SMark Fasheh } 2361328d5752SMark Fasheh 2362328d5752SMark Fasheh del_right_subtree = 1; 2363328d5752SMark Fasheh } 2364328d5752SMark Fasheh 2365328d5752SMark Fasheh /* 2366328d5752SMark Fasheh * Getting here with an empty extent in the right path implies 2367328d5752SMark Fasheh * that it's the rightmost path and will be deleted. 2368328d5752SMark Fasheh */ 2369328d5752SMark Fasheh BUG_ON(right_has_empty && !del_right_subtree); 2370328d5752SMark Fasheh 2371328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, root_bh, 2372328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2373328d5752SMark Fasheh if (ret) { 2374328d5752SMark Fasheh mlog_errno(ret); 2375328d5752SMark Fasheh goto out; 2376328d5752SMark Fasheh } 2377328d5752SMark Fasheh 2378328d5752SMark Fasheh for(i = subtree_index + 1; i < path_num_items(right_path); i++) { 2379328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2380328d5752SMark Fasheh right_path->p_node[i].bh, 2381328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2382328d5752SMark Fasheh if (ret) { 2383328d5752SMark Fasheh mlog_errno(ret); 2384328d5752SMark Fasheh goto out; 2385328d5752SMark Fasheh } 2386328d5752SMark Fasheh 2387328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2388328d5752SMark Fasheh left_path->p_node[i].bh, 2389328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2390328d5752SMark Fasheh if (ret) { 2391328d5752SMark Fasheh mlog_errno(ret); 2392328d5752SMark Fasheh goto out; 2393328d5752SMark Fasheh } 2394328d5752SMark Fasheh } 2395328d5752SMark Fasheh 2396328d5752SMark Fasheh if (!right_has_empty) { 2397328d5752SMark Fasheh /* 2398328d5752SMark Fasheh * Only do this if we're moving a real 2399328d5752SMark Fasheh * record. Otherwise, the action is delayed until 2400328d5752SMark Fasheh * after removal of the right path in which case we 2401328d5752SMark Fasheh * can do a simple shift to remove the empty extent. 2402328d5752SMark Fasheh */ 2403328d5752SMark Fasheh ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]); 2404328d5752SMark Fasheh memset(&right_leaf_el->l_recs[0], 0, 2405328d5752SMark Fasheh sizeof(struct ocfs2_extent_rec)); 2406328d5752SMark Fasheh } 2407328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0ULL) { 2408328d5752SMark Fasheh /* 2409328d5752SMark Fasheh * Move recs over to get rid of empty extent, decrease 2410328d5752SMark Fasheh * next_free. This is allowed to remove the last 2411328d5752SMark Fasheh * extent in our leaf (setting l_next_free_rec to 2412328d5752SMark Fasheh * zero) - the delete code below won't care. 2413328d5752SMark Fasheh */ 2414328d5752SMark Fasheh ocfs2_remove_empty_extent(right_leaf_el); 2415328d5752SMark Fasheh } 2416328d5752SMark Fasheh 2417328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 2418328d5752SMark Fasheh if (ret) 2419328d5752SMark Fasheh mlog_errno(ret); 2420328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path)); 2421328d5752SMark Fasheh if (ret) 2422328d5752SMark Fasheh mlog_errno(ret); 2423328d5752SMark Fasheh 2424328d5752SMark Fasheh if (del_right_subtree) { 2425328d5752SMark Fasheh ocfs2_unlink_subtree(inode, handle, left_path, right_path, 2426328d5752SMark Fasheh subtree_index, dealloc); 2427328d5752SMark Fasheh ocfs2_update_edge_lengths(inode, handle, left_path); 2428328d5752SMark Fasheh 2429328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 243035dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 2431328d5752SMark Fasheh 2432328d5752SMark Fasheh /* 2433328d5752SMark Fasheh * Removal of the extent in the left leaf was skipped 2434328d5752SMark Fasheh * above so we could delete the right path 2435328d5752SMark Fasheh * 1st. 2436328d5752SMark Fasheh */ 2437328d5752SMark Fasheh if (right_has_empty) 2438328d5752SMark Fasheh ocfs2_remove_empty_extent(left_leaf_el); 2439328d5752SMark Fasheh 2440e7d4cb6bSTao Ma ret = ocfs2_journal_dirty(handle, et_root_bh); 2441328d5752SMark Fasheh if (ret) 2442328d5752SMark Fasheh mlog_errno(ret); 2443328d5752SMark Fasheh 2444328d5752SMark Fasheh *deleted = 1; 2445328d5752SMark Fasheh } else 2446328d5752SMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, right_path, 2447328d5752SMark Fasheh subtree_index); 2448328d5752SMark Fasheh 2449328d5752SMark Fasheh out: 2450328d5752SMark Fasheh return ret; 2451328d5752SMark Fasheh } 2452328d5752SMark Fasheh 2453328d5752SMark Fasheh /* 2454328d5752SMark Fasheh * Given a full path, determine what cpos value would return us a path 2455328d5752SMark Fasheh * containing the leaf immediately to the right of the current one. 2456328d5752SMark Fasheh * 2457328d5752SMark Fasheh * Will return zero if the path passed in is already the rightmost path. 2458328d5752SMark Fasheh * 2459328d5752SMark Fasheh * This looks similar, but is subtly different to 2460328d5752SMark Fasheh * ocfs2_find_cpos_for_left_leaf(). 2461328d5752SMark Fasheh */ 2462328d5752SMark Fasheh static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb, 2463328d5752SMark Fasheh struct ocfs2_path *path, u32 *cpos) 2464328d5752SMark Fasheh { 2465328d5752SMark Fasheh int i, j, ret = 0; 2466328d5752SMark Fasheh u64 blkno; 2467328d5752SMark Fasheh struct ocfs2_extent_list *el; 2468328d5752SMark Fasheh 2469328d5752SMark Fasheh *cpos = 0; 2470328d5752SMark Fasheh 2471328d5752SMark Fasheh if (path->p_tree_depth == 0) 2472328d5752SMark Fasheh return 0; 2473328d5752SMark Fasheh 2474328d5752SMark Fasheh blkno = path_leaf_bh(path)->b_blocknr; 2475328d5752SMark Fasheh 2476328d5752SMark Fasheh /* Start at the tree node just above the leaf and work our way up. */ 2477328d5752SMark Fasheh i = path->p_tree_depth - 1; 2478328d5752SMark Fasheh while (i >= 0) { 2479328d5752SMark Fasheh int next_free; 2480328d5752SMark Fasheh 2481328d5752SMark Fasheh el = path->p_node[i].el; 2482328d5752SMark Fasheh 2483328d5752SMark Fasheh /* 2484328d5752SMark Fasheh * Find the extent record just after the one in our 2485328d5752SMark Fasheh * path. 2486328d5752SMark Fasheh */ 2487328d5752SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 2488328d5752SMark Fasheh for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) { 2489328d5752SMark Fasheh if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) { 2490328d5752SMark Fasheh if (j == (next_free - 1)) { 2491328d5752SMark Fasheh if (i == 0) { 2492328d5752SMark Fasheh /* 2493328d5752SMark Fasheh * We've determined that the 2494328d5752SMark Fasheh * path specified is already 2495328d5752SMark Fasheh * the rightmost one - return a 2496328d5752SMark Fasheh * cpos of zero. 2497328d5752SMark Fasheh */ 2498328d5752SMark Fasheh goto out; 2499328d5752SMark Fasheh } 2500328d5752SMark Fasheh /* 2501328d5752SMark Fasheh * The rightmost record points to our 2502328d5752SMark Fasheh * leaf - we need to travel up the 2503328d5752SMark Fasheh * tree one level. 2504328d5752SMark Fasheh */ 2505328d5752SMark Fasheh goto next_node; 2506328d5752SMark Fasheh } 2507328d5752SMark Fasheh 2508328d5752SMark Fasheh *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos); 2509328d5752SMark Fasheh goto out; 2510328d5752SMark Fasheh } 2511328d5752SMark Fasheh } 2512328d5752SMark Fasheh 2513328d5752SMark Fasheh /* 2514328d5752SMark Fasheh * If we got here, we never found a valid node where 2515328d5752SMark Fasheh * the tree indicated one should be. 2516328d5752SMark Fasheh */ 2517328d5752SMark Fasheh ocfs2_error(sb, 2518328d5752SMark Fasheh "Invalid extent tree at extent block %llu\n", 2519328d5752SMark Fasheh (unsigned long long)blkno); 2520328d5752SMark Fasheh ret = -EROFS; 2521328d5752SMark Fasheh goto out; 2522328d5752SMark Fasheh 2523328d5752SMark Fasheh next_node: 2524328d5752SMark Fasheh blkno = path->p_node[i].bh->b_blocknr; 2525328d5752SMark Fasheh i--; 2526328d5752SMark Fasheh } 2527328d5752SMark Fasheh 2528328d5752SMark Fasheh out: 2529328d5752SMark Fasheh return ret; 2530328d5752SMark Fasheh } 2531328d5752SMark Fasheh 2532328d5752SMark Fasheh static int ocfs2_rotate_rightmost_leaf_left(struct inode *inode, 2533328d5752SMark Fasheh handle_t *handle, 2534328d5752SMark Fasheh struct buffer_head *bh, 2535328d5752SMark Fasheh struct ocfs2_extent_list *el) 2536328d5752SMark Fasheh { 2537328d5752SMark Fasheh int ret; 2538328d5752SMark Fasheh 2539328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&el->l_recs[0])) 2540328d5752SMark Fasheh return 0; 2541328d5752SMark Fasheh 2542328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 2543328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2544328d5752SMark Fasheh if (ret) { 2545328d5752SMark Fasheh mlog_errno(ret); 2546328d5752SMark Fasheh goto out; 2547328d5752SMark Fasheh } 2548328d5752SMark Fasheh 2549328d5752SMark Fasheh ocfs2_remove_empty_extent(el); 2550328d5752SMark Fasheh 2551328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 2552328d5752SMark Fasheh if (ret) 2553328d5752SMark Fasheh mlog_errno(ret); 2554328d5752SMark Fasheh 2555328d5752SMark Fasheh out: 2556328d5752SMark Fasheh return ret; 2557328d5752SMark Fasheh } 2558328d5752SMark Fasheh 2559328d5752SMark Fasheh static int __ocfs2_rotate_tree_left(struct inode *inode, 2560328d5752SMark Fasheh handle_t *handle, int orig_credits, 2561328d5752SMark Fasheh struct ocfs2_path *path, 2562328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 2563e7d4cb6bSTao Ma struct ocfs2_path **empty_extent_path, 2564e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2565328d5752SMark Fasheh { 2566328d5752SMark Fasheh int ret, subtree_root, deleted; 2567328d5752SMark Fasheh u32 right_cpos; 2568328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 2569328d5752SMark Fasheh struct ocfs2_path *right_path = NULL; 2570328d5752SMark Fasheh 2571328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0]))); 2572328d5752SMark Fasheh 2573328d5752SMark Fasheh *empty_extent_path = NULL; 2574328d5752SMark Fasheh 2575328d5752SMark Fasheh ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, path, 2576328d5752SMark Fasheh &right_cpos); 2577328d5752SMark Fasheh if (ret) { 2578328d5752SMark Fasheh mlog_errno(ret); 2579328d5752SMark Fasheh goto out; 2580328d5752SMark Fasheh } 2581328d5752SMark Fasheh 2582328d5752SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 2583328d5752SMark Fasheh path_root_el(path)); 2584328d5752SMark Fasheh if (!left_path) { 2585328d5752SMark Fasheh ret = -ENOMEM; 2586328d5752SMark Fasheh mlog_errno(ret); 2587328d5752SMark Fasheh goto out; 2588328d5752SMark Fasheh } 2589328d5752SMark Fasheh 2590328d5752SMark Fasheh ocfs2_cp_path(left_path, path); 2591328d5752SMark Fasheh 2592328d5752SMark Fasheh right_path = ocfs2_new_path(path_root_bh(path), 2593328d5752SMark Fasheh path_root_el(path)); 2594328d5752SMark Fasheh if (!right_path) { 2595328d5752SMark Fasheh ret = -ENOMEM; 2596328d5752SMark Fasheh mlog_errno(ret); 2597328d5752SMark Fasheh goto out; 2598328d5752SMark Fasheh } 2599328d5752SMark Fasheh 2600328d5752SMark Fasheh while (right_cpos) { 2601328d5752SMark Fasheh ret = ocfs2_find_path(inode, right_path, right_cpos); 2602328d5752SMark Fasheh if (ret) { 2603328d5752SMark Fasheh mlog_errno(ret); 2604328d5752SMark Fasheh goto out; 2605328d5752SMark Fasheh } 2606328d5752SMark Fasheh 2607328d5752SMark Fasheh subtree_root = ocfs2_find_subtree_root(inode, left_path, 2608328d5752SMark Fasheh right_path); 2609328d5752SMark Fasheh 2610328d5752SMark Fasheh mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n", 2611328d5752SMark Fasheh subtree_root, 2612328d5752SMark Fasheh (unsigned long long) 2613328d5752SMark Fasheh right_path->p_node[subtree_root].bh->b_blocknr, 2614328d5752SMark Fasheh right_path->p_tree_depth); 2615328d5752SMark Fasheh 2616328d5752SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, subtree_root, 2617328d5752SMark Fasheh orig_credits, left_path); 2618328d5752SMark Fasheh if (ret) { 2619328d5752SMark Fasheh mlog_errno(ret); 2620328d5752SMark Fasheh goto out; 2621328d5752SMark Fasheh } 2622328d5752SMark Fasheh 2623e8aed345SMark Fasheh /* 2624e8aed345SMark Fasheh * Caller might still want to make changes to the 2625e8aed345SMark Fasheh * tree root, so re-add it to the journal here. 2626e8aed345SMark Fasheh */ 2627e8aed345SMark Fasheh ret = ocfs2_journal_access(handle, inode, 2628e8aed345SMark Fasheh path_root_bh(left_path), 2629e8aed345SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 2630e8aed345SMark Fasheh if (ret) { 2631e8aed345SMark Fasheh mlog_errno(ret); 2632e8aed345SMark Fasheh goto out; 2633e8aed345SMark Fasheh } 2634e8aed345SMark Fasheh 2635328d5752SMark Fasheh ret = ocfs2_rotate_subtree_left(inode, handle, left_path, 2636328d5752SMark Fasheh right_path, subtree_root, 2637e7d4cb6bSTao Ma dealloc, &deleted, et); 2638328d5752SMark Fasheh if (ret == -EAGAIN) { 2639328d5752SMark Fasheh /* 2640328d5752SMark Fasheh * The rotation has to temporarily stop due to 2641328d5752SMark Fasheh * the right subtree having an empty 2642328d5752SMark Fasheh * extent. Pass it back to the caller for a 2643328d5752SMark Fasheh * fixup. 2644328d5752SMark Fasheh */ 2645328d5752SMark Fasheh *empty_extent_path = right_path; 2646328d5752SMark Fasheh right_path = NULL; 2647328d5752SMark Fasheh goto out; 2648328d5752SMark Fasheh } 2649328d5752SMark Fasheh if (ret) { 2650328d5752SMark Fasheh mlog_errno(ret); 2651328d5752SMark Fasheh goto out; 2652328d5752SMark Fasheh } 2653328d5752SMark Fasheh 2654328d5752SMark Fasheh /* 2655328d5752SMark Fasheh * The subtree rotate might have removed records on 2656328d5752SMark Fasheh * the rightmost edge. If so, then rotation is 2657328d5752SMark Fasheh * complete. 2658328d5752SMark Fasheh */ 2659328d5752SMark Fasheh if (deleted) 2660328d5752SMark Fasheh break; 2661328d5752SMark Fasheh 2662328d5752SMark Fasheh ocfs2_mv_path(left_path, right_path); 2663328d5752SMark Fasheh 2664328d5752SMark Fasheh ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path, 2665328d5752SMark Fasheh &right_cpos); 2666328d5752SMark Fasheh if (ret) { 2667328d5752SMark Fasheh mlog_errno(ret); 2668328d5752SMark Fasheh goto out; 2669328d5752SMark Fasheh } 2670328d5752SMark Fasheh } 2671328d5752SMark Fasheh 2672328d5752SMark Fasheh out: 2673328d5752SMark Fasheh ocfs2_free_path(right_path); 2674328d5752SMark Fasheh ocfs2_free_path(left_path); 2675328d5752SMark Fasheh 2676328d5752SMark Fasheh return ret; 2677328d5752SMark Fasheh } 2678328d5752SMark Fasheh 2679328d5752SMark Fasheh static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle, 2680328d5752SMark Fasheh struct ocfs2_path *path, 2681e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 2682e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2683328d5752SMark Fasheh { 2684328d5752SMark Fasheh int ret, subtree_index; 2685328d5752SMark Fasheh u32 cpos; 2686328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 2687328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2688328d5752SMark Fasheh struct ocfs2_extent_list *el; 2689328d5752SMark Fasheh 2690328d5752SMark Fasheh 269135dc0aa3SJoel Becker ret = ocfs2_et_sanity_check(inode, et); 2692e7d4cb6bSTao Ma if (ret) 2693e7d4cb6bSTao Ma goto out; 2694328d5752SMark Fasheh /* 2695328d5752SMark Fasheh * There's two ways we handle this depending on 2696328d5752SMark Fasheh * whether path is the only existing one. 2697328d5752SMark Fasheh */ 2698328d5752SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, 0, 2699328d5752SMark Fasheh handle->h_buffer_credits, 2700328d5752SMark Fasheh path); 2701328d5752SMark Fasheh if (ret) { 2702328d5752SMark Fasheh mlog_errno(ret); 2703328d5752SMark Fasheh goto out; 2704328d5752SMark Fasheh } 2705328d5752SMark Fasheh 2706328d5752SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, path); 2707328d5752SMark Fasheh if (ret) { 2708328d5752SMark Fasheh mlog_errno(ret); 2709328d5752SMark Fasheh goto out; 2710328d5752SMark Fasheh } 2711328d5752SMark Fasheh 2712328d5752SMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos); 2713328d5752SMark Fasheh if (ret) { 2714328d5752SMark Fasheh mlog_errno(ret); 2715328d5752SMark Fasheh goto out; 2716328d5752SMark Fasheh } 2717328d5752SMark Fasheh 2718328d5752SMark Fasheh if (cpos) { 2719328d5752SMark Fasheh /* 2720328d5752SMark Fasheh * We have a path to the left of this one - it needs 2721328d5752SMark Fasheh * an update too. 2722328d5752SMark Fasheh */ 2723328d5752SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 2724328d5752SMark Fasheh path_root_el(path)); 2725328d5752SMark Fasheh if (!left_path) { 2726328d5752SMark Fasheh ret = -ENOMEM; 2727328d5752SMark Fasheh mlog_errno(ret); 2728328d5752SMark Fasheh goto out; 2729328d5752SMark Fasheh } 2730328d5752SMark Fasheh 2731328d5752SMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 2732328d5752SMark Fasheh if (ret) { 2733328d5752SMark Fasheh mlog_errno(ret); 2734328d5752SMark Fasheh goto out; 2735328d5752SMark Fasheh } 2736328d5752SMark Fasheh 2737328d5752SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 2738328d5752SMark Fasheh if (ret) { 2739328d5752SMark Fasheh mlog_errno(ret); 2740328d5752SMark Fasheh goto out; 2741328d5752SMark Fasheh } 2742328d5752SMark Fasheh 2743328d5752SMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, path); 2744328d5752SMark Fasheh 2745328d5752SMark Fasheh ocfs2_unlink_subtree(inode, handle, left_path, path, 2746328d5752SMark Fasheh subtree_index, dealloc); 2747328d5752SMark Fasheh ocfs2_update_edge_lengths(inode, handle, left_path); 2748328d5752SMark Fasheh 2749328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data; 275035dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno)); 2751328d5752SMark Fasheh } else { 2752328d5752SMark Fasheh /* 2753328d5752SMark Fasheh * 'path' is also the leftmost path which 2754328d5752SMark Fasheh * means it must be the only one. This gets 2755328d5752SMark Fasheh * handled differently because we want to 2756328d5752SMark Fasheh * revert the inode back to having extents 2757328d5752SMark Fasheh * in-line. 2758328d5752SMark Fasheh */ 2759328d5752SMark Fasheh ocfs2_unlink_path(inode, handle, dealloc, path, 1); 2760328d5752SMark Fasheh 2761ce1d9ea6SJoel Becker el = et->et_root_el; 2762328d5752SMark Fasheh el->l_tree_depth = 0; 2763328d5752SMark Fasheh el->l_next_free_rec = 0; 2764328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 2765328d5752SMark Fasheh 276635dc0aa3SJoel Becker ocfs2_et_set_last_eb_blk(et, 0); 2767328d5752SMark Fasheh } 2768328d5752SMark Fasheh 2769328d5752SMark Fasheh ocfs2_journal_dirty(handle, path_root_bh(path)); 2770328d5752SMark Fasheh 2771328d5752SMark Fasheh out: 2772328d5752SMark Fasheh ocfs2_free_path(left_path); 2773328d5752SMark Fasheh return ret; 2774328d5752SMark Fasheh } 2775328d5752SMark Fasheh 2776328d5752SMark Fasheh /* 2777328d5752SMark Fasheh * Left rotation of btree records. 2778328d5752SMark Fasheh * 2779328d5752SMark Fasheh * In many ways, this is (unsurprisingly) the opposite of right 2780328d5752SMark Fasheh * rotation. We start at some non-rightmost path containing an empty 2781328d5752SMark Fasheh * extent in the leaf block. The code works its way to the rightmost 2782328d5752SMark Fasheh * path by rotating records to the left in every subtree. 2783328d5752SMark Fasheh * 2784328d5752SMark Fasheh * This is used by any code which reduces the number of extent records 2785328d5752SMark Fasheh * in a leaf. After removal, an empty record should be placed in the 2786328d5752SMark Fasheh * leftmost list position. 2787328d5752SMark Fasheh * 2788328d5752SMark Fasheh * This won't handle a length update of the rightmost path records if 2789328d5752SMark Fasheh * the rightmost tree leaf record is removed so the caller is 2790328d5752SMark Fasheh * responsible for detecting and correcting that. 2791328d5752SMark Fasheh */ 2792328d5752SMark Fasheh static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle, 2793328d5752SMark Fasheh struct ocfs2_path *path, 2794e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 2795e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 2796328d5752SMark Fasheh { 2797328d5752SMark Fasheh int ret, orig_credits = handle->h_buffer_credits; 2798328d5752SMark Fasheh struct ocfs2_path *tmp_path = NULL, *restart_path = NULL; 2799328d5752SMark Fasheh struct ocfs2_extent_block *eb; 2800328d5752SMark Fasheh struct ocfs2_extent_list *el; 2801328d5752SMark Fasheh 2802328d5752SMark Fasheh el = path_leaf_el(path); 2803328d5752SMark Fasheh if (!ocfs2_is_empty_extent(&el->l_recs[0])) 2804328d5752SMark Fasheh return 0; 2805328d5752SMark Fasheh 2806328d5752SMark Fasheh if (path->p_tree_depth == 0) { 2807328d5752SMark Fasheh rightmost_no_delete: 2808328d5752SMark Fasheh /* 2809e7d4cb6bSTao Ma * Inline extents. This is trivially handled, so do 2810328d5752SMark Fasheh * it up front. 2811328d5752SMark Fasheh */ 2812328d5752SMark Fasheh ret = ocfs2_rotate_rightmost_leaf_left(inode, handle, 2813328d5752SMark Fasheh path_leaf_bh(path), 2814328d5752SMark Fasheh path_leaf_el(path)); 2815328d5752SMark Fasheh if (ret) 2816328d5752SMark Fasheh mlog_errno(ret); 2817328d5752SMark Fasheh goto out; 2818328d5752SMark Fasheh } 2819328d5752SMark Fasheh 2820328d5752SMark Fasheh /* 2821328d5752SMark Fasheh * Handle rightmost branch now. There's several cases: 2822328d5752SMark Fasheh * 1) simple rotation leaving records in there. That's trivial. 2823328d5752SMark Fasheh * 2) rotation requiring a branch delete - there's no more 2824328d5752SMark Fasheh * records left. Two cases of this: 2825328d5752SMark Fasheh * a) There are branches to the left. 2826328d5752SMark Fasheh * b) This is also the leftmost (the only) branch. 2827328d5752SMark Fasheh * 2828328d5752SMark Fasheh * 1) is handled via ocfs2_rotate_rightmost_leaf_left() 2829328d5752SMark Fasheh * 2a) we need the left branch so that we can update it with the unlink 2830328d5752SMark Fasheh * 2b) we need to bring the inode back to inline extents. 2831328d5752SMark Fasheh */ 2832328d5752SMark Fasheh 2833328d5752SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 2834328d5752SMark Fasheh el = &eb->h_list; 2835328d5752SMark Fasheh if (eb->h_next_leaf_blk == 0) { 2836328d5752SMark Fasheh /* 2837328d5752SMark Fasheh * This gets a bit tricky if we're going to delete the 2838328d5752SMark Fasheh * rightmost path. Get the other cases out of the way 2839328d5752SMark Fasheh * 1st. 2840328d5752SMark Fasheh */ 2841328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) > 1) 2842328d5752SMark Fasheh goto rightmost_no_delete; 2843328d5752SMark Fasheh 2844328d5752SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 2845328d5752SMark Fasheh ret = -EIO; 2846328d5752SMark Fasheh ocfs2_error(inode->i_sb, 2847328d5752SMark Fasheh "Inode %llu has empty extent block at %llu", 2848328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 2849328d5752SMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno)); 2850328d5752SMark Fasheh goto out; 2851328d5752SMark Fasheh } 2852328d5752SMark Fasheh 2853328d5752SMark Fasheh /* 2854328d5752SMark Fasheh * XXX: The caller can not trust "path" any more after 2855328d5752SMark Fasheh * this as it will have been deleted. What do we do? 2856328d5752SMark Fasheh * 2857328d5752SMark Fasheh * In theory the rotate-for-merge code will never get 2858328d5752SMark Fasheh * here because it'll always ask for a rotate in a 2859328d5752SMark Fasheh * nonempty list. 2860328d5752SMark Fasheh */ 2861328d5752SMark Fasheh 2862328d5752SMark Fasheh ret = ocfs2_remove_rightmost_path(inode, handle, path, 2863e7d4cb6bSTao Ma dealloc, et); 2864328d5752SMark Fasheh if (ret) 2865328d5752SMark Fasheh mlog_errno(ret); 2866328d5752SMark Fasheh goto out; 2867328d5752SMark Fasheh } 2868328d5752SMark Fasheh 2869328d5752SMark Fasheh /* 2870328d5752SMark Fasheh * Now we can loop, remembering the path we get from -EAGAIN 2871328d5752SMark Fasheh * and restarting from there. 2872328d5752SMark Fasheh */ 2873328d5752SMark Fasheh try_rotate: 2874328d5752SMark Fasheh ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path, 2875e7d4cb6bSTao Ma dealloc, &restart_path, et); 2876328d5752SMark Fasheh if (ret && ret != -EAGAIN) { 2877328d5752SMark Fasheh mlog_errno(ret); 2878328d5752SMark Fasheh goto out; 2879328d5752SMark Fasheh } 2880328d5752SMark Fasheh 2881328d5752SMark Fasheh while (ret == -EAGAIN) { 2882328d5752SMark Fasheh tmp_path = restart_path; 2883328d5752SMark Fasheh restart_path = NULL; 2884328d5752SMark Fasheh 2885328d5752SMark Fasheh ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, 2886328d5752SMark Fasheh tmp_path, dealloc, 2887e7d4cb6bSTao Ma &restart_path, et); 2888328d5752SMark Fasheh if (ret && ret != -EAGAIN) { 2889328d5752SMark Fasheh mlog_errno(ret); 2890328d5752SMark Fasheh goto out; 2891328d5752SMark Fasheh } 2892328d5752SMark Fasheh 2893328d5752SMark Fasheh ocfs2_free_path(tmp_path); 2894328d5752SMark Fasheh tmp_path = NULL; 2895328d5752SMark Fasheh 2896328d5752SMark Fasheh if (ret == 0) 2897328d5752SMark Fasheh goto try_rotate; 2898328d5752SMark Fasheh } 2899328d5752SMark Fasheh 2900328d5752SMark Fasheh out: 2901328d5752SMark Fasheh ocfs2_free_path(tmp_path); 2902328d5752SMark Fasheh ocfs2_free_path(restart_path); 2903328d5752SMark Fasheh return ret; 2904328d5752SMark Fasheh } 2905328d5752SMark Fasheh 2906328d5752SMark Fasheh static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el, 2907328d5752SMark Fasheh int index) 2908328d5752SMark Fasheh { 2909328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[index]; 2910328d5752SMark Fasheh unsigned int size; 2911328d5752SMark Fasheh 2912328d5752SMark Fasheh if (rec->e_leaf_clusters == 0) { 2913328d5752SMark Fasheh /* 2914328d5752SMark Fasheh * We consumed all of the merged-from record. An empty 2915328d5752SMark Fasheh * extent cannot exist anywhere but the 1st array 2916328d5752SMark Fasheh * position, so move things over if the merged-from 2917328d5752SMark Fasheh * record doesn't occupy that position. 2918328d5752SMark Fasheh * 2919328d5752SMark Fasheh * This creates a new empty extent so the caller 2920328d5752SMark Fasheh * should be smart enough to have removed any existing 2921328d5752SMark Fasheh * ones. 2922328d5752SMark Fasheh */ 2923328d5752SMark Fasheh if (index > 0) { 2924328d5752SMark Fasheh BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0])); 2925328d5752SMark Fasheh size = index * sizeof(struct ocfs2_extent_rec); 2926328d5752SMark Fasheh memmove(&el->l_recs[1], &el->l_recs[0], size); 2927328d5752SMark Fasheh } 2928328d5752SMark Fasheh 2929328d5752SMark Fasheh /* 2930328d5752SMark Fasheh * Always memset - the caller doesn't check whether it 2931328d5752SMark Fasheh * created an empty extent, so there could be junk in 2932328d5752SMark Fasheh * the other fields. 2933328d5752SMark Fasheh */ 2934328d5752SMark Fasheh memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec)); 2935328d5752SMark Fasheh } 2936328d5752SMark Fasheh } 2937328d5752SMark Fasheh 2938677b9752STao Ma static int ocfs2_get_right_path(struct inode *inode, 2939677b9752STao Ma struct ocfs2_path *left_path, 2940677b9752STao Ma struct ocfs2_path **ret_right_path) 2941328d5752SMark Fasheh { 2942328d5752SMark Fasheh int ret; 2943677b9752STao Ma u32 right_cpos; 2944677b9752STao Ma struct ocfs2_path *right_path = NULL; 2945677b9752STao Ma struct ocfs2_extent_list *left_el; 2946677b9752STao Ma 2947677b9752STao Ma *ret_right_path = NULL; 2948677b9752STao Ma 2949677b9752STao Ma /* This function shouldn't be called for non-trees. */ 2950677b9752STao Ma BUG_ON(left_path->p_tree_depth == 0); 2951677b9752STao Ma 2952677b9752STao Ma left_el = path_leaf_el(left_path); 2953677b9752STao Ma BUG_ON(left_el->l_next_free_rec != left_el->l_count); 2954677b9752STao Ma 2955677b9752STao Ma ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path, 2956677b9752STao Ma &right_cpos); 2957677b9752STao Ma if (ret) { 2958677b9752STao Ma mlog_errno(ret); 2959677b9752STao Ma goto out; 2960677b9752STao Ma } 2961677b9752STao Ma 2962677b9752STao Ma /* This function shouldn't be called for the rightmost leaf. */ 2963677b9752STao Ma BUG_ON(right_cpos == 0); 2964677b9752STao Ma 2965677b9752STao Ma right_path = ocfs2_new_path(path_root_bh(left_path), 2966677b9752STao Ma path_root_el(left_path)); 2967677b9752STao Ma if (!right_path) { 2968677b9752STao Ma ret = -ENOMEM; 2969677b9752STao Ma mlog_errno(ret); 2970677b9752STao Ma goto out; 2971677b9752STao Ma } 2972677b9752STao Ma 2973677b9752STao Ma ret = ocfs2_find_path(inode, right_path, right_cpos); 2974677b9752STao Ma if (ret) { 2975677b9752STao Ma mlog_errno(ret); 2976677b9752STao Ma goto out; 2977677b9752STao Ma } 2978677b9752STao Ma 2979677b9752STao Ma *ret_right_path = right_path; 2980677b9752STao Ma out: 2981677b9752STao Ma if (ret) 2982677b9752STao Ma ocfs2_free_path(right_path); 2983677b9752STao Ma return ret; 2984677b9752STao Ma } 2985677b9752STao Ma 2986677b9752STao Ma /* 2987677b9752STao Ma * Remove split_rec clusters from the record at index and merge them 2988677b9752STao Ma * onto the beginning of the record "next" to it. 2989677b9752STao Ma * For index < l_count - 1, the next means the extent rec at index + 1. 2990677b9752STao Ma * For index == l_count - 1, the "next" means the 1st extent rec of the 2991677b9752STao Ma * next extent block. 2992677b9752STao Ma */ 2993677b9752STao Ma static int ocfs2_merge_rec_right(struct inode *inode, 2994677b9752STao Ma struct ocfs2_path *left_path, 2995677b9752STao Ma handle_t *handle, 2996677b9752STao Ma struct ocfs2_extent_rec *split_rec, 2997677b9752STao Ma int index) 2998677b9752STao Ma { 2999677b9752STao Ma int ret, next_free, i; 3000328d5752SMark Fasheh unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters); 3001328d5752SMark Fasheh struct ocfs2_extent_rec *left_rec; 3002328d5752SMark Fasheh struct ocfs2_extent_rec *right_rec; 3003677b9752STao Ma struct ocfs2_extent_list *right_el; 3004677b9752STao Ma struct ocfs2_path *right_path = NULL; 3005677b9752STao Ma int subtree_index = 0; 3006677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(left_path); 3007677b9752STao Ma struct buffer_head *bh = path_leaf_bh(left_path); 3008677b9752STao Ma struct buffer_head *root_bh = NULL; 3009328d5752SMark Fasheh 3010328d5752SMark Fasheh BUG_ON(index >= le16_to_cpu(el->l_next_free_rec)); 3011328d5752SMark Fasheh left_rec = &el->l_recs[index]; 3012677b9752STao Ma 30139d8df6aaSAl Viro if (index == le16_to_cpu(el->l_next_free_rec) - 1 && 3014677b9752STao Ma le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) { 3015677b9752STao Ma /* we meet with a cross extent block merge. */ 3016677b9752STao Ma ret = ocfs2_get_right_path(inode, left_path, &right_path); 3017677b9752STao Ma if (ret) { 3018677b9752STao Ma mlog_errno(ret); 3019677b9752STao Ma goto out; 3020677b9752STao Ma } 3021677b9752STao Ma 3022677b9752STao Ma right_el = path_leaf_el(right_path); 3023677b9752STao Ma next_free = le16_to_cpu(right_el->l_next_free_rec); 3024677b9752STao Ma BUG_ON(next_free <= 0); 3025677b9752STao Ma right_rec = &right_el->l_recs[0]; 3026677b9752STao Ma if (ocfs2_is_empty_extent(right_rec)) { 30279d8df6aaSAl Viro BUG_ON(next_free <= 1); 3028677b9752STao Ma right_rec = &right_el->l_recs[1]; 3029677b9752STao Ma } 3030677b9752STao Ma 3031677b9752STao Ma BUG_ON(le32_to_cpu(left_rec->e_cpos) + 3032677b9752STao Ma le16_to_cpu(left_rec->e_leaf_clusters) != 3033677b9752STao Ma le32_to_cpu(right_rec->e_cpos)); 3034677b9752STao Ma 3035677b9752STao Ma subtree_index = ocfs2_find_subtree_root(inode, 3036677b9752STao Ma left_path, right_path); 3037677b9752STao Ma 3038677b9752STao Ma ret = ocfs2_extend_rotate_transaction(handle, subtree_index, 3039677b9752STao Ma handle->h_buffer_credits, 3040677b9752STao Ma right_path); 3041677b9752STao Ma if (ret) { 3042677b9752STao Ma mlog_errno(ret); 3043677b9752STao Ma goto out; 3044677b9752STao Ma } 3045677b9752STao Ma 3046677b9752STao Ma root_bh = left_path->p_node[subtree_index].bh; 3047677b9752STao Ma BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 3048677b9752STao Ma 3049677b9752STao Ma ret = ocfs2_journal_access(handle, inode, root_bh, 3050677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3051677b9752STao Ma if (ret) { 3052677b9752STao Ma mlog_errno(ret); 3053677b9752STao Ma goto out; 3054677b9752STao Ma } 3055677b9752STao Ma 3056677b9752STao Ma for (i = subtree_index + 1; 3057677b9752STao Ma i < path_num_items(right_path); i++) { 3058677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3059677b9752STao Ma right_path->p_node[i].bh, 3060677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3061677b9752STao Ma if (ret) { 3062677b9752STao Ma mlog_errno(ret); 3063677b9752STao Ma goto out; 3064677b9752STao Ma } 3065677b9752STao Ma 3066677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3067677b9752STao Ma left_path->p_node[i].bh, 3068677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3069677b9752STao Ma if (ret) { 3070677b9752STao Ma mlog_errno(ret); 3071677b9752STao Ma goto out; 3072677b9752STao Ma } 3073677b9752STao Ma } 3074677b9752STao Ma 3075677b9752STao Ma } else { 3076677b9752STao Ma BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1); 3077328d5752SMark Fasheh right_rec = &el->l_recs[index + 1]; 3078677b9752STao Ma } 3079328d5752SMark Fasheh 3080328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 3081328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3082328d5752SMark Fasheh if (ret) { 3083328d5752SMark Fasheh mlog_errno(ret); 3084328d5752SMark Fasheh goto out; 3085328d5752SMark Fasheh } 3086328d5752SMark Fasheh 3087328d5752SMark Fasheh le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters); 3088328d5752SMark Fasheh 3089328d5752SMark Fasheh le32_add_cpu(&right_rec->e_cpos, -split_clusters); 3090328d5752SMark Fasheh le64_add_cpu(&right_rec->e_blkno, 3091328d5752SMark Fasheh -ocfs2_clusters_to_blocks(inode->i_sb, split_clusters)); 3092328d5752SMark Fasheh le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters); 3093328d5752SMark Fasheh 3094328d5752SMark Fasheh ocfs2_cleanup_merge(el, index); 3095328d5752SMark Fasheh 3096328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3097328d5752SMark Fasheh if (ret) 3098328d5752SMark Fasheh mlog_errno(ret); 3099328d5752SMark Fasheh 3100677b9752STao Ma if (right_path) { 3101677b9752STao Ma ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path)); 3102677b9752STao Ma if (ret) 3103677b9752STao Ma mlog_errno(ret); 3104677b9752STao Ma 3105677b9752STao Ma ocfs2_complete_edge_insert(inode, handle, left_path, 3106677b9752STao Ma right_path, subtree_index); 3107677b9752STao Ma } 3108328d5752SMark Fasheh out: 3109677b9752STao Ma if (right_path) 3110677b9752STao Ma ocfs2_free_path(right_path); 3111677b9752STao Ma return ret; 3112677b9752STao Ma } 3113677b9752STao Ma 3114677b9752STao Ma static int ocfs2_get_left_path(struct inode *inode, 3115677b9752STao Ma struct ocfs2_path *right_path, 3116677b9752STao Ma struct ocfs2_path **ret_left_path) 3117677b9752STao Ma { 3118677b9752STao Ma int ret; 3119677b9752STao Ma u32 left_cpos; 3120677b9752STao Ma struct ocfs2_path *left_path = NULL; 3121677b9752STao Ma 3122677b9752STao Ma *ret_left_path = NULL; 3123677b9752STao Ma 3124677b9752STao Ma /* This function shouldn't be called for non-trees. */ 3125677b9752STao Ma BUG_ON(right_path->p_tree_depth == 0); 3126677b9752STao Ma 3127677b9752STao Ma ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, 3128677b9752STao Ma right_path, &left_cpos); 3129677b9752STao Ma if (ret) { 3130677b9752STao Ma mlog_errno(ret); 3131677b9752STao Ma goto out; 3132677b9752STao Ma } 3133677b9752STao Ma 3134677b9752STao Ma /* This function shouldn't be called for the leftmost leaf. */ 3135677b9752STao Ma BUG_ON(left_cpos == 0); 3136677b9752STao Ma 3137677b9752STao Ma left_path = ocfs2_new_path(path_root_bh(right_path), 3138677b9752STao Ma path_root_el(right_path)); 3139677b9752STao Ma if (!left_path) { 3140677b9752STao Ma ret = -ENOMEM; 3141677b9752STao Ma mlog_errno(ret); 3142677b9752STao Ma goto out; 3143677b9752STao Ma } 3144677b9752STao Ma 3145677b9752STao Ma ret = ocfs2_find_path(inode, left_path, left_cpos); 3146677b9752STao Ma if (ret) { 3147677b9752STao Ma mlog_errno(ret); 3148677b9752STao Ma goto out; 3149677b9752STao Ma } 3150677b9752STao Ma 3151677b9752STao Ma *ret_left_path = left_path; 3152677b9752STao Ma out: 3153677b9752STao Ma if (ret) 3154677b9752STao Ma ocfs2_free_path(left_path); 3155328d5752SMark Fasheh return ret; 3156328d5752SMark Fasheh } 3157328d5752SMark Fasheh 3158328d5752SMark Fasheh /* 3159328d5752SMark Fasheh * Remove split_rec clusters from the record at index and merge them 3160677b9752STao Ma * onto the tail of the record "before" it. 3161677b9752STao Ma * For index > 0, the "before" means the extent rec at index - 1. 3162677b9752STao Ma * 3163677b9752STao Ma * For index == 0, the "before" means the last record of the previous 3164677b9752STao Ma * extent block. And there is also a situation that we may need to 3165677b9752STao Ma * remove the rightmost leaf extent block in the right_path and change 3166677b9752STao Ma * the right path to indicate the new rightmost path. 3167328d5752SMark Fasheh */ 3168677b9752STao Ma static int ocfs2_merge_rec_left(struct inode *inode, 3169677b9752STao Ma struct ocfs2_path *right_path, 3170328d5752SMark Fasheh handle_t *handle, 3171328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3172677b9752STao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 3173e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 3174677b9752STao Ma int index) 3175328d5752SMark Fasheh { 3176677b9752STao Ma int ret, i, subtree_index = 0, has_empty_extent = 0; 3177328d5752SMark Fasheh unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters); 3178328d5752SMark Fasheh struct ocfs2_extent_rec *left_rec; 3179328d5752SMark Fasheh struct ocfs2_extent_rec *right_rec; 3180677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(right_path); 3181677b9752STao Ma struct buffer_head *bh = path_leaf_bh(right_path); 3182677b9752STao Ma struct buffer_head *root_bh = NULL; 3183677b9752STao Ma struct ocfs2_path *left_path = NULL; 3184677b9752STao Ma struct ocfs2_extent_list *left_el; 3185328d5752SMark Fasheh 3186677b9752STao Ma BUG_ON(index < 0); 3187328d5752SMark Fasheh 3188328d5752SMark Fasheh right_rec = &el->l_recs[index]; 3189677b9752STao Ma if (index == 0) { 3190677b9752STao Ma /* we meet with a cross extent block merge. */ 3191677b9752STao Ma ret = ocfs2_get_left_path(inode, right_path, &left_path); 3192677b9752STao Ma if (ret) { 3193677b9752STao Ma mlog_errno(ret); 3194677b9752STao Ma goto out; 3195677b9752STao Ma } 3196677b9752STao Ma 3197677b9752STao Ma left_el = path_leaf_el(left_path); 3198677b9752STao Ma BUG_ON(le16_to_cpu(left_el->l_next_free_rec) != 3199677b9752STao Ma le16_to_cpu(left_el->l_count)); 3200677b9752STao Ma 3201677b9752STao Ma left_rec = &left_el->l_recs[ 3202677b9752STao Ma le16_to_cpu(left_el->l_next_free_rec) - 1]; 3203677b9752STao Ma BUG_ON(le32_to_cpu(left_rec->e_cpos) + 3204677b9752STao Ma le16_to_cpu(left_rec->e_leaf_clusters) != 3205677b9752STao Ma le32_to_cpu(split_rec->e_cpos)); 3206677b9752STao Ma 3207677b9752STao Ma subtree_index = ocfs2_find_subtree_root(inode, 3208677b9752STao Ma left_path, right_path); 3209677b9752STao Ma 3210677b9752STao Ma ret = ocfs2_extend_rotate_transaction(handle, subtree_index, 3211677b9752STao Ma handle->h_buffer_credits, 3212677b9752STao Ma left_path); 3213677b9752STao Ma if (ret) { 3214677b9752STao Ma mlog_errno(ret); 3215677b9752STao Ma goto out; 3216677b9752STao Ma } 3217677b9752STao Ma 3218677b9752STao Ma root_bh = left_path->p_node[subtree_index].bh; 3219677b9752STao Ma BUG_ON(root_bh != right_path->p_node[subtree_index].bh); 3220677b9752STao Ma 3221677b9752STao Ma ret = ocfs2_journal_access(handle, inode, root_bh, 3222677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3223677b9752STao Ma if (ret) { 3224677b9752STao Ma mlog_errno(ret); 3225677b9752STao Ma goto out; 3226677b9752STao Ma } 3227677b9752STao Ma 3228677b9752STao Ma for (i = subtree_index + 1; 3229677b9752STao Ma i < path_num_items(right_path); i++) { 3230677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3231677b9752STao Ma right_path->p_node[i].bh, 3232677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3233677b9752STao Ma if (ret) { 3234677b9752STao Ma mlog_errno(ret); 3235677b9752STao Ma goto out; 3236677b9752STao Ma } 3237677b9752STao Ma 3238677b9752STao Ma ret = ocfs2_journal_access(handle, inode, 3239677b9752STao Ma left_path->p_node[i].bh, 3240677b9752STao Ma OCFS2_JOURNAL_ACCESS_WRITE); 3241677b9752STao Ma if (ret) { 3242677b9752STao Ma mlog_errno(ret); 3243677b9752STao Ma goto out; 3244677b9752STao Ma } 3245677b9752STao Ma } 3246677b9752STao Ma } else { 3247677b9752STao Ma left_rec = &el->l_recs[index - 1]; 3248328d5752SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) 3249328d5752SMark Fasheh has_empty_extent = 1; 3250677b9752STao Ma } 3251328d5752SMark Fasheh 3252328d5752SMark Fasheh ret = ocfs2_journal_access(handle, inode, bh, 3253328d5752SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3254328d5752SMark Fasheh if (ret) { 3255328d5752SMark Fasheh mlog_errno(ret); 3256328d5752SMark Fasheh goto out; 3257328d5752SMark Fasheh } 3258328d5752SMark Fasheh 3259328d5752SMark Fasheh if (has_empty_extent && index == 1) { 3260328d5752SMark Fasheh /* 3261328d5752SMark Fasheh * The easy case - we can just plop the record right in. 3262328d5752SMark Fasheh */ 3263328d5752SMark Fasheh *left_rec = *split_rec; 3264328d5752SMark Fasheh 3265328d5752SMark Fasheh has_empty_extent = 0; 3266677b9752STao Ma } else 3267328d5752SMark Fasheh le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters); 3268328d5752SMark Fasheh 3269328d5752SMark Fasheh le32_add_cpu(&right_rec->e_cpos, split_clusters); 3270328d5752SMark Fasheh le64_add_cpu(&right_rec->e_blkno, 3271328d5752SMark Fasheh ocfs2_clusters_to_blocks(inode->i_sb, split_clusters)); 3272328d5752SMark Fasheh le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters); 3273328d5752SMark Fasheh 3274328d5752SMark Fasheh ocfs2_cleanup_merge(el, index); 3275328d5752SMark Fasheh 3276328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3277328d5752SMark Fasheh if (ret) 3278328d5752SMark Fasheh mlog_errno(ret); 3279328d5752SMark Fasheh 3280677b9752STao Ma if (left_path) { 3281677b9752STao Ma ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path)); 3282677b9752STao Ma if (ret) 3283677b9752STao Ma mlog_errno(ret); 3284677b9752STao Ma 3285677b9752STao Ma /* 3286677b9752STao Ma * In the situation that the right_rec is empty and the extent 3287677b9752STao Ma * block is empty also, ocfs2_complete_edge_insert can't handle 3288677b9752STao Ma * it and we need to delete the right extent block. 3289677b9752STao Ma */ 3290677b9752STao Ma if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 && 3291677b9752STao Ma le16_to_cpu(el->l_next_free_rec) == 1) { 3292677b9752STao Ma 3293677b9752STao Ma ret = ocfs2_remove_rightmost_path(inode, handle, 3294e7d4cb6bSTao Ma right_path, 3295e7d4cb6bSTao Ma dealloc, et); 3296677b9752STao Ma if (ret) { 3297677b9752STao Ma mlog_errno(ret); 3298677b9752STao Ma goto out; 3299677b9752STao Ma } 3300677b9752STao Ma 3301677b9752STao Ma /* Now the rightmost extent block has been deleted. 3302677b9752STao Ma * So we use the new rightmost path. 3303677b9752STao Ma */ 3304677b9752STao Ma ocfs2_mv_path(right_path, left_path); 3305677b9752STao Ma left_path = NULL; 3306677b9752STao Ma } else 3307677b9752STao Ma ocfs2_complete_edge_insert(inode, handle, left_path, 3308677b9752STao Ma right_path, subtree_index); 3309677b9752STao Ma } 3310328d5752SMark Fasheh out: 3311677b9752STao Ma if (left_path) 3312677b9752STao Ma ocfs2_free_path(left_path); 3313328d5752SMark Fasheh return ret; 3314328d5752SMark Fasheh } 3315328d5752SMark Fasheh 3316328d5752SMark Fasheh static int ocfs2_try_to_merge_extent(struct inode *inode, 3317328d5752SMark Fasheh handle_t *handle, 3318677b9752STao Ma struct ocfs2_path *path, 3319328d5752SMark Fasheh int split_index, 3320328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3321328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 3322e7d4cb6bSTao Ma struct ocfs2_merge_ctxt *ctxt, 3323e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 3324328d5752SMark Fasheh 3325328d5752SMark Fasheh { 3326518d7269STao Mao int ret = 0; 3327677b9752STao Ma struct ocfs2_extent_list *el = path_leaf_el(path); 3328328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[split_index]; 3329328d5752SMark Fasheh 3330328d5752SMark Fasheh BUG_ON(ctxt->c_contig_type == CONTIG_NONE); 3331328d5752SMark Fasheh 3332518d7269STao Mao if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) { 3333328d5752SMark Fasheh /* 3334328d5752SMark Fasheh * The merge code will need to create an empty 3335328d5752SMark Fasheh * extent to take the place of the newly 3336328d5752SMark Fasheh * emptied slot. Remove any pre-existing empty 3337328d5752SMark Fasheh * extents - having more than one in a leaf is 3338328d5752SMark Fasheh * illegal. 3339328d5752SMark Fasheh */ 3340677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3341e7d4cb6bSTao Ma dealloc, et); 3342328d5752SMark Fasheh if (ret) { 3343328d5752SMark Fasheh mlog_errno(ret); 3344328d5752SMark Fasheh goto out; 3345328d5752SMark Fasheh } 3346328d5752SMark Fasheh split_index--; 3347328d5752SMark Fasheh rec = &el->l_recs[split_index]; 3348328d5752SMark Fasheh } 3349328d5752SMark Fasheh 3350328d5752SMark Fasheh if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) { 3351328d5752SMark Fasheh /* 3352328d5752SMark Fasheh * Left-right contig implies this. 3353328d5752SMark Fasheh */ 3354328d5752SMark Fasheh BUG_ON(!ctxt->c_split_covers_rec); 3355328d5752SMark Fasheh 3356328d5752SMark Fasheh /* 3357328d5752SMark Fasheh * Since the leftright insert always covers the entire 3358328d5752SMark Fasheh * extent, this call will delete the insert record 3359328d5752SMark Fasheh * entirely, resulting in an empty extent record added to 3360328d5752SMark Fasheh * the extent block. 3361328d5752SMark Fasheh * 3362328d5752SMark Fasheh * Since the adding of an empty extent shifts 3363328d5752SMark Fasheh * everything back to the right, there's no need to 3364328d5752SMark Fasheh * update split_index here. 3365677b9752STao Ma * 3366677b9752STao Ma * When the split_index is zero, we need to merge it to the 3367677b9752STao Ma * prevoius extent block. It is more efficient and easier 3368677b9752STao Ma * if we do merge_right first and merge_left later. 3369328d5752SMark Fasheh */ 3370677b9752STao Ma ret = ocfs2_merge_rec_right(inode, path, 3371677b9752STao Ma handle, split_rec, 3372677b9752STao Ma split_index); 3373328d5752SMark Fasheh if (ret) { 3374328d5752SMark Fasheh mlog_errno(ret); 3375328d5752SMark Fasheh goto out; 3376328d5752SMark Fasheh } 3377328d5752SMark Fasheh 3378328d5752SMark Fasheh /* 3379328d5752SMark Fasheh * We can only get this from logic error above. 3380328d5752SMark Fasheh */ 3381328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0])); 3382328d5752SMark Fasheh 3383677b9752STao Ma /* The merge left us with an empty extent, remove it. */ 3384e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3385e7d4cb6bSTao Ma dealloc, et); 3386328d5752SMark Fasheh if (ret) { 3387328d5752SMark Fasheh mlog_errno(ret); 3388328d5752SMark Fasheh goto out; 3389328d5752SMark Fasheh } 3390677b9752STao Ma 3391328d5752SMark Fasheh rec = &el->l_recs[split_index]; 3392328d5752SMark Fasheh 3393328d5752SMark Fasheh /* 3394328d5752SMark Fasheh * Note that we don't pass split_rec here on purpose - 3395677b9752STao Ma * we've merged it into the rec already. 3396328d5752SMark Fasheh */ 3397677b9752STao Ma ret = ocfs2_merge_rec_left(inode, path, 3398677b9752STao Ma handle, rec, 3399e7d4cb6bSTao Ma dealloc, et, 3400677b9752STao Ma split_index); 3401677b9752STao Ma 3402328d5752SMark Fasheh if (ret) { 3403328d5752SMark Fasheh mlog_errno(ret); 3404328d5752SMark Fasheh goto out; 3405328d5752SMark Fasheh } 3406328d5752SMark Fasheh 3407677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3408e7d4cb6bSTao Ma dealloc, et); 3409328d5752SMark Fasheh /* 3410328d5752SMark Fasheh * Error from this last rotate is not critical, so 3411328d5752SMark Fasheh * print but don't bubble it up. 3412328d5752SMark Fasheh */ 3413328d5752SMark Fasheh if (ret) 3414328d5752SMark Fasheh mlog_errno(ret); 3415328d5752SMark Fasheh ret = 0; 3416328d5752SMark Fasheh } else { 3417328d5752SMark Fasheh /* 3418328d5752SMark Fasheh * Merge a record to the left or right. 3419328d5752SMark Fasheh * 3420328d5752SMark Fasheh * 'contig_type' is relative to the existing record, 3421328d5752SMark Fasheh * so for example, if we're "right contig", it's to 3422328d5752SMark Fasheh * the record on the left (hence the left merge). 3423328d5752SMark Fasheh */ 3424328d5752SMark Fasheh if (ctxt->c_contig_type == CONTIG_RIGHT) { 3425328d5752SMark Fasheh ret = ocfs2_merge_rec_left(inode, 3426677b9752STao Ma path, 3427677b9752STao Ma handle, split_rec, 3428e7d4cb6bSTao Ma dealloc, et, 3429328d5752SMark Fasheh split_index); 3430328d5752SMark Fasheh if (ret) { 3431328d5752SMark Fasheh mlog_errno(ret); 3432328d5752SMark Fasheh goto out; 3433328d5752SMark Fasheh } 3434328d5752SMark Fasheh } else { 3435328d5752SMark Fasheh ret = ocfs2_merge_rec_right(inode, 3436677b9752STao Ma path, 3437677b9752STao Ma handle, split_rec, 3438328d5752SMark Fasheh split_index); 3439328d5752SMark Fasheh if (ret) { 3440328d5752SMark Fasheh mlog_errno(ret); 3441328d5752SMark Fasheh goto out; 3442328d5752SMark Fasheh } 3443328d5752SMark Fasheh } 3444328d5752SMark Fasheh 3445328d5752SMark Fasheh if (ctxt->c_split_covers_rec) { 3446328d5752SMark Fasheh /* 3447328d5752SMark Fasheh * The merge may have left an empty extent in 3448328d5752SMark Fasheh * our leaf. Try to rotate it away. 3449328d5752SMark Fasheh */ 3450677b9752STao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, 3451e7d4cb6bSTao Ma dealloc, et); 3452328d5752SMark Fasheh if (ret) 3453328d5752SMark Fasheh mlog_errno(ret); 3454328d5752SMark Fasheh ret = 0; 3455328d5752SMark Fasheh } 3456328d5752SMark Fasheh } 3457328d5752SMark Fasheh 3458328d5752SMark Fasheh out: 3459328d5752SMark Fasheh return ret; 3460328d5752SMark Fasheh } 3461328d5752SMark Fasheh 3462328d5752SMark Fasheh static void ocfs2_subtract_from_rec(struct super_block *sb, 3463328d5752SMark Fasheh enum ocfs2_split_type split, 3464328d5752SMark Fasheh struct ocfs2_extent_rec *rec, 3465328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec) 3466328d5752SMark Fasheh { 3467328d5752SMark Fasheh u64 len_blocks; 3468328d5752SMark Fasheh 3469328d5752SMark Fasheh len_blocks = ocfs2_clusters_to_blocks(sb, 3470328d5752SMark Fasheh le16_to_cpu(split_rec->e_leaf_clusters)); 3471328d5752SMark Fasheh 3472328d5752SMark Fasheh if (split == SPLIT_LEFT) { 3473328d5752SMark Fasheh /* 3474328d5752SMark Fasheh * Region is on the left edge of the existing 3475328d5752SMark Fasheh * record. 3476328d5752SMark Fasheh */ 3477328d5752SMark Fasheh le32_add_cpu(&rec->e_cpos, 3478328d5752SMark Fasheh le16_to_cpu(split_rec->e_leaf_clusters)); 3479328d5752SMark Fasheh le64_add_cpu(&rec->e_blkno, len_blocks); 3480328d5752SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3481328d5752SMark Fasheh -le16_to_cpu(split_rec->e_leaf_clusters)); 3482328d5752SMark Fasheh } else { 3483328d5752SMark Fasheh /* 3484328d5752SMark Fasheh * Region is on the right edge of the existing 3485328d5752SMark Fasheh * record. 3486328d5752SMark Fasheh */ 3487328d5752SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3488328d5752SMark Fasheh -le16_to_cpu(split_rec->e_leaf_clusters)); 3489328d5752SMark Fasheh } 3490328d5752SMark Fasheh } 3491328d5752SMark Fasheh 3492dcd0538fSMark Fasheh /* 3493dcd0538fSMark Fasheh * Do the final bits of extent record insertion at the target leaf 3494dcd0538fSMark Fasheh * list. If this leaf is part of an allocation tree, it is assumed 3495dcd0538fSMark Fasheh * that the tree above has been prepared. 3496dcd0538fSMark Fasheh */ 3497dcd0538fSMark Fasheh static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec, 3498dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 3499dcd0538fSMark Fasheh struct ocfs2_insert_type *insert, 3500dcd0538fSMark Fasheh struct inode *inode) 3501dcd0538fSMark Fasheh { 3502dcd0538fSMark Fasheh int i = insert->ins_contig_index; 3503dcd0538fSMark Fasheh unsigned int range; 3504dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 3505dcd0538fSMark Fasheh 3506e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 3507dcd0538fSMark Fasheh 3508328d5752SMark Fasheh if (insert->ins_split != SPLIT_NONE) { 3509328d5752SMark Fasheh i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos)); 3510328d5752SMark Fasheh BUG_ON(i == -1); 3511328d5752SMark Fasheh rec = &el->l_recs[i]; 3512328d5752SMark Fasheh ocfs2_subtract_from_rec(inode->i_sb, insert->ins_split, rec, 3513328d5752SMark Fasheh insert_rec); 3514328d5752SMark Fasheh goto rotate; 3515328d5752SMark Fasheh } 3516328d5752SMark Fasheh 3517dcd0538fSMark Fasheh /* 3518dcd0538fSMark Fasheh * Contiguous insert - either left or right. 3519dcd0538fSMark Fasheh */ 3520dcd0538fSMark Fasheh if (insert->ins_contig != CONTIG_NONE) { 3521dcd0538fSMark Fasheh rec = &el->l_recs[i]; 3522dcd0538fSMark Fasheh if (insert->ins_contig == CONTIG_LEFT) { 3523dcd0538fSMark Fasheh rec->e_blkno = insert_rec->e_blkno; 3524dcd0538fSMark Fasheh rec->e_cpos = insert_rec->e_cpos; 3525dcd0538fSMark Fasheh } 3526e48edee2SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, 3527e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3528dcd0538fSMark Fasheh return; 3529dcd0538fSMark Fasheh } 3530dcd0538fSMark Fasheh 3531dcd0538fSMark Fasheh /* 3532dcd0538fSMark Fasheh * Handle insert into an empty leaf. 3533dcd0538fSMark Fasheh */ 3534dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0 || 3535dcd0538fSMark Fasheh ((le16_to_cpu(el->l_next_free_rec) == 1) && 3536dcd0538fSMark Fasheh ocfs2_is_empty_extent(&el->l_recs[0]))) { 3537dcd0538fSMark Fasheh el->l_recs[0] = *insert_rec; 3538dcd0538fSMark Fasheh el->l_next_free_rec = cpu_to_le16(1); 3539dcd0538fSMark Fasheh return; 3540dcd0538fSMark Fasheh } 3541dcd0538fSMark Fasheh 3542dcd0538fSMark Fasheh /* 3543dcd0538fSMark Fasheh * Appending insert. 3544dcd0538fSMark Fasheh */ 3545dcd0538fSMark Fasheh if (insert->ins_appending == APPEND_TAIL) { 3546dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 3547dcd0538fSMark Fasheh rec = &el->l_recs[i]; 3548e48edee2SMark Fasheh range = le32_to_cpu(rec->e_cpos) 3549e48edee2SMark Fasheh + le16_to_cpu(rec->e_leaf_clusters); 3550dcd0538fSMark Fasheh BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range); 3551dcd0538fSMark Fasheh 3552dcd0538fSMark Fasheh mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >= 3553dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 3554dcd0538fSMark Fasheh "inode %lu, depth %u, count %u, next free %u, " 3555dcd0538fSMark Fasheh "rec.cpos %u, rec.clusters %u, " 3556dcd0538fSMark Fasheh "insert.cpos %u, insert.clusters %u\n", 3557dcd0538fSMark Fasheh inode->i_ino, 3558dcd0538fSMark Fasheh le16_to_cpu(el->l_tree_depth), 3559dcd0538fSMark Fasheh le16_to_cpu(el->l_count), 3560dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec), 3561dcd0538fSMark Fasheh le32_to_cpu(el->l_recs[i].e_cpos), 3562e48edee2SMark Fasheh le16_to_cpu(el->l_recs[i].e_leaf_clusters), 3563dcd0538fSMark Fasheh le32_to_cpu(insert_rec->e_cpos), 3564e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3565dcd0538fSMark Fasheh i++; 3566dcd0538fSMark Fasheh el->l_recs[i] = *insert_rec; 3567dcd0538fSMark Fasheh le16_add_cpu(&el->l_next_free_rec, 1); 3568dcd0538fSMark Fasheh return; 3569dcd0538fSMark Fasheh } 3570dcd0538fSMark Fasheh 3571328d5752SMark Fasheh rotate: 3572dcd0538fSMark Fasheh /* 3573dcd0538fSMark Fasheh * Ok, we have to rotate. 3574dcd0538fSMark Fasheh * 3575dcd0538fSMark Fasheh * At this point, it is safe to assume that inserting into an 3576dcd0538fSMark Fasheh * empty leaf and appending to a leaf have both been handled 3577dcd0538fSMark Fasheh * above. 3578dcd0538fSMark Fasheh * 3579dcd0538fSMark Fasheh * This leaf needs to have space, either by the empty 1st 3580dcd0538fSMark Fasheh * extent record, or by virtue of an l_next_rec < l_count. 3581dcd0538fSMark Fasheh */ 3582dcd0538fSMark Fasheh ocfs2_rotate_leaf(el, insert_rec); 3583dcd0538fSMark Fasheh } 3584dcd0538fSMark Fasheh 3585328d5752SMark Fasheh static void ocfs2_adjust_rightmost_records(struct inode *inode, 3586328d5752SMark Fasheh handle_t *handle, 3587328d5752SMark Fasheh struct ocfs2_path *path, 3588328d5752SMark Fasheh struct ocfs2_extent_rec *insert_rec) 3589328d5752SMark Fasheh { 3590328d5752SMark Fasheh int ret, i, next_free; 3591328d5752SMark Fasheh struct buffer_head *bh; 3592328d5752SMark Fasheh struct ocfs2_extent_list *el; 3593328d5752SMark Fasheh struct ocfs2_extent_rec *rec; 3594328d5752SMark Fasheh 3595328d5752SMark Fasheh /* 3596328d5752SMark Fasheh * Update everything except the leaf block. 3597328d5752SMark Fasheh */ 3598328d5752SMark Fasheh for (i = 0; i < path->p_tree_depth; i++) { 3599328d5752SMark Fasheh bh = path->p_node[i].bh; 3600328d5752SMark Fasheh el = path->p_node[i].el; 3601328d5752SMark Fasheh 3602328d5752SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 3603328d5752SMark Fasheh if (next_free == 0) { 3604328d5752SMark Fasheh ocfs2_error(inode->i_sb, 3605328d5752SMark Fasheh "Dinode %llu has a bad extent list", 3606328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 3607328d5752SMark Fasheh ret = -EIO; 3608328d5752SMark Fasheh return; 3609328d5752SMark Fasheh } 3610328d5752SMark Fasheh 3611328d5752SMark Fasheh rec = &el->l_recs[next_free - 1]; 3612328d5752SMark Fasheh 3613328d5752SMark Fasheh rec->e_int_clusters = insert_rec->e_cpos; 3614328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 3615328d5752SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3616328d5752SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 3617328d5752SMark Fasheh -le32_to_cpu(rec->e_cpos)); 3618328d5752SMark Fasheh 3619328d5752SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 3620328d5752SMark Fasheh if (ret) 3621328d5752SMark Fasheh mlog_errno(ret); 3622328d5752SMark Fasheh 3623328d5752SMark Fasheh } 3624328d5752SMark Fasheh } 3625328d5752SMark Fasheh 3626dcd0538fSMark Fasheh static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle, 3627dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3628dcd0538fSMark Fasheh struct ocfs2_path *right_path, 3629dcd0538fSMark Fasheh struct ocfs2_path **ret_left_path) 3630dcd0538fSMark Fasheh { 3631328d5752SMark Fasheh int ret, next_free; 3632dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 3633dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 3634dcd0538fSMark Fasheh 3635dcd0538fSMark Fasheh *ret_left_path = NULL; 3636dcd0538fSMark Fasheh 3637dcd0538fSMark Fasheh /* 3638e48edee2SMark Fasheh * This shouldn't happen for non-trees. The extent rec cluster 3639e48edee2SMark Fasheh * count manipulation below only works for interior nodes. 3640e48edee2SMark Fasheh */ 3641e48edee2SMark Fasheh BUG_ON(right_path->p_tree_depth == 0); 3642e48edee2SMark Fasheh 3643e48edee2SMark Fasheh /* 3644dcd0538fSMark Fasheh * If our appending insert is at the leftmost edge of a leaf, 3645dcd0538fSMark Fasheh * then we might need to update the rightmost records of the 3646dcd0538fSMark Fasheh * neighboring path. 3647dcd0538fSMark Fasheh */ 3648dcd0538fSMark Fasheh el = path_leaf_el(right_path); 3649dcd0538fSMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 3650dcd0538fSMark Fasheh if (next_free == 0 || 3651dcd0538fSMark Fasheh (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) { 3652dcd0538fSMark Fasheh u32 left_cpos; 3653dcd0538fSMark Fasheh 3654dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, 3655dcd0538fSMark Fasheh &left_cpos); 3656dcd0538fSMark Fasheh if (ret) { 3657dcd0538fSMark Fasheh mlog_errno(ret); 3658dcd0538fSMark Fasheh goto out; 3659dcd0538fSMark Fasheh } 3660dcd0538fSMark Fasheh 3661dcd0538fSMark Fasheh mlog(0, "Append may need a left path update. cpos: %u, " 3662dcd0538fSMark Fasheh "left_cpos: %u\n", le32_to_cpu(insert_rec->e_cpos), 3663dcd0538fSMark Fasheh left_cpos); 3664dcd0538fSMark Fasheh 3665dcd0538fSMark Fasheh /* 3666dcd0538fSMark Fasheh * No need to worry if the append is already in the 3667dcd0538fSMark Fasheh * leftmost leaf. 3668dcd0538fSMark Fasheh */ 3669dcd0538fSMark Fasheh if (left_cpos) { 3670dcd0538fSMark Fasheh left_path = ocfs2_new_path(path_root_bh(right_path), 3671dcd0538fSMark Fasheh path_root_el(right_path)); 3672dcd0538fSMark Fasheh if (!left_path) { 3673dcd0538fSMark Fasheh ret = -ENOMEM; 3674dcd0538fSMark Fasheh mlog_errno(ret); 3675dcd0538fSMark Fasheh goto out; 3676dcd0538fSMark Fasheh } 3677dcd0538fSMark Fasheh 3678dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, left_path, left_cpos); 3679dcd0538fSMark Fasheh if (ret) { 3680dcd0538fSMark Fasheh mlog_errno(ret); 3681dcd0538fSMark Fasheh goto out; 3682dcd0538fSMark Fasheh } 3683dcd0538fSMark Fasheh 3684dcd0538fSMark Fasheh /* 3685dcd0538fSMark Fasheh * ocfs2_insert_path() will pass the left_path to the 3686dcd0538fSMark Fasheh * journal for us. 3687dcd0538fSMark Fasheh */ 3688dcd0538fSMark Fasheh } 3689dcd0538fSMark Fasheh } 3690dcd0538fSMark Fasheh 3691dcd0538fSMark Fasheh ret = ocfs2_journal_access_path(inode, handle, right_path); 3692dcd0538fSMark Fasheh if (ret) { 3693dcd0538fSMark Fasheh mlog_errno(ret); 3694dcd0538fSMark Fasheh goto out; 3695dcd0538fSMark Fasheh } 3696dcd0538fSMark Fasheh 3697328d5752SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, right_path, insert_rec); 3698dcd0538fSMark Fasheh 3699dcd0538fSMark Fasheh *ret_left_path = left_path; 3700dcd0538fSMark Fasheh ret = 0; 3701dcd0538fSMark Fasheh out: 3702dcd0538fSMark Fasheh if (ret != 0) 3703dcd0538fSMark Fasheh ocfs2_free_path(left_path); 3704dcd0538fSMark Fasheh 3705dcd0538fSMark Fasheh return ret; 3706dcd0538fSMark Fasheh } 3707dcd0538fSMark Fasheh 3708328d5752SMark Fasheh static void ocfs2_split_record(struct inode *inode, 3709328d5752SMark Fasheh struct ocfs2_path *left_path, 3710328d5752SMark Fasheh struct ocfs2_path *right_path, 3711328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 3712328d5752SMark Fasheh enum ocfs2_split_type split) 3713328d5752SMark Fasheh { 3714328d5752SMark Fasheh int index; 3715328d5752SMark Fasheh u32 cpos = le32_to_cpu(split_rec->e_cpos); 3716328d5752SMark Fasheh struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el; 3717328d5752SMark Fasheh struct ocfs2_extent_rec *rec, *tmprec; 3718328d5752SMark Fasheh 3719328d5752SMark Fasheh right_el = path_leaf_el(right_path);; 3720328d5752SMark Fasheh if (left_path) 3721328d5752SMark Fasheh left_el = path_leaf_el(left_path); 3722328d5752SMark Fasheh 3723328d5752SMark Fasheh el = right_el; 3724328d5752SMark Fasheh insert_el = right_el; 3725328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 3726328d5752SMark Fasheh if (index != -1) { 3727328d5752SMark Fasheh if (index == 0 && left_path) { 3728328d5752SMark Fasheh BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0])); 3729328d5752SMark Fasheh 3730328d5752SMark Fasheh /* 3731328d5752SMark Fasheh * This typically means that the record 3732328d5752SMark Fasheh * started in the left path but moved to the 3733328d5752SMark Fasheh * right as a result of rotation. We either 3734328d5752SMark Fasheh * move the existing record to the left, or we 3735328d5752SMark Fasheh * do the later insert there. 3736328d5752SMark Fasheh * 3737328d5752SMark Fasheh * In this case, the left path should always 3738328d5752SMark Fasheh * exist as the rotate code will have passed 3739328d5752SMark Fasheh * it back for a post-insert update. 3740328d5752SMark Fasheh */ 3741328d5752SMark Fasheh 3742328d5752SMark Fasheh if (split == SPLIT_LEFT) { 3743328d5752SMark Fasheh /* 3744328d5752SMark Fasheh * It's a left split. Since we know 3745328d5752SMark Fasheh * that the rotate code gave us an 3746328d5752SMark Fasheh * empty extent in the left path, we 3747328d5752SMark Fasheh * can just do the insert there. 3748328d5752SMark Fasheh */ 3749328d5752SMark Fasheh insert_el = left_el; 3750328d5752SMark Fasheh } else { 3751328d5752SMark Fasheh /* 3752328d5752SMark Fasheh * Right split - we have to move the 3753328d5752SMark Fasheh * existing record over to the left 3754328d5752SMark Fasheh * leaf. The insert will be into the 3755328d5752SMark Fasheh * newly created empty extent in the 3756328d5752SMark Fasheh * right leaf. 3757328d5752SMark Fasheh */ 3758328d5752SMark Fasheh tmprec = &right_el->l_recs[index]; 3759328d5752SMark Fasheh ocfs2_rotate_leaf(left_el, tmprec); 3760328d5752SMark Fasheh el = left_el; 3761328d5752SMark Fasheh 3762328d5752SMark Fasheh memset(tmprec, 0, sizeof(*tmprec)); 3763328d5752SMark Fasheh index = ocfs2_search_extent_list(left_el, cpos); 3764328d5752SMark Fasheh BUG_ON(index == -1); 3765328d5752SMark Fasheh } 3766328d5752SMark Fasheh } 3767328d5752SMark Fasheh } else { 3768328d5752SMark Fasheh BUG_ON(!left_path); 3769328d5752SMark Fasheh BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0])); 3770328d5752SMark Fasheh /* 3771328d5752SMark Fasheh * Left path is easy - we can just allow the insert to 3772328d5752SMark Fasheh * happen. 3773328d5752SMark Fasheh */ 3774328d5752SMark Fasheh el = left_el; 3775328d5752SMark Fasheh insert_el = left_el; 3776328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 3777328d5752SMark Fasheh BUG_ON(index == -1); 3778328d5752SMark Fasheh } 3779328d5752SMark Fasheh 3780328d5752SMark Fasheh rec = &el->l_recs[index]; 3781328d5752SMark Fasheh ocfs2_subtract_from_rec(inode->i_sb, split, rec, split_rec); 3782328d5752SMark Fasheh ocfs2_rotate_leaf(insert_el, split_rec); 3783328d5752SMark Fasheh } 3784328d5752SMark Fasheh 3785dcd0538fSMark Fasheh /* 3786e7d4cb6bSTao Ma * This function only does inserts on an allocation b-tree. For tree 3787e7d4cb6bSTao Ma * depth = 0, ocfs2_insert_at_leaf() is called directly. 3788dcd0538fSMark Fasheh * 3789dcd0538fSMark Fasheh * right_path is the path we want to do the actual insert 3790dcd0538fSMark Fasheh * in. left_path should only be passed in if we need to update that 3791dcd0538fSMark Fasheh * portion of the tree after an edge insert. 3792dcd0538fSMark Fasheh */ 3793dcd0538fSMark Fasheh static int ocfs2_insert_path(struct inode *inode, 3794dcd0538fSMark Fasheh handle_t *handle, 3795dcd0538fSMark Fasheh struct ocfs2_path *left_path, 3796dcd0538fSMark Fasheh struct ocfs2_path *right_path, 3797dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3798dcd0538fSMark Fasheh struct ocfs2_insert_type *insert) 3799dcd0538fSMark Fasheh { 3800dcd0538fSMark Fasheh int ret, subtree_index; 3801dcd0538fSMark Fasheh struct buffer_head *leaf_bh = path_leaf_bh(right_path); 3802dcd0538fSMark Fasheh 3803dcd0538fSMark Fasheh if (left_path) { 3804dcd0538fSMark Fasheh int credits = handle->h_buffer_credits; 3805dcd0538fSMark Fasheh 3806dcd0538fSMark Fasheh /* 3807dcd0538fSMark Fasheh * There's a chance that left_path got passed back to 3808dcd0538fSMark Fasheh * us without being accounted for in the 3809dcd0538fSMark Fasheh * journal. Extend our transaction here to be sure we 3810dcd0538fSMark Fasheh * can change those blocks. 3811dcd0538fSMark Fasheh */ 3812dcd0538fSMark Fasheh credits += left_path->p_tree_depth; 3813dcd0538fSMark Fasheh 3814dcd0538fSMark Fasheh ret = ocfs2_extend_trans(handle, credits); 3815dcd0538fSMark Fasheh if (ret < 0) { 3816dcd0538fSMark Fasheh mlog_errno(ret); 3817dcd0538fSMark Fasheh goto out; 3818dcd0538fSMark Fasheh } 3819dcd0538fSMark Fasheh 3820dcd0538fSMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 3821dcd0538fSMark Fasheh if (ret < 0) { 3822dcd0538fSMark Fasheh mlog_errno(ret); 3823dcd0538fSMark Fasheh goto out; 3824dcd0538fSMark Fasheh } 3825dcd0538fSMark Fasheh } 3826dcd0538fSMark Fasheh 3827e8aed345SMark Fasheh /* 3828e8aed345SMark Fasheh * Pass both paths to the journal. The majority of inserts 3829e8aed345SMark Fasheh * will be touching all components anyway. 3830e8aed345SMark Fasheh */ 3831e8aed345SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, right_path); 3832e8aed345SMark Fasheh if (ret < 0) { 3833e8aed345SMark Fasheh mlog_errno(ret); 3834e8aed345SMark Fasheh goto out; 3835e8aed345SMark Fasheh } 3836e8aed345SMark Fasheh 3837328d5752SMark Fasheh if (insert->ins_split != SPLIT_NONE) { 3838328d5752SMark Fasheh /* 3839328d5752SMark Fasheh * We could call ocfs2_insert_at_leaf() for some types 3840c78bad11SJoe Perches * of splits, but it's easier to just let one separate 3841328d5752SMark Fasheh * function sort it all out. 3842328d5752SMark Fasheh */ 3843328d5752SMark Fasheh ocfs2_split_record(inode, left_path, right_path, 3844328d5752SMark Fasheh insert_rec, insert->ins_split); 3845e8aed345SMark Fasheh 3846e8aed345SMark Fasheh /* 3847e8aed345SMark Fasheh * Split might have modified either leaf and we don't 3848e8aed345SMark Fasheh * have a guarantee that the later edge insert will 3849e8aed345SMark Fasheh * dirty this for us. 3850e8aed345SMark Fasheh */ 3851e8aed345SMark Fasheh if (left_path) 3852e8aed345SMark Fasheh ret = ocfs2_journal_dirty(handle, 3853e8aed345SMark Fasheh path_leaf_bh(left_path)); 3854e8aed345SMark Fasheh if (ret) 3855e8aed345SMark Fasheh mlog_errno(ret); 3856328d5752SMark Fasheh } else 3857328d5752SMark Fasheh ocfs2_insert_at_leaf(insert_rec, path_leaf_el(right_path), 3858328d5752SMark Fasheh insert, inode); 3859dcd0538fSMark Fasheh 3860dcd0538fSMark Fasheh ret = ocfs2_journal_dirty(handle, leaf_bh); 3861dcd0538fSMark Fasheh if (ret) 3862dcd0538fSMark Fasheh mlog_errno(ret); 3863dcd0538fSMark Fasheh 3864dcd0538fSMark Fasheh if (left_path) { 3865dcd0538fSMark Fasheh /* 3866dcd0538fSMark Fasheh * The rotate code has indicated that we need to fix 3867dcd0538fSMark Fasheh * up portions of the tree after the insert. 3868dcd0538fSMark Fasheh * 3869dcd0538fSMark Fasheh * XXX: Should we extend the transaction here? 3870dcd0538fSMark Fasheh */ 3871dcd0538fSMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, 3872dcd0538fSMark Fasheh right_path); 3873dcd0538fSMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, 3874dcd0538fSMark Fasheh right_path, subtree_index); 3875dcd0538fSMark Fasheh } 3876dcd0538fSMark Fasheh 3877dcd0538fSMark Fasheh ret = 0; 3878dcd0538fSMark Fasheh out: 3879dcd0538fSMark Fasheh return ret; 3880dcd0538fSMark Fasheh } 3881dcd0538fSMark Fasheh 3882dcd0538fSMark Fasheh static int ocfs2_do_insert_extent(struct inode *inode, 3883dcd0538fSMark Fasheh handle_t *handle, 3884e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 3885dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 3886dcd0538fSMark Fasheh struct ocfs2_insert_type *type) 3887dcd0538fSMark Fasheh { 3888dcd0538fSMark Fasheh int ret, rotate = 0; 3889dcd0538fSMark Fasheh u32 cpos; 3890dcd0538fSMark Fasheh struct ocfs2_path *right_path = NULL; 3891dcd0538fSMark Fasheh struct ocfs2_path *left_path = NULL; 3892dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 3893dcd0538fSMark Fasheh 3894ce1d9ea6SJoel Becker el = et->et_root_el; 3895dcd0538fSMark Fasheh 3896ce1d9ea6SJoel Becker ret = ocfs2_journal_access(handle, inode, et->et_root_bh, 3897dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3898dcd0538fSMark Fasheh if (ret) { 3899dcd0538fSMark Fasheh mlog_errno(ret); 3900dcd0538fSMark Fasheh goto out; 3901dcd0538fSMark Fasheh } 3902dcd0538fSMark Fasheh 3903dcd0538fSMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 3904dcd0538fSMark Fasheh ocfs2_insert_at_leaf(insert_rec, el, type, inode); 3905dcd0538fSMark Fasheh goto out_update_clusters; 3906dcd0538fSMark Fasheh } 3907dcd0538fSMark Fasheh 3908ce1d9ea6SJoel Becker right_path = ocfs2_new_path(et->et_root_bh, et->et_root_el); 3909dcd0538fSMark Fasheh if (!right_path) { 3910dcd0538fSMark Fasheh ret = -ENOMEM; 3911dcd0538fSMark Fasheh mlog_errno(ret); 3912dcd0538fSMark Fasheh goto out; 3913dcd0538fSMark Fasheh } 3914dcd0538fSMark Fasheh 3915dcd0538fSMark Fasheh /* 3916dcd0538fSMark Fasheh * Determine the path to start with. Rotations need the 3917dcd0538fSMark Fasheh * rightmost path, everything else can go directly to the 3918dcd0538fSMark Fasheh * target leaf. 3919dcd0538fSMark Fasheh */ 3920dcd0538fSMark Fasheh cpos = le32_to_cpu(insert_rec->e_cpos); 3921dcd0538fSMark Fasheh if (type->ins_appending == APPEND_NONE && 3922dcd0538fSMark Fasheh type->ins_contig == CONTIG_NONE) { 3923dcd0538fSMark Fasheh rotate = 1; 3924dcd0538fSMark Fasheh cpos = UINT_MAX; 3925dcd0538fSMark Fasheh } 3926dcd0538fSMark Fasheh 3927dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, right_path, cpos); 3928dcd0538fSMark Fasheh if (ret) { 3929dcd0538fSMark Fasheh mlog_errno(ret); 3930dcd0538fSMark Fasheh goto out; 3931dcd0538fSMark Fasheh } 3932dcd0538fSMark Fasheh 3933dcd0538fSMark Fasheh /* 3934dcd0538fSMark Fasheh * Rotations and appends need special treatment - they modify 3935dcd0538fSMark Fasheh * parts of the tree's above them. 3936dcd0538fSMark Fasheh * 3937dcd0538fSMark Fasheh * Both might pass back a path immediate to the left of the 3938dcd0538fSMark Fasheh * one being inserted to. This will be cause 3939dcd0538fSMark Fasheh * ocfs2_insert_path() to modify the rightmost records of 3940dcd0538fSMark Fasheh * left_path to account for an edge insert. 3941dcd0538fSMark Fasheh * 3942dcd0538fSMark Fasheh * XXX: When modifying this code, keep in mind that an insert 3943dcd0538fSMark Fasheh * can wind up skipping both of these two special cases... 3944dcd0538fSMark Fasheh */ 3945dcd0538fSMark Fasheh if (rotate) { 3946328d5752SMark Fasheh ret = ocfs2_rotate_tree_right(inode, handle, type->ins_split, 3947dcd0538fSMark Fasheh le32_to_cpu(insert_rec->e_cpos), 3948dcd0538fSMark Fasheh right_path, &left_path); 3949dcd0538fSMark Fasheh if (ret) { 3950dcd0538fSMark Fasheh mlog_errno(ret); 3951dcd0538fSMark Fasheh goto out; 3952dcd0538fSMark Fasheh } 3953e8aed345SMark Fasheh 3954e8aed345SMark Fasheh /* 3955e8aed345SMark Fasheh * ocfs2_rotate_tree_right() might have extended the 3956e8aed345SMark Fasheh * transaction without re-journaling our tree root. 3957e8aed345SMark Fasheh */ 3958ce1d9ea6SJoel Becker ret = ocfs2_journal_access(handle, inode, et->et_root_bh, 3959e8aed345SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 3960e8aed345SMark Fasheh if (ret) { 3961e8aed345SMark Fasheh mlog_errno(ret); 3962e8aed345SMark Fasheh goto out; 3963e8aed345SMark Fasheh } 3964dcd0538fSMark Fasheh } else if (type->ins_appending == APPEND_TAIL 3965dcd0538fSMark Fasheh && type->ins_contig != CONTIG_LEFT) { 3966dcd0538fSMark Fasheh ret = ocfs2_append_rec_to_path(inode, handle, insert_rec, 3967dcd0538fSMark Fasheh right_path, &left_path); 3968dcd0538fSMark Fasheh if (ret) { 3969dcd0538fSMark Fasheh mlog_errno(ret); 3970dcd0538fSMark Fasheh goto out; 3971dcd0538fSMark Fasheh } 3972dcd0538fSMark Fasheh } 3973dcd0538fSMark Fasheh 3974dcd0538fSMark Fasheh ret = ocfs2_insert_path(inode, handle, left_path, right_path, 3975dcd0538fSMark Fasheh insert_rec, type); 3976dcd0538fSMark Fasheh if (ret) { 3977dcd0538fSMark Fasheh mlog_errno(ret); 3978dcd0538fSMark Fasheh goto out; 3979dcd0538fSMark Fasheh } 3980dcd0538fSMark Fasheh 3981dcd0538fSMark Fasheh out_update_clusters: 3982328d5752SMark Fasheh if (type->ins_split == SPLIT_NONE) 398335dc0aa3SJoel Becker ocfs2_et_update_clusters(inode, et, 3984e48edee2SMark Fasheh le16_to_cpu(insert_rec->e_leaf_clusters)); 3985dcd0538fSMark Fasheh 3986ce1d9ea6SJoel Becker ret = ocfs2_journal_dirty(handle, et->et_root_bh); 3987dcd0538fSMark Fasheh if (ret) 3988dcd0538fSMark Fasheh mlog_errno(ret); 3989dcd0538fSMark Fasheh 3990dcd0538fSMark Fasheh out: 3991dcd0538fSMark Fasheh ocfs2_free_path(left_path); 3992dcd0538fSMark Fasheh ocfs2_free_path(right_path); 3993dcd0538fSMark Fasheh 3994dcd0538fSMark Fasheh return ret; 3995dcd0538fSMark Fasheh } 3996dcd0538fSMark Fasheh 3997328d5752SMark Fasheh static enum ocfs2_contig_type 3998ad5a4d70STao Ma ocfs2_figure_merge_contig_type(struct inode *inode, struct ocfs2_path *path, 3999328d5752SMark Fasheh struct ocfs2_extent_list *el, int index, 4000328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec) 4001328d5752SMark Fasheh { 4002ad5a4d70STao Ma int status; 4003328d5752SMark Fasheh enum ocfs2_contig_type ret = CONTIG_NONE; 4004ad5a4d70STao Ma u32 left_cpos, right_cpos; 4005ad5a4d70STao Ma struct ocfs2_extent_rec *rec = NULL; 4006ad5a4d70STao Ma struct ocfs2_extent_list *new_el; 4007ad5a4d70STao Ma struct ocfs2_path *left_path = NULL, *right_path = NULL; 4008ad5a4d70STao Ma struct buffer_head *bh; 4009ad5a4d70STao Ma struct ocfs2_extent_block *eb; 4010ad5a4d70STao Ma 4011ad5a4d70STao Ma if (index > 0) { 4012ad5a4d70STao Ma rec = &el->l_recs[index - 1]; 4013ad5a4d70STao Ma } else if (path->p_tree_depth > 0) { 4014ad5a4d70STao Ma status = ocfs2_find_cpos_for_left_leaf(inode->i_sb, 4015ad5a4d70STao Ma path, &left_cpos); 4016ad5a4d70STao Ma if (status) 4017ad5a4d70STao Ma goto out; 4018ad5a4d70STao Ma 4019ad5a4d70STao Ma if (left_cpos != 0) { 4020ad5a4d70STao Ma left_path = ocfs2_new_path(path_root_bh(path), 4021ad5a4d70STao Ma path_root_el(path)); 4022ad5a4d70STao Ma if (!left_path) 4023ad5a4d70STao Ma goto out; 4024ad5a4d70STao Ma 4025ad5a4d70STao Ma status = ocfs2_find_path(inode, left_path, left_cpos); 4026ad5a4d70STao Ma if (status) 4027ad5a4d70STao Ma goto out; 4028ad5a4d70STao Ma 4029ad5a4d70STao Ma new_el = path_leaf_el(left_path); 4030ad5a4d70STao Ma 4031ad5a4d70STao Ma if (le16_to_cpu(new_el->l_next_free_rec) != 4032ad5a4d70STao Ma le16_to_cpu(new_el->l_count)) { 4033ad5a4d70STao Ma bh = path_leaf_bh(left_path); 4034ad5a4d70STao Ma eb = (struct ocfs2_extent_block *)bh->b_data; 4035ad5a4d70STao Ma OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, 4036ad5a4d70STao Ma eb); 4037ad5a4d70STao Ma goto out; 4038ad5a4d70STao Ma } 4039ad5a4d70STao Ma rec = &new_el->l_recs[ 4040ad5a4d70STao Ma le16_to_cpu(new_el->l_next_free_rec) - 1]; 4041ad5a4d70STao Ma } 4042ad5a4d70STao Ma } 4043328d5752SMark Fasheh 4044328d5752SMark Fasheh /* 4045328d5752SMark Fasheh * We're careful to check for an empty extent record here - 4046328d5752SMark Fasheh * the merge code will know what to do if it sees one. 4047328d5752SMark Fasheh */ 4048ad5a4d70STao Ma if (rec) { 4049328d5752SMark Fasheh if (index == 1 && ocfs2_is_empty_extent(rec)) { 4050328d5752SMark Fasheh if (split_rec->e_cpos == el->l_recs[index].e_cpos) 4051328d5752SMark Fasheh ret = CONTIG_RIGHT; 4052328d5752SMark Fasheh } else { 4053328d5752SMark Fasheh ret = ocfs2_extent_contig(inode, rec, split_rec); 4054328d5752SMark Fasheh } 4055328d5752SMark Fasheh } 4056328d5752SMark Fasheh 4057ad5a4d70STao Ma rec = NULL; 4058ad5a4d70STao Ma if (index < (le16_to_cpu(el->l_next_free_rec) - 1)) 4059ad5a4d70STao Ma rec = &el->l_recs[index + 1]; 4060ad5a4d70STao Ma else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) && 4061ad5a4d70STao Ma path->p_tree_depth > 0) { 4062ad5a4d70STao Ma status = ocfs2_find_cpos_for_right_leaf(inode->i_sb, 4063ad5a4d70STao Ma path, &right_cpos); 4064ad5a4d70STao Ma if (status) 4065ad5a4d70STao Ma goto out; 4066ad5a4d70STao Ma 4067ad5a4d70STao Ma if (right_cpos == 0) 4068ad5a4d70STao Ma goto out; 4069ad5a4d70STao Ma 4070ad5a4d70STao Ma right_path = ocfs2_new_path(path_root_bh(path), 4071ad5a4d70STao Ma path_root_el(path)); 4072ad5a4d70STao Ma if (!right_path) 4073ad5a4d70STao Ma goto out; 4074ad5a4d70STao Ma 4075ad5a4d70STao Ma status = ocfs2_find_path(inode, right_path, right_cpos); 4076ad5a4d70STao Ma if (status) 4077ad5a4d70STao Ma goto out; 4078ad5a4d70STao Ma 4079ad5a4d70STao Ma new_el = path_leaf_el(right_path); 4080ad5a4d70STao Ma rec = &new_el->l_recs[0]; 4081ad5a4d70STao Ma if (ocfs2_is_empty_extent(rec)) { 4082ad5a4d70STao Ma if (le16_to_cpu(new_el->l_next_free_rec) <= 1) { 4083ad5a4d70STao Ma bh = path_leaf_bh(right_path); 4084ad5a4d70STao Ma eb = (struct ocfs2_extent_block *)bh->b_data; 4085ad5a4d70STao Ma OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, 4086ad5a4d70STao Ma eb); 4087ad5a4d70STao Ma goto out; 4088ad5a4d70STao Ma } 4089ad5a4d70STao Ma rec = &new_el->l_recs[1]; 4090ad5a4d70STao Ma } 4091ad5a4d70STao Ma } 4092ad5a4d70STao Ma 4093ad5a4d70STao Ma if (rec) { 4094328d5752SMark Fasheh enum ocfs2_contig_type contig_type; 4095328d5752SMark Fasheh 4096328d5752SMark Fasheh contig_type = ocfs2_extent_contig(inode, rec, split_rec); 4097328d5752SMark Fasheh 4098328d5752SMark Fasheh if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT) 4099328d5752SMark Fasheh ret = CONTIG_LEFTRIGHT; 4100328d5752SMark Fasheh else if (ret == CONTIG_NONE) 4101328d5752SMark Fasheh ret = contig_type; 4102328d5752SMark Fasheh } 4103328d5752SMark Fasheh 4104ad5a4d70STao Ma out: 4105ad5a4d70STao Ma if (left_path) 4106ad5a4d70STao Ma ocfs2_free_path(left_path); 4107ad5a4d70STao Ma if (right_path) 4108ad5a4d70STao Ma ocfs2_free_path(right_path); 4109ad5a4d70STao Ma 4110328d5752SMark Fasheh return ret; 4111328d5752SMark Fasheh } 4112328d5752SMark Fasheh 4113dcd0538fSMark Fasheh static void ocfs2_figure_contig_type(struct inode *inode, 4114dcd0538fSMark Fasheh struct ocfs2_insert_type *insert, 4115dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 4116ca12b7c4STao Ma struct ocfs2_extent_rec *insert_rec, 4117ca12b7c4STao Ma struct ocfs2_extent_tree *et) 4118dcd0538fSMark Fasheh { 4119dcd0538fSMark Fasheh int i; 4120dcd0538fSMark Fasheh enum ocfs2_contig_type contig_type = CONTIG_NONE; 4121dcd0538fSMark Fasheh 4122e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 4123e48edee2SMark Fasheh 4124dcd0538fSMark Fasheh for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 4125dcd0538fSMark Fasheh contig_type = ocfs2_extent_contig(inode, &el->l_recs[i], 4126dcd0538fSMark Fasheh insert_rec); 4127dcd0538fSMark Fasheh if (contig_type != CONTIG_NONE) { 4128dcd0538fSMark Fasheh insert->ins_contig_index = i; 4129dcd0538fSMark Fasheh break; 4130dcd0538fSMark Fasheh } 4131dcd0538fSMark Fasheh } 4132dcd0538fSMark Fasheh insert->ins_contig = contig_type; 4133ca12b7c4STao Ma 4134ca12b7c4STao Ma if (insert->ins_contig != CONTIG_NONE) { 4135ca12b7c4STao Ma struct ocfs2_extent_rec *rec = 4136ca12b7c4STao Ma &el->l_recs[insert->ins_contig_index]; 4137ca12b7c4STao Ma unsigned int len = le16_to_cpu(rec->e_leaf_clusters) + 4138ca12b7c4STao Ma le16_to_cpu(insert_rec->e_leaf_clusters); 4139ca12b7c4STao Ma 4140ca12b7c4STao Ma /* 4141ca12b7c4STao Ma * Caller might want us to limit the size of extents, don't 4142ca12b7c4STao Ma * calculate contiguousness if we might exceed that limit. 4143ca12b7c4STao Ma */ 4144ce1d9ea6SJoel Becker if (et->et_max_leaf_clusters && 4145ce1d9ea6SJoel Becker (len > et->et_max_leaf_clusters)) 4146ca12b7c4STao Ma insert->ins_contig = CONTIG_NONE; 4147ca12b7c4STao Ma } 4148dcd0538fSMark Fasheh } 4149dcd0538fSMark Fasheh 4150dcd0538fSMark Fasheh /* 4151dcd0538fSMark Fasheh * This should only be called against the righmost leaf extent list. 4152dcd0538fSMark Fasheh * 4153dcd0538fSMark Fasheh * ocfs2_figure_appending_type() will figure out whether we'll have to 4154dcd0538fSMark Fasheh * insert at the tail of the rightmost leaf. 4155dcd0538fSMark Fasheh * 4156e7d4cb6bSTao Ma * This should also work against the root extent list for tree's with 0 4157e7d4cb6bSTao Ma * depth. If we consider the root extent list to be the rightmost leaf node 4158dcd0538fSMark Fasheh * then the logic here makes sense. 4159dcd0538fSMark Fasheh */ 4160dcd0538fSMark Fasheh static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert, 4161dcd0538fSMark Fasheh struct ocfs2_extent_list *el, 4162dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec) 4163dcd0538fSMark Fasheh { 4164dcd0538fSMark Fasheh int i; 4165dcd0538fSMark Fasheh u32 cpos = le32_to_cpu(insert_rec->e_cpos); 4166dcd0538fSMark Fasheh struct ocfs2_extent_rec *rec; 4167dcd0538fSMark Fasheh 4168dcd0538fSMark Fasheh insert->ins_appending = APPEND_NONE; 4169dcd0538fSMark Fasheh 4170e48edee2SMark Fasheh BUG_ON(le16_to_cpu(el->l_tree_depth) != 0); 4171dcd0538fSMark Fasheh 4172dcd0538fSMark Fasheh if (!el->l_next_free_rec) 4173dcd0538fSMark Fasheh goto set_tail_append; 4174dcd0538fSMark Fasheh 4175dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 4176dcd0538fSMark Fasheh /* Were all records empty? */ 4177dcd0538fSMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 1) 4178dcd0538fSMark Fasheh goto set_tail_append; 4179dcd0538fSMark Fasheh } 4180dcd0538fSMark Fasheh 4181dcd0538fSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 4182dcd0538fSMark Fasheh rec = &el->l_recs[i]; 4183dcd0538fSMark Fasheh 4184e48edee2SMark Fasheh if (cpos >= 4185e48edee2SMark Fasheh (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters))) 4186dcd0538fSMark Fasheh goto set_tail_append; 4187dcd0538fSMark Fasheh 4188dcd0538fSMark Fasheh return; 4189dcd0538fSMark Fasheh 4190dcd0538fSMark Fasheh set_tail_append: 4191dcd0538fSMark Fasheh insert->ins_appending = APPEND_TAIL; 4192dcd0538fSMark Fasheh } 4193dcd0538fSMark Fasheh 4194dcd0538fSMark Fasheh /* 4195dcd0538fSMark Fasheh * Helper function called at the begining of an insert. 4196dcd0538fSMark Fasheh * 4197dcd0538fSMark Fasheh * This computes a few things that are commonly used in the process of 4198dcd0538fSMark Fasheh * inserting into the btree: 4199dcd0538fSMark Fasheh * - Whether the new extent is contiguous with an existing one. 4200dcd0538fSMark Fasheh * - The current tree depth. 4201dcd0538fSMark Fasheh * - Whether the insert is an appending one. 4202dcd0538fSMark Fasheh * - The total # of free records in the tree. 4203dcd0538fSMark Fasheh * 4204dcd0538fSMark Fasheh * All of the information is stored on the ocfs2_insert_type 4205dcd0538fSMark Fasheh * structure. 4206dcd0538fSMark Fasheh */ 4207dcd0538fSMark Fasheh static int ocfs2_figure_insert_type(struct inode *inode, 4208e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4209dcd0538fSMark Fasheh struct buffer_head **last_eb_bh, 4210dcd0538fSMark Fasheh struct ocfs2_extent_rec *insert_rec, 4211c77534f6STao Mao int *free_records, 4212dcd0538fSMark Fasheh struct ocfs2_insert_type *insert) 4213dcd0538fSMark Fasheh { 4214dcd0538fSMark Fasheh int ret; 4215dcd0538fSMark Fasheh struct ocfs2_extent_block *eb; 4216dcd0538fSMark Fasheh struct ocfs2_extent_list *el; 4217dcd0538fSMark Fasheh struct ocfs2_path *path = NULL; 4218dcd0538fSMark Fasheh struct buffer_head *bh = NULL; 4219dcd0538fSMark Fasheh 4220328d5752SMark Fasheh insert->ins_split = SPLIT_NONE; 4221328d5752SMark Fasheh 4222ce1d9ea6SJoel Becker el = et->et_root_el; 4223dcd0538fSMark Fasheh insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth); 4224dcd0538fSMark Fasheh 4225dcd0538fSMark Fasheh if (el->l_tree_depth) { 4226dcd0538fSMark Fasheh /* 4227dcd0538fSMark Fasheh * If we have tree depth, we read in the 4228dcd0538fSMark Fasheh * rightmost extent block ahead of time as 4229dcd0538fSMark Fasheh * ocfs2_figure_insert_type() and ocfs2_add_branch() 4230dcd0538fSMark Fasheh * may want it later. 4231dcd0538fSMark Fasheh */ 4232dcd0538fSMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 423335dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), &bh, 4234dcd0538fSMark Fasheh OCFS2_BH_CACHED, inode); 4235dcd0538fSMark Fasheh if (ret) { 4236dcd0538fSMark Fasheh mlog_exit(ret); 4237dcd0538fSMark Fasheh goto out; 4238dcd0538fSMark Fasheh } 4239dcd0538fSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 4240dcd0538fSMark Fasheh el = &eb->h_list; 4241dcd0538fSMark Fasheh } 4242dcd0538fSMark Fasheh 4243dcd0538fSMark Fasheh /* 4244dcd0538fSMark Fasheh * Unless we have a contiguous insert, we'll need to know if 4245dcd0538fSMark Fasheh * there is room left in our allocation tree for another 4246dcd0538fSMark Fasheh * extent record. 4247dcd0538fSMark Fasheh * 4248dcd0538fSMark Fasheh * XXX: This test is simplistic, we can search for empty 4249dcd0538fSMark Fasheh * extent records too. 4250dcd0538fSMark Fasheh */ 4251c77534f6STao Mao *free_records = le16_to_cpu(el->l_count) - 4252dcd0538fSMark Fasheh le16_to_cpu(el->l_next_free_rec); 4253dcd0538fSMark Fasheh 4254dcd0538fSMark Fasheh if (!insert->ins_tree_depth) { 4255ca12b7c4STao Ma ocfs2_figure_contig_type(inode, insert, el, insert_rec, et); 4256dcd0538fSMark Fasheh ocfs2_figure_appending_type(insert, el, insert_rec); 4257dcd0538fSMark Fasheh return 0; 4258dcd0538fSMark Fasheh } 4259dcd0538fSMark Fasheh 4260ce1d9ea6SJoel Becker path = ocfs2_new_path(et->et_root_bh, et->et_root_el); 4261dcd0538fSMark Fasheh if (!path) { 4262dcd0538fSMark Fasheh ret = -ENOMEM; 4263dcd0538fSMark Fasheh mlog_errno(ret); 4264dcd0538fSMark Fasheh goto out; 4265dcd0538fSMark Fasheh } 4266dcd0538fSMark Fasheh 4267dcd0538fSMark Fasheh /* 4268dcd0538fSMark Fasheh * In the case that we're inserting past what the tree 4269dcd0538fSMark Fasheh * currently accounts for, ocfs2_find_path() will return for 4270dcd0538fSMark Fasheh * us the rightmost tree path. This is accounted for below in 4271dcd0538fSMark Fasheh * the appending code. 4272dcd0538fSMark Fasheh */ 4273dcd0538fSMark Fasheh ret = ocfs2_find_path(inode, path, le32_to_cpu(insert_rec->e_cpos)); 4274dcd0538fSMark Fasheh if (ret) { 4275dcd0538fSMark Fasheh mlog_errno(ret); 4276dcd0538fSMark Fasheh goto out; 4277dcd0538fSMark Fasheh } 4278dcd0538fSMark Fasheh 4279dcd0538fSMark Fasheh el = path_leaf_el(path); 4280dcd0538fSMark Fasheh 4281dcd0538fSMark Fasheh /* 4282dcd0538fSMark Fasheh * Now that we have the path, there's two things we want to determine: 4283dcd0538fSMark Fasheh * 1) Contiguousness (also set contig_index if this is so) 4284dcd0538fSMark Fasheh * 4285dcd0538fSMark Fasheh * 2) Are we doing an append? We can trivially break this up 4286dcd0538fSMark Fasheh * into two types of appends: simple record append, or a 4287dcd0538fSMark Fasheh * rotate inside the tail leaf. 4288dcd0538fSMark Fasheh */ 4289ca12b7c4STao Ma ocfs2_figure_contig_type(inode, insert, el, insert_rec, et); 4290dcd0538fSMark Fasheh 4291dcd0538fSMark Fasheh /* 4292dcd0538fSMark Fasheh * The insert code isn't quite ready to deal with all cases of 4293dcd0538fSMark Fasheh * left contiguousness. Specifically, if it's an insert into 4294dcd0538fSMark Fasheh * the 1st record in a leaf, it will require the adjustment of 4295e48edee2SMark Fasheh * cluster count on the last record of the path directly to it's 4296dcd0538fSMark Fasheh * left. For now, just catch that case and fool the layers 4297dcd0538fSMark Fasheh * above us. This works just fine for tree_depth == 0, which 4298dcd0538fSMark Fasheh * is why we allow that above. 4299dcd0538fSMark Fasheh */ 4300dcd0538fSMark Fasheh if (insert->ins_contig == CONTIG_LEFT && 4301dcd0538fSMark Fasheh insert->ins_contig_index == 0) 4302dcd0538fSMark Fasheh insert->ins_contig = CONTIG_NONE; 4303dcd0538fSMark Fasheh 4304dcd0538fSMark Fasheh /* 4305dcd0538fSMark Fasheh * Ok, so we can simply compare against last_eb to figure out 4306dcd0538fSMark Fasheh * whether the path doesn't exist. This will only happen in 4307dcd0538fSMark Fasheh * the case that we're doing a tail append, so maybe we can 4308dcd0538fSMark Fasheh * take advantage of that information somehow. 4309dcd0538fSMark Fasheh */ 431035dc0aa3SJoel Becker if (ocfs2_et_get_last_eb_blk(et) == 4311e7d4cb6bSTao Ma path_leaf_bh(path)->b_blocknr) { 4312dcd0538fSMark Fasheh /* 4313dcd0538fSMark Fasheh * Ok, ocfs2_find_path() returned us the rightmost 4314dcd0538fSMark Fasheh * tree path. This might be an appending insert. There are 4315dcd0538fSMark Fasheh * two cases: 4316dcd0538fSMark Fasheh * 1) We're doing a true append at the tail: 4317dcd0538fSMark Fasheh * -This might even be off the end of the leaf 4318dcd0538fSMark Fasheh * 2) We're "appending" by rotating in the tail 4319dcd0538fSMark Fasheh */ 4320dcd0538fSMark Fasheh ocfs2_figure_appending_type(insert, el, insert_rec); 4321dcd0538fSMark Fasheh } 4322dcd0538fSMark Fasheh 4323dcd0538fSMark Fasheh out: 4324dcd0538fSMark Fasheh ocfs2_free_path(path); 4325dcd0538fSMark Fasheh 4326dcd0538fSMark Fasheh if (ret == 0) 4327dcd0538fSMark Fasheh *last_eb_bh = bh; 4328dcd0538fSMark Fasheh else 4329dcd0538fSMark Fasheh brelse(bh); 4330dcd0538fSMark Fasheh return ret; 4331dcd0538fSMark Fasheh } 4332dcd0538fSMark Fasheh 4333dcd0538fSMark Fasheh /* 4334dcd0538fSMark Fasheh * Insert an extent into an inode btree. 4335dcd0538fSMark Fasheh * 4336dcd0538fSMark Fasheh * The caller needs to update fe->i_clusters 4337dcd0538fSMark Fasheh */ 4338f56654c4STao Ma static int ocfs2_insert_extent(struct ocfs2_super *osb, 43391fabe148SMark Fasheh handle_t *handle, 4340ccd979bdSMark Fasheh struct inode *inode, 4341e7d4cb6bSTao Ma struct buffer_head *root_bh, 4342dcd0538fSMark Fasheh u32 cpos, 4343ccd979bdSMark Fasheh u64 start_blk, 4344ccd979bdSMark Fasheh u32 new_clusters, 43452ae99a60SMark Fasheh u8 flags, 4346e7d4cb6bSTao Ma struct ocfs2_alloc_context *meta_ac, 4347f56654c4STao Ma struct ocfs2_extent_tree *et) 4348ccd979bdSMark Fasheh { 4349c3afcbb3SMark Fasheh int status; 4350c77534f6STao Mao int uninitialized_var(free_records); 4351ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 4352dcd0538fSMark Fasheh struct ocfs2_insert_type insert = {0, }; 4353dcd0538fSMark Fasheh struct ocfs2_extent_rec rec; 4354ccd979bdSMark Fasheh 43551afc32b9SMark Fasheh BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL); 43561afc32b9SMark Fasheh 4357dcd0538fSMark Fasheh mlog(0, "add %u clusters at position %u to inode %llu\n", 4358dcd0538fSMark Fasheh new_clusters, cpos, (unsigned long long)OCFS2_I(inode)->ip_blkno); 4359ccd979bdSMark Fasheh 4360dcd0538fSMark Fasheh mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) && 4361dcd0538fSMark Fasheh (OCFS2_I(inode)->ip_clusters != cpos), 4362dcd0538fSMark Fasheh "Device %s, asking for sparse allocation: inode %llu, " 4363dcd0538fSMark Fasheh "cpos %u, clusters %u\n", 4364dcd0538fSMark Fasheh osb->dev_str, 4365dcd0538fSMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, 4366dcd0538fSMark Fasheh OCFS2_I(inode)->ip_clusters); 4367ccd979bdSMark Fasheh 4368e48edee2SMark Fasheh memset(&rec, 0, sizeof(rec)); 4369dcd0538fSMark Fasheh rec.e_cpos = cpu_to_le32(cpos); 4370dcd0538fSMark Fasheh rec.e_blkno = cpu_to_le64(start_blk); 4371e48edee2SMark Fasheh rec.e_leaf_clusters = cpu_to_le16(new_clusters); 43722ae99a60SMark Fasheh rec.e_flags = flags; 4373ccd979bdSMark Fasheh 4374e7d4cb6bSTao Ma status = ocfs2_figure_insert_type(inode, et, &last_eb_bh, &rec, 4375c77534f6STao Mao &free_records, &insert); 4376ccd979bdSMark Fasheh if (status < 0) { 4377dcd0538fSMark Fasheh mlog_errno(status); 4378ccd979bdSMark Fasheh goto bail; 4379ccd979bdSMark Fasheh } 4380ccd979bdSMark Fasheh 4381dcd0538fSMark Fasheh mlog(0, "Insert.appending: %u, Insert.Contig: %u, " 4382dcd0538fSMark Fasheh "Insert.contig_index: %d, Insert.free_records: %d, " 4383dcd0538fSMark Fasheh "Insert.tree_depth: %d\n", 4384dcd0538fSMark Fasheh insert.ins_appending, insert.ins_contig, insert.ins_contig_index, 4385c77534f6STao Mao free_records, insert.ins_tree_depth); 4386dcd0538fSMark Fasheh 4387c77534f6STao Mao if (insert.ins_contig == CONTIG_NONE && free_records == 0) { 4388e7d4cb6bSTao Ma status = ocfs2_grow_tree(inode, handle, et, 4389328d5752SMark Fasheh &insert.ins_tree_depth, &last_eb_bh, 4390ccd979bdSMark Fasheh meta_ac); 4391c3afcbb3SMark Fasheh if (status) { 4392ccd979bdSMark Fasheh mlog_errno(status); 4393ccd979bdSMark Fasheh goto bail; 4394ccd979bdSMark Fasheh } 4395c3afcbb3SMark Fasheh } 4396ccd979bdSMark Fasheh 4397dcd0538fSMark Fasheh /* Finally, we can add clusters. This might rotate the tree for us. */ 4398e7d4cb6bSTao Ma status = ocfs2_do_insert_extent(inode, handle, et, &rec, &insert); 4399ccd979bdSMark Fasheh if (status < 0) 4400ccd979bdSMark Fasheh mlog_errno(status); 4401ce1d9ea6SJoel Becker else if (et->et_type == OCFS2_DINODE_EXTENT) 440283418978SMark Fasheh ocfs2_extent_map_insert_rec(inode, &rec); 4403ccd979bdSMark Fasheh 4404ccd979bdSMark Fasheh bail: 4405ccd979bdSMark Fasheh if (last_eb_bh) 4406ccd979bdSMark Fasheh brelse(last_eb_bh); 4407ccd979bdSMark Fasheh 4408f56654c4STao Ma mlog_exit(status); 4409f56654c4STao Ma return status; 4410f56654c4STao Ma } 4411f56654c4STao Ma 4412f56654c4STao Ma int ocfs2_dinode_insert_extent(struct ocfs2_super *osb, 4413f56654c4STao Ma handle_t *handle, 4414f56654c4STao Ma struct inode *inode, 4415f56654c4STao Ma struct buffer_head *root_bh, 4416f56654c4STao Ma u32 cpos, 4417f56654c4STao Ma u64 start_blk, 4418f56654c4STao Ma u32 new_clusters, 4419f56654c4STao Ma u8 flags, 4420f56654c4STao Ma struct ocfs2_alloc_context *meta_ac) 4421f56654c4STao Ma { 4422f56654c4STao Ma int status; 4423dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4424f56654c4STao Ma 4425dc0ce61aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, OCFS2_DINODE_EXTENT, 4426dc0ce61aSJoel Becker NULL); 4427f56654c4STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4428f56654c4STao Ma cpos, start_blk, new_clusters, 4429dc0ce61aSJoel Becker flags, meta_ac, &et); 4430dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4431f56654c4STao Ma 4432f56654c4STao Ma return status; 4433f56654c4STao Ma } 4434f56654c4STao Ma 4435f56654c4STao Ma int ocfs2_xattr_value_insert_extent(struct ocfs2_super *osb, 4436f56654c4STao Ma handle_t *handle, 4437f56654c4STao Ma struct inode *inode, 4438f56654c4STao Ma struct buffer_head *root_bh, 4439f56654c4STao Ma u32 cpos, 4440f56654c4STao Ma u64 start_blk, 4441f56654c4STao Ma u32 new_clusters, 4442f56654c4STao Ma u8 flags, 4443f56654c4STao Ma struct ocfs2_alloc_context *meta_ac, 4444f56654c4STao Ma void *private) 4445f56654c4STao Ma { 4446f56654c4STao Ma int status; 4447dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4448f56654c4STao Ma 4449dc0ce61aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, 4450ca12b7c4STao Ma OCFS2_XATTR_VALUE_EXTENT, private); 4451f56654c4STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4452f56654c4STao Ma cpos, start_blk, new_clusters, 4453dc0ce61aSJoel Becker flags, meta_ac, &et); 4454dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4455f56654c4STao Ma 4456ccd979bdSMark Fasheh return status; 4457ccd979bdSMark Fasheh } 4458ccd979bdSMark Fasheh 4459ba492615STao Ma int ocfs2_xattr_tree_insert_extent(struct ocfs2_super *osb, 4460ba492615STao Ma handle_t *handle, 4461ba492615STao Ma struct inode *inode, 4462ba492615STao Ma struct buffer_head *root_bh, 4463ba492615STao Ma u32 cpos, 4464ba492615STao Ma u64 start_blk, 4465ba492615STao Ma u32 new_clusters, 4466ba492615STao Ma u8 flags, 4467ba492615STao Ma struct ocfs2_alloc_context *meta_ac) 4468ba492615STao Ma { 4469ba492615STao Ma int status; 4470dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4471ba492615STao Ma 4472dc0ce61aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, OCFS2_XATTR_TREE_EXTENT, 4473ca12b7c4STao Ma NULL); 4474ba492615STao Ma status = ocfs2_insert_extent(osb, handle, inode, root_bh, 4475ba492615STao Ma cpos, start_blk, new_clusters, 4476dc0ce61aSJoel Becker flags, meta_ac, &et); 4477dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4478ba492615STao Ma 4479ba492615STao Ma return status; 4480ba492615STao Ma } 4481ba492615STao Ma 44820eb8d47eSTao Ma /* 44830eb8d47eSTao Ma * Allcate and add clusters into the extent b-tree. 44840eb8d47eSTao Ma * The new clusters(clusters_to_add) will be inserted at logical_offset. 44850eb8d47eSTao Ma * The extent b-tree's root is root_el and it should be in root_bh, and 44860eb8d47eSTao Ma * it is not limited to the file storage. Any extent tree can use this 44870eb8d47eSTao Ma * function if it implements the proper ocfs2_extent_tree. 44880eb8d47eSTao Ma */ 44890eb8d47eSTao Ma int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb, 44900eb8d47eSTao Ma struct inode *inode, 44910eb8d47eSTao Ma u32 *logical_offset, 44920eb8d47eSTao Ma u32 clusters_to_add, 44930eb8d47eSTao Ma int mark_unwritten, 44940eb8d47eSTao Ma struct buffer_head *root_bh, 44950eb8d47eSTao Ma struct ocfs2_extent_list *root_el, 44960eb8d47eSTao Ma handle_t *handle, 44970eb8d47eSTao Ma struct ocfs2_alloc_context *data_ac, 44980eb8d47eSTao Ma struct ocfs2_alloc_context *meta_ac, 44990eb8d47eSTao Ma enum ocfs2_alloc_restarted *reason_ret, 4500f56654c4STao Ma enum ocfs2_extent_tree_type type, 4501f56654c4STao Ma void *private) 45020eb8d47eSTao Ma { 45030eb8d47eSTao Ma int status = 0; 45040eb8d47eSTao Ma int free_extents; 45050eb8d47eSTao Ma enum ocfs2_alloc_restarted reason = RESTART_NONE; 45060eb8d47eSTao Ma u32 bit_off, num_bits; 45070eb8d47eSTao Ma u64 block; 45080eb8d47eSTao Ma u8 flags = 0; 45090eb8d47eSTao Ma 45100eb8d47eSTao Ma BUG_ON(!clusters_to_add); 45110eb8d47eSTao Ma 45120eb8d47eSTao Ma if (mark_unwritten) 45130eb8d47eSTao Ma flags = OCFS2_EXT_UNWRITTEN; 45140eb8d47eSTao Ma 4515f56654c4STao Ma free_extents = ocfs2_num_free_extents(osb, inode, root_bh, type, 4516f56654c4STao Ma private); 45170eb8d47eSTao Ma if (free_extents < 0) { 45180eb8d47eSTao Ma status = free_extents; 45190eb8d47eSTao Ma mlog_errno(status); 45200eb8d47eSTao Ma goto leave; 45210eb8d47eSTao Ma } 45220eb8d47eSTao Ma 45230eb8d47eSTao Ma /* there are two cases which could cause us to EAGAIN in the 45240eb8d47eSTao Ma * we-need-more-metadata case: 45250eb8d47eSTao Ma * 1) we haven't reserved *any* 45260eb8d47eSTao Ma * 2) we are so fragmented, we've needed to add metadata too 45270eb8d47eSTao Ma * many times. */ 45280eb8d47eSTao Ma if (!free_extents && !meta_ac) { 45290eb8d47eSTao Ma mlog(0, "we haven't reserved any metadata!\n"); 45300eb8d47eSTao Ma status = -EAGAIN; 45310eb8d47eSTao Ma reason = RESTART_META; 45320eb8d47eSTao Ma goto leave; 45330eb8d47eSTao Ma } else if ((!free_extents) 45340eb8d47eSTao Ma && (ocfs2_alloc_context_bits_left(meta_ac) 45350eb8d47eSTao Ma < ocfs2_extend_meta_needed(root_el))) { 45360eb8d47eSTao Ma mlog(0, "filesystem is really fragmented...\n"); 45370eb8d47eSTao Ma status = -EAGAIN; 45380eb8d47eSTao Ma reason = RESTART_META; 45390eb8d47eSTao Ma goto leave; 45400eb8d47eSTao Ma } 45410eb8d47eSTao Ma 45420eb8d47eSTao Ma status = __ocfs2_claim_clusters(osb, handle, data_ac, 1, 45430eb8d47eSTao Ma clusters_to_add, &bit_off, &num_bits); 45440eb8d47eSTao Ma if (status < 0) { 45450eb8d47eSTao Ma if (status != -ENOSPC) 45460eb8d47eSTao Ma mlog_errno(status); 45470eb8d47eSTao Ma goto leave; 45480eb8d47eSTao Ma } 45490eb8d47eSTao Ma 45500eb8d47eSTao Ma BUG_ON(num_bits > clusters_to_add); 45510eb8d47eSTao Ma 45520eb8d47eSTao Ma /* reserve our write early -- insert_extent may update the inode */ 45530eb8d47eSTao Ma status = ocfs2_journal_access(handle, inode, root_bh, 45540eb8d47eSTao Ma OCFS2_JOURNAL_ACCESS_WRITE); 45550eb8d47eSTao Ma if (status < 0) { 45560eb8d47eSTao Ma mlog_errno(status); 45570eb8d47eSTao Ma goto leave; 45580eb8d47eSTao Ma } 45590eb8d47eSTao Ma 45600eb8d47eSTao Ma block = ocfs2_clusters_to_blocks(osb->sb, bit_off); 45610eb8d47eSTao Ma mlog(0, "Allocating %u clusters at block %u for inode %llu\n", 45620eb8d47eSTao Ma num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno); 4563f56654c4STao Ma if (type == OCFS2_DINODE_EXTENT) 4564f56654c4STao Ma status = ocfs2_dinode_insert_extent(osb, handle, inode, root_bh, 4565f56654c4STao Ma *logical_offset, block, 4566f56654c4STao Ma num_bits, flags, meta_ac); 4567ba492615STao Ma else if (type == OCFS2_XATTR_TREE_EXTENT) 4568ba492615STao Ma status = ocfs2_xattr_tree_insert_extent(osb, handle, 4569ba492615STao Ma inode, root_bh, 4570ba492615STao Ma *logical_offset, 4571ba492615STao Ma block, num_bits, flags, 4572ba492615STao Ma meta_ac); 4573f56654c4STao Ma else 4574f56654c4STao Ma status = ocfs2_xattr_value_insert_extent(osb, handle, 4575f56654c4STao Ma inode, root_bh, 4576f56654c4STao Ma *logical_offset, 4577f56654c4STao Ma block, num_bits, flags, 4578f56654c4STao Ma meta_ac, private); 45790eb8d47eSTao Ma if (status < 0) { 45800eb8d47eSTao Ma mlog_errno(status); 45810eb8d47eSTao Ma goto leave; 45820eb8d47eSTao Ma } 45830eb8d47eSTao Ma 45840eb8d47eSTao Ma status = ocfs2_journal_dirty(handle, root_bh); 45850eb8d47eSTao Ma if (status < 0) { 45860eb8d47eSTao Ma mlog_errno(status); 45870eb8d47eSTao Ma goto leave; 45880eb8d47eSTao Ma } 45890eb8d47eSTao Ma 45900eb8d47eSTao Ma clusters_to_add -= num_bits; 45910eb8d47eSTao Ma *logical_offset += num_bits; 45920eb8d47eSTao Ma 45930eb8d47eSTao Ma if (clusters_to_add) { 45940eb8d47eSTao Ma mlog(0, "need to alloc once more, wanted = %u\n", 45950eb8d47eSTao Ma clusters_to_add); 45960eb8d47eSTao Ma status = -EAGAIN; 45970eb8d47eSTao Ma reason = RESTART_TRANS; 45980eb8d47eSTao Ma } 45990eb8d47eSTao Ma 46000eb8d47eSTao Ma leave: 46010eb8d47eSTao Ma mlog_exit(status); 46020eb8d47eSTao Ma if (reason_ret) 46030eb8d47eSTao Ma *reason_ret = reason; 46040eb8d47eSTao Ma return status; 46050eb8d47eSTao Ma } 46060eb8d47eSTao Ma 4607328d5752SMark Fasheh static void ocfs2_make_right_split_rec(struct super_block *sb, 4608328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 4609328d5752SMark Fasheh u32 cpos, 4610328d5752SMark Fasheh struct ocfs2_extent_rec *rec) 4611328d5752SMark Fasheh { 4612328d5752SMark Fasheh u32 rec_cpos = le32_to_cpu(rec->e_cpos); 4613328d5752SMark Fasheh u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters); 4614328d5752SMark Fasheh 4615328d5752SMark Fasheh memset(split_rec, 0, sizeof(struct ocfs2_extent_rec)); 4616328d5752SMark Fasheh 4617328d5752SMark Fasheh split_rec->e_cpos = cpu_to_le32(cpos); 4618328d5752SMark Fasheh split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos); 4619328d5752SMark Fasheh 4620328d5752SMark Fasheh split_rec->e_blkno = rec->e_blkno; 4621328d5752SMark Fasheh le64_add_cpu(&split_rec->e_blkno, 4622328d5752SMark Fasheh ocfs2_clusters_to_blocks(sb, cpos - rec_cpos)); 4623328d5752SMark Fasheh 4624328d5752SMark Fasheh split_rec->e_flags = rec->e_flags; 4625328d5752SMark Fasheh } 4626328d5752SMark Fasheh 4627328d5752SMark Fasheh static int ocfs2_split_and_insert(struct inode *inode, 4628328d5752SMark Fasheh handle_t *handle, 4629328d5752SMark Fasheh struct ocfs2_path *path, 4630e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4631328d5752SMark Fasheh struct buffer_head **last_eb_bh, 4632328d5752SMark Fasheh int split_index, 4633328d5752SMark Fasheh struct ocfs2_extent_rec *orig_split_rec, 4634328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac) 4635328d5752SMark Fasheh { 4636328d5752SMark Fasheh int ret = 0, depth; 4637328d5752SMark Fasheh unsigned int insert_range, rec_range, do_leftright = 0; 4638328d5752SMark Fasheh struct ocfs2_extent_rec tmprec; 4639328d5752SMark Fasheh struct ocfs2_extent_list *rightmost_el; 4640328d5752SMark Fasheh struct ocfs2_extent_rec rec; 4641328d5752SMark Fasheh struct ocfs2_extent_rec split_rec = *orig_split_rec; 4642328d5752SMark Fasheh struct ocfs2_insert_type insert; 4643328d5752SMark Fasheh struct ocfs2_extent_block *eb; 4644328d5752SMark Fasheh 4645328d5752SMark Fasheh leftright: 4646328d5752SMark Fasheh /* 4647328d5752SMark Fasheh * Store a copy of the record on the stack - it might move 4648328d5752SMark Fasheh * around as the tree is manipulated below. 4649328d5752SMark Fasheh */ 4650328d5752SMark Fasheh rec = path_leaf_el(path)->l_recs[split_index]; 4651328d5752SMark Fasheh 4652ce1d9ea6SJoel Becker rightmost_el = et->et_root_el; 4653328d5752SMark Fasheh 4654328d5752SMark Fasheh depth = le16_to_cpu(rightmost_el->l_tree_depth); 4655328d5752SMark Fasheh if (depth) { 4656328d5752SMark Fasheh BUG_ON(!(*last_eb_bh)); 4657328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data; 4658328d5752SMark Fasheh rightmost_el = &eb->h_list; 4659328d5752SMark Fasheh } 4660328d5752SMark Fasheh 4661328d5752SMark Fasheh if (le16_to_cpu(rightmost_el->l_next_free_rec) == 4662328d5752SMark Fasheh le16_to_cpu(rightmost_el->l_count)) { 4663e7d4cb6bSTao Ma ret = ocfs2_grow_tree(inode, handle, et, 4664e7d4cb6bSTao Ma &depth, last_eb_bh, meta_ac); 4665328d5752SMark Fasheh if (ret) { 4666328d5752SMark Fasheh mlog_errno(ret); 4667328d5752SMark Fasheh goto out; 4668328d5752SMark Fasheh } 4669328d5752SMark Fasheh } 4670328d5752SMark Fasheh 4671328d5752SMark Fasheh memset(&insert, 0, sizeof(struct ocfs2_insert_type)); 4672328d5752SMark Fasheh insert.ins_appending = APPEND_NONE; 4673328d5752SMark Fasheh insert.ins_contig = CONTIG_NONE; 4674328d5752SMark Fasheh insert.ins_tree_depth = depth; 4675328d5752SMark Fasheh 4676328d5752SMark Fasheh insert_range = le32_to_cpu(split_rec.e_cpos) + 4677328d5752SMark Fasheh le16_to_cpu(split_rec.e_leaf_clusters); 4678328d5752SMark Fasheh rec_range = le32_to_cpu(rec.e_cpos) + 4679328d5752SMark Fasheh le16_to_cpu(rec.e_leaf_clusters); 4680328d5752SMark Fasheh 4681328d5752SMark Fasheh if (split_rec.e_cpos == rec.e_cpos) { 4682328d5752SMark Fasheh insert.ins_split = SPLIT_LEFT; 4683328d5752SMark Fasheh } else if (insert_range == rec_range) { 4684328d5752SMark Fasheh insert.ins_split = SPLIT_RIGHT; 4685328d5752SMark Fasheh } else { 4686328d5752SMark Fasheh /* 4687328d5752SMark Fasheh * Left/right split. We fake this as a right split 4688328d5752SMark Fasheh * first and then make a second pass as a left split. 4689328d5752SMark Fasheh */ 4690328d5752SMark Fasheh insert.ins_split = SPLIT_RIGHT; 4691328d5752SMark Fasheh 4692328d5752SMark Fasheh ocfs2_make_right_split_rec(inode->i_sb, &tmprec, insert_range, 4693328d5752SMark Fasheh &rec); 4694328d5752SMark Fasheh 4695328d5752SMark Fasheh split_rec = tmprec; 4696328d5752SMark Fasheh 4697328d5752SMark Fasheh BUG_ON(do_leftright); 4698328d5752SMark Fasheh do_leftright = 1; 4699328d5752SMark Fasheh } 4700328d5752SMark Fasheh 4701e7d4cb6bSTao Ma ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert); 4702328d5752SMark Fasheh if (ret) { 4703328d5752SMark Fasheh mlog_errno(ret); 4704328d5752SMark Fasheh goto out; 4705328d5752SMark Fasheh } 4706328d5752SMark Fasheh 4707328d5752SMark Fasheh if (do_leftright == 1) { 4708328d5752SMark Fasheh u32 cpos; 4709328d5752SMark Fasheh struct ocfs2_extent_list *el; 4710328d5752SMark Fasheh 4711328d5752SMark Fasheh do_leftright++; 4712328d5752SMark Fasheh split_rec = *orig_split_rec; 4713328d5752SMark Fasheh 4714328d5752SMark Fasheh ocfs2_reinit_path(path, 1); 4715328d5752SMark Fasheh 4716328d5752SMark Fasheh cpos = le32_to_cpu(split_rec.e_cpos); 4717328d5752SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 4718328d5752SMark Fasheh if (ret) { 4719328d5752SMark Fasheh mlog_errno(ret); 4720328d5752SMark Fasheh goto out; 4721328d5752SMark Fasheh } 4722328d5752SMark Fasheh 4723328d5752SMark Fasheh el = path_leaf_el(path); 4724328d5752SMark Fasheh split_index = ocfs2_search_extent_list(el, cpos); 4725328d5752SMark Fasheh goto leftright; 4726328d5752SMark Fasheh } 4727328d5752SMark Fasheh out: 4728328d5752SMark Fasheh 4729328d5752SMark Fasheh return ret; 4730328d5752SMark Fasheh } 4731328d5752SMark Fasheh 4732328d5752SMark Fasheh /* 4733328d5752SMark Fasheh * Mark part or all of the extent record at split_index in the leaf 4734328d5752SMark Fasheh * pointed to by path as written. This removes the unwritten 4735328d5752SMark Fasheh * extent flag. 4736328d5752SMark Fasheh * 4737328d5752SMark Fasheh * Care is taken to handle contiguousness so as to not grow the tree. 4738328d5752SMark Fasheh * 4739328d5752SMark Fasheh * meta_ac is not strictly necessary - we only truly need it if growth 4740328d5752SMark Fasheh * of the tree is required. All other cases will degrade into a less 4741328d5752SMark Fasheh * optimal tree layout. 4742328d5752SMark Fasheh * 4743e7d4cb6bSTao Ma * last_eb_bh should be the rightmost leaf block for any extent 4744e7d4cb6bSTao Ma * btree. Since a split may grow the tree or a merge might shrink it, 4745e7d4cb6bSTao Ma * the caller cannot trust the contents of that buffer after this call. 4746328d5752SMark Fasheh * 4747328d5752SMark Fasheh * This code is optimized for readability - several passes might be 4748328d5752SMark Fasheh * made over certain portions of the tree. All of those blocks will 4749328d5752SMark Fasheh * have been brought into cache (and pinned via the journal), so the 4750328d5752SMark Fasheh * extra overhead is not expressed in terms of disk reads. 4751328d5752SMark Fasheh */ 4752328d5752SMark Fasheh static int __ocfs2_mark_extent_written(struct inode *inode, 4753e7d4cb6bSTao Ma struct ocfs2_extent_tree *et, 4754328d5752SMark Fasheh handle_t *handle, 4755328d5752SMark Fasheh struct ocfs2_path *path, 4756328d5752SMark Fasheh int split_index, 4757328d5752SMark Fasheh struct ocfs2_extent_rec *split_rec, 4758328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac, 4759328d5752SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc) 4760328d5752SMark Fasheh { 4761328d5752SMark Fasheh int ret = 0; 4762328d5752SMark Fasheh struct ocfs2_extent_list *el = path_leaf_el(path); 4763e8aed345SMark Fasheh struct buffer_head *last_eb_bh = NULL; 4764328d5752SMark Fasheh struct ocfs2_extent_rec *rec = &el->l_recs[split_index]; 4765328d5752SMark Fasheh struct ocfs2_merge_ctxt ctxt; 4766328d5752SMark Fasheh struct ocfs2_extent_list *rightmost_el; 4767328d5752SMark Fasheh 47683cf0c507SRoel Kluin if (!(rec->e_flags & OCFS2_EXT_UNWRITTEN)) { 4769328d5752SMark Fasheh ret = -EIO; 4770328d5752SMark Fasheh mlog_errno(ret); 4771328d5752SMark Fasheh goto out; 4772328d5752SMark Fasheh } 4773328d5752SMark Fasheh 4774328d5752SMark Fasheh if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) || 4775328d5752SMark Fasheh ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) < 4776328d5752SMark Fasheh (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) { 4777328d5752SMark Fasheh ret = -EIO; 4778328d5752SMark Fasheh mlog_errno(ret); 4779328d5752SMark Fasheh goto out; 4780328d5752SMark Fasheh } 4781328d5752SMark Fasheh 4782ad5a4d70STao Ma ctxt.c_contig_type = ocfs2_figure_merge_contig_type(inode, path, el, 4783328d5752SMark Fasheh split_index, 4784328d5752SMark Fasheh split_rec); 4785328d5752SMark Fasheh 4786328d5752SMark Fasheh /* 4787328d5752SMark Fasheh * The core merge / split code wants to know how much room is 4788328d5752SMark Fasheh * left in this inodes allocation tree, so we pass the 4789328d5752SMark Fasheh * rightmost extent list. 4790328d5752SMark Fasheh */ 4791328d5752SMark Fasheh if (path->p_tree_depth) { 4792328d5752SMark Fasheh struct ocfs2_extent_block *eb; 4793328d5752SMark Fasheh 4794328d5752SMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 479535dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), 4796328d5752SMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 4797328d5752SMark Fasheh if (ret) { 4798328d5752SMark Fasheh mlog_exit(ret); 4799328d5752SMark Fasheh goto out; 4800328d5752SMark Fasheh } 4801328d5752SMark Fasheh 4802328d5752SMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 4803328d5752SMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 4804328d5752SMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 4805328d5752SMark Fasheh ret = -EROFS; 4806328d5752SMark Fasheh goto out; 4807328d5752SMark Fasheh } 4808328d5752SMark Fasheh 4809328d5752SMark Fasheh rightmost_el = &eb->h_list; 4810328d5752SMark Fasheh } else 4811328d5752SMark Fasheh rightmost_el = path_root_el(path); 4812328d5752SMark Fasheh 4813328d5752SMark Fasheh if (rec->e_cpos == split_rec->e_cpos && 4814328d5752SMark Fasheh rec->e_leaf_clusters == split_rec->e_leaf_clusters) 4815328d5752SMark Fasheh ctxt.c_split_covers_rec = 1; 4816328d5752SMark Fasheh else 4817328d5752SMark Fasheh ctxt.c_split_covers_rec = 0; 4818328d5752SMark Fasheh 4819328d5752SMark Fasheh ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]); 4820328d5752SMark Fasheh 4821015452b1SMark Fasheh mlog(0, "index: %d, contig: %u, has_empty: %u, split_covers: %u\n", 4822015452b1SMark Fasheh split_index, ctxt.c_contig_type, ctxt.c_has_empty_extent, 4823015452b1SMark Fasheh ctxt.c_split_covers_rec); 4824328d5752SMark Fasheh 4825328d5752SMark Fasheh if (ctxt.c_contig_type == CONTIG_NONE) { 4826328d5752SMark Fasheh if (ctxt.c_split_covers_rec) 4827328d5752SMark Fasheh el->l_recs[split_index] = *split_rec; 4828328d5752SMark Fasheh else 4829e7d4cb6bSTao Ma ret = ocfs2_split_and_insert(inode, handle, path, et, 4830328d5752SMark Fasheh &last_eb_bh, split_index, 4831328d5752SMark Fasheh split_rec, meta_ac); 4832328d5752SMark Fasheh if (ret) 4833328d5752SMark Fasheh mlog_errno(ret); 4834328d5752SMark Fasheh } else { 4835328d5752SMark Fasheh ret = ocfs2_try_to_merge_extent(inode, handle, path, 4836328d5752SMark Fasheh split_index, split_rec, 4837e7d4cb6bSTao Ma dealloc, &ctxt, et); 4838328d5752SMark Fasheh if (ret) 4839328d5752SMark Fasheh mlog_errno(ret); 4840328d5752SMark Fasheh } 4841328d5752SMark Fasheh 4842328d5752SMark Fasheh out: 4843328d5752SMark Fasheh brelse(last_eb_bh); 4844328d5752SMark Fasheh return ret; 4845328d5752SMark Fasheh } 4846328d5752SMark Fasheh 4847328d5752SMark Fasheh /* 4848328d5752SMark Fasheh * Mark the already-existing extent at cpos as written for len clusters. 4849328d5752SMark Fasheh * 4850328d5752SMark Fasheh * If the existing extent is larger than the request, initiate a 4851328d5752SMark Fasheh * split. An attempt will be made at merging with adjacent extents. 4852328d5752SMark Fasheh * 4853328d5752SMark Fasheh * The caller is responsible for passing down meta_ac if we'll need it. 4854328d5752SMark Fasheh */ 4855e7d4cb6bSTao Ma int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *root_bh, 4856328d5752SMark Fasheh handle_t *handle, u32 cpos, u32 len, u32 phys, 4857328d5752SMark Fasheh struct ocfs2_alloc_context *meta_ac, 4858e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 4859f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 4860f56654c4STao Ma void *private) 4861328d5752SMark Fasheh { 4862328d5752SMark Fasheh int ret, index; 4863328d5752SMark Fasheh u64 start_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys); 4864328d5752SMark Fasheh struct ocfs2_extent_rec split_rec; 4865328d5752SMark Fasheh struct ocfs2_path *left_path = NULL; 4866328d5752SMark Fasheh struct ocfs2_extent_list *el; 4867dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 4868328d5752SMark Fasheh 4869328d5752SMark Fasheh mlog(0, "Inode %lu cpos %u, len %u, phys %u (%llu)\n", 4870328d5752SMark Fasheh inode->i_ino, cpos, len, phys, (unsigned long long)start_blkno); 4871328d5752SMark Fasheh 4872dc0ce61aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, et_type, private); 4873dc0ce61aSJoel Becker 4874328d5752SMark Fasheh if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) { 4875328d5752SMark Fasheh ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents " 4876328d5752SMark Fasheh "that are being written to, but the feature bit " 4877328d5752SMark Fasheh "is not set in the super block.", 4878328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno); 4879328d5752SMark Fasheh ret = -EROFS; 4880328d5752SMark Fasheh goto out; 4881328d5752SMark Fasheh } 4882328d5752SMark Fasheh 4883328d5752SMark Fasheh /* 4884328d5752SMark Fasheh * XXX: This should be fixed up so that we just re-insert the 4885328d5752SMark Fasheh * next extent records. 4886328d5752SMark Fasheh */ 4887e7d4cb6bSTao Ma if (et_type == OCFS2_DINODE_EXTENT) 4888328d5752SMark Fasheh ocfs2_extent_map_trunc(inode, 0); 4889328d5752SMark Fasheh 4890dc0ce61aSJoel Becker left_path = ocfs2_new_path(et.et_root_bh, et.et_root_el); 4891328d5752SMark Fasheh if (!left_path) { 4892328d5752SMark Fasheh ret = -ENOMEM; 4893328d5752SMark Fasheh mlog_errno(ret); 4894328d5752SMark Fasheh goto out; 4895328d5752SMark Fasheh } 4896328d5752SMark Fasheh 4897328d5752SMark Fasheh ret = ocfs2_find_path(inode, left_path, cpos); 4898328d5752SMark Fasheh if (ret) { 4899328d5752SMark Fasheh mlog_errno(ret); 4900328d5752SMark Fasheh goto out; 4901328d5752SMark Fasheh } 4902328d5752SMark Fasheh el = path_leaf_el(left_path); 4903328d5752SMark Fasheh 4904328d5752SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 4905328d5752SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 4906328d5752SMark Fasheh ocfs2_error(inode->i_sb, 4907328d5752SMark Fasheh "Inode %llu has an extent at cpos %u which can no " 4908328d5752SMark Fasheh "longer be found.\n", 4909328d5752SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos); 4910328d5752SMark Fasheh ret = -EROFS; 4911328d5752SMark Fasheh goto out; 4912328d5752SMark Fasheh } 4913328d5752SMark Fasheh 4914328d5752SMark Fasheh memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec)); 4915328d5752SMark Fasheh split_rec.e_cpos = cpu_to_le32(cpos); 4916328d5752SMark Fasheh split_rec.e_leaf_clusters = cpu_to_le16(len); 4917328d5752SMark Fasheh split_rec.e_blkno = cpu_to_le64(start_blkno); 4918328d5752SMark Fasheh split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags; 4919328d5752SMark Fasheh split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN; 4920328d5752SMark Fasheh 4921dc0ce61aSJoel Becker ret = __ocfs2_mark_extent_written(inode, &et, handle, left_path, 4922e7d4cb6bSTao Ma index, &split_rec, meta_ac, 4923e7d4cb6bSTao Ma dealloc); 4924328d5752SMark Fasheh if (ret) 4925328d5752SMark Fasheh mlog_errno(ret); 4926328d5752SMark Fasheh 4927328d5752SMark Fasheh out: 4928328d5752SMark Fasheh ocfs2_free_path(left_path); 4929dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 4930328d5752SMark Fasheh return ret; 4931328d5752SMark Fasheh } 4932328d5752SMark Fasheh 4933e7d4cb6bSTao Ma static int ocfs2_split_tree(struct inode *inode, struct ocfs2_extent_tree *et, 4934d0c7d708SMark Fasheh handle_t *handle, struct ocfs2_path *path, 4935d0c7d708SMark Fasheh int index, u32 new_range, 4936d0c7d708SMark Fasheh struct ocfs2_alloc_context *meta_ac) 4937d0c7d708SMark Fasheh { 4938d0c7d708SMark Fasheh int ret, depth, credits = handle->h_buffer_credits; 4939d0c7d708SMark Fasheh struct buffer_head *last_eb_bh = NULL; 4940d0c7d708SMark Fasheh struct ocfs2_extent_block *eb; 4941d0c7d708SMark Fasheh struct ocfs2_extent_list *rightmost_el, *el; 4942d0c7d708SMark Fasheh struct ocfs2_extent_rec split_rec; 4943d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 4944d0c7d708SMark Fasheh struct ocfs2_insert_type insert; 4945d0c7d708SMark Fasheh 4946d0c7d708SMark Fasheh /* 4947d0c7d708SMark Fasheh * Setup the record to split before we grow the tree. 4948d0c7d708SMark Fasheh */ 4949d0c7d708SMark Fasheh el = path_leaf_el(path); 4950d0c7d708SMark Fasheh rec = &el->l_recs[index]; 4951d0c7d708SMark Fasheh ocfs2_make_right_split_rec(inode->i_sb, &split_rec, new_range, rec); 4952d0c7d708SMark Fasheh 4953d0c7d708SMark Fasheh depth = path->p_tree_depth; 4954d0c7d708SMark Fasheh if (depth > 0) { 4955d0c7d708SMark Fasheh ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), 495635dc0aa3SJoel Becker ocfs2_et_get_last_eb_blk(et), 4957d0c7d708SMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 4958d0c7d708SMark Fasheh if (ret < 0) { 4959d0c7d708SMark Fasheh mlog_errno(ret); 4960d0c7d708SMark Fasheh goto out; 4961d0c7d708SMark Fasheh } 4962d0c7d708SMark Fasheh 4963d0c7d708SMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 4964d0c7d708SMark Fasheh rightmost_el = &eb->h_list; 4965d0c7d708SMark Fasheh } else 4966d0c7d708SMark Fasheh rightmost_el = path_leaf_el(path); 4967d0c7d708SMark Fasheh 4968811f933dSTao Ma credits += path->p_tree_depth + 4969ce1d9ea6SJoel Becker ocfs2_extend_meta_needed(et->et_root_el); 4970d0c7d708SMark Fasheh ret = ocfs2_extend_trans(handle, credits); 4971d0c7d708SMark Fasheh if (ret) { 4972d0c7d708SMark Fasheh mlog_errno(ret); 4973d0c7d708SMark Fasheh goto out; 4974d0c7d708SMark Fasheh } 4975d0c7d708SMark Fasheh 4976d0c7d708SMark Fasheh if (le16_to_cpu(rightmost_el->l_next_free_rec) == 4977d0c7d708SMark Fasheh le16_to_cpu(rightmost_el->l_count)) { 4978e7d4cb6bSTao Ma ret = ocfs2_grow_tree(inode, handle, et, &depth, &last_eb_bh, 4979d0c7d708SMark Fasheh meta_ac); 4980d0c7d708SMark Fasheh if (ret) { 4981d0c7d708SMark Fasheh mlog_errno(ret); 4982d0c7d708SMark Fasheh goto out; 4983d0c7d708SMark Fasheh } 4984d0c7d708SMark Fasheh } 4985d0c7d708SMark Fasheh 4986d0c7d708SMark Fasheh memset(&insert, 0, sizeof(struct ocfs2_insert_type)); 4987d0c7d708SMark Fasheh insert.ins_appending = APPEND_NONE; 4988d0c7d708SMark Fasheh insert.ins_contig = CONTIG_NONE; 4989d0c7d708SMark Fasheh insert.ins_split = SPLIT_RIGHT; 4990d0c7d708SMark Fasheh insert.ins_tree_depth = depth; 4991d0c7d708SMark Fasheh 4992e7d4cb6bSTao Ma ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert); 4993d0c7d708SMark Fasheh if (ret) 4994d0c7d708SMark Fasheh mlog_errno(ret); 4995d0c7d708SMark Fasheh 4996d0c7d708SMark Fasheh out: 4997d0c7d708SMark Fasheh brelse(last_eb_bh); 4998d0c7d708SMark Fasheh return ret; 4999d0c7d708SMark Fasheh } 5000d0c7d708SMark Fasheh 5001d0c7d708SMark Fasheh static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle, 5002d0c7d708SMark Fasheh struct ocfs2_path *path, int index, 5003d0c7d708SMark Fasheh struct ocfs2_cached_dealloc_ctxt *dealloc, 5004e7d4cb6bSTao Ma u32 cpos, u32 len, 5005e7d4cb6bSTao Ma struct ocfs2_extent_tree *et) 5006d0c7d708SMark Fasheh { 5007d0c7d708SMark Fasheh int ret; 5008d0c7d708SMark Fasheh u32 left_cpos, rec_range, trunc_range; 5009d0c7d708SMark Fasheh int wants_rotate = 0, is_rightmost_tree_rec = 0; 5010d0c7d708SMark Fasheh struct super_block *sb = inode->i_sb; 5011d0c7d708SMark Fasheh struct ocfs2_path *left_path = NULL; 5012d0c7d708SMark Fasheh struct ocfs2_extent_list *el = path_leaf_el(path); 5013d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 5014d0c7d708SMark Fasheh struct ocfs2_extent_block *eb; 5015d0c7d708SMark Fasheh 5016d0c7d708SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) { 5017e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et); 5018d0c7d708SMark Fasheh if (ret) { 5019d0c7d708SMark Fasheh mlog_errno(ret); 5020d0c7d708SMark Fasheh goto out; 5021d0c7d708SMark Fasheh } 5022d0c7d708SMark Fasheh 5023d0c7d708SMark Fasheh index--; 5024d0c7d708SMark Fasheh } 5025d0c7d708SMark Fasheh 5026d0c7d708SMark Fasheh if (index == (le16_to_cpu(el->l_next_free_rec) - 1) && 5027d0c7d708SMark Fasheh path->p_tree_depth) { 5028d0c7d708SMark Fasheh /* 5029d0c7d708SMark Fasheh * Check whether this is the rightmost tree record. If 5030d0c7d708SMark Fasheh * we remove all of this record or part of its right 5031d0c7d708SMark Fasheh * edge then an update of the record lengths above it 5032d0c7d708SMark Fasheh * will be required. 5033d0c7d708SMark Fasheh */ 5034d0c7d708SMark Fasheh eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data; 5035d0c7d708SMark Fasheh if (eb->h_next_leaf_blk == 0) 5036d0c7d708SMark Fasheh is_rightmost_tree_rec = 1; 5037d0c7d708SMark Fasheh } 5038d0c7d708SMark Fasheh 5039d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5040d0c7d708SMark Fasheh if (index == 0 && path->p_tree_depth && 5041d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos) == cpos) { 5042d0c7d708SMark Fasheh /* 5043d0c7d708SMark Fasheh * Changing the leftmost offset (via partial or whole 5044d0c7d708SMark Fasheh * record truncate) of an interior (or rightmost) path 5045d0c7d708SMark Fasheh * means we have to update the subtree that is formed 5046d0c7d708SMark Fasheh * by this leaf and the one to it's left. 5047d0c7d708SMark Fasheh * 5048d0c7d708SMark Fasheh * There are two cases we can skip: 5049d0c7d708SMark Fasheh * 1) Path is the leftmost one in our inode tree. 5050d0c7d708SMark Fasheh * 2) The leaf is rightmost and will be empty after 5051d0c7d708SMark Fasheh * we remove the extent record - the rotate code 5052d0c7d708SMark Fasheh * knows how to update the newly formed edge. 5053d0c7d708SMark Fasheh */ 5054d0c7d708SMark Fasheh 5055d0c7d708SMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, 5056d0c7d708SMark Fasheh &left_cpos); 5057d0c7d708SMark Fasheh if (ret) { 5058d0c7d708SMark Fasheh mlog_errno(ret); 5059d0c7d708SMark Fasheh goto out; 5060d0c7d708SMark Fasheh } 5061d0c7d708SMark Fasheh 5062d0c7d708SMark Fasheh if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) { 5063d0c7d708SMark Fasheh left_path = ocfs2_new_path(path_root_bh(path), 5064d0c7d708SMark Fasheh path_root_el(path)); 5065d0c7d708SMark Fasheh if (!left_path) { 5066d0c7d708SMark Fasheh ret = -ENOMEM; 5067d0c7d708SMark Fasheh mlog_errno(ret); 5068d0c7d708SMark Fasheh goto out; 5069d0c7d708SMark Fasheh } 5070d0c7d708SMark Fasheh 5071d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, left_path, left_cpos); 5072d0c7d708SMark Fasheh if (ret) { 5073d0c7d708SMark Fasheh mlog_errno(ret); 5074d0c7d708SMark Fasheh goto out; 5075d0c7d708SMark Fasheh } 5076d0c7d708SMark Fasheh } 5077d0c7d708SMark Fasheh } 5078d0c7d708SMark Fasheh 5079d0c7d708SMark Fasheh ret = ocfs2_extend_rotate_transaction(handle, 0, 5080d0c7d708SMark Fasheh handle->h_buffer_credits, 5081d0c7d708SMark Fasheh path); 5082d0c7d708SMark Fasheh if (ret) { 5083d0c7d708SMark Fasheh mlog_errno(ret); 5084d0c7d708SMark Fasheh goto out; 5085d0c7d708SMark Fasheh } 5086d0c7d708SMark Fasheh 5087d0c7d708SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, path); 5088d0c7d708SMark Fasheh if (ret) { 5089d0c7d708SMark Fasheh mlog_errno(ret); 5090d0c7d708SMark Fasheh goto out; 5091d0c7d708SMark Fasheh } 5092d0c7d708SMark Fasheh 5093d0c7d708SMark Fasheh ret = ocfs2_journal_access_path(inode, handle, left_path); 5094d0c7d708SMark Fasheh if (ret) { 5095d0c7d708SMark Fasheh mlog_errno(ret); 5096d0c7d708SMark Fasheh goto out; 5097d0c7d708SMark Fasheh } 5098d0c7d708SMark Fasheh 5099d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 5100d0c7d708SMark Fasheh trunc_range = cpos + len; 5101d0c7d708SMark Fasheh 5102d0c7d708SMark Fasheh if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) { 5103d0c7d708SMark Fasheh int next_free; 5104d0c7d708SMark Fasheh 5105d0c7d708SMark Fasheh memset(rec, 0, sizeof(*rec)); 5106d0c7d708SMark Fasheh ocfs2_cleanup_merge(el, index); 5107d0c7d708SMark Fasheh wants_rotate = 1; 5108d0c7d708SMark Fasheh 5109d0c7d708SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 5110d0c7d708SMark Fasheh if (is_rightmost_tree_rec && next_free > 1) { 5111d0c7d708SMark Fasheh /* 5112d0c7d708SMark Fasheh * We skip the edge update if this path will 5113d0c7d708SMark Fasheh * be deleted by the rotate code. 5114d0c7d708SMark Fasheh */ 5115d0c7d708SMark Fasheh rec = &el->l_recs[next_free - 1]; 5116d0c7d708SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, path, 5117d0c7d708SMark Fasheh rec); 5118d0c7d708SMark Fasheh } 5119d0c7d708SMark Fasheh } else if (le32_to_cpu(rec->e_cpos) == cpos) { 5120d0c7d708SMark Fasheh /* Remove leftmost portion of the record. */ 5121d0c7d708SMark Fasheh le32_add_cpu(&rec->e_cpos, len); 5122d0c7d708SMark Fasheh le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len)); 5123d0c7d708SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -len); 5124d0c7d708SMark Fasheh } else if (rec_range == trunc_range) { 5125d0c7d708SMark Fasheh /* Remove rightmost portion of the record */ 5126d0c7d708SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -len); 5127d0c7d708SMark Fasheh if (is_rightmost_tree_rec) 5128d0c7d708SMark Fasheh ocfs2_adjust_rightmost_records(inode, handle, path, rec); 5129d0c7d708SMark Fasheh } else { 5130d0c7d708SMark Fasheh /* Caller should have trapped this. */ 5131d0c7d708SMark Fasheh mlog(ML_ERROR, "Inode %llu: Invalid record truncate: (%u, %u) " 5132d0c7d708SMark Fasheh "(%u, %u)\n", (unsigned long long)OCFS2_I(inode)->ip_blkno, 5133d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos), 5134d0c7d708SMark Fasheh le16_to_cpu(rec->e_leaf_clusters), cpos, len); 5135d0c7d708SMark Fasheh BUG(); 5136d0c7d708SMark Fasheh } 5137d0c7d708SMark Fasheh 5138d0c7d708SMark Fasheh if (left_path) { 5139d0c7d708SMark Fasheh int subtree_index; 5140d0c7d708SMark Fasheh 5141d0c7d708SMark Fasheh subtree_index = ocfs2_find_subtree_root(inode, left_path, path); 5142d0c7d708SMark Fasheh ocfs2_complete_edge_insert(inode, handle, left_path, path, 5143d0c7d708SMark Fasheh subtree_index); 5144d0c7d708SMark Fasheh } 5145d0c7d708SMark Fasheh 5146d0c7d708SMark Fasheh ocfs2_journal_dirty(handle, path_leaf_bh(path)); 5147d0c7d708SMark Fasheh 5148e7d4cb6bSTao Ma ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et); 5149d0c7d708SMark Fasheh if (ret) { 5150d0c7d708SMark Fasheh mlog_errno(ret); 5151d0c7d708SMark Fasheh goto out; 5152d0c7d708SMark Fasheh } 5153d0c7d708SMark Fasheh 5154d0c7d708SMark Fasheh out: 5155d0c7d708SMark Fasheh ocfs2_free_path(left_path); 5156d0c7d708SMark Fasheh return ret; 5157d0c7d708SMark Fasheh } 5158d0c7d708SMark Fasheh 5159e7d4cb6bSTao Ma int ocfs2_remove_extent(struct inode *inode, struct buffer_head *root_bh, 5160d0c7d708SMark Fasheh u32 cpos, u32 len, handle_t *handle, 5161d0c7d708SMark Fasheh struct ocfs2_alloc_context *meta_ac, 5162e7d4cb6bSTao Ma struct ocfs2_cached_dealloc_ctxt *dealloc, 5163f56654c4STao Ma enum ocfs2_extent_tree_type et_type, 5164f56654c4STao Ma void *private) 5165d0c7d708SMark Fasheh { 5166d0c7d708SMark Fasheh int ret, index; 5167d0c7d708SMark Fasheh u32 rec_range, trunc_range; 5168d0c7d708SMark Fasheh struct ocfs2_extent_rec *rec; 5169d0c7d708SMark Fasheh struct ocfs2_extent_list *el; 5170e7d4cb6bSTao Ma struct ocfs2_path *path = NULL; 5171dc0ce61aSJoel Becker struct ocfs2_extent_tree et; 5172e7d4cb6bSTao Ma 5173dc0ce61aSJoel Becker ocfs2_get_extent_tree(&et, inode, root_bh, et_type, private); 5174d0c7d708SMark Fasheh 5175d0c7d708SMark Fasheh ocfs2_extent_map_trunc(inode, 0); 5176d0c7d708SMark Fasheh 5177dc0ce61aSJoel Becker path = ocfs2_new_path(et.et_root_bh, et.et_root_el); 5178d0c7d708SMark Fasheh if (!path) { 5179d0c7d708SMark Fasheh ret = -ENOMEM; 5180d0c7d708SMark Fasheh mlog_errno(ret); 5181d0c7d708SMark Fasheh goto out; 5182d0c7d708SMark Fasheh } 5183d0c7d708SMark Fasheh 5184d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 5185d0c7d708SMark Fasheh if (ret) { 5186d0c7d708SMark Fasheh mlog_errno(ret); 5187d0c7d708SMark Fasheh goto out; 5188d0c7d708SMark Fasheh } 5189d0c7d708SMark Fasheh 5190d0c7d708SMark Fasheh el = path_leaf_el(path); 5191d0c7d708SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 5192d0c7d708SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 5193d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5194d0c7d708SMark Fasheh "Inode %llu has an extent at cpos %u which can no " 5195d0c7d708SMark Fasheh "longer be found.\n", 5196d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos); 5197d0c7d708SMark Fasheh ret = -EROFS; 5198d0c7d708SMark Fasheh goto out; 5199d0c7d708SMark Fasheh } 5200d0c7d708SMark Fasheh 5201d0c7d708SMark Fasheh /* 5202d0c7d708SMark Fasheh * We have 3 cases of extent removal: 5203d0c7d708SMark Fasheh * 1) Range covers the entire extent rec 5204d0c7d708SMark Fasheh * 2) Range begins or ends on one edge of the extent rec 5205d0c7d708SMark Fasheh * 3) Range is in the middle of the extent rec (no shared edges) 5206d0c7d708SMark Fasheh * 5207d0c7d708SMark Fasheh * For case 1 we remove the extent rec and left rotate to 5208d0c7d708SMark Fasheh * fill the hole. 5209d0c7d708SMark Fasheh * 5210d0c7d708SMark Fasheh * For case 2 we just shrink the existing extent rec, with a 5211d0c7d708SMark Fasheh * tree update if the shrinking edge is also the edge of an 5212d0c7d708SMark Fasheh * extent block. 5213d0c7d708SMark Fasheh * 5214d0c7d708SMark Fasheh * For case 3 we do a right split to turn the extent rec into 5215d0c7d708SMark Fasheh * something case 2 can handle. 5216d0c7d708SMark Fasheh */ 5217d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5218d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec); 5219d0c7d708SMark Fasheh trunc_range = cpos + len; 5220d0c7d708SMark Fasheh 5221d0c7d708SMark Fasheh BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range); 5222d0c7d708SMark Fasheh 5223d0c7d708SMark Fasheh mlog(0, "Inode %llu, remove (cpos %u, len %u). Existing index %d " 5224d0c7d708SMark Fasheh "(cpos %u, len %u)\n", 5225d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, len, index, 5226d0c7d708SMark Fasheh le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec)); 5227d0c7d708SMark Fasheh 5228d0c7d708SMark Fasheh if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) { 5229d0c7d708SMark Fasheh ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc, 5230dc0ce61aSJoel Becker cpos, len, &et); 5231d0c7d708SMark Fasheh if (ret) { 5232d0c7d708SMark Fasheh mlog_errno(ret); 5233d0c7d708SMark Fasheh goto out; 5234d0c7d708SMark Fasheh } 5235d0c7d708SMark Fasheh } else { 5236dc0ce61aSJoel Becker ret = ocfs2_split_tree(inode, &et, handle, path, index, 5237d0c7d708SMark Fasheh trunc_range, meta_ac); 5238d0c7d708SMark Fasheh if (ret) { 5239d0c7d708SMark Fasheh mlog_errno(ret); 5240d0c7d708SMark Fasheh goto out; 5241d0c7d708SMark Fasheh } 5242d0c7d708SMark Fasheh 5243d0c7d708SMark Fasheh /* 5244d0c7d708SMark Fasheh * The split could have manipulated the tree enough to 5245d0c7d708SMark Fasheh * move the record location, so we have to look for it again. 5246d0c7d708SMark Fasheh */ 5247d0c7d708SMark Fasheh ocfs2_reinit_path(path, 1); 5248d0c7d708SMark Fasheh 5249d0c7d708SMark Fasheh ret = ocfs2_find_path(inode, path, cpos); 5250d0c7d708SMark Fasheh if (ret) { 5251d0c7d708SMark Fasheh mlog_errno(ret); 5252d0c7d708SMark Fasheh goto out; 5253d0c7d708SMark Fasheh } 5254d0c7d708SMark Fasheh 5255d0c7d708SMark Fasheh el = path_leaf_el(path); 5256d0c7d708SMark Fasheh index = ocfs2_search_extent_list(el, cpos); 5257d0c7d708SMark Fasheh if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) { 5258d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5259d0c7d708SMark Fasheh "Inode %llu: split at cpos %u lost record.", 5260d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 5261d0c7d708SMark Fasheh cpos); 5262d0c7d708SMark Fasheh ret = -EROFS; 5263d0c7d708SMark Fasheh goto out; 5264d0c7d708SMark Fasheh } 5265d0c7d708SMark Fasheh 5266d0c7d708SMark Fasheh /* 5267d0c7d708SMark Fasheh * Double check our values here. If anything is fishy, 5268d0c7d708SMark Fasheh * it's easier to catch it at the top level. 5269d0c7d708SMark Fasheh */ 5270d0c7d708SMark Fasheh rec = &el->l_recs[index]; 5271d0c7d708SMark Fasheh rec_range = le32_to_cpu(rec->e_cpos) + 5272d0c7d708SMark Fasheh ocfs2_rec_clusters(el, rec); 5273d0c7d708SMark Fasheh if (rec_range != trunc_range) { 5274d0c7d708SMark Fasheh ocfs2_error(inode->i_sb, 5275d0c7d708SMark Fasheh "Inode %llu: error after split at cpos %u" 5276d0c7d708SMark Fasheh "trunc len %u, existing record is (%u,%u)", 5277d0c7d708SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 5278d0c7d708SMark Fasheh cpos, len, le32_to_cpu(rec->e_cpos), 5279d0c7d708SMark Fasheh ocfs2_rec_clusters(el, rec)); 5280d0c7d708SMark Fasheh ret = -EROFS; 5281d0c7d708SMark Fasheh goto out; 5282d0c7d708SMark Fasheh } 5283d0c7d708SMark Fasheh 5284d0c7d708SMark Fasheh ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc, 5285dc0ce61aSJoel Becker cpos, len, &et); 5286d0c7d708SMark Fasheh if (ret) { 5287d0c7d708SMark Fasheh mlog_errno(ret); 5288d0c7d708SMark Fasheh goto out; 5289d0c7d708SMark Fasheh } 5290d0c7d708SMark Fasheh } 5291d0c7d708SMark Fasheh 5292d0c7d708SMark Fasheh out: 5293d0c7d708SMark Fasheh ocfs2_free_path(path); 5294dc0ce61aSJoel Becker ocfs2_put_extent_tree(&et); 5295d0c7d708SMark Fasheh return ret; 5296d0c7d708SMark Fasheh } 5297d0c7d708SMark Fasheh 5298063c4561SMark Fasheh int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb) 5299ccd979bdSMark Fasheh { 5300ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5301ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5302ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5303ccd979bdSMark Fasheh 5304ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5305ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5306ccd979bdSMark Fasheh 5307ccd979bdSMark Fasheh mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count), 5308ccd979bdSMark Fasheh "slot %d, invalid truncate log parameters: used = " 5309ccd979bdSMark Fasheh "%u, count = %u\n", osb->slot_num, 5310ccd979bdSMark Fasheh le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count)); 5311ccd979bdSMark Fasheh return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count); 5312ccd979bdSMark Fasheh } 5313ccd979bdSMark Fasheh 5314ccd979bdSMark Fasheh static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl, 5315ccd979bdSMark Fasheh unsigned int new_start) 5316ccd979bdSMark Fasheh { 5317ccd979bdSMark Fasheh unsigned int tail_index; 5318ccd979bdSMark Fasheh unsigned int current_tail; 5319ccd979bdSMark Fasheh 5320ccd979bdSMark Fasheh /* No records, nothing to coalesce */ 5321ccd979bdSMark Fasheh if (!le16_to_cpu(tl->tl_used)) 5322ccd979bdSMark Fasheh return 0; 5323ccd979bdSMark Fasheh 5324ccd979bdSMark Fasheh tail_index = le16_to_cpu(tl->tl_used) - 1; 5325ccd979bdSMark Fasheh current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start); 5326ccd979bdSMark Fasheh current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters); 5327ccd979bdSMark Fasheh 5328ccd979bdSMark Fasheh return current_tail == new_start; 5329ccd979bdSMark Fasheh } 5330ccd979bdSMark Fasheh 5331063c4561SMark Fasheh int ocfs2_truncate_log_append(struct ocfs2_super *osb, 53321fabe148SMark Fasheh handle_t *handle, 5333ccd979bdSMark Fasheh u64 start_blk, 5334ccd979bdSMark Fasheh unsigned int num_clusters) 5335ccd979bdSMark Fasheh { 5336ccd979bdSMark Fasheh int status, index; 5337ccd979bdSMark Fasheh unsigned int start_cluster, tl_count; 5338ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5339ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5340ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5341ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5342ccd979bdSMark Fasheh 5343b0697053SMark Fasheh mlog_entry("start_blk = %llu, num_clusters = %u\n", 5344b0697053SMark Fasheh (unsigned long long)start_blk, num_clusters); 5345ccd979bdSMark Fasheh 53461b1dcc1bSJes Sorensen BUG_ON(mutex_trylock(&tl_inode->i_mutex)); 5347ccd979bdSMark Fasheh 5348ccd979bdSMark Fasheh start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk); 5349ccd979bdSMark Fasheh 5350ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5351ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5352ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5353ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(osb->sb, di); 5354ccd979bdSMark Fasheh status = -EIO; 5355ccd979bdSMark Fasheh goto bail; 5356ccd979bdSMark Fasheh } 5357ccd979bdSMark Fasheh 5358ccd979bdSMark Fasheh tl_count = le16_to_cpu(tl->tl_count); 5359ccd979bdSMark Fasheh mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) || 5360ccd979bdSMark Fasheh tl_count == 0, 5361b0697053SMark Fasheh "Truncate record count on #%llu invalid " 5362b0697053SMark Fasheh "wanted %u, actual %u\n", 5363b0697053SMark Fasheh (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, 5364ccd979bdSMark Fasheh ocfs2_truncate_recs_per_inode(osb->sb), 5365ccd979bdSMark Fasheh le16_to_cpu(tl->tl_count)); 5366ccd979bdSMark Fasheh 5367ccd979bdSMark Fasheh /* Caller should have known to flush before calling us. */ 5368ccd979bdSMark Fasheh index = le16_to_cpu(tl->tl_used); 5369ccd979bdSMark Fasheh if (index >= tl_count) { 5370ccd979bdSMark Fasheh status = -ENOSPC; 5371ccd979bdSMark Fasheh mlog_errno(status); 5372ccd979bdSMark Fasheh goto bail; 5373ccd979bdSMark Fasheh } 5374ccd979bdSMark Fasheh 5375ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, tl_inode, tl_bh, 5376ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 5377ccd979bdSMark Fasheh if (status < 0) { 5378ccd979bdSMark Fasheh mlog_errno(status); 5379ccd979bdSMark Fasheh goto bail; 5380ccd979bdSMark Fasheh } 5381ccd979bdSMark Fasheh 5382ccd979bdSMark Fasheh mlog(0, "Log truncate of %u clusters starting at cluster %u to " 5383b0697053SMark Fasheh "%llu (index = %d)\n", num_clusters, start_cluster, 5384b0697053SMark Fasheh (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index); 5385ccd979bdSMark Fasheh 5386ccd979bdSMark Fasheh if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) { 5387ccd979bdSMark Fasheh /* 5388ccd979bdSMark Fasheh * Move index back to the record we are coalescing with. 5389ccd979bdSMark Fasheh * ocfs2_truncate_log_can_coalesce() guarantees nonzero 5390ccd979bdSMark Fasheh */ 5391ccd979bdSMark Fasheh index--; 5392ccd979bdSMark Fasheh 5393ccd979bdSMark Fasheh num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters); 5394ccd979bdSMark Fasheh mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n", 5395ccd979bdSMark Fasheh index, le32_to_cpu(tl->tl_recs[index].t_start), 5396ccd979bdSMark Fasheh num_clusters); 5397ccd979bdSMark Fasheh } else { 5398ccd979bdSMark Fasheh tl->tl_recs[index].t_start = cpu_to_le32(start_cluster); 5399ccd979bdSMark Fasheh tl->tl_used = cpu_to_le16(index + 1); 5400ccd979bdSMark Fasheh } 5401ccd979bdSMark Fasheh tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters); 5402ccd979bdSMark Fasheh 5403ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, tl_bh); 5404ccd979bdSMark Fasheh if (status < 0) { 5405ccd979bdSMark Fasheh mlog_errno(status); 5406ccd979bdSMark Fasheh goto bail; 5407ccd979bdSMark Fasheh } 5408ccd979bdSMark Fasheh 5409ccd979bdSMark Fasheh bail: 5410ccd979bdSMark Fasheh mlog_exit(status); 5411ccd979bdSMark Fasheh return status; 5412ccd979bdSMark Fasheh } 5413ccd979bdSMark Fasheh 5414ccd979bdSMark Fasheh static int ocfs2_replay_truncate_records(struct ocfs2_super *osb, 54151fabe148SMark Fasheh handle_t *handle, 5416ccd979bdSMark Fasheh struct inode *data_alloc_inode, 5417ccd979bdSMark Fasheh struct buffer_head *data_alloc_bh) 5418ccd979bdSMark Fasheh { 5419ccd979bdSMark Fasheh int status = 0; 5420ccd979bdSMark Fasheh int i; 5421ccd979bdSMark Fasheh unsigned int num_clusters; 5422ccd979bdSMark Fasheh u64 start_blk; 5423ccd979bdSMark Fasheh struct ocfs2_truncate_rec rec; 5424ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5425ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5426ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5427ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5428ccd979bdSMark Fasheh 5429ccd979bdSMark Fasheh mlog_entry_void(); 5430ccd979bdSMark Fasheh 5431ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5432ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5433ccd979bdSMark Fasheh i = le16_to_cpu(tl->tl_used) - 1; 5434ccd979bdSMark Fasheh while (i >= 0) { 5435ccd979bdSMark Fasheh /* Caller has given us at least enough credits to 5436ccd979bdSMark Fasheh * update the truncate log dinode */ 5437ccd979bdSMark Fasheh status = ocfs2_journal_access(handle, tl_inode, tl_bh, 5438ccd979bdSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 5439ccd979bdSMark Fasheh if (status < 0) { 5440ccd979bdSMark Fasheh mlog_errno(status); 5441ccd979bdSMark Fasheh goto bail; 5442ccd979bdSMark Fasheh } 5443ccd979bdSMark Fasheh 5444ccd979bdSMark Fasheh tl->tl_used = cpu_to_le16(i); 5445ccd979bdSMark Fasheh 5446ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, tl_bh); 5447ccd979bdSMark Fasheh if (status < 0) { 5448ccd979bdSMark Fasheh mlog_errno(status); 5449ccd979bdSMark Fasheh goto bail; 5450ccd979bdSMark Fasheh } 5451ccd979bdSMark Fasheh 5452ccd979bdSMark Fasheh /* TODO: Perhaps we can calculate the bulk of the 5453ccd979bdSMark Fasheh * credits up front rather than extending like 5454ccd979bdSMark Fasheh * this. */ 5455ccd979bdSMark Fasheh status = ocfs2_extend_trans(handle, 5456ccd979bdSMark Fasheh OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC); 5457ccd979bdSMark Fasheh if (status < 0) { 5458ccd979bdSMark Fasheh mlog_errno(status); 5459ccd979bdSMark Fasheh goto bail; 5460ccd979bdSMark Fasheh } 5461ccd979bdSMark Fasheh 5462ccd979bdSMark Fasheh rec = tl->tl_recs[i]; 5463ccd979bdSMark Fasheh start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb, 5464ccd979bdSMark Fasheh le32_to_cpu(rec.t_start)); 5465ccd979bdSMark Fasheh num_clusters = le32_to_cpu(rec.t_clusters); 5466ccd979bdSMark Fasheh 5467ccd979bdSMark Fasheh /* if start_blk is not set, we ignore the record as 5468ccd979bdSMark Fasheh * invalid. */ 5469ccd979bdSMark Fasheh if (start_blk) { 5470ccd979bdSMark Fasheh mlog(0, "free record %d, start = %u, clusters = %u\n", 5471ccd979bdSMark Fasheh i, le32_to_cpu(rec.t_start), num_clusters); 5472ccd979bdSMark Fasheh 5473ccd979bdSMark Fasheh status = ocfs2_free_clusters(handle, data_alloc_inode, 5474ccd979bdSMark Fasheh data_alloc_bh, start_blk, 5475ccd979bdSMark Fasheh num_clusters); 5476ccd979bdSMark Fasheh if (status < 0) { 5477ccd979bdSMark Fasheh mlog_errno(status); 5478ccd979bdSMark Fasheh goto bail; 5479ccd979bdSMark Fasheh } 5480ccd979bdSMark Fasheh } 5481ccd979bdSMark Fasheh i--; 5482ccd979bdSMark Fasheh } 5483ccd979bdSMark Fasheh 5484ccd979bdSMark Fasheh bail: 5485ccd979bdSMark Fasheh mlog_exit(status); 5486ccd979bdSMark Fasheh return status; 5487ccd979bdSMark Fasheh } 5488ccd979bdSMark Fasheh 54891b1dcc1bSJes Sorensen /* Expects you to already be holding tl_inode->i_mutex */ 5490063c4561SMark Fasheh int __ocfs2_flush_truncate_log(struct ocfs2_super *osb) 5491ccd979bdSMark Fasheh { 5492ccd979bdSMark Fasheh int status; 5493ccd979bdSMark Fasheh unsigned int num_to_flush; 54941fabe148SMark Fasheh handle_t *handle; 5495ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5496ccd979bdSMark Fasheh struct inode *data_alloc_inode = NULL; 5497ccd979bdSMark Fasheh struct buffer_head *tl_bh = osb->osb_tl_bh; 5498ccd979bdSMark Fasheh struct buffer_head *data_alloc_bh = NULL; 5499ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5500ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5501ccd979bdSMark Fasheh 5502ccd979bdSMark Fasheh mlog_entry_void(); 5503ccd979bdSMark Fasheh 55041b1dcc1bSJes Sorensen BUG_ON(mutex_trylock(&tl_inode->i_mutex)); 5505ccd979bdSMark Fasheh 5506ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5507ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5508ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5509ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(osb->sb, di); 5510ccd979bdSMark Fasheh status = -EIO; 5511e08dc8b9SMark Fasheh goto out; 5512ccd979bdSMark Fasheh } 5513ccd979bdSMark Fasheh 5514ccd979bdSMark Fasheh num_to_flush = le16_to_cpu(tl->tl_used); 5515b0697053SMark Fasheh mlog(0, "Flush %u records from truncate log #%llu\n", 5516b0697053SMark Fasheh num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno); 5517ccd979bdSMark Fasheh if (!num_to_flush) { 5518ccd979bdSMark Fasheh status = 0; 5519e08dc8b9SMark Fasheh goto out; 5520ccd979bdSMark Fasheh } 5521ccd979bdSMark Fasheh 5522ccd979bdSMark Fasheh data_alloc_inode = ocfs2_get_system_file_inode(osb, 5523ccd979bdSMark Fasheh GLOBAL_BITMAP_SYSTEM_INODE, 5524ccd979bdSMark Fasheh OCFS2_INVALID_SLOT); 5525ccd979bdSMark Fasheh if (!data_alloc_inode) { 5526ccd979bdSMark Fasheh status = -EINVAL; 5527ccd979bdSMark Fasheh mlog(ML_ERROR, "Could not get bitmap inode!\n"); 5528e08dc8b9SMark Fasheh goto out; 5529ccd979bdSMark Fasheh } 5530ccd979bdSMark Fasheh 5531e08dc8b9SMark Fasheh mutex_lock(&data_alloc_inode->i_mutex); 5532e08dc8b9SMark Fasheh 5533e63aecb6SMark Fasheh status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1); 5534ccd979bdSMark Fasheh if (status < 0) { 5535ccd979bdSMark Fasheh mlog_errno(status); 5536e08dc8b9SMark Fasheh goto out_mutex; 5537ccd979bdSMark Fasheh } 5538ccd979bdSMark Fasheh 553965eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE); 5540ccd979bdSMark Fasheh if (IS_ERR(handle)) { 5541ccd979bdSMark Fasheh status = PTR_ERR(handle); 5542ccd979bdSMark Fasheh mlog_errno(status); 5543e08dc8b9SMark Fasheh goto out_unlock; 5544ccd979bdSMark Fasheh } 5545ccd979bdSMark Fasheh 5546ccd979bdSMark Fasheh status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode, 5547ccd979bdSMark Fasheh data_alloc_bh); 5548e08dc8b9SMark Fasheh if (status < 0) 5549ccd979bdSMark Fasheh mlog_errno(status); 5550ccd979bdSMark Fasheh 555102dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 5552ccd979bdSMark Fasheh 5553e08dc8b9SMark Fasheh out_unlock: 5554e08dc8b9SMark Fasheh brelse(data_alloc_bh); 5555e63aecb6SMark Fasheh ocfs2_inode_unlock(data_alloc_inode, 1); 5556e08dc8b9SMark Fasheh 5557e08dc8b9SMark Fasheh out_mutex: 5558e08dc8b9SMark Fasheh mutex_unlock(&data_alloc_inode->i_mutex); 5559ccd979bdSMark Fasheh iput(data_alloc_inode); 5560ccd979bdSMark Fasheh 5561e08dc8b9SMark Fasheh out: 5562ccd979bdSMark Fasheh mlog_exit(status); 5563ccd979bdSMark Fasheh return status; 5564ccd979bdSMark Fasheh } 5565ccd979bdSMark Fasheh 5566ccd979bdSMark Fasheh int ocfs2_flush_truncate_log(struct ocfs2_super *osb) 5567ccd979bdSMark Fasheh { 5568ccd979bdSMark Fasheh int status; 5569ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5570ccd979bdSMark Fasheh 55711b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 5572ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 55731b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 5574ccd979bdSMark Fasheh 5575ccd979bdSMark Fasheh return status; 5576ccd979bdSMark Fasheh } 5577ccd979bdSMark Fasheh 5578c4028958SDavid Howells static void ocfs2_truncate_log_worker(struct work_struct *work) 5579ccd979bdSMark Fasheh { 5580ccd979bdSMark Fasheh int status; 5581c4028958SDavid Howells struct ocfs2_super *osb = 5582c4028958SDavid Howells container_of(work, struct ocfs2_super, 5583c4028958SDavid Howells osb_truncate_log_wq.work); 5584ccd979bdSMark Fasheh 5585ccd979bdSMark Fasheh mlog_entry_void(); 5586ccd979bdSMark Fasheh 5587ccd979bdSMark Fasheh status = ocfs2_flush_truncate_log(osb); 5588ccd979bdSMark Fasheh if (status < 0) 5589ccd979bdSMark Fasheh mlog_errno(status); 55904d0ddb2cSTao Ma else 55914d0ddb2cSTao Ma ocfs2_init_inode_steal_slot(osb); 5592ccd979bdSMark Fasheh 5593ccd979bdSMark Fasheh mlog_exit(status); 5594ccd979bdSMark Fasheh } 5595ccd979bdSMark Fasheh 5596ccd979bdSMark Fasheh #define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ) 5597ccd979bdSMark Fasheh void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb, 5598ccd979bdSMark Fasheh int cancel) 5599ccd979bdSMark Fasheh { 5600ccd979bdSMark Fasheh if (osb->osb_tl_inode) { 5601ccd979bdSMark Fasheh /* We want to push off log flushes while truncates are 5602ccd979bdSMark Fasheh * still running. */ 5603ccd979bdSMark Fasheh if (cancel) 5604ccd979bdSMark Fasheh cancel_delayed_work(&osb->osb_truncate_log_wq); 5605ccd979bdSMark Fasheh 5606ccd979bdSMark Fasheh queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq, 5607ccd979bdSMark Fasheh OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL); 5608ccd979bdSMark Fasheh } 5609ccd979bdSMark Fasheh } 5610ccd979bdSMark Fasheh 5611ccd979bdSMark Fasheh static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb, 5612ccd979bdSMark Fasheh int slot_num, 5613ccd979bdSMark Fasheh struct inode **tl_inode, 5614ccd979bdSMark Fasheh struct buffer_head **tl_bh) 5615ccd979bdSMark Fasheh { 5616ccd979bdSMark Fasheh int status; 5617ccd979bdSMark Fasheh struct inode *inode = NULL; 5618ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 5619ccd979bdSMark Fasheh 5620ccd979bdSMark Fasheh inode = ocfs2_get_system_file_inode(osb, 5621ccd979bdSMark Fasheh TRUNCATE_LOG_SYSTEM_INODE, 5622ccd979bdSMark Fasheh slot_num); 5623ccd979bdSMark Fasheh if (!inode) { 5624ccd979bdSMark Fasheh status = -EINVAL; 5625ccd979bdSMark Fasheh mlog(ML_ERROR, "Could not get load truncate log inode!\n"); 5626ccd979bdSMark Fasheh goto bail; 5627ccd979bdSMark Fasheh } 5628ccd979bdSMark Fasheh 5629ccd979bdSMark Fasheh status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh, 5630ccd979bdSMark Fasheh OCFS2_BH_CACHED, inode); 5631ccd979bdSMark Fasheh if (status < 0) { 5632ccd979bdSMark Fasheh iput(inode); 5633ccd979bdSMark Fasheh mlog_errno(status); 5634ccd979bdSMark Fasheh goto bail; 5635ccd979bdSMark Fasheh } 5636ccd979bdSMark Fasheh 5637ccd979bdSMark Fasheh *tl_inode = inode; 5638ccd979bdSMark Fasheh *tl_bh = bh; 5639ccd979bdSMark Fasheh bail: 5640ccd979bdSMark Fasheh mlog_exit(status); 5641ccd979bdSMark Fasheh return status; 5642ccd979bdSMark Fasheh } 5643ccd979bdSMark Fasheh 5644ccd979bdSMark Fasheh /* called during the 1st stage of node recovery. we stamp a clean 5645ccd979bdSMark Fasheh * truncate log and pass back a copy for processing later. if the 5646ccd979bdSMark Fasheh * truncate log does not require processing, a *tl_copy is set to 5647ccd979bdSMark Fasheh * NULL. */ 5648ccd979bdSMark Fasheh int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb, 5649ccd979bdSMark Fasheh int slot_num, 5650ccd979bdSMark Fasheh struct ocfs2_dinode **tl_copy) 5651ccd979bdSMark Fasheh { 5652ccd979bdSMark Fasheh int status; 5653ccd979bdSMark Fasheh struct inode *tl_inode = NULL; 5654ccd979bdSMark Fasheh struct buffer_head *tl_bh = NULL; 5655ccd979bdSMark Fasheh struct ocfs2_dinode *di; 5656ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5657ccd979bdSMark Fasheh 5658ccd979bdSMark Fasheh *tl_copy = NULL; 5659ccd979bdSMark Fasheh 5660ccd979bdSMark Fasheh mlog(0, "recover truncate log from slot %d\n", slot_num); 5661ccd979bdSMark Fasheh 5662ccd979bdSMark Fasheh status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh); 5663ccd979bdSMark Fasheh if (status < 0) { 5664ccd979bdSMark Fasheh mlog_errno(status); 5665ccd979bdSMark Fasheh goto bail; 5666ccd979bdSMark Fasheh } 5667ccd979bdSMark Fasheh 5668ccd979bdSMark Fasheh di = (struct ocfs2_dinode *) tl_bh->b_data; 5669ccd979bdSMark Fasheh tl = &di->id2.i_dealloc; 5670ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_DINODE(di)) { 5671ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_DINODE(tl_inode->i_sb, di); 5672ccd979bdSMark Fasheh status = -EIO; 5673ccd979bdSMark Fasheh goto bail; 5674ccd979bdSMark Fasheh } 5675ccd979bdSMark Fasheh 5676ccd979bdSMark Fasheh if (le16_to_cpu(tl->tl_used)) { 5677ccd979bdSMark Fasheh mlog(0, "We'll have %u logs to recover\n", 5678ccd979bdSMark Fasheh le16_to_cpu(tl->tl_used)); 5679ccd979bdSMark Fasheh 5680ccd979bdSMark Fasheh *tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL); 5681ccd979bdSMark Fasheh if (!(*tl_copy)) { 5682ccd979bdSMark Fasheh status = -ENOMEM; 5683ccd979bdSMark Fasheh mlog_errno(status); 5684ccd979bdSMark Fasheh goto bail; 5685ccd979bdSMark Fasheh } 5686ccd979bdSMark Fasheh 5687ccd979bdSMark Fasheh /* Assuming the write-out below goes well, this copy 5688ccd979bdSMark Fasheh * will be passed back to recovery for processing. */ 5689ccd979bdSMark Fasheh memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size); 5690ccd979bdSMark Fasheh 5691ccd979bdSMark Fasheh /* All we need to do to clear the truncate log is set 5692ccd979bdSMark Fasheh * tl_used. */ 5693ccd979bdSMark Fasheh tl->tl_used = 0; 5694ccd979bdSMark Fasheh 5695ccd979bdSMark Fasheh status = ocfs2_write_block(osb, tl_bh, tl_inode); 5696ccd979bdSMark Fasheh if (status < 0) { 5697ccd979bdSMark Fasheh mlog_errno(status); 5698ccd979bdSMark Fasheh goto bail; 5699ccd979bdSMark Fasheh } 5700ccd979bdSMark Fasheh } 5701ccd979bdSMark Fasheh 5702ccd979bdSMark Fasheh bail: 5703ccd979bdSMark Fasheh if (tl_inode) 5704ccd979bdSMark Fasheh iput(tl_inode); 5705ccd979bdSMark Fasheh if (tl_bh) 5706ccd979bdSMark Fasheh brelse(tl_bh); 5707ccd979bdSMark Fasheh 5708ccd979bdSMark Fasheh if (status < 0 && (*tl_copy)) { 5709ccd979bdSMark Fasheh kfree(*tl_copy); 5710ccd979bdSMark Fasheh *tl_copy = NULL; 5711ccd979bdSMark Fasheh } 5712ccd979bdSMark Fasheh 5713ccd979bdSMark Fasheh mlog_exit(status); 5714ccd979bdSMark Fasheh return status; 5715ccd979bdSMark Fasheh } 5716ccd979bdSMark Fasheh 5717ccd979bdSMark Fasheh int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb, 5718ccd979bdSMark Fasheh struct ocfs2_dinode *tl_copy) 5719ccd979bdSMark Fasheh { 5720ccd979bdSMark Fasheh int status = 0; 5721ccd979bdSMark Fasheh int i; 5722ccd979bdSMark Fasheh unsigned int clusters, num_recs, start_cluster; 5723ccd979bdSMark Fasheh u64 start_blk; 57241fabe148SMark Fasheh handle_t *handle; 5725ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5726ccd979bdSMark Fasheh struct ocfs2_truncate_log *tl; 5727ccd979bdSMark Fasheh 5728ccd979bdSMark Fasheh mlog_entry_void(); 5729ccd979bdSMark Fasheh 5730ccd979bdSMark Fasheh if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) { 5731ccd979bdSMark Fasheh mlog(ML_ERROR, "Asked to recover my own truncate log!\n"); 5732ccd979bdSMark Fasheh return -EINVAL; 5733ccd979bdSMark Fasheh } 5734ccd979bdSMark Fasheh 5735ccd979bdSMark Fasheh tl = &tl_copy->id2.i_dealloc; 5736ccd979bdSMark Fasheh num_recs = le16_to_cpu(tl->tl_used); 5737b0697053SMark Fasheh mlog(0, "cleanup %u records from %llu\n", num_recs, 57381ca1a111SMark Fasheh (unsigned long long)le64_to_cpu(tl_copy->i_blkno)); 5739ccd979bdSMark Fasheh 57401b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 5741ccd979bdSMark Fasheh for(i = 0; i < num_recs; i++) { 5742ccd979bdSMark Fasheh if (ocfs2_truncate_log_needs_flush(osb)) { 5743ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 5744ccd979bdSMark Fasheh if (status < 0) { 5745ccd979bdSMark Fasheh mlog_errno(status); 5746ccd979bdSMark Fasheh goto bail_up; 5747ccd979bdSMark Fasheh } 5748ccd979bdSMark Fasheh } 5749ccd979bdSMark Fasheh 575065eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE); 5751ccd979bdSMark Fasheh if (IS_ERR(handle)) { 5752ccd979bdSMark Fasheh status = PTR_ERR(handle); 5753ccd979bdSMark Fasheh mlog_errno(status); 5754ccd979bdSMark Fasheh goto bail_up; 5755ccd979bdSMark Fasheh } 5756ccd979bdSMark Fasheh 5757ccd979bdSMark Fasheh clusters = le32_to_cpu(tl->tl_recs[i].t_clusters); 5758ccd979bdSMark Fasheh start_cluster = le32_to_cpu(tl->tl_recs[i].t_start); 5759ccd979bdSMark Fasheh start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster); 5760ccd979bdSMark Fasheh 5761ccd979bdSMark Fasheh status = ocfs2_truncate_log_append(osb, handle, 5762ccd979bdSMark Fasheh start_blk, clusters); 576302dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 5764ccd979bdSMark Fasheh if (status < 0) { 5765ccd979bdSMark Fasheh mlog_errno(status); 5766ccd979bdSMark Fasheh goto bail_up; 5767ccd979bdSMark Fasheh } 5768ccd979bdSMark Fasheh } 5769ccd979bdSMark Fasheh 5770ccd979bdSMark Fasheh bail_up: 57711b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 5772ccd979bdSMark Fasheh 5773ccd979bdSMark Fasheh mlog_exit(status); 5774ccd979bdSMark Fasheh return status; 5775ccd979bdSMark Fasheh } 5776ccd979bdSMark Fasheh 5777ccd979bdSMark Fasheh void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb) 5778ccd979bdSMark Fasheh { 5779ccd979bdSMark Fasheh int status; 5780ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 5781ccd979bdSMark Fasheh 5782ccd979bdSMark Fasheh mlog_entry_void(); 5783ccd979bdSMark Fasheh 5784ccd979bdSMark Fasheh if (tl_inode) { 5785ccd979bdSMark Fasheh cancel_delayed_work(&osb->osb_truncate_log_wq); 5786ccd979bdSMark Fasheh flush_workqueue(ocfs2_wq); 5787ccd979bdSMark Fasheh 5788ccd979bdSMark Fasheh status = ocfs2_flush_truncate_log(osb); 5789ccd979bdSMark Fasheh if (status < 0) 5790ccd979bdSMark Fasheh mlog_errno(status); 5791ccd979bdSMark Fasheh 5792ccd979bdSMark Fasheh brelse(osb->osb_tl_bh); 5793ccd979bdSMark Fasheh iput(osb->osb_tl_inode); 5794ccd979bdSMark Fasheh } 5795ccd979bdSMark Fasheh 5796ccd979bdSMark Fasheh mlog_exit_void(); 5797ccd979bdSMark Fasheh } 5798ccd979bdSMark Fasheh 5799ccd979bdSMark Fasheh int ocfs2_truncate_log_init(struct ocfs2_super *osb) 5800ccd979bdSMark Fasheh { 5801ccd979bdSMark Fasheh int status; 5802ccd979bdSMark Fasheh struct inode *tl_inode = NULL; 5803ccd979bdSMark Fasheh struct buffer_head *tl_bh = NULL; 5804ccd979bdSMark Fasheh 5805ccd979bdSMark Fasheh mlog_entry_void(); 5806ccd979bdSMark Fasheh 5807ccd979bdSMark Fasheh status = ocfs2_get_truncate_log_info(osb, 5808ccd979bdSMark Fasheh osb->slot_num, 5809ccd979bdSMark Fasheh &tl_inode, 5810ccd979bdSMark Fasheh &tl_bh); 5811ccd979bdSMark Fasheh if (status < 0) 5812ccd979bdSMark Fasheh mlog_errno(status); 5813ccd979bdSMark Fasheh 5814ccd979bdSMark Fasheh /* ocfs2_truncate_log_shutdown keys on the existence of 5815ccd979bdSMark Fasheh * osb->osb_tl_inode so we don't set any of the osb variables 5816ccd979bdSMark Fasheh * until we're sure all is well. */ 5817c4028958SDavid Howells INIT_DELAYED_WORK(&osb->osb_truncate_log_wq, 5818c4028958SDavid Howells ocfs2_truncate_log_worker); 5819ccd979bdSMark Fasheh osb->osb_tl_bh = tl_bh; 5820ccd979bdSMark Fasheh osb->osb_tl_inode = tl_inode; 5821ccd979bdSMark Fasheh 5822ccd979bdSMark Fasheh mlog_exit(status); 5823ccd979bdSMark Fasheh return status; 5824ccd979bdSMark Fasheh } 5825ccd979bdSMark Fasheh 58262b604351SMark Fasheh /* 58272b604351SMark Fasheh * Delayed de-allocation of suballocator blocks. 58282b604351SMark Fasheh * 58292b604351SMark Fasheh * Some sets of block de-allocations might involve multiple suballocator inodes. 58302b604351SMark Fasheh * 58312b604351SMark Fasheh * The locking for this can get extremely complicated, especially when 58322b604351SMark Fasheh * the suballocator inodes to delete from aren't known until deep 58332b604351SMark Fasheh * within an unrelated codepath. 58342b604351SMark Fasheh * 58352b604351SMark Fasheh * ocfs2_extent_block structures are a good example of this - an inode 58362b604351SMark Fasheh * btree could have been grown by any number of nodes each allocating 58372b604351SMark Fasheh * out of their own suballoc inode. 58382b604351SMark Fasheh * 58392b604351SMark Fasheh * These structures allow the delay of block de-allocation until a 58402b604351SMark Fasheh * later time, when locking of multiple cluster inodes won't cause 58412b604351SMark Fasheh * deadlock. 58422b604351SMark Fasheh */ 58432b604351SMark Fasheh 58442b604351SMark Fasheh /* 58452b604351SMark Fasheh * Describes a single block free from a suballocator 58462b604351SMark Fasheh */ 58472b604351SMark Fasheh struct ocfs2_cached_block_free { 58482b604351SMark Fasheh struct ocfs2_cached_block_free *free_next; 58492b604351SMark Fasheh u64 free_blk; 58502b604351SMark Fasheh unsigned int free_bit; 58512b604351SMark Fasheh }; 58522b604351SMark Fasheh 58532b604351SMark Fasheh struct ocfs2_per_slot_free_list { 58542b604351SMark Fasheh struct ocfs2_per_slot_free_list *f_next_suballocator; 58552b604351SMark Fasheh int f_inode_type; 58562b604351SMark Fasheh int f_slot; 58572b604351SMark Fasheh struct ocfs2_cached_block_free *f_first; 58582b604351SMark Fasheh }; 58592b604351SMark Fasheh 58602b604351SMark Fasheh static int ocfs2_free_cached_items(struct ocfs2_super *osb, 58612b604351SMark Fasheh int sysfile_type, 58622b604351SMark Fasheh int slot, 58632b604351SMark Fasheh struct ocfs2_cached_block_free *head) 58642b604351SMark Fasheh { 58652b604351SMark Fasheh int ret; 58662b604351SMark Fasheh u64 bg_blkno; 58672b604351SMark Fasheh handle_t *handle; 58682b604351SMark Fasheh struct inode *inode; 58692b604351SMark Fasheh struct buffer_head *di_bh = NULL; 58702b604351SMark Fasheh struct ocfs2_cached_block_free *tmp; 58712b604351SMark Fasheh 58722b604351SMark Fasheh inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot); 58732b604351SMark Fasheh if (!inode) { 58742b604351SMark Fasheh ret = -EINVAL; 58752b604351SMark Fasheh mlog_errno(ret); 58762b604351SMark Fasheh goto out; 58772b604351SMark Fasheh } 58782b604351SMark Fasheh 58792b604351SMark Fasheh mutex_lock(&inode->i_mutex); 58802b604351SMark Fasheh 5881e63aecb6SMark Fasheh ret = ocfs2_inode_lock(inode, &di_bh, 1); 58822b604351SMark Fasheh if (ret) { 58832b604351SMark Fasheh mlog_errno(ret); 58842b604351SMark Fasheh goto out_mutex; 58852b604351SMark Fasheh } 58862b604351SMark Fasheh 58872b604351SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE); 58882b604351SMark Fasheh if (IS_ERR(handle)) { 58892b604351SMark Fasheh ret = PTR_ERR(handle); 58902b604351SMark Fasheh mlog_errno(ret); 58912b604351SMark Fasheh goto out_unlock; 58922b604351SMark Fasheh } 58932b604351SMark Fasheh 58942b604351SMark Fasheh while (head) { 58952b604351SMark Fasheh bg_blkno = ocfs2_which_suballoc_group(head->free_blk, 58962b604351SMark Fasheh head->free_bit); 58972b604351SMark Fasheh mlog(0, "Free bit: (bit %u, blkno %llu)\n", 58982b604351SMark Fasheh head->free_bit, (unsigned long long)head->free_blk); 58992b604351SMark Fasheh 59002b604351SMark Fasheh ret = ocfs2_free_suballoc_bits(handle, inode, di_bh, 59012b604351SMark Fasheh head->free_bit, bg_blkno, 1); 59022b604351SMark Fasheh if (ret) { 59032b604351SMark Fasheh mlog_errno(ret); 59042b604351SMark Fasheh goto out_journal; 59052b604351SMark Fasheh } 59062b604351SMark Fasheh 59072b604351SMark Fasheh ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE); 59082b604351SMark Fasheh if (ret) { 59092b604351SMark Fasheh mlog_errno(ret); 59102b604351SMark Fasheh goto out_journal; 59112b604351SMark Fasheh } 59122b604351SMark Fasheh 59132b604351SMark Fasheh tmp = head; 59142b604351SMark Fasheh head = head->free_next; 59152b604351SMark Fasheh kfree(tmp); 59162b604351SMark Fasheh } 59172b604351SMark Fasheh 59182b604351SMark Fasheh out_journal: 59192b604351SMark Fasheh ocfs2_commit_trans(osb, handle); 59202b604351SMark Fasheh 59212b604351SMark Fasheh out_unlock: 5922e63aecb6SMark Fasheh ocfs2_inode_unlock(inode, 1); 59232b604351SMark Fasheh brelse(di_bh); 59242b604351SMark Fasheh out_mutex: 59252b604351SMark Fasheh mutex_unlock(&inode->i_mutex); 59262b604351SMark Fasheh iput(inode); 59272b604351SMark Fasheh out: 59282b604351SMark Fasheh while(head) { 59292b604351SMark Fasheh /* Premature exit may have left some dangling items. */ 59302b604351SMark Fasheh tmp = head; 59312b604351SMark Fasheh head = head->free_next; 59322b604351SMark Fasheh kfree(tmp); 59332b604351SMark Fasheh } 59342b604351SMark Fasheh 59352b604351SMark Fasheh return ret; 59362b604351SMark Fasheh } 59372b604351SMark Fasheh 59382b604351SMark Fasheh int ocfs2_run_deallocs(struct ocfs2_super *osb, 59392b604351SMark Fasheh struct ocfs2_cached_dealloc_ctxt *ctxt) 59402b604351SMark Fasheh { 59412b604351SMark Fasheh int ret = 0, ret2; 59422b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl; 59432b604351SMark Fasheh 59442b604351SMark Fasheh if (!ctxt) 59452b604351SMark Fasheh return 0; 59462b604351SMark Fasheh 59472b604351SMark Fasheh while (ctxt->c_first_suballocator) { 59482b604351SMark Fasheh fl = ctxt->c_first_suballocator; 59492b604351SMark Fasheh 59502b604351SMark Fasheh if (fl->f_first) { 59512b604351SMark Fasheh mlog(0, "Free items: (type %u, slot %d)\n", 59522b604351SMark Fasheh fl->f_inode_type, fl->f_slot); 59532b604351SMark Fasheh ret2 = ocfs2_free_cached_items(osb, fl->f_inode_type, 59542b604351SMark Fasheh fl->f_slot, fl->f_first); 59552b604351SMark Fasheh if (ret2) 59562b604351SMark Fasheh mlog_errno(ret2); 59572b604351SMark Fasheh if (!ret) 59582b604351SMark Fasheh ret = ret2; 59592b604351SMark Fasheh } 59602b604351SMark Fasheh 59612b604351SMark Fasheh ctxt->c_first_suballocator = fl->f_next_suballocator; 59622b604351SMark Fasheh kfree(fl); 59632b604351SMark Fasheh } 59642b604351SMark Fasheh 59652b604351SMark Fasheh return ret; 59662b604351SMark Fasheh } 59672b604351SMark Fasheh 59682b604351SMark Fasheh static struct ocfs2_per_slot_free_list * 59692b604351SMark Fasheh ocfs2_find_per_slot_free_list(int type, 59702b604351SMark Fasheh int slot, 59712b604351SMark Fasheh struct ocfs2_cached_dealloc_ctxt *ctxt) 59722b604351SMark Fasheh { 59732b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator; 59742b604351SMark Fasheh 59752b604351SMark Fasheh while (fl) { 59762b604351SMark Fasheh if (fl->f_inode_type == type && fl->f_slot == slot) 59772b604351SMark Fasheh return fl; 59782b604351SMark Fasheh 59792b604351SMark Fasheh fl = fl->f_next_suballocator; 59802b604351SMark Fasheh } 59812b604351SMark Fasheh 59822b604351SMark Fasheh fl = kmalloc(sizeof(*fl), GFP_NOFS); 59832b604351SMark Fasheh if (fl) { 59842b604351SMark Fasheh fl->f_inode_type = type; 59852b604351SMark Fasheh fl->f_slot = slot; 59862b604351SMark Fasheh fl->f_first = NULL; 59872b604351SMark Fasheh fl->f_next_suballocator = ctxt->c_first_suballocator; 59882b604351SMark Fasheh 59892b604351SMark Fasheh ctxt->c_first_suballocator = fl; 59902b604351SMark Fasheh } 59912b604351SMark Fasheh return fl; 59922b604351SMark Fasheh } 59932b604351SMark Fasheh 59942b604351SMark Fasheh static int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt, 59952b604351SMark Fasheh int type, int slot, u64 blkno, 59962b604351SMark Fasheh unsigned int bit) 59972b604351SMark Fasheh { 59982b604351SMark Fasheh int ret; 59992b604351SMark Fasheh struct ocfs2_per_slot_free_list *fl; 60002b604351SMark Fasheh struct ocfs2_cached_block_free *item; 60012b604351SMark Fasheh 60022b604351SMark Fasheh fl = ocfs2_find_per_slot_free_list(type, slot, ctxt); 60032b604351SMark Fasheh if (fl == NULL) { 60042b604351SMark Fasheh ret = -ENOMEM; 60052b604351SMark Fasheh mlog_errno(ret); 60062b604351SMark Fasheh goto out; 60072b604351SMark Fasheh } 60082b604351SMark Fasheh 60092b604351SMark Fasheh item = kmalloc(sizeof(*item), GFP_NOFS); 60102b604351SMark Fasheh if (item == NULL) { 60112b604351SMark Fasheh ret = -ENOMEM; 60122b604351SMark Fasheh mlog_errno(ret); 60132b604351SMark Fasheh goto out; 60142b604351SMark Fasheh } 60152b604351SMark Fasheh 60162b604351SMark Fasheh mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n", 60172b604351SMark Fasheh type, slot, bit, (unsigned long long)blkno); 60182b604351SMark Fasheh 60192b604351SMark Fasheh item->free_blk = blkno; 60202b604351SMark Fasheh item->free_bit = bit; 60212b604351SMark Fasheh item->free_next = fl->f_first; 60222b604351SMark Fasheh 60232b604351SMark Fasheh fl->f_first = item; 60242b604351SMark Fasheh 60252b604351SMark Fasheh ret = 0; 60262b604351SMark Fasheh out: 60272b604351SMark Fasheh return ret; 60282b604351SMark Fasheh } 60292b604351SMark Fasheh 603059a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt, 603159a5e416SMark Fasheh struct ocfs2_extent_block *eb) 603259a5e416SMark Fasheh { 603359a5e416SMark Fasheh return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE, 603459a5e416SMark Fasheh le16_to_cpu(eb->h_suballoc_slot), 603559a5e416SMark Fasheh le64_to_cpu(eb->h_blkno), 603659a5e416SMark Fasheh le16_to_cpu(eb->h_suballoc_bit)); 603759a5e416SMark Fasheh } 603859a5e416SMark Fasheh 6039ccd979bdSMark Fasheh /* This function will figure out whether the currently last extent 6040ccd979bdSMark Fasheh * block will be deleted, and if it will, what the new last extent 6041ccd979bdSMark Fasheh * block will be so we can update his h_next_leaf_blk field, as well 6042ccd979bdSMark Fasheh * as the dinodes i_last_eb_blk */ 6043dcd0538fSMark Fasheh static int ocfs2_find_new_last_ext_blk(struct inode *inode, 60443a0782d0SMark Fasheh unsigned int clusters_to_del, 6045dcd0538fSMark Fasheh struct ocfs2_path *path, 6046ccd979bdSMark Fasheh struct buffer_head **new_last_eb) 6047ccd979bdSMark Fasheh { 60483a0782d0SMark Fasheh int next_free, ret = 0; 6049dcd0538fSMark Fasheh u32 cpos; 60503a0782d0SMark Fasheh struct ocfs2_extent_rec *rec; 6051ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 6052ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 6053ccd979bdSMark Fasheh struct buffer_head *bh = NULL; 6054ccd979bdSMark Fasheh 6055ccd979bdSMark Fasheh *new_last_eb = NULL; 6056ccd979bdSMark Fasheh 6057ccd979bdSMark Fasheh /* we have no tree, so of course, no last_eb. */ 6058dcd0538fSMark Fasheh if (!path->p_tree_depth) 6059dcd0538fSMark Fasheh goto out; 6060ccd979bdSMark Fasheh 6061ccd979bdSMark Fasheh /* trunc to zero special case - this makes tree_depth = 0 6062ccd979bdSMark Fasheh * regardless of what it is. */ 60633a0782d0SMark Fasheh if (OCFS2_I(inode)->ip_clusters == clusters_to_del) 6064dcd0538fSMark Fasheh goto out; 6065ccd979bdSMark Fasheh 6066dcd0538fSMark Fasheh el = path_leaf_el(path); 6067ccd979bdSMark Fasheh BUG_ON(!el->l_next_free_rec); 6068ccd979bdSMark Fasheh 60693a0782d0SMark Fasheh /* 60703a0782d0SMark Fasheh * Make sure that this extent list will actually be empty 60713a0782d0SMark Fasheh * after we clear away the data. We can shortcut out if 60723a0782d0SMark Fasheh * there's more than one non-empty extent in the 60733a0782d0SMark Fasheh * list. Otherwise, a check of the remaining extent is 60743a0782d0SMark Fasheh * necessary. 60753a0782d0SMark Fasheh */ 60763a0782d0SMark Fasheh next_free = le16_to_cpu(el->l_next_free_rec); 60773a0782d0SMark Fasheh rec = NULL; 6078dcd0538fSMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 60793a0782d0SMark Fasheh if (next_free > 2) 6080dcd0538fSMark Fasheh goto out; 60813a0782d0SMark Fasheh 60823a0782d0SMark Fasheh /* We may have a valid extent in index 1, check it. */ 60833a0782d0SMark Fasheh if (next_free == 2) 60843a0782d0SMark Fasheh rec = &el->l_recs[1]; 60853a0782d0SMark Fasheh 60863a0782d0SMark Fasheh /* 60873a0782d0SMark Fasheh * Fall through - no more nonempty extents, so we want 60883a0782d0SMark Fasheh * to delete this leaf. 60893a0782d0SMark Fasheh */ 60903a0782d0SMark Fasheh } else { 60913a0782d0SMark Fasheh if (next_free > 1) 6092dcd0538fSMark Fasheh goto out; 6093ccd979bdSMark Fasheh 60943a0782d0SMark Fasheh rec = &el->l_recs[0]; 60953a0782d0SMark Fasheh } 60963a0782d0SMark Fasheh 60973a0782d0SMark Fasheh if (rec) { 60983a0782d0SMark Fasheh /* 60993a0782d0SMark Fasheh * Check it we'll only be trimming off the end of this 61003a0782d0SMark Fasheh * cluster. 61013a0782d0SMark Fasheh */ 6102e48edee2SMark Fasheh if (le16_to_cpu(rec->e_leaf_clusters) > clusters_to_del) 61033a0782d0SMark Fasheh goto out; 61043a0782d0SMark Fasheh } 61053a0782d0SMark Fasheh 6106dcd0538fSMark Fasheh ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos); 6107dcd0538fSMark Fasheh if (ret) { 6108dcd0538fSMark Fasheh mlog_errno(ret); 6109dcd0538fSMark Fasheh goto out; 6110ccd979bdSMark Fasheh } 6111ccd979bdSMark Fasheh 6112dcd0538fSMark Fasheh ret = ocfs2_find_leaf(inode, path_root_el(path), cpos, &bh); 6113dcd0538fSMark Fasheh if (ret) { 6114dcd0538fSMark Fasheh mlog_errno(ret); 6115dcd0538fSMark Fasheh goto out; 6116ccd979bdSMark Fasheh } 6117dcd0538fSMark Fasheh 6118ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) bh->b_data; 6119ccd979bdSMark Fasheh el = &eb->h_list; 6120ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 6121ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 6122dcd0538fSMark Fasheh ret = -EROFS; 6123dcd0538fSMark Fasheh goto out; 6124ccd979bdSMark Fasheh } 6125ccd979bdSMark Fasheh 6126ccd979bdSMark Fasheh *new_last_eb = bh; 6127ccd979bdSMark Fasheh get_bh(*new_last_eb); 6128dcd0538fSMark Fasheh mlog(0, "returning block %llu, (cpos: %u)\n", 6129dcd0538fSMark Fasheh (unsigned long long)le64_to_cpu(eb->h_blkno), cpos); 6130dcd0538fSMark Fasheh out: 6131ccd979bdSMark Fasheh brelse(bh); 6132ccd979bdSMark Fasheh 6133dcd0538fSMark Fasheh return ret; 6134ccd979bdSMark Fasheh } 6135ccd979bdSMark Fasheh 61363a0782d0SMark Fasheh /* 61373a0782d0SMark Fasheh * Trim some clusters off the rightmost edge of a tree. Only called 61383a0782d0SMark Fasheh * during truncate. 61393a0782d0SMark Fasheh * 61403a0782d0SMark Fasheh * The caller needs to: 61413a0782d0SMark Fasheh * - start journaling of each path component. 61423a0782d0SMark Fasheh * - compute and fully set up any new last ext block 61433a0782d0SMark Fasheh */ 61443a0782d0SMark Fasheh static int ocfs2_trim_tree(struct inode *inode, struct ocfs2_path *path, 61453a0782d0SMark Fasheh handle_t *handle, struct ocfs2_truncate_context *tc, 61463a0782d0SMark Fasheh u32 clusters_to_del, u64 *delete_start) 61473a0782d0SMark Fasheh { 61483a0782d0SMark Fasheh int ret, i, index = path->p_tree_depth; 61493a0782d0SMark Fasheh u32 new_edge = 0; 61503a0782d0SMark Fasheh u64 deleted_eb = 0; 61513a0782d0SMark Fasheh struct buffer_head *bh; 61523a0782d0SMark Fasheh struct ocfs2_extent_list *el; 61533a0782d0SMark Fasheh struct ocfs2_extent_rec *rec; 61543a0782d0SMark Fasheh 61553a0782d0SMark Fasheh *delete_start = 0; 61563a0782d0SMark Fasheh 61573a0782d0SMark Fasheh while (index >= 0) { 61583a0782d0SMark Fasheh bh = path->p_node[index].bh; 61593a0782d0SMark Fasheh el = path->p_node[index].el; 61603a0782d0SMark Fasheh 61613a0782d0SMark Fasheh mlog(0, "traveling tree (index = %d, block = %llu)\n", 61623a0782d0SMark Fasheh index, (unsigned long long)bh->b_blocknr); 61633a0782d0SMark Fasheh 61643a0782d0SMark Fasheh BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0); 61653a0782d0SMark Fasheh 61663a0782d0SMark Fasheh if (index != 61673a0782d0SMark Fasheh (path->p_tree_depth - le16_to_cpu(el->l_tree_depth))) { 61683a0782d0SMark Fasheh ocfs2_error(inode->i_sb, 61693a0782d0SMark Fasheh "Inode %lu has invalid ext. block %llu", 61703a0782d0SMark Fasheh inode->i_ino, 61713a0782d0SMark Fasheh (unsigned long long)bh->b_blocknr); 61723a0782d0SMark Fasheh ret = -EROFS; 61733a0782d0SMark Fasheh goto out; 61743a0782d0SMark Fasheh } 61753a0782d0SMark Fasheh 61763a0782d0SMark Fasheh find_tail_record: 61773a0782d0SMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 61783a0782d0SMark Fasheh rec = &el->l_recs[i]; 61793a0782d0SMark Fasheh 61803a0782d0SMark Fasheh mlog(0, "Extent list before: record %d: (%u, %u, %llu), " 61813a0782d0SMark Fasheh "next = %u\n", i, le32_to_cpu(rec->e_cpos), 6182e48edee2SMark Fasheh ocfs2_rec_clusters(el, rec), 61833a0782d0SMark Fasheh (unsigned long long)le64_to_cpu(rec->e_blkno), 61843a0782d0SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 61853a0782d0SMark Fasheh 6186e48edee2SMark Fasheh BUG_ON(ocfs2_rec_clusters(el, rec) < clusters_to_del); 61873a0782d0SMark Fasheh 61883a0782d0SMark Fasheh if (le16_to_cpu(el->l_tree_depth) == 0) { 61893a0782d0SMark Fasheh /* 61903a0782d0SMark Fasheh * If the leaf block contains a single empty 61913a0782d0SMark Fasheh * extent and no records, we can just remove 61923a0782d0SMark Fasheh * the block. 61933a0782d0SMark Fasheh */ 61943a0782d0SMark Fasheh if (i == 0 && ocfs2_is_empty_extent(rec)) { 61953a0782d0SMark Fasheh memset(rec, 0, 61963a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 61973a0782d0SMark Fasheh el->l_next_free_rec = cpu_to_le16(0); 61983a0782d0SMark Fasheh 61993a0782d0SMark Fasheh goto delete; 62003a0782d0SMark Fasheh } 62013a0782d0SMark Fasheh 62023a0782d0SMark Fasheh /* 62033a0782d0SMark Fasheh * Remove any empty extents by shifting things 62043a0782d0SMark Fasheh * left. That should make life much easier on 62053a0782d0SMark Fasheh * the code below. This condition is rare 62063a0782d0SMark Fasheh * enough that we shouldn't see a performance 62073a0782d0SMark Fasheh * hit. 62083a0782d0SMark Fasheh */ 62093a0782d0SMark Fasheh if (ocfs2_is_empty_extent(&el->l_recs[0])) { 62103a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 62113a0782d0SMark Fasheh 62123a0782d0SMark Fasheh for(i = 0; 62133a0782d0SMark Fasheh i < le16_to_cpu(el->l_next_free_rec); i++) 62143a0782d0SMark Fasheh el->l_recs[i] = el->l_recs[i + 1]; 62153a0782d0SMark Fasheh 62163a0782d0SMark Fasheh memset(&el->l_recs[i], 0, 62173a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 62183a0782d0SMark Fasheh 62193a0782d0SMark Fasheh /* 62203a0782d0SMark Fasheh * We've modified our extent list. The 62213a0782d0SMark Fasheh * simplest way to handle this change 62223a0782d0SMark Fasheh * is to being the search from the 62233a0782d0SMark Fasheh * start again. 62243a0782d0SMark Fasheh */ 62253a0782d0SMark Fasheh goto find_tail_record; 62263a0782d0SMark Fasheh } 62273a0782d0SMark Fasheh 6228e48edee2SMark Fasheh le16_add_cpu(&rec->e_leaf_clusters, -clusters_to_del); 62293a0782d0SMark Fasheh 62303a0782d0SMark Fasheh /* 62313a0782d0SMark Fasheh * We'll use "new_edge" on our way back up the 62323a0782d0SMark Fasheh * tree to know what our rightmost cpos is. 62333a0782d0SMark Fasheh */ 6234e48edee2SMark Fasheh new_edge = le16_to_cpu(rec->e_leaf_clusters); 62353a0782d0SMark Fasheh new_edge += le32_to_cpu(rec->e_cpos); 62363a0782d0SMark Fasheh 62373a0782d0SMark Fasheh /* 62383a0782d0SMark Fasheh * The caller will use this to delete data blocks. 62393a0782d0SMark Fasheh */ 62403a0782d0SMark Fasheh *delete_start = le64_to_cpu(rec->e_blkno) 62413a0782d0SMark Fasheh + ocfs2_clusters_to_blocks(inode->i_sb, 6242e48edee2SMark Fasheh le16_to_cpu(rec->e_leaf_clusters)); 62433a0782d0SMark Fasheh 62443a0782d0SMark Fasheh /* 62453a0782d0SMark Fasheh * If it's now empty, remove this record. 62463a0782d0SMark Fasheh */ 6247e48edee2SMark Fasheh if (le16_to_cpu(rec->e_leaf_clusters) == 0) { 62483a0782d0SMark Fasheh memset(rec, 0, 62493a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 62503a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 62513a0782d0SMark Fasheh } 62523a0782d0SMark Fasheh } else { 62533a0782d0SMark Fasheh if (le64_to_cpu(rec->e_blkno) == deleted_eb) { 62543a0782d0SMark Fasheh memset(rec, 0, 62553a0782d0SMark Fasheh sizeof(struct ocfs2_extent_rec)); 62563a0782d0SMark Fasheh le16_add_cpu(&el->l_next_free_rec, -1); 62573a0782d0SMark Fasheh 62583a0782d0SMark Fasheh goto delete; 62593a0782d0SMark Fasheh } 62603a0782d0SMark Fasheh 62613a0782d0SMark Fasheh /* Can this actually happen? */ 62623a0782d0SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) 62633a0782d0SMark Fasheh goto delete; 62643a0782d0SMark Fasheh 62653a0782d0SMark Fasheh /* 62663a0782d0SMark Fasheh * We never actually deleted any clusters 62673a0782d0SMark Fasheh * because our leaf was empty. There's no 62683a0782d0SMark Fasheh * reason to adjust the rightmost edge then. 62693a0782d0SMark Fasheh */ 62703a0782d0SMark Fasheh if (new_edge == 0) 62713a0782d0SMark Fasheh goto delete; 62723a0782d0SMark Fasheh 6273e48edee2SMark Fasheh rec->e_int_clusters = cpu_to_le32(new_edge); 6274e48edee2SMark Fasheh le32_add_cpu(&rec->e_int_clusters, 62753a0782d0SMark Fasheh -le32_to_cpu(rec->e_cpos)); 62763a0782d0SMark Fasheh 62773a0782d0SMark Fasheh /* 62783a0782d0SMark Fasheh * A deleted child record should have been 62793a0782d0SMark Fasheh * caught above. 62803a0782d0SMark Fasheh */ 6281e48edee2SMark Fasheh BUG_ON(le32_to_cpu(rec->e_int_clusters) == 0); 62823a0782d0SMark Fasheh } 62833a0782d0SMark Fasheh 62843a0782d0SMark Fasheh delete: 62853a0782d0SMark Fasheh ret = ocfs2_journal_dirty(handle, bh); 62863a0782d0SMark Fasheh if (ret) { 62873a0782d0SMark Fasheh mlog_errno(ret); 62883a0782d0SMark Fasheh goto out; 62893a0782d0SMark Fasheh } 62903a0782d0SMark Fasheh 62913a0782d0SMark Fasheh mlog(0, "extent list container %llu, after: record %d: " 62923a0782d0SMark Fasheh "(%u, %u, %llu), next = %u.\n", 62933a0782d0SMark Fasheh (unsigned long long)bh->b_blocknr, i, 6294e48edee2SMark Fasheh le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec), 62953a0782d0SMark Fasheh (unsigned long long)le64_to_cpu(rec->e_blkno), 62963a0782d0SMark Fasheh le16_to_cpu(el->l_next_free_rec)); 62973a0782d0SMark Fasheh 62983a0782d0SMark Fasheh /* 62993a0782d0SMark Fasheh * We must be careful to only attempt delete of an 63003a0782d0SMark Fasheh * extent block (and not the root inode block). 63013a0782d0SMark Fasheh */ 63023a0782d0SMark Fasheh if (index > 0 && le16_to_cpu(el->l_next_free_rec) == 0) { 63033a0782d0SMark Fasheh struct ocfs2_extent_block *eb = 63043a0782d0SMark Fasheh (struct ocfs2_extent_block *)bh->b_data; 63053a0782d0SMark Fasheh 63063a0782d0SMark Fasheh /* 63073a0782d0SMark Fasheh * Save this for use when processing the 63083a0782d0SMark Fasheh * parent block. 63093a0782d0SMark Fasheh */ 63103a0782d0SMark Fasheh deleted_eb = le64_to_cpu(eb->h_blkno); 63113a0782d0SMark Fasheh 63123a0782d0SMark Fasheh mlog(0, "deleting this extent block.\n"); 63133a0782d0SMark Fasheh 63143a0782d0SMark Fasheh ocfs2_remove_from_cache(inode, bh); 63153a0782d0SMark Fasheh 6316e48edee2SMark Fasheh BUG_ON(ocfs2_rec_clusters(el, &el->l_recs[0])); 63173a0782d0SMark Fasheh BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos)); 63183a0782d0SMark Fasheh BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno)); 63193a0782d0SMark Fasheh 632059a5e416SMark Fasheh ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb); 63213a0782d0SMark Fasheh /* An error here is not fatal. */ 63223a0782d0SMark Fasheh if (ret < 0) 63233a0782d0SMark Fasheh mlog_errno(ret); 63243a0782d0SMark Fasheh } else { 63253a0782d0SMark Fasheh deleted_eb = 0; 63263a0782d0SMark Fasheh } 63273a0782d0SMark Fasheh 63283a0782d0SMark Fasheh index--; 63293a0782d0SMark Fasheh } 63303a0782d0SMark Fasheh 63313a0782d0SMark Fasheh ret = 0; 63323a0782d0SMark Fasheh out: 63333a0782d0SMark Fasheh return ret; 63343a0782d0SMark Fasheh } 63353a0782d0SMark Fasheh 6336ccd979bdSMark Fasheh static int ocfs2_do_truncate(struct ocfs2_super *osb, 6337ccd979bdSMark Fasheh unsigned int clusters_to_del, 6338ccd979bdSMark Fasheh struct inode *inode, 6339ccd979bdSMark Fasheh struct buffer_head *fe_bh, 63401fabe148SMark Fasheh handle_t *handle, 6341dcd0538fSMark Fasheh struct ocfs2_truncate_context *tc, 6342dcd0538fSMark Fasheh struct ocfs2_path *path) 6343ccd979bdSMark Fasheh { 63443a0782d0SMark Fasheh int status; 6345ccd979bdSMark Fasheh struct ocfs2_dinode *fe; 6346ccd979bdSMark Fasheh struct ocfs2_extent_block *last_eb = NULL; 6347ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 6348ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 6349ccd979bdSMark Fasheh u64 delete_blk = 0; 6350ccd979bdSMark Fasheh 6351ccd979bdSMark Fasheh fe = (struct ocfs2_dinode *) fe_bh->b_data; 6352ccd979bdSMark Fasheh 63533a0782d0SMark Fasheh status = ocfs2_find_new_last_ext_blk(inode, clusters_to_del, 6354dcd0538fSMark Fasheh path, &last_eb_bh); 6355ccd979bdSMark Fasheh if (status < 0) { 6356ccd979bdSMark Fasheh mlog_errno(status); 6357ccd979bdSMark Fasheh goto bail; 6358ccd979bdSMark Fasheh } 6359ccd979bdSMark Fasheh 6360dcd0538fSMark Fasheh /* 6361dcd0538fSMark Fasheh * Each component will be touched, so we might as well journal 6362dcd0538fSMark Fasheh * here to avoid having to handle errors later. 6363dcd0538fSMark Fasheh */ 63643a0782d0SMark Fasheh status = ocfs2_journal_access_path(inode, handle, path); 6365ccd979bdSMark Fasheh if (status < 0) { 6366ccd979bdSMark Fasheh mlog_errno(status); 6367ccd979bdSMark Fasheh goto bail; 6368ccd979bdSMark Fasheh } 6369dcd0538fSMark Fasheh 6370dcd0538fSMark Fasheh if (last_eb_bh) { 6371dcd0538fSMark Fasheh status = ocfs2_journal_access(handle, inode, last_eb_bh, 6372dcd0538fSMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 6373dcd0538fSMark Fasheh if (status < 0) { 6374dcd0538fSMark Fasheh mlog_errno(status); 6375dcd0538fSMark Fasheh goto bail; 6376dcd0538fSMark Fasheh } 6377dcd0538fSMark Fasheh 6378dcd0538fSMark Fasheh last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 6379dcd0538fSMark Fasheh } 6380dcd0538fSMark Fasheh 6381ccd979bdSMark Fasheh el = &(fe->id2.i_list); 6382ccd979bdSMark Fasheh 6383dcd0538fSMark Fasheh /* 6384dcd0538fSMark Fasheh * Lower levels depend on this never happening, but it's best 6385dcd0538fSMark Fasheh * to check it up here before changing the tree. 6386dcd0538fSMark Fasheh */ 6387e48edee2SMark Fasheh if (el->l_tree_depth && el->l_recs[0].e_int_clusters == 0) { 6388dcd0538fSMark Fasheh ocfs2_error(inode->i_sb, 6389dcd0538fSMark Fasheh "Inode %lu has an empty extent record, depth %u\n", 6390dcd0538fSMark Fasheh inode->i_ino, le16_to_cpu(el->l_tree_depth)); 63913a0782d0SMark Fasheh status = -EROFS; 6392dcd0538fSMark Fasheh goto bail; 6393dcd0538fSMark Fasheh } 6394dcd0538fSMark Fasheh 6395ccd979bdSMark Fasheh spin_lock(&OCFS2_I(inode)->ip_lock); 6396ccd979bdSMark Fasheh OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) - 6397ccd979bdSMark Fasheh clusters_to_del; 6398ccd979bdSMark Fasheh spin_unlock(&OCFS2_I(inode)->ip_lock); 6399ccd979bdSMark Fasheh le32_add_cpu(&fe->i_clusters, -clusters_to_del); 6400e535e2efSMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 6401ccd979bdSMark Fasheh 64023a0782d0SMark Fasheh status = ocfs2_trim_tree(inode, path, handle, tc, 64033a0782d0SMark Fasheh clusters_to_del, &delete_blk); 64043a0782d0SMark Fasheh if (status) { 64053a0782d0SMark Fasheh mlog_errno(status); 64063a0782d0SMark Fasheh goto bail; 6407ccd979bdSMark Fasheh } 6408ccd979bdSMark Fasheh 6409dcd0538fSMark Fasheh if (le32_to_cpu(fe->i_clusters) == 0) { 6410ccd979bdSMark Fasheh /* trunc to zero is a special case. */ 6411ccd979bdSMark Fasheh el->l_tree_depth = 0; 6412ccd979bdSMark Fasheh fe->i_last_eb_blk = 0; 6413ccd979bdSMark Fasheh } else if (last_eb) 6414ccd979bdSMark Fasheh fe->i_last_eb_blk = last_eb->h_blkno; 6415ccd979bdSMark Fasheh 6416ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, fe_bh); 6417ccd979bdSMark Fasheh if (status < 0) { 6418ccd979bdSMark Fasheh mlog_errno(status); 6419ccd979bdSMark Fasheh goto bail; 6420ccd979bdSMark Fasheh } 6421ccd979bdSMark Fasheh 6422ccd979bdSMark Fasheh if (last_eb) { 6423ccd979bdSMark Fasheh /* If there will be a new last extent block, then by 6424ccd979bdSMark Fasheh * definition, there cannot be any leaves to the right of 6425ccd979bdSMark Fasheh * him. */ 6426ccd979bdSMark Fasheh last_eb->h_next_leaf_blk = 0; 6427ccd979bdSMark Fasheh status = ocfs2_journal_dirty(handle, last_eb_bh); 6428ccd979bdSMark Fasheh if (status < 0) { 6429ccd979bdSMark Fasheh mlog_errno(status); 6430ccd979bdSMark Fasheh goto bail; 6431ccd979bdSMark Fasheh } 6432ccd979bdSMark Fasheh } 6433ccd979bdSMark Fasheh 64343a0782d0SMark Fasheh if (delete_blk) { 6435ccd979bdSMark Fasheh status = ocfs2_truncate_log_append(osb, handle, delete_blk, 6436ccd979bdSMark Fasheh clusters_to_del); 6437ccd979bdSMark Fasheh if (status < 0) { 6438ccd979bdSMark Fasheh mlog_errno(status); 6439ccd979bdSMark Fasheh goto bail; 6440ccd979bdSMark Fasheh } 64413a0782d0SMark Fasheh } 6442ccd979bdSMark Fasheh status = 0; 6443ccd979bdSMark Fasheh bail: 6444dcd0538fSMark Fasheh 6445ccd979bdSMark Fasheh mlog_exit(status); 6446ccd979bdSMark Fasheh return status; 6447ccd979bdSMark Fasheh } 6448ccd979bdSMark Fasheh 644960b11392SMark Fasheh static int ocfs2_writeback_zero_func(handle_t *handle, struct buffer_head *bh) 645060b11392SMark Fasheh { 645160b11392SMark Fasheh set_buffer_uptodate(bh); 645260b11392SMark Fasheh mark_buffer_dirty(bh); 645360b11392SMark Fasheh return 0; 645460b11392SMark Fasheh } 645560b11392SMark Fasheh 645660b11392SMark Fasheh static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh) 645760b11392SMark Fasheh { 645860b11392SMark Fasheh set_buffer_uptodate(bh); 645960b11392SMark Fasheh mark_buffer_dirty(bh); 646060b11392SMark Fasheh return ocfs2_journal_dirty_data(handle, bh); 646160b11392SMark Fasheh } 646260b11392SMark Fasheh 64631d410a6eSMark Fasheh static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle, 64641d410a6eSMark Fasheh unsigned int from, unsigned int to, 64651d410a6eSMark Fasheh struct page *page, int zero, u64 *phys) 646660b11392SMark Fasheh { 64671d410a6eSMark Fasheh int ret, partial = 0; 646860b11392SMark Fasheh 64691d410a6eSMark Fasheh ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0); 647060b11392SMark Fasheh if (ret) 647160b11392SMark Fasheh mlog_errno(ret); 647260b11392SMark Fasheh 64731d410a6eSMark Fasheh if (zero) 6474eebd2aa3SChristoph Lameter zero_user_segment(page, from, to); 647560b11392SMark Fasheh 647660b11392SMark Fasheh /* 647760b11392SMark Fasheh * Need to set the buffers we zero'd into uptodate 647860b11392SMark Fasheh * here if they aren't - ocfs2_map_page_blocks() 647960b11392SMark Fasheh * might've skipped some 648060b11392SMark Fasheh */ 648160b11392SMark Fasheh if (ocfs2_should_order_data(inode)) { 648260b11392SMark Fasheh ret = walk_page_buffers(handle, 648360b11392SMark Fasheh page_buffers(page), 648460b11392SMark Fasheh from, to, &partial, 648560b11392SMark Fasheh ocfs2_ordered_zero_func); 648660b11392SMark Fasheh if (ret < 0) 648760b11392SMark Fasheh mlog_errno(ret); 648860b11392SMark Fasheh } else { 648960b11392SMark Fasheh ret = walk_page_buffers(handle, page_buffers(page), 649060b11392SMark Fasheh from, to, &partial, 649160b11392SMark Fasheh ocfs2_writeback_zero_func); 649260b11392SMark Fasheh if (ret < 0) 649360b11392SMark Fasheh mlog_errno(ret); 649460b11392SMark Fasheh } 649560b11392SMark Fasheh 649660b11392SMark Fasheh if (!partial) 649760b11392SMark Fasheh SetPageUptodate(page); 649860b11392SMark Fasheh 649960b11392SMark Fasheh flush_dcache_page(page); 65001d410a6eSMark Fasheh } 65011d410a6eSMark Fasheh 65021d410a6eSMark Fasheh static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start, 65031d410a6eSMark Fasheh loff_t end, struct page **pages, 65041d410a6eSMark Fasheh int numpages, u64 phys, handle_t *handle) 65051d410a6eSMark Fasheh { 65061d410a6eSMark Fasheh int i; 65071d410a6eSMark Fasheh struct page *page; 65081d410a6eSMark Fasheh unsigned int from, to = PAGE_CACHE_SIZE; 65091d410a6eSMark Fasheh struct super_block *sb = inode->i_sb; 65101d410a6eSMark Fasheh 65111d410a6eSMark Fasheh BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb))); 65121d410a6eSMark Fasheh 65131d410a6eSMark Fasheh if (numpages == 0) 65141d410a6eSMark Fasheh goto out; 65151d410a6eSMark Fasheh 65161d410a6eSMark Fasheh to = PAGE_CACHE_SIZE; 65171d410a6eSMark Fasheh for(i = 0; i < numpages; i++) { 65181d410a6eSMark Fasheh page = pages[i]; 65191d410a6eSMark Fasheh 65201d410a6eSMark Fasheh from = start & (PAGE_CACHE_SIZE - 1); 65211d410a6eSMark Fasheh if ((end >> PAGE_CACHE_SHIFT) == page->index) 65221d410a6eSMark Fasheh to = end & (PAGE_CACHE_SIZE - 1); 65231d410a6eSMark Fasheh 65241d410a6eSMark Fasheh BUG_ON(from > PAGE_CACHE_SIZE); 65251d410a6eSMark Fasheh BUG_ON(to > PAGE_CACHE_SIZE); 65261d410a6eSMark Fasheh 65271d410a6eSMark Fasheh ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1, 65281d410a6eSMark Fasheh &phys); 652960b11392SMark Fasheh 653035edec1dSMark Fasheh start = (page->index + 1) << PAGE_CACHE_SHIFT; 653160b11392SMark Fasheh } 653260b11392SMark Fasheh out: 65331d410a6eSMark Fasheh if (pages) 65341d410a6eSMark Fasheh ocfs2_unlock_and_free_pages(pages, numpages); 653560b11392SMark Fasheh } 653660b11392SMark Fasheh 653735edec1dSMark Fasheh static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end, 65381d410a6eSMark Fasheh struct page **pages, int *num) 653960b11392SMark Fasheh { 65401d410a6eSMark Fasheh int numpages, ret = 0; 654160b11392SMark Fasheh struct super_block *sb = inode->i_sb; 654260b11392SMark Fasheh struct address_space *mapping = inode->i_mapping; 654360b11392SMark Fasheh unsigned long index; 654435edec1dSMark Fasheh loff_t last_page_bytes; 654560b11392SMark Fasheh 654635edec1dSMark Fasheh BUG_ON(start > end); 654760b11392SMark Fasheh 654835edec1dSMark Fasheh BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits != 654935edec1dSMark Fasheh (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits); 655035edec1dSMark Fasheh 65511d410a6eSMark Fasheh numpages = 0; 655235edec1dSMark Fasheh last_page_bytes = PAGE_ALIGN(end); 655335edec1dSMark Fasheh index = start >> PAGE_CACHE_SHIFT; 655460b11392SMark Fasheh do { 655560b11392SMark Fasheh pages[numpages] = grab_cache_page(mapping, index); 655660b11392SMark Fasheh if (!pages[numpages]) { 655760b11392SMark Fasheh ret = -ENOMEM; 655860b11392SMark Fasheh mlog_errno(ret); 655960b11392SMark Fasheh goto out; 656060b11392SMark Fasheh } 656160b11392SMark Fasheh 656260b11392SMark Fasheh numpages++; 656360b11392SMark Fasheh index++; 656435edec1dSMark Fasheh } while (index < (last_page_bytes >> PAGE_CACHE_SHIFT)); 656560b11392SMark Fasheh 656660b11392SMark Fasheh out: 656760b11392SMark Fasheh if (ret != 0) { 65681d410a6eSMark Fasheh if (pages) 65691d410a6eSMark Fasheh ocfs2_unlock_and_free_pages(pages, numpages); 657060b11392SMark Fasheh numpages = 0; 657160b11392SMark Fasheh } 657260b11392SMark Fasheh 657360b11392SMark Fasheh *num = numpages; 657460b11392SMark Fasheh 657560b11392SMark Fasheh return ret; 657660b11392SMark Fasheh } 657760b11392SMark Fasheh 657860b11392SMark Fasheh /* 657960b11392SMark Fasheh * Zero the area past i_size but still within an allocated 658060b11392SMark Fasheh * cluster. This avoids exposing nonzero data on subsequent file 658160b11392SMark Fasheh * extends. 658260b11392SMark Fasheh * 658360b11392SMark Fasheh * We need to call this before i_size is updated on the inode because 658460b11392SMark Fasheh * otherwise block_write_full_page() will skip writeout of pages past 658560b11392SMark Fasheh * i_size. The new_i_size parameter is passed for this reason. 658660b11392SMark Fasheh */ 658735edec1dSMark Fasheh int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle, 658835edec1dSMark Fasheh u64 range_start, u64 range_end) 658960b11392SMark Fasheh { 65901d410a6eSMark Fasheh int ret = 0, numpages; 659160b11392SMark Fasheh struct page **pages = NULL; 659260b11392SMark Fasheh u64 phys; 65931d410a6eSMark Fasheh unsigned int ext_flags; 65941d410a6eSMark Fasheh struct super_block *sb = inode->i_sb; 659560b11392SMark Fasheh 659660b11392SMark Fasheh /* 659760b11392SMark Fasheh * File systems which don't support sparse files zero on every 659860b11392SMark Fasheh * extend. 659960b11392SMark Fasheh */ 66001d410a6eSMark Fasheh if (!ocfs2_sparse_alloc(OCFS2_SB(sb))) 660160b11392SMark Fasheh return 0; 660260b11392SMark Fasheh 66031d410a6eSMark Fasheh pages = kcalloc(ocfs2_pages_per_cluster(sb), 660460b11392SMark Fasheh sizeof(struct page *), GFP_NOFS); 660560b11392SMark Fasheh if (pages == NULL) { 660660b11392SMark Fasheh ret = -ENOMEM; 660760b11392SMark Fasheh mlog_errno(ret); 660860b11392SMark Fasheh goto out; 660960b11392SMark Fasheh } 661060b11392SMark Fasheh 66111d410a6eSMark Fasheh if (range_start == range_end) 66121d410a6eSMark Fasheh goto out; 66131d410a6eSMark Fasheh 66141d410a6eSMark Fasheh ret = ocfs2_extent_map_get_blocks(inode, 66151d410a6eSMark Fasheh range_start >> sb->s_blocksize_bits, 66161d410a6eSMark Fasheh &phys, NULL, &ext_flags); 661760b11392SMark Fasheh if (ret) { 661860b11392SMark Fasheh mlog_errno(ret); 661960b11392SMark Fasheh goto out; 662060b11392SMark Fasheh } 662160b11392SMark Fasheh 66221d410a6eSMark Fasheh /* 66231d410a6eSMark Fasheh * Tail is a hole, or is marked unwritten. In either case, we 66241d410a6eSMark Fasheh * can count on read and write to return/push zero's. 66251d410a6eSMark Fasheh */ 66261d410a6eSMark Fasheh if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN) 662760b11392SMark Fasheh goto out; 662860b11392SMark Fasheh 66291d410a6eSMark Fasheh ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages, 66301d410a6eSMark Fasheh &numpages); 66311d410a6eSMark Fasheh if (ret) { 66321d410a6eSMark Fasheh mlog_errno(ret); 66331d410a6eSMark Fasheh goto out; 66341d410a6eSMark Fasheh } 66351d410a6eSMark Fasheh 663635edec1dSMark Fasheh ocfs2_zero_cluster_pages(inode, range_start, range_end, pages, 663735edec1dSMark Fasheh numpages, phys, handle); 663860b11392SMark Fasheh 663960b11392SMark Fasheh /* 664060b11392SMark Fasheh * Initiate writeout of the pages we zero'd here. We don't 664160b11392SMark Fasheh * wait on them - the truncate_inode_pages() call later will 664260b11392SMark Fasheh * do that for us. 664360b11392SMark Fasheh */ 664435edec1dSMark Fasheh ret = do_sync_mapping_range(inode->i_mapping, range_start, 664535edec1dSMark Fasheh range_end - 1, SYNC_FILE_RANGE_WRITE); 664660b11392SMark Fasheh if (ret) 664760b11392SMark Fasheh mlog_errno(ret); 664860b11392SMark Fasheh 664960b11392SMark Fasheh out: 665060b11392SMark Fasheh if (pages) 665160b11392SMark Fasheh kfree(pages); 665260b11392SMark Fasheh 665360b11392SMark Fasheh return ret; 665460b11392SMark Fasheh } 665560b11392SMark Fasheh 6656fdd77704STiger Yang static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode, 6657fdd77704STiger Yang struct ocfs2_dinode *di) 66581afc32b9SMark Fasheh { 66591afc32b9SMark Fasheh unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits; 6660fdd77704STiger Yang unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size); 66611afc32b9SMark Fasheh 6662fdd77704STiger Yang if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL) 6663fdd77704STiger Yang memset(&di->id2, 0, blocksize - 6664fdd77704STiger Yang offsetof(struct ocfs2_dinode, id2) - 6665fdd77704STiger Yang xattrsize); 6666fdd77704STiger Yang else 6667fdd77704STiger Yang memset(&di->id2, 0, blocksize - 6668fdd77704STiger Yang offsetof(struct ocfs2_dinode, id2)); 66691afc32b9SMark Fasheh } 66701afc32b9SMark Fasheh 66715b6a3a2bSMark Fasheh void ocfs2_dinode_new_extent_list(struct inode *inode, 66725b6a3a2bSMark Fasheh struct ocfs2_dinode *di) 66735b6a3a2bSMark Fasheh { 6674fdd77704STiger Yang ocfs2_zero_dinode_id2_with_xattr(inode, di); 66755b6a3a2bSMark Fasheh di->id2.i_list.l_tree_depth = 0; 66765b6a3a2bSMark Fasheh di->id2.i_list.l_next_free_rec = 0; 6677fdd77704STiger Yang di->id2.i_list.l_count = cpu_to_le16( 6678fdd77704STiger Yang ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di)); 66795b6a3a2bSMark Fasheh } 66805b6a3a2bSMark Fasheh 66811afc32b9SMark Fasheh void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di) 66821afc32b9SMark Fasheh { 66831afc32b9SMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 66841afc32b9SMark Fasheh struct ocfs2_inline_data *idata = &di->id2.i_data; 66851afc32b9SMark Fasheh 66861afc32b9SMark Fasheh spin_lock(&oi->ip_lock); 66871afc32b9SMark Fasheh oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL; 66881afc32b9SMark Fasheh di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 66891afc32b9SMark Fasheh spin_unlock(&oi->ip_lock); 66901afc32b9SMark Fasheh 66911afc32b9SMark Fasheh /* 66921afc32b9SMark Fasheh * We clear the entire i_data structure here so that all 66931afc32b9SMark Fasheh * fields can be properly initialized. 66941afc32b9SMark Fasheh */ 6695fdd77704STiger Yang ocfs2_zero_dinode_id2_with_xattr(inode, di); 66961afc32b9SMark Fasheh 6697fdd77704STiger Yang idata->id_count = cpu_to_le16( 6698fdd77704STiger Yang ocfs2_max_inline_data_with_xattr(inode->i_sb, di)); 66991afc32b9SMark Fasheh } 67001afc32b9SMark Fasheh 67011afc32b9SMark Fasheh int ocfs2_convert_inline_data_to_extents(struct inode *inode, 67021afc32b9SMark Fasheh struct buffer_head *di_bh) 67031afc32b9SMark Fasheh { 67041afc32b9SMark Fasheh int ret, i, has_data, num_pages = 0; 67051afc32b9SMark Fasheh handle_t *handle; 67061afc32b9SMark Fasheh u64 uninitialized_var(block); 67071afc32b9SMark Fasheh struct ocfs2_inode_info *oi = OCFS2_I(inode); 67081afc32b9SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 67091afc32b9SMark Fasheh struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 67101afc32b9SMark Fasheh struct ocfs2_alloc_context *data_ac = NULL; 67111afc32b9SMark Fasheh struct page **pages = NULL; 67121afc32b9SMark Fasheh loff_t end = osb->s_clustersize; 67131afc32b9SMark Fasheh 67141afc32b9SMark Fasheh has_data = i_size_read(inode) ? 1 : 0; 67151afc32b9SMark Fasheh 67161afc32b9SMark Fasheh if (has_data) { 67171afc32b9SMark Fasheh pages = kcalloc(ocfs2_pages_per_cluster(osb->sb), 67181afc32b9SMark Fasheh sizeof(struct page *), GFP_NOFS); 67191afc32b9SMark Fasheh if (pages == NULL) { 67201afc32b9SMark Fasheh ret = -ENOMEM; 67211afc32b9SMark Fasheh mlog_errno(ret); 67221afc32b9SMark Fasheh goto out; 67231afc32b9SMark Fasheh } 67241afc32b9SMark Fasheh 67251afc32b9SMark Fasheh ret = ocfs2_reserve_clusters(osb, 1, &data_ac); 67261afc32b9SMark Fasheh if (ret) { 67271afc32b9SMark Fasheh mlog_errno(ret); 67281afc32b9SMark Fasheh goto out; 67291afc32b9SMark Fasheh } 67301afc32b9SMark Fasheh } 67311afc32b9SMark Fasheh 67321afc32b9SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_INLINE_TO_EXTENTS_CREDITS); 67331afc32b9SMark Fasheh if (IS_ERR(handle)) { 67341afc32b9SMark Fasheh ret = PTR_ERR(handle); 67351afc32b9SMark Fasheh mlog_errno(ret); 67361afc32b9SMark Fasheh goto out_unlock; 67371afc32b9SMark Fasheh } 67381afc32b9SMark Fasheh 67391afc32b9SMark Fasheh ret = ocfs2_journal_access(handle, inode, di_bh, 67401afc32b9SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 67411afc32b9SMark Fasheh if (ret) { 67421afc32b9SMark Fasheh mlog_errno(ret); 67431afc32b9SMark Fasheh goto out_commit; 67441afc32b9SMark Fasheh } 67451afc32b9SMark Fasheh 67461afc32b9SMark Fasheh if (has_data) { 67471afc32b9SMark Fasheh u32 bit_off, num; 67481afc32b9SMark Fasheh unsigned int page_end; 67491afc32b9SMark Fasheh u64 phys; 67501afc32b9SMark Fasheh 67511afc32b9SMark Fasheh ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, 67521afc32b9SMark Fasheh &num); 67531afc32b9SMark Fasheh if (ret) { 67541afc32b9SMark Fasheh mlog_errno(ret); 67551afc32b9SMark Fasheh goto out_commit; 67561afc32b9SMark Fasheh } 67571afc32b9SMark Fasheh 67581afc32b9SMark Fasheh /* 67591afc32b9SMark Fasheh * Save two copies, one for insert, and one that can 67601afc32b9SMark Fasheh * be changed by ocfs2_map_and_dirty_page() below. 67611afc32b9SMark Fasheh */ 67621afc32b9SMark Fasheh block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); 67631afc32b9SMark Fasheh 67641afc32b9SMark Fasheh /* 67651afc32b9SMark Fasheh * Non sparse file systems zero on extend, so no need 67661afc32b9SMark Fasheh * to do that now. 67671afc32b9SMark Fasheh */ 67681afc32b9SMark Fasheh if (!ocfs2_sparse_alloc(osb) && 67691afc32b9SMark Fasheh PAGE_CACHE_SIZE < osb->s_clustersize) 67701afc32b9SMark Fasheh end = PAGE_CACHE_SIZE; 67711afc32b9SMark Fasheh 67721afc32b9SMark Fasheh ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages); 67731afc32b9SMark Fasheh if (ret) { 67741afc32b9SMark Fasheh mlog_errno(ret); 67751afc32b9SMark Fasheh goto out_commit; 67761afc32b9SMark Fasheh } 67771afc32b9SMark Fasheh 67781afc32b9SMark Fasheh /* 67791afc32b9SMark Fasheh * This should populate the 1st page for us and mark 67801afc32b9SMark Fasheh * it up to date. 67811afc32b9SMark Fasheh */ 67821afc32b9SMark Fasheh ret = ocfs2_read_inline_data(inode, pages[0], di_bh); 67831afc32b9SMark Fasheh if (ret) { 67841afc32b9SMark Fasheh mlog_errno(ret); 67851afc32b9SMark Fasheh goto out_commit; 67861afc32b9SMark Fasheh } 67871afc32b9SMark Fasheh 67881afc32b9SMark Fasheh page_end = PAGE_CACHE_SIZE; 67891afc32b9SMark Fasheh if (PAGE_CACHE_SIZE > osb->s_clustersize) 67901afc32b9SMark Fasheh page_end = osb->s_clustersize; 67911afc32b9SMark Fasheh 67921afc32b9SMark Fasheh for (i = 0; i < num_pages; i++) 67931afc32b9SMark Fasheh ocfs2_map_and_dirty_page(inode, handle, 0, page_end, 67941afc32b9SMark Fasheh pages[i], i > 0, &phys); 67951afc32b9SMark Fasheh } 67961afc32b9SMark Fasheh 67971afc32b9SMark Fasheh spin_lock(&oi->ip_lock); 67981afc32b9SMark Fasheh oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL; 67991afc32b9SMark Fasheh di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 68001afc32b9SMark Fasheh spin_unlock(&oi->ip_lock); 68011afc32b9SMark Fasheh 68025b6a3a2bSMark Fasheh ocfs2_dinode_new_extent_list(inode, di); 68031afc32b9SMark Fasheh 68041afc32b9SMark Fasheh ocfs2_journal_dirty(handle, di_bh); 68051afc32b9SMark Fasheh 68061afc32b9SMark Fasheh if (has_data) { 68071afc32b9SMark Fasheh /* 68081afc32b9SMark Fasheh * An error at this point should be extremely rare. If 68091afc32b9SMark Fasheh * this proves to be false, we could always re-build 68101afc32b9SMark Fasheh * the in-inode data from our pages. 68111afc32b9SMark Fasheh */ 6812f56654c4STao Ma ret = ocfs2_dinode_insert_extent(osb, handle, inode, di_bh, 6813f56654c4STao Ma 0, block, 1, 0, NULL); 68141afc32b9SMark Fasheh if (ret) { 68151afc32b9SMark Fasheh mlog_errno(ret); 68161afc32b9SMark Fasheh goto out_commit; 68171afc32b9SMark Fasheh } 68181afc32b9SMark Fasheh 68191afc32b9SMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 68201afc32b9SMark Fasheh } 68211afc32b9SMark Fasheh 68221afc32b9SMark Fasheh out_commit: 68231afc32b9SMark Fasheh ocfs2_commit_trans(osb, handle); 68241afc32b9SMark Fasheh 68251afc32b9SMark Fasheh out_unlock: 68261afc32b9SMark Fasheh if (data_ac) 68271afc32b9SMark Fasheh ocfs2_free_alloc_context(data_ac); 68281afc32b9SMark Fasheh 68291afc32b9SMark Fasheh out: 68301afc32b9SMark Fasheh if (pages) { 68311afc32b9SMark Fasheh ocfs2_unlock_and_free_pages(pages, num_pages); 68321afc32b9SMark Fasheh kfree(pages); 68331afc32b9SMark Fasheh } 68341afc32b9SMark Fasheh 68351afc32b9SMark Fasheh return ret; 68361afc32b9SMark Fasheh } 68371afc32b9SMark Fasheh 6838ccd979bdSMark Fasheh /* 6839ccd979bdSMark Fasheh * It is expected, that by the time you call this function, 6840ccd979bdSMark Fasheh * inode->i_size and fe->i_size have been adjusted. 6841ccd979bdSMark Fasheh * 6842ccd979bdSMark Fasheh * WARNING: This will kfree the truncate context 6843ccd979bdSMark Fasheh */ 6844ccd979bdSMark Fasheh int ocfs2_commit_truncate(struct ocfs2_super *osb, 6845ccd979bdSMark Fasheh struct inode *inode, 6846ccd979bdSMark Fasheh struct buffer_head *fe_bh, 6847ccd979bdSMark Fasheh struct ocfs2_truncate_context *tc) 6848ccd979bdSMark Fasheh { 6849ccd979bdSMark Fasheh int status, i, credits, tl_sem = 0; 6850dcd0538fSMark Fasheh u32 clusters_to_del, new_highest_cpos, range; 6851ccd979bdSMark Fasheh struct ocfs2_extent_list *el; 68521fabe148SMark Fasheh handle_t *handle = NULL; 6853ccd979bdSMark Fasheh struct inode *tl_inode = osb->osb_tl_inode; 6854dcd0538fSMark Fasheh struct ocfs2_path *path = NULL; 6855e7d4cb6bSTao Ma struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data; 6856ccd979bdSMark Fasheh 6857ccd979bdSMark Fasheh mlog_entry_void(); 6858ccd979bdSMark Fasheh 6859dcd0538fSMark Fasheh new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb, 6860ccd979bdSMark Fasheh i_size_read(inode)); 6861ccd979bdSMark Fasheh 6862e7d4cb6bSTao Ma path = ocfs2_new_path(fe_bh, &di->id2.i_list); 6863dcd0538fSMark Fasheh if (!path) { 6864dcd0538fSMark Fasheh status = -ENOMEM; 6865ccd979bdSMark Fasheh mlog_errno(status); 6866ccd979bdSMark Fasheh goto bail; 6867ccd979bdSMark Fasheh } 686883418978SMark Fasheh 686983418978SMark Fasheh ocfs2_extent_map_trunc(inode, new_highest_cpos); 687083418978SMark Fasheh 6871dcd0538fSMark Fasheh start: 6872dcd0538fSMark Fasheh /* 68733a0782d0SMark Fasheh * Check that we still have allocation to delete. 68743a0782d0SMark Fasheh */ 68753a0782d0SMark Fasheh if (OCFS2_I(inode)->ip_clusters == 0) { 68763a0782d0SMark Fasheh status = 0; 68773a0782d0SMark Fasheh goto bail; 68783a0782d0SMark Fasheh } 68793a0782d0SMark Fasheh 68803a0782d0SMark Fasheh /* 6881dcd0538fSMark Fasheh * Truncate always works against the rightmost tree branch. 6882dcd0538fSMark Fasheh */ 6883dcd0538fSMark Fasheh status = ocfs2_find_path(inode, path, UINT_MAX); 6884dcd0538fSMark Fasheh if (status) { 6885dcd0538fSMark Fasheh mlog_errno(status); 6886ccd979bdSMark Fasheh goto bail; 6887ccd979bdSMark Fasheh } 6888ccd979bdSMark Fasheh 6889dcd0538fSMark Fasheh mlog(0, "inode->ip_clusters = %u, tree_depth = %u\n", 6890dcd0538fSMark Fasheh OCFS2_I(inode)->ip_clusters, path->p_tree_depth); 6891dcd0538fSMark Fasheh 6892dcd0538fSMark Fasheh /* 6893dcd0538fSMark Fasheh * By now, el will point to the extent list on the bottom most 6894dcd0538fSMark Fasheh * portion of this tree. Only the tail record is considered in 6895dcd0538fSMark Fasheh * each pass. 6896dcd0538fSMark Fasheh * 6897dcd0538fSMark Fasheh * We handle the following cases, in order: 6898dcd0538fSMark Fasheh * - empty extent: delete the remaining branch 6899dcd0538fSMark Fasheh * - remove the entire record 6900dcd0538fSMark Fasheh * - remove a partial record 6901dcd0538fSMark Fasheh * - no record needs to be removed (truncate has completed) 6902dcd0538fSMark Fasheh */ 6903dcd0538fSMark Fasheh el = path_leaf_el(path); 69043a0782d0SMark Fasheh if (le16_to_cpu(el->l_next_free_rec) == 0) { 69053a0782d0SMark Fasheh ocfs2_error(inode->i_sb, 69063a0782d0SMark Fasheh "Inode %llu has empty extent block at %llu\n", 69073a0782d0SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 69083a0782d0SMark Fasheh (unsigned long long)path_leaf_bh(path)->b_blocknr); 69093a0782d0SMark Fasheh status = -EROFS; 69103a0782d0SMark Fasheh goto bail; 69113a0782d0SMark Fasheh } 69123a0782d0SMark Fasheh 6913ccd979bdSMark Fasheh i = le16_to_cpu(el->l_next_free_rec) - 1; 6914dcd0538fSMark Fasheh range = le32_to_cpu(el->l_recs[i].e_cpos) + 6915e48edee2SMark Fasheh ocfs2_rec_clusters(el, &el->l_recs[i]); 6916dcd0538fSMark Fasheh if (i == 0 && ocfs2_is_empty_extent(&el->l_recs[i])) { 6917dcd0538fSMark Fasheh clusters_to_del = 0; 6918dcd0538fSMark Fasheh } else if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_highest_cpos) { 6919e48edee2SMark Fasheh clusters_to_del = ocfs2_rec_clusters(el, &el->l_recs[i]); 6920dcd0538fSMark Fasheh } else if (range > new_highest_cpos) { 6921e48edee2SMark Fasheh clusters_to_del = (ocfs2_rec_clusters(el, &el->l_recs[i]) + 6922ccd979bdSMark Fasheh le32_to_cpu(el->l_recs[i].e_cpos)) - 6923dcd0538fSMark Fasheh new_highest_cpos; 6924dcd0538fSMark Fasheh } else { 6925dcd0538fSMark Fasheh status = 0; 6926dcd0538fSMark Fasheh goto bail; 6927dcd0538fSMark Fasheh } 6928ccd979bdSMark Fasheh 6929dcd0538fSMark Fasheh mlog(0, "clusters_to_del = %u in this pass, tail blk=%llu\n", 6930dcd0538fSMark Fasheh clusters_to_del, (unsigned long long)path_leaf_bh(path)->b_blocknr); 6931dcd0538fSMark Fasheh 69321b1dcc1bSJes Sorensen mutex_lock(&tl_inode->i_mutex); 6933ccd979bdSMark Fasheh tl_sem = 1; 6934ccd979bdSMark Fasheh /* ocfs2_truncate_log_needs_flush guarantees us at least one 6935ccd979bdSMark Fasheh * record is free for use. If there isn't any, we flush to get 6936ccd979bdSMark Fasheh * an empty truncate log. */ 6937ccd979bdSMark Fasheh if (ocfs2_truncate_log_needs_flush(osb)) { 6938ccd979bdSMark Fasheh status = __ocfs2_flush_truncate_log(osb); 6939ccd979bdSMark Fasheh if (status < 0) { 6940ccd979bdSMark Fasheh mlog_errno(status); 6941ccd979bdSMark Fasheh goto bail; 6942ccd979bdSMark Fasheh } 6943ccd979bdSMark Fasheh } 6944ccd979bdSMark Fasheh 6945ccd979bdSMark Fasheh credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del, 6946dcd0538fSMark Fasheh (struct ocfs2_dinode *)fe_bh->b_data, 6947dcd0538fSMark Fasheh el); 694865eff9ccSMark Fasheh handle = ocfs2_start_trans(osb, credits); 6949ccd979bdSMark Fasheh if (IS_ERR(handle)) { 6950ccd979bdSMark Fasheh status = PTR_ERR(handle); 6951ccd979bdSMark Fasheh handle = NULL; 6952ccd979bdSMark Fasheh mlog_errno(status); 6953ccd979bdSMark Fasheh goto bail; 6954ccd979bdSMark Fasheh } 6955ccd979bdSMark Fasheh 6956dcd0538fSMark Fasheh status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh, handle, 6957dcd0538fSMark Fasheh tc, path); 6958ccd979bdSMark Fasheh if (status < 0) { 6959ccd979bdSMark Fasheh mlog_errno(status); 6960ccd979bdSMark Fasheh goto bail; 6961ccd979bdSMark Fasheh } 6962ccd979bdSMark Fasheh 69631b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 6964ccd979bdSMark Fasheh tl_sem = 0; 6965ccd979bdSMark Fasheh 696602dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 6967ccd979bdSMark Fasheh handle = NULL; 6968ccd979bdSMark Fasheh 6969dcd0538fSMark Fasheh ocfs2_reinit_path(path, 1); 6970dcd0538fSMark Fasheh 6971dcd0538fSMark Fasheh /* 69723a0782d0SMark Fasheh * The check above will catch the case where we've truncated 69733a0782d0SMark Fasheh * away all allocation. 6974dcd0538fSMark Fasheh */ 6975ccd979bdSMark Fasheh goto start; 69763a0782d0SMark Fasheh 6977ccd979bdSMark Fasheh bail: 6978ccd979bdSMark Fasheh 6979ccd979bdSMark Fasheh ocfs2_schedule_truncate_log_flush(osb, 1); 6980ccd979bdSMark Fasheh 6981ccd979bdSMark Fasheh if (tl_sem) 69821b1dcc1bSJes Sorensen mutex_unlock(&tl_inode->i_mutex); 6983ccd979bdSMark Fasheh 6984ccd979bdSMark Fasheh if (handle) 698502dc1af4SMark Fasheh ocfs2_commit_trans(osb, handle); 6986ccd979bdSMark Fasheh 698759a5e416SMark Fasheh ocfs2_run_deallocs(osb, &tc->tc_dealloc); 698859a5e416SMark Fasheh 6989dcd0538fSMark Fasheh ocfs2_free_path(path); 6990ccd979bdSMark Fasheh 6991ccd979bdSMark Fasheh /* This will drop the ext_alloc cluster lock for us */ 6992ccd979bdSMark Fasheh ocfs2_free_truncate_context(tc); 6993ccd979bdSMark Fasheh 6994ccd979bdSMark Fasheh mlog_exit(status); 6995ccd979bdSMark Fasheh return status; 6996ccd979bdSMark Fasheh } 6997ccd979bdSMark Fasheh 6998ccd979bdSMark Fasheh /* 699959a5e416SMark Fasheh * Expects the inode to already be locked. 7000ccd979bdSMark Fasheh */ 7001ccd979bdSMark Fasheh int ocfs2_prepare_truncate(struct ocfs2_super *osb, 7002ccd979bdSMark Fasheh struct inode *inode, 7003ccd979bdSMark Fasheh struct buffer_head *fe_bh, 7004ccd979bdSMark Fasheh struct ocfs2_truncate_context **tc) 7005ccd979bdSMark Fasheh { 700659a5e416SMark Fasheh int status; 7007ccd979bdSMark Fasheh unsigned int new_i_clusters; 7008ccd979bdSMark Fasheh struct ocfs2_dinode *fe; 7009ccd979bdSMark Fasheh struct ocfs2_extent_block *eb; 7010ccd979bdSMark Fasheh struct buffer_head *last_eb_bh = NULL; 7011ccd979bdSMark Fasheh 7012ccd979bdSMark Fasheh mlog_entry_void(); 7013ccd979bdSMark Fasheh 7014ccd979bdSMark Fasheh *tc = NULL; 7015ccd979bdSMark Fasheh 7016ccd979bdSMark Fasheh new_i_clusters = ocfs2_clusters_for_bytes(osb->sb, 7017ccd979bdSMark Fasheh i_size_read(inode)); 7018ccd979bdSMark Fasheh fe = (struct ocfs2_dinode *) fe_bh->b_data; 7019ccd979bdSMark Fasheh 7020ccd979bdSMark Fasheh mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size =" 70211ca1a111SMark Fasheh "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters, 70221ca1a111SMark Fasheh (unsigned long long)le64_to_cpu(fe->i_size)); 7023ccd979bdSMark Fasheh 7024cd861280SRobert P. J. Day *tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL); 7025ccd979bdSMark Fasheh if (!(*tc)) { 7026ccd979bdSMark Fasheh status = -ENOMEM; 7027ccd979bdSMark Fasheh mlog_errno(status); 7028ccd979bdSMark Fasheh goto bail; 7029ccd979bdSMark Fasheh } 703059a5e416SMark Fasheh ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc); 7031ccd979bdSMark Fasheh 7032ccd979bdSMark Fasheh if (fe->id2.i_list.l_tree_depth) { 7033ccd979bdSMark Fasheh status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk), 7034ccd979bdSMark Fasheh &last_eb_bh, OCFS2_BH_CACHED, inode); 7035ccd979bdSMark Fasheh if (status < 0) { 7036ccd979bdSMark Fasheh mlog_errno(status); 7037ccd979bdSMark Fasheh goto bail; 7038ccd979bdSMark Fasheh } 7039ccd979bdSMark Fasheh eb = (struct ocfs2_extent_block *) last_eb_bh->b_data; 7040ccd979bdSMark Fasheh if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) { 7041ccd979bdSMark Fasheh OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb); 7042ccd979bdSMark Fasheh 7043ccd979bdSMark Fasheh brelse(last_eb_bh); 7044ccd979bdSMark Fasheh status = -EIO; 7045ccd979bdSMark Fasheh goto bail; 7046ccd979bdSMark Fasheh } 7047ccd979bdSMark Fasheh } 7048ccd979bdSMark Fasheh 7049ccd979bdSMark Fasheh (*tc)->tc_last_eb_bh = last_eb_bh; 7050ccd979bdSMark Fasheh 7051ccd979bdSMark Fasheh status = 0; 7052ccd979bdSMark Fasheh bail: 7053ccd979bdSMark Fasheh if (status < 0) { 7054ccd979bdSMark Fasheh if (*tc) 7055ccd979bdSMark Fasheh ocfs2_free_truncate_context(*tc); 7056ccd979bdSMark Fasheh *tc = NULL; 7057ccd979bdSMark Fasheh } 7058ccd979bdSMark Fasheh mlog_exit_void(); 7059ccd979bdSMark Fasheh return status; 7060ccd979bdSMark Fasheh } 7061ccd979bdSMark Fasheh 70621afc32b9SMark Fasheh /* 70631afc32b9SMark Fasheh * 'start' is inclusive, 'end' is not. 70641afc32b9SMark Fasheh */ 70651afc32b9SMark Fasheh int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh, 70661afc32b9SMark Fasheh unsigned int start, unsigned int end, int trunc) 70671afc32b9SMark Fasheh { 70681afc32b9SMark Fasheh int ret; 70691afc32b9SMark Fasheh unsigned int numbytes; 70701afc32b9SMark Fasheh handle_t *handle; 70711afc32b9SMark Fasheh struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 70721afc32b9SMark Fasheh struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 70731afc32b9SMark Fasheh struct ocfs2_inline_data *idata = &di->id2.i_data; 70741afc32b9SMark Fasheh 70751afc32b9SMark Fasheh if (end > i_size_read(inode)) 70761afc32b9SMark Fasheh end = i_size_read(inode); 70771afc32b9SMark Fasheh 70781afc32b9SMark Fasheh BUG_ON(start >= end); 70791afc32b9SMark Fasheh 70801afc32b9SMark Fasheh if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) || 70811afc32b9SMark Fasheh !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) || 70821afc32b9SMark Fasheh !ocfs2_supports_inline_data(osb)) { 70831afc32b9SMark Fasheh ocfs2_error(inode->i_sb, 70841afc32b9SMark Fasheh "Inline data flags for inode %llu don't agree! " 70851afc32b9SMark Fasheh "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n", 70861afc32b9SMark Fasheh (unsigned long long)OCFS2_I(inode)->ip_blkno, 70871afc32b9SMark Fasheh le16_to_cpu(di->i_dyn_features), 70881afc32b9SMark Fasheh OCFS2_I(inode)->ip_dyn_features, 70891afc32b9SMark Fasheh osb->s_feature_incompat); 70901afc32b9SMark Fasheh ret = -EROFS; 70911afc32b9SMark Fasheh goto out; 70921afc32b9SMark Fasheh } 70931afc32b9SMark Fasheh 70941afc32b9SMark Fasheh handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 70951afc32b9SMark Fasheh if (IS_ERR(handle)) { 70961afc32b9SMark Fasheh ret = PTR_ERR(handle); 70971afc32b9SMark Fasheh mlog_errno(ret); 70981afc32b9SMark Fasheh goto out; 70991afc32b9SMark Fasheh } 71001afc32b9SMark Fasheh 71011afc32b9SMark Fasheh ret = ocfs2_journal_access(handle, inode, di_bh, 71021afc32b9SMark Fasheh OCFS2_JOURNAL_ACCESS_WRITE); 71031afc32b9SMark Fasheh if (ret) { 71041afc32b9SMark Fasheh mlog_errno(ret); 71051afc32b9SMark Fasheh goto out_commit; 71061afc32b9SMark Fasheh } 71071afc32b9SMark Fasheh 71081afc32b9SMark Fasheh numbytes = end - start; 71091afc32b9SMark Fasheh memset(idata->id_data + start, 0, numbytes); 71101afc32b9SMark Fasheh 71111afc32b9SMark Fasheh /* 71121afc32b9SMark Fasheh * No need to worry about the data page here - it's been 71131afc32b9SMark Fasheh * truncated already and inline data doesn't need it for 71141afc32b9SMark Fasheh * pushing zero's to disk, so we'll let readpage pick it up 71151afc32b9SMark Fasheh * later. 71161afc32b9SMark Fasheh */ 71171afc32b9SMark Fasheh if (trunc) { 71181afc32b9SMark Fasheh i_size_write(inode, start); 71191afc32b9SMark Fasheh di->i_size = cpu_to_le64(start); 71201afc32b9SMark Fasheh } 71211afc32b9SMark Fasheh 71221afc32b9SMark Fasheh inode->i_blocks = ocfs2_inode_sector_count(inode); 71231afc32b9SMark Fasheh inode->i_ctime = inode->i_mtime = CURRENT_TIME; 71241afc32b9SMark Fasheh 71251afc32b9SMark Fasheh di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec); 71261afc32b9SMark Fasheh di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 71271afc32b9SMark Fasheh 71281afc32b9SMark Fasheh ocfs2_journal_dirty(handle, di_bh); 71291afc32b9SMark Fasheh 71301afc32b9SMark Fasheh out_commit: 71311afc32b9SMark Fasheh ocfs2_commit_trans(osb, handle); 71321afc32b9SMark Fasheh 71331afc32b9SMark Fasheh out: 71341afc32b9SMark Fasheh return ret; 71351afc32b9SMark Fasheh } 71361afc32b9SMark Fasheh 7137ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc) 7138ccd979bdSMark Fasheh { 713959a5e416SMark Fasheh /* 714059a5e416SMark Fasheh * The caller is responsible for completing deallocation 714159a5e416SMark Fasheh * before freeing the context. 714259a5e416SMark Fasheh */ 714359a5e416SMark Fasheh if (tc->tc_dealloc.c_first_suballocator != NULL) 714459a5e416SMark Fasheh mlog(ML_NOTICE, 714559a5e416SMark Fasheh "Truncate completion has non-empty dealloc context\n"); 7146ccd979bdSMark Fasheh 7147ccd979bdSMark Fasheh if (tc->tc_last_eb_bh) 7148ccd979bdSMark Fasheh brelse(tc->tc_last_eb_bh); 7149ccd979bdSMark Fasheh 7150ccd979bdSMark Fasheh kfree(tc); 7151ccd979bdSMark Fasheh } 7152