alloc.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * alloc.c
   4 *
   5 * Extent allocs and frees
   6 *
   7 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   8 */
   9
  10#include <linux/fs.h>
  11#include <linux/types.h>
  12#include <linux/slab.h>
  13#include <linux/string.h>
  14#include <linux/highmem.h>
  15#include <linux/swap.h>
  16#include <linux/quotaops.h>
  17#include <linux/blkdev.h>
  18#include <linux/sched/signal.h>
  19
  20#include <cluster/masklog.h>
  21
  22#include "ocfs2.h"
  23
  24#include "alloc.h"
  25#include "aops.h"
  26#include "blockcheck.h"
  27#include "dlmglue.h"
  28#include "extent_map.h"
  29#include "inode.h"
  30#include "journal.h"
  31#include "localalloc.h"
  32#include "suballoc.h"
  33#include "sysfile.h"
  34#include "file.h"
  35#include "super.h"
  36#include "uptodate.h"
  37#include "xattr.h"
  38#include "refcounttree.h"
  39#include "ocfs2_trace.h"
  40
  41#include "buffer_head_io.h"
  42
  43enum ocfs2_contig_type {
  44	CONTIG_NONE = 0,
  45	CONTIG_LEFT,
  46	CONTIG_RIGHT,
  47	CONTIG_LEFTRIGHT,
  48};
  49
  50static enum ocfs2_contig_type
  51	ocfs2_extent_rec_contig(struct super_block *sb,
  52				struct ocfs2_extent_rec *ext,
  53				struct ocfs2_extent_rec *insert_rec);
  54/*
  55 * Operations for a specific extent tree type.
  56 *
  57 * To implement an on-disk btree (extent tree) type in ocfs2, add
  58 * an ocfs2_extent_tree_operations structure and the matching
  59 * ocfs2_init_<thingy>_extent_tree() function.  That's pretty much it
  60 * for the allocation portion of the extent tree.
  61 */
  62struct ocfs2_extent_tree_operations {
  63	/*
  64	 * last_eb_blk is the block number of the right most leaf extent
  65	 * block.  Most on-disk structures containing an extent tree store
  66	 * this value for fast access.  The ->eo_set_last_eb_blk() and
  67	 * ->eo_get_last_eb_blk() operations access this value.  They are
  68	 *  both required.
  69	 */
  70	void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
  71				   u64 blkno);
  72	u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
  73
  74	/*
  75	 * The on-disk structure usually keeps track of how many total
  76	 * clusters are stored in this extent tree.  This function updates
  77	 * that value.  new_clusters is the delta, and must be
  78	 * added to the total.  Required.
  79	 */
  80	void (*eo_update_clusters)(struct ocfs2_extent_tree *et,
  81				   u32 new_clusters);
  82
  83	/*
  84	 * If this extent tree is supported by an extent map, insert
  85	 * a record into the map.
  86	 */
  87	void (*eo_extent_map_insert)(struct ocfs2_extent_tree *et,
  88				     struct ocfs2_extent_rec *rec);
  89
  90	/*
  91	 * If this extent tree is supported by an extent map, truncate the
  92	 * map to clusters,
  93	 */
  94	void (*eo_extent_map_truncate)(struct ocfs2_extent_tree *et,
  95				       u32 clusters);
  96
  97	/*
  98	 * If ->eo_insert_check() exists, it is called before rec is
  99	 * inserted into the extent tree.  It is optional.
 100	 */
 101	int (*eo_insert_check)(struct ocfs2_extent_tree *et,
 102			       struct ocfs2_extent_rec *rec);
 103	int (*eo_sanity_check)(struct ocfs2_extent_tree *et);
 104
 105	/*
 106	 * --------------------------------------------------------------
 107	 * The remaining are internal to ocfs2_extent_tree and don't have
 108	 * accessor functions
 109	 */
 110
 111	/*
 112	 * ->eo_fill_root_el() takes et->et_object and sets et->et_root_el.
 113	 * It is required.
 114	 */
 115	void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
 116
 117	/*
 118	 * ->eo_fill_max_leaf_clusters sets et->et_max_leaf_clusters if
 119	 * it exists.  If it does not, et->et_max_leaf_clusters is set
 120	 * to 0 (unlimited).  Optional.
 121	 */
 122	void (*eo_fill_max_leaf_clusters)(struct ocfs2_extent_tree *et);
 123
 124	/*
 125	 * ->eo_extent_contig test whether the 2 ocfs2_extent_rec
 126	 * are contiguous or not. Optional. Don't need to set it if use
 127	 * ocfs2_extent_rec as the tree leaf.
 128	 */
 129	enum ocfs2_contig_type
 130		(*eo_extent_contig)(struct ocfs2_extent_tree *et,
 131				    struct ocfs2_extent_rec *ext,
 132				    struct ocfs2_extent_rec *insert_rec);
 133};
 134
 135
 136/*
 137 * Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check
 138 * in the methods.
 139 */
 140static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
 141static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
 142					 u64 blkno);
 143static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
 144					 u32 clusters);
 145static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
 146					   struct ocfs2_extent_rec *rec);
 147static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
 148					     u32 clusters);
 149static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
 150				     struct ocfs2_extent_rec *rec);
 151static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et);
 152static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
 153
 154static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
 155					struct ocfs2_extent_tree *et,
 156					struct buffer_head **new_eb_bh,
 157					int blk_wanted, int *blk_given);
 158static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et);
 159
 160static const struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
 161	.eo_set_last_eb_blk	= ocfs2_dinode_set_last_eb_blk,
 162	.eo_get_last_eb_blk	= ocfs2_dinode_get_last_eb_blk,
 163	.eo_update_clusters	= ocfs2_dinode_update_clusters,
 164	.eo_extent_map_insert	= ocfs2_dinode_extent_map_insert,
 165	.eo_extent_map_truncate	= ocfs2_dinode_extent_map_truncate,
 166	.eo_insert_check	= ocfs2_dinode_insert_check,
 167	.eo_sanity_check	= ocfs2_dinode_sanity_check,
 168	.eo_fill_root_el	= ocfs2_dinode_fill_root_el,
 169};
 170
 171static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
 172					 u64 blkno)
 173{
 174	struct ocfs2_dinode *di = et->et_object;
 175
 176	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
 177	di->i_last_eb_blk = cpu_to_le64(blkno);
 178}
 179
 180static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
 181{
 182	struct ocfs2_dinode *di = et->et_object;
 183
 184	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
 185	return le64_to_cpu(di->i_last_eb_blk);
 186}
 187
 188static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
 189					 u32 clusters)
 190{
 191	struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
 192	struct ocfs2_dinode *di = et->et_object;
 193
 194	le32_add_cpu(&di->i_clusters, clusters);
 195	spin_lock(&oi->ip_lock);
 196	oi->ip_clusters = le32_to_cpu(di->i_clusters);
 197	spin_unlock(&oi->ip_lock);
 198}
 199
 200static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
 201					   struct ocfs2_extent_rec *rec)
 202{
 203	struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
 204
 205	ocfs2_extent_map_insert_rec(inode, rec);
 206}
 207
 208static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
 209					     u32 clusters)
 210{
 211	struct inode *inode = &cache_info_to_inode(et->et_ci)->vfs_inode;
 212
 213	ocfs2_extent_map_trunc(inode, clusters);
 214}
 215
 216static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
 217				     struct ocfs2_extent_rec *rec)
 218{
 219	struct ocfs2_inode_info *oi = cache_info_to_inode(et->et_ci);
 220	struct ocfs2_super *osb = OCFS2_SB(oi->vfs_inode.i_sb);
 221
 222	BUG_ON(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL);
 223	mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
 224			(oi->ip_clusters != le32_to_cpu(rec->e_cpos)),
 225			"Device %s, asking for sparse allocation: inode %llu, "
 226			"cpos %u, clusters %u\n",
 227			osb->dev_str,
 228			(unsigned long long)oi->ip_blkno,
 229			rec->e_cpos, oi->ip_clusters);
 230
 231	return 0;
 232}
 233
 234static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et)
 235{
 236	struct ocfs2_dinode *di = et->et_object;
 237
 238	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
 239	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
 240
 241	return 0;
 242}
 243
 244static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
 245{
 246	struct ocfs2_dinode *di = et->et_object;
 247
 248	et->et_root_el = &di->id2.i_list;
 249}
 250
 251
 252static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
 253{
 254	struct ocfs2_xattr_value_buf *vb = et->et_object;
 255
 256	et->et_root_el = &vb->vb_xv->xr_list;
 257}
 258
 259static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
 260					      u64 blkno)
 261{
 262	struct ocfs2_xattr_value_buf *vb = et->et_object;
 263
 264	vb->vb_xv->xr_last_eb_blk = cpu_to_le64(blkno);
 265}
 266
 267static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
 268{
 269	struct ocfs2_xattr_value_buf *vb = et->et_object;
 270
 271	return le64_to_cpu(vb->vb_xv->xr_last_eb_blk);
 272}
 273
 274static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et,
 275					      u32 clusters)
 276{
 277	struct ocfs2_xattr_value_buf *vb = et->et_object;
 278
 279	le32_add_cpu(&vb->vb_xv->xr_clusters, clusters);
 280}
 281
 282static const struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
 283	.eo_set_last_eb_blk	= ocfs2_xattr_value_set_last_eb_blk,
 284	.eo_get_last_eb_blk	= ocfs2_xattr_value_get_last_eb_blk,
 285	.eo_update_clusters	= ocfs2_xattr_value_update_clusters,
 286	.eo_fill_root_el	= ocfs2_xattr_value_fill_root_el,
 287};
 288
 289static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
 290{
 291	struct ocfs2_xattr_block *xb = et->et_object;
 292
 293	et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
 294}
 295
 296static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et)
 297{
 298	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
 299	et->et_max_leaf_clusters =
 300		ocfs2_clusters_for_bytes(sb, OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
 301}
 302
 303static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
 304					     u64 blkno)
 305{
 306	struct ocfs2_xattr_block *xb = et->et_object;
 307	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
 308
 309	xt->xt_last_eb_blk = cpu_to_le64(blkno);
 310}
 311
 312static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
 313{
 314	struct ocfs2_xattr_block *xb = et->et_object;
 315	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
 316
 317	return le64_to_cpu(xt->xt_last_eb_blk);
 318}
 319
 320static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et,
 321					     u32 clusters)
 322{
 323	struct ocfs2_xattr_block *xb = et->et_object;
 324
 325	le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
 326}
 327
 328static const struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
 329	.eo_set_last_eb_blk	= ocfs2_xattr_tree_set_last_eb_blk,
 330	.eo_get_last_eb_blk	= ocfs2_xattr_tree_get_last_eb_blk,
 331	.eo_update_clusters	= ocfs2_xattr_tree_update_clusters,
 332	.eo_fill_root_el	= ocfs2_xattr_tree_fill_root_el,
 333	.eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
 334};
 335
 336static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et,
 337					  u64 blkno)
 338{
 339	struct ocfs2_dx_root_block *dx_root = et->et_object;
 340
 341	dx_root->dr_last_eb_blk = cpu_to_le64(blkno);
 342}
 343
 344static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et)
 345{
 346	struct ocfs2_dx_root_block *dx_root = et->et_object;
 347
 348	return le64_to_cpu(dx_root->dr_last_eb_blk);
 349}
 350
 351static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et,
 352					  u32 clusters)
 353{
 354	struct ocfs2_dx_root_block *dx_root = et->et_object;
 355
 356	le32_add_cpu(&dx_root->dr_clusters, clusters);
 357}
 358
 359static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et)
 360{
 361	struct ocfs2_dx_root_block *dx_root = et->et_object;
 362
 363	BUG_ON(!OCFS2_IS_VALID_DX_ROOT(dx_root));
 364
 365	return 0;
 366}
 367
 368static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et)
 369{
 370	struct ocfs2_dx_root_block *dx_root = et->et_object;
 371
 372	et->et_root_el = &dx_root->dr_list;
 373}
 374
 375static const struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = {
 376	.eo_set_last_eb_blk	= ocfs2_dx_root_set_last_eb_blk,
 377	.eo_get_last_eb_blk	= ocfs2_dx_root_get_last_eb_blk,
 378	.eo_update_clusters	= ocfs2_dx_root_update_clusters,
 379	.eo_sanity_check	= ocfs2_dx_root_sanity_check,
 380	.eo_fill_root_el	= ocfs2_dx_root_fill_root_el,
 381};
 382
 383static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et)
 384{
 385	struct ocfs2_refcount_block *rb = et->et_object;
 386
 387	et->et_root_el = &rb->rf_list;
 388}
 389
 390static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
 391						u64 blkno)
 392{
 393	struct ocfs2_refcount_block *rb = et->et_object;
 394
 395	rb->rf_last_eb_blk = cpu_to_le64(blkno);
 396}
 397
 398static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
 399{
 400	struct ocfs2_refcount_block *rb = et->et_object;
 401
 402	return le64_to_cpu(rb->rf_last_eb_blk);
 403}
 404
 405static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et,
 406						u32 clusters)
 407{
 408	struct ocfs2_refcount_block *rb = et->et_object;
 409
 410	le32_add_cpu(&rb->rf_clusters, clusters);
 411}
 412
 413static enum ocfs2_contig_type
 414ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et,
 415				  struct ocfs2_extent_rec *ext,
 416				  struct ocfs2_extent_rec *insert_rec)
 417{
 418	return CONTIG_NONE;
 419}
 420
 421static const struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = {
 422	.eo_set_last_eb_blk	= ocfs2_refcount_tree_set_last_eb_blk,
 423	.eo_get_last_eb_blk	= ocfs2_refcount_tree_get_last_eb_blk,
 424	.eo_update_clusters	= ocfs2_refcount_tree_update_clusters,
 425	.eo_fill_root_el	= ocfs2_refcount_tree_fill_root_el,
 426	.eo_extent_contig	= ocfs2_refcount_tree_extent_contig,
 427};
 428
 429static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
 430				     struct ocfs2_caching_info *ci,
 431				     struct buffer_head *bh,
 432				     ocfs2_journal_access_func access,
 433				     void *obj,
 434				     const struct ocfs2_extent_tree_operations *ops)
 435{
 436	et->et_ops = ops;
 437	et->et_root_bh = bh;
 438	et->et_ci = ci;
 439	et->et_root_journal_access = access;
 440	if (!obj)
 441		obj = (void *)bh->b_data;
 442	et->et_object = obj;
 443	et->et_dealloc = NULL;
 444
 445	et->et_ops->eo_fill_root_el(et);
 446	if (!et->et_ops->eo_fill_max_leaf_clusters)
 447		et->et_max_leaf_clusters = 0;
 448	else
 449		et->et_ops->eo_fill_max_leaf_clusters(et);
 450}
 451
 452void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
 453				   struct ocfs2_caching_info *ci,
 454				   struct buffer_head *bh)
 455{
 456	__ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_di,
 457				 NULL, &ocfs2_dinode_et_ops);
 458}
 459
 460void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
 461				       struct ocfs2_caching_info *ci,
 462				       struct buffer_head *bh)
 463{
 464	__ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_xb,
 465				 NULL, &ocfs2_xattr_tree_et_ops);
 466}
 467
 468void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
 469					struct ocfs2_caching_info *ci,
 470					struct ocfs2_xattr_value_buf *vb)
 471{
 472	__ocfs2_init_extent_tree(et, ci, vb->vb_bh, vb->vb_access, vb,
 473				 &ocfs2_xattr_value_et_ops);
 474}
 475
 476void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et,
 477				    struct ocfs2_caching_info *ci,
 478				    struct buffer_head *bh)
 479{
 480	__ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_dr,
 481				 NULL, &ocfs2_dx_root_et_ops);
 482}
 483
 484void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et,
 485				     struct ocfs2_caching_info *ci,
 486				     struct buffer_head *bh)
 487{
 488	__ocfs2_init_extent_tree(et, ci, bh, ocfs2_journal_access_rb,
 489				 NULL, &ocfs2_refcount_tree_et_ops);
 490}
 491
 492static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
 493					    u64 new_last_eb_blk)
 494{
 495	et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
 496}
 497
 498static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
 499{
 500	return et->et_ops->eo_get_last_eb_blk(et);
 501}
 502
 503static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et,
 504					    u32 clusters)
 505{
 506	et->et_ops->eo_update_clusters(et, clusters);
 507}
 508
 509static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et,
 510					      struct ocfs2_extent_rec *rec)
 511{
 512	if (et->et_ops->eo_extent_map_insert)
 513		et->et_ops->eo_extent_map_insert(et, rec);
 514}
 515
 516static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et,
 517						u32 clusters)
 518{
 519	if (et->et_ops->eo_extent_map_truncate)
 520		et->et_ops->eo_extent_map_truncate(et, clusters);
 521}
 522
 523static inline int ocfs2_et_root_journal_access(handle_t *handle,
 524					       struct ocfs2_extent_tree *et,
 525					       int type)
 526{
 527	return et->et_root_journal_access(handle, et->et_ci, et->et_root_bh,
 528					  type);
 529}
 530
 531static inline enum ocfs2_contig_type
 532	ocfs2_et_extent_contig(struct ocfs2_extent_tree *et,
 533			       struct ocfs2_extent_rec *rec,
 534			       struct ocfs2_extent_rec *insert_rec)
 535{
 536	if (et->et_ops->eo_extent_contig)
 537		return et->et_ops->eo_extent_contig(et, rec, insert_rec);
 538
 539	return ocfs2_extent_rec_contig(
 540				ocfs2_metadata_cache_get_super(et->et_ci),
 541				rec, insert_rec);
 542}
 543
 544static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et,
 545					struct ocfs2_extent_rec *rec)
 546{
 547	int ret = 0;
 548
 549	if (et->et_ops->eo_insert_check)
 550		ret = et->et_ops->eo_insert_check(et, rec);
 551	return ret;
 552}
 553
 554static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et)
 555{
 556	int ret = 0;
 557
 558	if (et->et_ops->eo_sanity_check)
 559		ret = et->et_ops->eo_sanity_check(et);
 560	return ret;
 561}
 562
 563static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
 564					 struct ocfs2_extent_block *eb);
 565static void ocfs2_adjust_rightmost_records(handle_t *handle,
 566					   struct ocfs2_extent_tree *et,
 567					   struct ocfs2_path *path,
 568					   struct ocfs2_extent_rec *insert_rec);
 569/*
 570 * Reset the actual path elements so that we can reuse the structure
 571 * to build another path. Generally, this involves freeing the buffer
 572 * heads.
 573 */
 574void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
 575{
 576	int i, start = 0, depth = 0;
 577	struct ocfs2_path_item *node;
 578
 579	if (keep_root)
 580		start = 1;
 581
 582	for(i = start; i < path_num_items(path); i++) {
 583		node = &path->p_node[i];
 584
 585		brelse(node->bh);
 586		node->bh = NULL;
 587		node->el = NULL;
 588	}
 589
 590	/*
 591	 * Tree depth may change during truncate, or insert. If we're
 592	 * keeping the root extent list, then make sure that our path
 593	 * structure reflects the proper depth.
 594	 */
 595	if (keep_root)
 596		depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
 597	else
 598		path_root_access(path) = NULL;
 599
 600	path->p_tree_depth = depth;
 601}
 602
 603void ocfs2_free_path(struct ocfs2_path *path)
 604{
 605	if (path) {
 606		ocfs2_reinit_path(path, 0);
 607		kfree(path);
 608	}
 609}
 610
 611/*
 612 * All the elements of src into dest. After this call, src could be freed
 613 * without affecting dest.
 614 *
 615 * Both paths should have the same root. Any non-root elements of dest
 616 * will be freed.
 617 */
 618static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
 619{
 620	int i;
 621
 622	BUG_ON(path_root_bh(dest) != path_root_bh(src));
 623	BUG_ON(path_root_el(dest) != path_root_el(src));
 624	BUG_ON(path_root_access(dest) != path_root_access(src));
 625
 626	ocfs2_reinit_path(dest, 1);
 627
 628	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
 629		dest->p_node[i].bh = src->p_node[i].bh;
 630		dest->p_node[i].el = src->p_node[i].el;
 631
 632		if (dest->p_node[i].bh)
 633			get_bh(dest->p_node[i].bh);
 634	}
 635}
 636
 637/*
 638 * Make the *dest path the same as src and re-initialize src path to
 639 * have a root only.
 640 */
 641static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
 642{
 643	int i;
 644
 645	BUG_ON(path_root_bh(dest) != path_root_bh(src));
 646	BUG_ON(path_root_access(dest) != path_root_access(src));
 647
 648	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
 649		brelse(dest->p_node[i].bh);
 650
 651		dest->p_node[i].bh = src->p_node[i].bh;
 652		dest->p_node[i].el = src->p_node[i].el;
 653
 654		src->p_node[i].bh = NULL;
 655		src->p_node[i].el = NULL;
 656	}
 657}
 658
 659/*
 660 * Insert an extent block at given index.
 661 *
 662 * This will not take an additional reference on eb_bh.
 663 */
 664static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
 665					struct buffer_head *eb_bh)
 666{
 667	struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
 668
 669	/*
 670	 * Right now, no root bh is an extent block, so this helps
 671	 * catch code errors with dinode trees. The assertion can be
 672	 * safely removed if we ever need to insert extent block
 673	 * structures at the root.
 674	 */
 675	BUG_ON(index == 0);
 676
 677	path->p_node[index].bh = eb_bh;
 678	path->p_node[index].el = &eb->h_list;
 679}
 680
 681static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
 682					 struct ocfs2_extent_list *root_el,
 683					 ocfs2_journal_access_func access)
 684{
 685	struct ocfs2_path *path;
 686
 687	BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
 688
 689	path = kzalloc(sizeof(*path), GFP_NOFS);
 690	if (path) {
 691		path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
 692		get_bh(root_bh);
 693		path_root_bh(path) = root_bh;
 694		path_root_el(path) = root_el;
 695		path_root_access(path) = access;
 696	}
 697
 698	return path;
 699}
 700
 701struct ocfs2_path *ocfs2_new_path_from_path(struct ocfs2_path *path)
 702{
 703	return ocfs2_new_path(path_root_bh(path), path_root_el(path),
 704			      path_root_access(path));
 705}
 706
 707struct ocfs2_path *ocfs2_new_path_from_et(struct ocfs2_extent_tree *et)
 708{
 709	return ocfs2_new_path(et->et_root_bh, et->et_root_el,
 710			      et->et_root_journal_access);
 711}
 712
 713/*
 714 * Journal the buffer at depth idx.  All idx>0 are extent_blocks,
 715 * otherwise it's the root_access function.
 716 *
 717 * I don't like the way this function's name looks next to
 718 * ocfs2_journal_access_path(), but I don't have a better one.
 719 */
 720int ocfs2_path_bh_journal_access(handle_t *handle,
 721				 struct ocfs2_caching_info *ci,
 722				 struct ocfs2_path *path,
 723				 int idx)
 724{
 725	ocfs2_journal_access_func access = path_root_access(path);
 726
 727	if (!access)
 728		access = ocfs2_journal_access;
 729
 730	if (idx)
 731		access = ocfs2_journal_access_eb;
 732
 733	return access(handle, ci, path->p_node[idx].bh,
 734		      OCFS2_JOURNAL_ACCESS_WRITE);
 735}
 736
 737/*
 738 * Convenience function to journal all components in a path.
 739 */
 740int ocfs2_journal_access_path(struct ocfs2_caching_info *ci,
 741			      handle_t *handle,
 742			      struct ocfs2_path *path)
 743{
 744	int i, ret = 0;
 745
 746	if (!path)
 747		goto out;
 748
 749	for(i = 0; i < path_num_items(path); i++) {
 750		ret = ocfs2_path_bh_journal_access(handle, ci, path, i);
 751		if (ret < 0) {
 752			mlog_errno(ret);
 753			goto out;
 754		}
 755	}
 756
 757out:
 758	return ret;
 759}
 760
 761/*
 762 * Return the index of the extent record which contains cluster #v_cluster.
 763 * -1 is returned if it was not found.
 764 *
 765 * Should work fine on interior and exterior nodes.
 766 */
 767int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
 768{
 769	int ret = -1;
 770	int i;
 771	struct ocfs2_extent_rec *rec;
 772	u32 rec_end, rec_start, clusters;
 773
 774	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
 775		rec = &el->l_recs[i];
 776
 777		rec_start = le32_to_cpu(rec->e_cpos);
 778		clusters = ocfs2_rec_clusters(el, rec);
 779
 780		rec_end = rec_start + clusters;
 781
 782		if (v_cluster >= rec_start && v_cluster < rec_end) {
 783			ret = i;
 784			break;
 785		}
 786	}
 787
 788	return ret;
 789}
 790
 791/*
 792 * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
 793 * ocfs2_extent_rec_contig only work properly against leaf nodes!
 794 */
 795static int ocfs2_block_extent_contig(struct super_block *sb,
 796				     struct ocfs2_extent_rec *ext,
 797				     u64 blkno)
 798{
 799	u64 blk_end = le64_to_cpu(ext->e_blkno);
 800
 801	blk_end += ocfs2_clusters_to_blocks(sb,
 802				    le16_to_cpu(ext->e_leaf_clusters));
 803
 804	return blkno == blk_end;
 805}
 806
 807static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
 808				  struct ocfs2_extent_rec *right)
 809{
 810	u32 left_range;
 811
 812	left_range = le32_to_cpu(left->e_cpos) +
 813		le16_to_cpu(left->e_leaf_clusters);
 814
 815	return (left_range == le32_to_cpu(right->e_cpos));
 816}
 817
 818static enum ocfs2_contig_type
 819	ocfs2_extent_rec_contig(struct super_block *sb,
 820				struct ocfs2_extent_rec *ext,
 821				struct ocfs2_extent_rec *insert_rec)
 822{
 823	u64 blkno = le64_to_cpu(insert_rec->e_blkno);
 824
 825	/*
 826	 * Refuse to coalesce extent records with different flag
 827	 * fields - we don't want to mix unwritten extents with user
 828	 * data.
 829	 */
 830	if (ext->e_flags != insert_rec->e_flags)
 831		return CONTIG_NONE;
 832
 833	if (ocfs2_extents_adjacent(ext, insert_rec) &&
 834	    ocfs2_block_extent_contig(sb, ext, blkno))
 835			return CONTIG_RIGHT;
 836
 837	blkno = le64_to_cpu(ext->e_blkno);
 838	if (ocfs2_extents_adjacent(insert_rec, ext) &&
 839	    ocfs2_block_extent_contig(sb, insert_rec, blkno))
 840		return CONTIG_LEFT;
 841
 842	return CONTIG_NONE;
 843}
 844
 845/*
 846 * NOTE: We can have pretty much any combination of contiguousness and
 847 * appending.
 848 *
 849 * The usefulness of APPEND_TAIL is more in that it lets us know that
 850 * we'll have to update the path to that leaf.
 851 */
 852enum ocfs2_append_type {
 853	APPEND_NONE = 0,
 854	APPEND_TAIL,
 855};
 856
 857enum ocfs2_split_type {
 858	SPLIT_NONE = 0,
 859	SPLIT_LEFT,
 860	SPLIT_RIGHT,
 861};
 862
 863struct ocfs2_insert_type {
 864	enum ocfs2_split_type	ins_split;
 865	enum ocfs2_append_type	ins_appending;
 866	enum ocfs2_contig_type	ins_contig;
 867	int			ins_contig_index;
 868	int			ins_tree_depth;
 869};
 870
 871struct ocfs2_merge_ctxt {
 872	enum ocfs2_contig_type	c_contig_type;
 873	int			c_has_empty_extent;
 874	int			c_split_covers_rec;
 875};
 876
 877static int ocfs2_validate_extent_block(struct super_block *sb,
 878				       struct buffer_head *bh)
 879{
 880	int rc;
 881	struct ocfs2_extent_block *eb =
 882		(struct ocfs2_extent_block *)bh->b_data;
 883
 884	trace_ocfs2_validate_extent_block((unsigned long long)bh->b_blocknr);
 885
 886	BUG_ON(!buffer_uptodate(bh));
 887
 888	/*
 889	 * If the ecc fails, we return the error but otherwise
 890	 * leave the filesystem running.  We know any error is
 891	 * local to this block.
 892	 */
 893	rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &eb->h_check);
 894	if (rc) {
 895		mlog(ML_ERROR, "Checksum failed for extent block %llu\n",
 896		     (unsigned long long)bh->b_blocknr);
 897		return rc;
 898	}
 899
 900	/*
 901	 * Errors after here are fatal.
 902	 */
 903
 904	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
 905		rc = ocfs2_error(sb,
 906				 "Extent block #%llu has bad signature %.*s\n",
 907				 (unsigned long long)bh->b_blocknr, 7,
 908				 eb->h_signature);
 909		goto bail;
 910	}
 911
 912	if (le64_to_cpu(eb->h_blkno) != bh->b_blocknr) {
 913		rc = ocfs2_error(sb,
 914				 "Extent block #%llu has an invalid h_blkno of %llu\n",
 915				 (unsigned long long)bh->b_blocknr,
 916				 (unsigned long long)le64_to_cpu(eb->h_blkno));
 917		goto bail;
 918	}
 919
 920	if (le32_to_cpu(eb->h_fs_generation) != OCFS2_SB(sb)->fs_generation)
 921		rc = ocfs2_error(sb,
 922				 "Extent block #%llu has an invalid h_fs_generation of #%u\n",
 923				 (unsigned long long)bh->b_blocknr,
 924				 le32_to_cpu(eb->h_fs_generation));
 925bail:
 926	return rc;
 927}
 928
 929int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno,
 930			    struct buffer_head **bh)
 931{
 932	int rc;
 933	struct buffer_head *tmp = *bh;
 934
 935	rc = ocfs2_read_block(ci, eb_blkno, &tmp,
 936			      ocfs2_validate_extent_block);
 937
 938	/* If ocfs2_read_block() got us a new bh, pass it up. */
 939	if (!rc && !*bh)
 940		*bh = tmp;
 941
 942	return rc;
 943}
 944
 945
 946/*
 947 * How many free extents have we got before we need more meta data?
 948 */
 949int ocfs2_num_free_extents(struct ocfs2_extent_tree *et)
 950{
 951	int retval;
 952	struct ocfs2_extent_list *el = NULL;
 953	struct ocfs2_extent_block *eb;
 954	struct buffer_head *eb_bh = NULL;
 955	u64 last_eb_blk = 0;
 956
 957	el = et->et_root_el;
 958	last_eb_blk = ocfs2_et_get_last_eb_blk(et);
 959
 960	if (last_eb_blk) {
 961		retval = ocfs2_read_extent_block(et->et_ci, last_eb_blk,
 962						 &eb_bh);
 963		if (retval < 0) {
 964			mlog_errno(retval);
 965			goto bail;
 966		}
 967		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
 968		el = &eb->h_list;
 969	}
 970
 971	if (el->l_tree_depth != 0) {
 972		retval = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
 973				"Owner %llu has leaf extent block %llu with an invalid l_tree_depth of %u\n",
 974				(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
 975				(unsigned long long)last_eb_blk,
 976				le16_to_cpu(el->l_tree_depth));
 977		goto bail;
 978	}
 979
 980	retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
 981bail:
 982	brelse(eb_bh);
 983
 984	trace_ocfs2_num_free_extents(retval);
 985	return retval;
 986}
 987
 988/* expects array to already be allocated
 989 *
 990 * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
 991 * l_count for you
 992 */
 993static int ocfs2_create_new_meta_bhs(handle_t *handle,
 994				     struct ocfs2_extent_tree *et,
 995				     int wanted,
 996				     struct ocfs2_alloc_context *meta_ac,
 997				     struct buffer_head *bhs[])
 998{
 999	int count, status, i;
1000	u16 suballoc_bit_start;
1001	u32 num_got;
1002	u64 suballoc_loc, first_blkno;
1003	struct ocfs2_super *osb =
1004		OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
1005	struct ocfs2_extent_block *eb;
1006
1007	count = 0;
1008	while (count < wanted) {
1009		status = ocfs2_claim_metadata(handle,
1010					      meta_ac,
1011					      wanted - count,
1012					      &suballoc_loc,
1013					      &suballoc_bit_start,
1014					      &num_got,
1015					      &first_blkno);
1016		if (status < 0) {
1017			mlog_errno(status);
1018			goto bail;
1019		}
1020
1021		for(i = count;  i < (num_got + count); i++) {
1022			bhs[i] = sb_getblk(osb->sb, first_blkno);
1023			if (bhs[i] == NULL) {
1024				status = -ENOMEM;
1025				mlog_errno(status);
1026				goto bail;
1027			}
1028			ocfs2_set_new_buffer_uptodate(et->et_ci, bhs[i]);
1029
1030			status = ocfs2_journal_access_eb(handle, et->et_ci,
1031							 bhs[i],
1032							 OCFS2_JOURNAL_ACCESS_CREATE);
1033			if (status < 0) {
1034				mlog_errno(status);
1035				goto bail;
1036			}
1037
1038			memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
1039			eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
1040			/* Ok, setup the minimal stuff here. */
1041			strscpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
1042			eb->h_blkno = cpu_to_le64(first_blkno);
1043			eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
1044			eb->h_suballoc_slot =
1045				cpu_to_le16(meta_ac->ac_alloc_slot);
1046			eb->h_suballoc_loc = cpu_to_le64(suballoc_loc);
1047			eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1048			eb->h_list.l_count =
1049				cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
1050
1051			suballoc_bit_start++;
1052			first_blkno++;
1053
1054			/* We'll also be dirtied by the caller, so
1055			 * this isn't absolutely necessary. */
1056			ocfs2_journal_dirty(handle, bhs[i]);
1057		}
1058
1059		count += num_got;
1060	}
1061
1062	status = 0;
1063bail:
1064	if (status < 0) {
1065		for(i = 0; i < wanted; i++) {
1066			brelse(bhs[i]);
1067			bhs[i] = NULL;
1068		}
1069	}
1070	return status;
1071}
1072
1073/*
1074 * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
1075 *
1076 * Returns the sum of the rightmost extent rec logical offset and
1077 * cluster count.
1078 *
1079 * ocfs2_add_branch() uses this to determine what logical cluster
1080 * value should be populated into the leftmost new branch records.
1081 *
1082 * ocfs2_shift_tree_depth() uses this to determine the # clusters
1083 * value for the new topmost tree record.
1084 */
1085static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list  *el)
1086{
1087	int i;
1088
1089	i = le16_to_cpu(el->l_next_free_rec) - 1;
1090
1091	return le32_to_cpu(el->l_recs[i].e_cpos) +
1092		ocfs2_rec_clusters(el, &el->l_recs[i]);
1093}
1094
1095/*
1096 * Change range of the branches in the right most path according to the leaf
1097 * extent block's rightmost record.
1098 */
1099static int ocfs2_adjust_rightmost_branch(handle_t *handle,
1100					 struct ocfs2_extent_tree *et)
1101{
1102	int status;
1103	struct ocfs2_path *path = NULL;
1104	struct ocfs2_extent_list *el;
1105	struct ocfs2_extent_rec *rec;
1106
1107	path = ocfs2_new_path_from_et(et);
1108	if (!path) {
1109		status = -ENOMEM;
1110		return status;
1111	}
1112
1113	status = ocfs2_find_path(et->et_ci, path, UINT_MAX);
1114	if (status < 0) {
1115		mlog_errno(status);
1116		goto out;
1117	}
1118
1119	status = ocfs2_extend_trans(handle, path_num_items(path));
1120	if (status < 0) {
1121		mlog_errno(status);
1122		goto out;
1123	}
1124
1125	status = ocfs2_journal_access_path(et->et_ci, handle, path);
1126	if (status < 0) {
1127		mlog_errno(status);
1128		goto out;
1129	}
1130
1131	el = path_leaf_el(path);
1132	rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec) - 1];
1133
1134	ocfs2_adjust_rightmost_records(handle, et, path, rec);
1135
1136out:
1137	ocfs2_free_path(path);
1138	return status;
1139}
1140
1141/*
1142 * Add an entire tree branch to our inode. eb_bh is the extent block
1143 * to start at, if we don't want to start the branch at the root
1144 * structure.
1145 *
1146 * last_eb_bh is required as we have to update it's next_leaf pointer
1147 * for the new last extent block.
1148 *
1149 * the new branch will be 'empty' in the sense that every block will
1150 * contain a single record with cluster count == 0.
1151 */
1152static int ocfs2_add_branch(handle_t *handle,
1153			    struct ocfs2_extent_tree *et,
1154			    struct buffer_head *eb_bh,
1155			    struct buffer_head **last_eb_bh,
1156			    struct ocfs2_alloc_context *meta_ac)
1157{
1158	int status, new_blocks, i, block_given = 0;
1159	u64 next_blkno, new_last_eb_blk;
1160	struct buffer_head *bh;
1161	struct buffer_head **new_eb_bhs = NULL;
1162	struct ocfs2_extent_block *eb;
1163	struct ocfs2_extent_list  *eb_el;
1164	struct ocfs2_extent_list  *el;
1165	u32 new_cpos, root_end;
1166
1167	BUG_ON(!last_eb_bh || !*last_eb_bh);
1168
1169	if (eb_bh) {
1170		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1171		el = &eb->h_list;
1172	} else
1173		el = et->et_root_el;
1174
1175	/* we never add a branch to a leaf. */
1176	BUG_ON(!el->l_tree_depth);
1177
1178	new_blocks = le16_to_cpu(el->l_tree_depth);
1179
1180	eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
1181	new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
1182	root_end = ocfs2_sum_rightmost_rec(et->et_root_el);
1183
1184	/*
1185	 * If there is a gap before the root end and the real end
1186	 * of the rightmost leaf block, we need to remove the gap
1187	 * between new_cpos and root_end first so that the tree
1188	 * is consistent after we add a new branch(it will start
1189	 * from new_cpos).
1190	 */
1191	if (root_end > new_cpos) {
1192		trace_ocfs2_adjust_rightmost_branch(
1193			(unsigned long long)
1194			ocfs2_metadata_cache_owner(et->et_ci),
1195			root_end, new_cpos);
1196
1197		status = ocfs2_adjust_rightmost_branch(handle, et);
1198		if (status) {
1199			mlog_errno(status);
1200			goto bail;
1201		}
1202	}
1203
1204	/* allocate the number of new eb blocks we need */
1205	new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
1206			     GFP_KERNEL);
1207	if (!new_eb_bhs) {
1208		status = -ENOMEM;
1209		mlog_errno(status);
1210		goto bail;
1211	}
1212
1213	/* Firstyly, try to reuse dealloc since we have already estimated how
1214	 * many extent blocks we may use.
1215	 */
1216	if (!ocfs2_is_dealloc_empty(et)) {
1217		status = ocfs2_reuse_blk_from_dealloc(handle, et,
1218						      new_eb_bhs, new_blocks,
1219						      &block_given);
1220		if (status < 0) {
1221			mlog_errno(status);
1222			goto bail;
1223		}
1224	}
1225
1226	BUG_ON(block_given > new_blocks);
1227
1228	if (block_given < new_blocks) {
1229		BUG_ON(!meta_ac);
1230		status = ocfs2_create_new_meta_bhs(handle, et,
1231						   new_blocks - block_given,
1232						   meta_ac,
1233						   &new_eb_bhs[block_given]);
1234		if (status < 0) {
1235			mlog_errno(status);
1236			goto bail;
1237		}
1238	}
1239
1240	/* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
1241	 * linked with the rest of the tree.
1242	 * conversely, new_eb_bhs[0] is the new bottommost leaf.
1243	 *
1244	 * when we leave the loop, new_last_eb_blk will point to the
1245	 * newest leaf, and next_blkno will point to the topmost extent
1246	 * block. */
1247	next_blkno = new_last_eb_blk = 0;
1248	for(i = 0; i < new_blocks; i++) {
1249		bh = new_eb_bhs[i];
1250		eb = (struct ocfs2_extent_block *) bh->b_data;
1251		/* ocfs2_create_new_meta_bhs() should create it right! */
1252		BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1253		eb_el = &eb->h_list;
1254
1255		status = ocfs2_journal_access_eb(handle, et->et_ci, bh,
1256						 OCFS2_JOURNAL_ACCESS_CREATE);
1257		if (status < 0) {
1258			mlog_errno(status);
1259			goto bail;
1260		}
1261
1262		eb->h_next_leaf_blk = 0;
1263		eb_el->l_tree_depth = cpu_to_le16(i);
1264		eb_el->l_next_free_rec = cpu_to_le16(1);
1265		/*
1266		 * This actually counts as an empty extent as
1267		 * c_clusters == 0
1268		 */
1269		eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
1270		eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
1271		/*
1272		 * eb_el isn't always an interior node, but even leaf
1273		 * nodes want a zero'd flags and reserved field so
1274		 * this gets the whole 32 bits regardless of use.
1275		 */
1276		eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
1277		if (!eb_el->l_tree_depth)
1278			new_last_eb_blk = le64_to_cpu(eb->h_blkno);
1279
1280		ocfs2_journal_dirty(handle, bh);
1281		next_blkno = le64_to_cpu(eb->h_blkno);
1282	}
1283
1284	/* This is a bit hairy. We want to update up to three blocks
1285	 * here without leaving any of them in an inconsistent state
1286	 * in case of error. We don't have to worry about
1287	 * journal_dirty erroring as it won't unless we've aborted the
1288	 * handle (in which case we would never be here) so reserving
1289	 * the write with journal_access is all we need to do. */
1290	status = ocfs2_journal_access_eb(handle, et->et_ci, *last_eb_bh,
1291					 OCFS2_JOURNAL_ACCESS_WRITE);
1292	if (status < 0) {
1293		mlog_errno(status);
1294		goto bail;
1295	}
1296	status = ocfs2_et_root_journal_access(handle, et,
1297					      OCFS2_JOURNAL_ACCESS_WRITE);
1298	if (status < 0) {
1299		mlog_errno(status);
1300		goto bail;
1301	}
1302	if (eb_bh) {
1303		status = ocfs2_journal_access_eb(handle, et->et_ci, eb_bh,
1304						 OCFS2_JOURNAL_ACCESS_WRITE);
1305		if (status < 0) {
1306			mlog_errno(status);
1307			goto bail;
1308		}
1309	}
1310
1311	/* Link the new branch into the rest of the tree (el will
1312	 * either be on the root_bh, or the extent block passed in. */
1313	i = le16_to_cpu(el->l_next_free_rec);
1314	el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
1315	el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1316	el->l_recs[i].e_int_clusters = 0;
1317	le16_add_cpu(&el->l_next_free_rec, 1);
1318
1319	/* fe needs a new last extent block pointer, as does the
1320	 * next_leaf on the previously last-extent-block. */
1321	ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
1322
1323	eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
1324	eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
1325
1326	ocfs2_journal_dirty(handle, *last_eb_bh);
1327	ocfs2_journal_dirty(handle, et->et_root_bh);
1328	if (eb_bh)
1329		ocfs2_journal_dirty(handle, eb_bh);
1330
1331	/*
1332	 * Some callers want to track the rightmost leaf so pass it
1333	 * back here.
1334	 */
1335	brelse(*last_eb_bh);
1336	get_bh(new_eb_bhs[0]);
1337	*last_eb_bh = new_eb_bhs[0];
1338
1339	status = 0;
1340bail:
1341	if (new_eb_bhs) {
1342		for (i = 0; i < new_blocks; i++)
1343			brelse(new_eb_bhs[i]);
1344		kfree(new_eb_bhs);
1345	}
1346
1347	return status;
1348}
1349
1350/*
1351 * adds another level to the allocation tree.
1352 * returns back the new extent block so you can add a branch to it
1353 * after this call.
1354 */
1355static int ocfs2_shift_tree_depth(handle_t *handle,
1356				  struct ocfs2_extent_tree *et,
1357				  struct ocfs2_alloc_context *meta_ac,
1358				  struct buffer_head **ret_new_eb_bh)
1359{
1360	int status, i, block_given = 0;
1361	u32 new_clusters;
1362	struct buffer_head *new_eb_bh = NULL;
1363	struct ocfs2_extent_block *eb;
1364	struct ocfs2_extent_list  *root_el;
1365	struct ocfs2_extent_list  *eb_el;
1366
1367	if (!ocfs2_is_dealloc_empty(et)) {
1368		status = ocfs2_reuse_blk_from_dealloc(handle, et,
1369						      &new_eb_bh, 1,
1370						      &block_given);
1371	} else if (meta_ac) {
1372		status = ocfs2_create_new_meta_bhs(handle, et, 1, meta_ac,
1373						   &new_eb_bh);
1374
1375	} else {
1376		BUG();
1377	}
1378
1379	if (status < 0) {
1380		mlog_errno(status);
1381		goto bail;
1382	}
1383
1384	eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
1385	/* ocfs2_create_new_meta_bhs() should create it right! */
1386	BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1387
1388	eb_el = &eb->h_list;
1389	root_el = et->et_root_el;
1390
1391	status = ocfs2_journal_access_eb(handle, et->et_ci, new_eb_bh,
1392					 OCFS2_JOURNAL_ACCESS_CREATE);
1393	if (status < 0) {
1394		mlog_errno(status);
1395		goto bail;
1396	}
1397
1398	/* copy the root extent list data into the new extent block */
1399	eb_el->l_tree_depth = root_el->l_tree_depth;
1400	eb_el->l_next_free_rec = root_el->l_next_free_rec;
1401	for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1402		eb_el->l_recs[i] = root_el->l_recs[i];
1403
1404	ocfs2_journal_dirty(handle, new_eb_bh);
1405
1406	status = ocfs2_et_root_journal_access(handle, et,
1407					      OCFS2_JOURNAL_ACCESS_WRITE);
1408	if (status < 0) {
1409		mlog_errno(status);
1410		goto bail;
1411	}
1412
1413	new_clusters = ocfs2_sum_rightmost_rec(eb_el);
1414
1415	/* update root_bh now */
1416	le16_add_cpu(&root_el->l_tree_depth, 1);
1417	root_el->l_recs[0].e_cpos = 0;
1418	root_el->l_recs[0].e_blkno = eb->h_blkno;
1419	root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1420	for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1421		memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1422	root_el->l_next_free_rec = cpu_to_le16(1);
1423
1424	/* If this is our 1st tree depth shift, then last_eb_blk
1425	 * becomes the allocated extent block */
1426	if (root_el->l_tree_depth == cpu_to_le16(1))
1427		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1428
1429	ocfs2_journal_dirty(handle, et->et_root_bh);
1430
1431	*ret_new_eb_bh = new_eb_bh;
1432	new_eb_bh = NULL;
1433	status = 0;
1434bail:
1435	brelse(new_eb_bh);
1436
1437	return status;
1438}
1439
1440/*
1441 * Should only be called when there is no space left in any of the
1442 * leaf nodes. What we want to do is find the lowest tree depth
1443 * non-leaf extent block with room for new records. There are three
1444 * valid results of this search:
1445 *
1446 * 1) a lowest extent block is found, then we pass it back in
1447 *    *lowest_eb_bh and return '0'
1448 *
1449 * 2) the search fails to find anything, but the root_el has room. We
1450 *    pass NULL back in *lowest_eb_bh, but still return '0'
1451 *
1452 * 3) the search fails to find anything AND the root_el is full, in
1453 *    which case we return > 0
1454 *
1455 * return status < 0 indicates an error.
1456 */
1457static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et,
1458				    struct buffer_head **target_bh)
1459{
1460	int status = 0, i;
1461	u64 blkno;
1462	struct ocfs2_extent_block *eb;
1463	struct ocfs2_extent_list  *el;
1464	struct buffer_head *bh = NULL;
1465	struct buffer_head *lowest_bh = NULL;
1466
1467	*target_bh = NULL;
1468
1469	el = et->et_root_el;
1470
1471	while(le16_to_cpu(el->l_tree_depth) > 1) {
1472		if (le16_to_cpu(el->l_next_free_rec) == 0) {
1473			status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1474					"Owner %llu has empty extent list (next_free_rec == 0)\n",
1475					(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
1476			goto bail;
1477		}
1478		i = le16_to_cpu(el->l_next_free_rec) - 1;
1479		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1480		if (!blkno) {
1481			status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1482					"Owner %llu has extent list where extent # %d has no physical block start\n",
1483					(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci), i);
1484			goto bail;
1485		}
1486
1487		brelse(bh);
1488		bh = NULL;
1489
1490		status = ocfs2_read_extent_block(et->et_ci, blkno, &bh);
1491		if (status < 0) {
1492			mlog_errno(status);
1493			goto bail;
1494		}
1495
1496		eb = (struct ocfs2_extent_block *) bh->b_data;
1497		el = &eb->h_list;
1498
1499		if (le16_to_cpu(el->l_next_free_rec) <
1500		    le16_to_cpu(el->l_count)) {
1501			brelse(lowest_bh);
1502			lowest_bh = bh;
1503			get_bh(lowest_bh);
1504		}
1505	}
1506
1507	/* If we didn't find one and the fe doesn't have any room,
1508	 * then return '1' */
1509	el = et->et_root_el;
1510	if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1511		status = 1;
1512
1513	*target_bh = lowest_bh;
1514bail:
1515	brelse(bh);
1516
1517	return status;
1518}
1519
1520/*
1521 * Grow a b-tree so that it has more records.
1522 *
1523 * We might shift the tree depth in which case existing paths should
1524 * be considered invalid.
1525 *
1526 * Tree depth after the grow is returned via *final_depth.
1527 *
1528 * *last_eb_bh will be updated by ocfs2_add_branch().
1529 */
1530static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et,
1531			   int *final_depth, struct buffer_head **last_eb_bh,
1532			   struct ocfs2_alloc_context *meta_ac)
1533{
1534	int ret, shift;
1535	struct ocfs2_extent_list *el = et->et_root_el;
1536	int depth = le16_to_cpu(el->l_tree_depth);
1537	struct buffer_head *bh = NULL;
1538
1539	BUG_ON(meta_ac == NULL && ocfs2_is_dealloc_empty(et));
1540
1541	shift = ocfs2_find_branch_target(et, &bh);
1542	if (shift < 0) {
1543		ret = shift;
1544		mlog_errno(ret);
1545		goto out;
1546	}
1547
1548	/* We traveled all the way to the bottom of the allocation tree
1549	 * and didn't find room for any more extents - we need to add
1550	 * another tree level */
1551	if (shift) {
1552		BUG_ON(bh);
1553		trace_ocfs2_grow_tree(
1554			(unsigned long long)
1555			ocfs2_metadata_cache_owner(et->et_ci),
1556			depth);
1557
1558		/* ocfs2_shift_tree_depth will return us a buffer with
1559		 * the new extent block (so we can pass that to
1560		 * ocfs2_add_branch). */
1561		ret = ocfs2_shift_tree_depth(handle, et, meta_ac, &bh);
1562		if (ret < 0) {
1563			mlog_errno(ret);
1564			goto out;
1565		}
1566		depth++;
1567		if (depth == 1) {
1568			/*
1569			 * Special case: we have room now if we shifted from
1570			 * tree_depth 0, so no more work needs to be done.
1571			 *
1572			 * We won't be calling add_branch, so pass
1573			 * back *last_eb_bh as the new leaf. At depth
1574			 * zero, it should always be null so there's
1575			 * no reason to brelse.
1576			 */
1577			BUG_ON(*last_eb_bh);
1578			get_bh(bh);
1579			*last_eb_bh = bh;
1580			goto out;
1581		}
1582	}
1583
1584	/* call ocfs2_add_branch to add the final part of the tree with
1585	 * the new data. */
1586	ret = ocfs2_add_branch(handle, et, bh, last_eb_bh,
1587			       meta_ac);
1588	if (ret < 0)
1589		mlog_errno(ret);
1590
1591out:
1592	if (final_depth)
1593		*final_depth = depth;
1594	brelse(bh);
1595	return ret;
1596}
1597
1598/*
1599 * This function will discard the rightmost extent record.
1600 */
1601static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1602{
1603	int next_free = le16_to_cpu(el->l_next_free_rec);
1604	int count = le16_to_cpu(el->l_count);
1605	unsigned int num_bytes;
1606
1607	BUG_ON(!next_free);
1608	/* This will cause us to go off the end of our extent list. */
1609	BUG_ON(next_free >= count);
1610
1611	num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1612
1613	memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1614}
1615
1616static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1617			      struct ocfs2_extent_rec *insert_rec)
1618{
1619	int i, insert_index, next_free, has_empty, num_bytes;
1620	u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1621	struct ocfs2_extent_rec *rec;
1622
1623	next_free = le16_to_cpu(el->l_next_free_rec);
1624	has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1625
1626	BUG_ON(!next_free);
1627
1628	/* The tree code before us didn't allow enough room in the leaf. */
1629	BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1630
1631	/*
1632	 * The easiest way to approach this is to just remove the
1633	 * empty extent and temporarily decrement next_free.
1634	 */
1635	if (has_empty) {
1636		/*
1637		 * If next_free was 1 (only an empty extent), this
1638		 * loop won't execute, which is fine. We still want
1639		 * the decrement above to happen.
1640		 */
1641		for(i = 0; i < (next_free - 1); i++)
1642			el->l_recs[i] = el->l_recs[i+1];
1643
1644		next_free--;
1645	}
1646
1647	/*
1648	 * Figure out what the new record index should be.
1649	 */
1650	for(i = 0; i < next_free; i++) {
1651		rec = &el->l_recs[i];
1652
1653		if (insert_cpos < le32_to_cpu(rec->e_cpos))
1654			break;
1655	}
1656	insert_index = i;
1657
1658	trace_ocfs2_rotate_leaf(insert_cpos, insert_index,
1659				has_empty, next_free,
1660				le16_to_cpu(el->l_count));
1661
1662	BUG_ON(insert_index < 0);
1663	BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1664	BUG_ON(insert_index > next_free);
1665
1666	/*
1667	 * No need to memmove if we're just adding to the tail.
1668	 */
1669	if (insert_index != next_free) {
1670		BUG_ON(next_free >= le16_to_cpu(el->l_count));
1671
1672		num_bytes = next_free - insert_index;
1673		num_bytes *= sizeof(struct ocfs2_extent_rec);
1674		memmove(&el->l_recs[insert_index + 1],
1675			&el->l_recs[insert_index],
1676			num_bytes);
1677	}
1678
1679	/*
1680	 * Either we had an empty extent, and need to re-increment or
1681	 * there was no empty extent on a non full rightmost leaf node,
1682	 * in which case we still need to increment.
1683	 */
1684	next_free++;
1685	el->l_next_free_rec = cpu_to_le16(next_free);
1686	/*
1687	 * Make sure none of the math above just messed up our tree.
1688	 */
1689	BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1690
1691	el->l_recs[insert_index] = *insert_rec;
1692
1693}
1694
1695static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1696{
1697	int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1698
1699	BUG_ON(num_recs == 0);
1700
1701	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1702		num_recs--;
1703		size = num_recs * sizeof(struct ocfs2_extent_rec);
1704		memmove(&el->l_recs[0], &el->l_recs[1], size);
1705		memset(&el->l_recs[num_recs], 0,
1706		       sizeof(struct ocfs2_extent_rec));
1707		el->l_next_free_rec = cpu_to_le16(num_recs);
1708	}
1709}
1710
1711/*
1712 * Create an empty extent record .
1713 *
1714 * l_next_free_rec may be updated.
1715 *
1716 * If an empty extent already exists do nothing.
1717 */
1718static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1719{
1720	int next_free = le16_to_cpu(el->l_next_free_rec);
1721
1722	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1723
1724	if (next_free == 0)
1725		goto set_and_inc;
1726
1727	if (ocfs2_is_empty_extent(&el->l_recs[0]))
1728		return;
1729
1730	mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1731			"Asked to create an empty extent in a full list:\n"
1732			"count = %u, tree depth = %u",
1733			le16_to_cpu(el->l_count),
1734			le16_to_cpu(el->l_tree_depth));
1735
1736	ocfs2_shift_records_right(el);
1737
1738set_and_inc:
1739	le16_add_cpu(&el->l_next_free_rec, 1);
1740	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1741}
1742
1743/*
1744 * For a rotation which involves two leaf nodes, the "root node" is
1745 * the lowest level tree node which contains a path to both leafs. This
1746 * resulting set of information can be used to form a complete "subtree"
1747 *
1748 * This function is passed two full paths from the dinode down to a
1749 * pair of adjacent leaves. It's task is to figure out which path
1750 * index contains the subtree root - this can be the root index itself
1751 * in a worst-case rotation.
1752 *
1753 * The array index of the subtree root is passed back.
1754 */
1755int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et,
1756			    struct ocfs2_path *left,
1757			    struct ocfs2_path *right)
1758{
1759	int i = 0;
1760
1761	/*
1762	 * Check that the caller passed in two paths from the same tree.
1763	 */
1764	BUG_ON(path_root_bh(left) != path_root_bh(right));
1765
1766	do {
1767		i++;
1768
1769		/*
1770		 * The caller didn't pass two adjacent paths.
1771		 */
1772		mlog_bug_on_msg(i > left->p_tree_depth,
1773				"Owner %llu, left depth %u, right depth %u\n"
1774				"left leaf blk %llu, right leaf blk %llu\n",
1775				(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
1776				left->p_tree_depth, right->p_tree_depth,
1777				(unsigned long long)path_leaf_bh(left)->b_blocknr,
1778				(unsigned long long)path_leaf_bh(right)->b_blocknr);
1779	} while (left->p_node[i].bh->b_blocknr ==
1780		 right->p_node[i].bh->b_blocknr);
1781
1782	return i - 1;
1783}
1784
1785typedef void (path_insert_t)(void *, struct buffer_head *);
1786
1787/*
1788 * Traverse a btree path in search of cpos, starting at root_el.
1789 *
1790 * This code can be called with a cpos larger than the tree, in which
1791 * case it will return the rightmost path.
1792 */
1793static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
1794			     struct ocfs2_extent_list *root_el, u32 cpos,
1795			     path_insert_t *func, void *data)
1796{
1797	int i, ret = 0;
1798	u32 range;
1799	u64 blkno;
1800	struct buffer_head *bh = NULL;
1801	struct ocfs2_extent_block *eb;
1802	struct ocfs2_extent_list *el;
1803	struct ocfs2_extent_rec *rec;
1804
1805	el = root_el;
1806	while (el->l_tree_depth) {
1807		if (unlikely(le16_to_cpu(el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH)) {
1808			ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1809				    "Owner %llu has invalid tree depth %u in extent list\n",
1810				    (unsigned long long)ocfs2_metadata_cache_owner(ci),
1811				    le16_to_cpu(el->l_tree_depth));
1812			ret = -EROFS;
1813			goto out;
1814		}
1815		if (le16_to_cpu(el->l_next_free_rec) == 0) {
1816			ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1817				    "Owner %llu has empty extent list at depth %u\n",
1818				    (unsigned long long)ocfs2_metadata_cache_owner(ci),
1819				    le16_to_cpu(el->l_tree_depth));
1820			ret = -EROFS;
1821			goto out;
1822
1823		}
1824
1825		for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1826			rec = &el->l_recs[i];
1827
1828			/*
1829			 * In the case that cpos is off the allocation
1830			 * tree, this should just wind up returning the
1831			 * rightmost record.
1832			 */
1833			range = le32_to_cpu(rec->e_cpos) +
1834				ocfs2_rec_clusters(el, rec);
1835			if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1836			    break;
1837		}
1838
1839		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1840		if (blkno == 0) {
1841			ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1842				    "Owner %llu has bad blkno in extent list at depth %u (index %d)\n",
1843				    (unsigned long long)ocfs2_metadata_cache_owner(ci),
1844				    le16_to_cpu(el->l_tree_depth), i);
1845			ret = -EROFS;
1846			goto out;
1847		}
1848
1849		brelse(bh);
1850		bh = NULL;
1851		ret = ocfs2_read_extent_block(ci, blkno, &bh);
1852		if (ret) {
1853			mlog_errno(ret);
1854			goto out;
1855		}
1856
1857		eb = (struct ocfs2_extent_block *) bh->b_data;
1858		el = &eb->h_list;
1859
1860		if (le16_to_cpu(el->l_next_free_rec) >
1861		    le16_to_cpu(el->l_count)) {
1862			ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1863				    "Owner %llu has bad count in extent list at block %llu (next free=%u, count=%u)\n",
1864				    (unsigned long long)ocfs2_metadata_cache_owner(ci),
1865				    (unsigned long long)bh->b_blocknr,
1866				    le16_to_cpu(el->l_next_free_rec),
1867				    le16_to_cpu(el->l_count));
1868			ret = -EROFS;
1869			goto out;
1870		}
1871
1872		if (func)
1873			func(data, bh);
1874	}
1875
1876out:
1877	/*
1878	 * Catch any trailing bh that the loop didn't handle.
1879	 */
1880	brelse(bh);
1881
1882	return ret;
1883}
1884
1885/*
1886 * Given an initialized path (that is, it has a valid root extent
1887 * list), this function will traverse the btree in search of the path
1888 * which would contain cpos.
1889 *
1890 * The path traveled is recorded in the path structure.
1891 *
1892 * Note that this will not do any comparisons on leaf node extent
1893 * records, so it will work fine in the case that we just added a tree
1894 * branch.
1895 */
1896struct find_path_data {
1897	int index;
1898	struct ocfs2_path *path;
1899};
1900static void find_path_ins(void *data, struct buffer_head *bh)
1901{
1902	struct find_path_data *fp = data;
1903
1904	get_bh(bh);
1905	ocfs2_path_insert_eb(fp->path, fp->index, bh);
1906	fp->index++;
1907}
1908int ocfs2_find_path(struct ocfs2_caching_info *ci,
1909		    struct ocfs2_path *path, u32 cpos)
1910{
1911	struct find_path_data data;
1912
1913	data.index = 1;
1914	data.path = path;
1915	return __ocfs2_find_path(ci, path_root_el(path), cpos,
1916				 find_path_ins, &data);
1917}
1918
1919static void find_leaf_ins(void *data, struct buffer_head *bh)
1920{
1921	struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1922	struct ocfs2_extent_list *el = &eb->h_list;
1923	struct buffer_head **ret = data;
1924
1925	/* We want to retain only the leaf block. */
1926	if (le16_to_cpu(el->l_tree_depth) == 0) {
1927		get_bh(bh);
1928		*ret = bh;
1929	}
1930}
1931/*
1932 * Find the leaf block in the tree which would contain cpos. No
1933 * checking of the actual leaf is done.
1934 *
1935 * Some paths want to call this instead of allocating a path structure
1936 * and calling ocfs2_find_path().
1937 *
1938 * This function doesn't handle non btree extent lists.
1939 */
1940int ocfs2_find_leaf(struct ocfs2_caching_info *ci,
1941		    struct ocfs2_extent_list *root_el, u32 cpos,
1942		    struct buffer_head **leaf_bh)
1943{
1944	int ret;
1945	struct buffer_head *bh = NULL;
1946
1947	ret = __ocfs2_find_path(ci, root_el, cpos, find_leaf_ins, &bh);
1948	if (ret) {
1949		mlog_errno(ret);
1950		goto out;
1951	}
1952
1953	*leaf_bh = bh;
1954out:
1955	return ret;
1956}
1957
1958/*
1959 * Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1960 *
1961 * Basically, we've moved stuff around at the bottom of the tree and
1962 * we need to fix up the extent records above the changes to reflect
1963 * the new changes.
1964 *
1965 * left_rec: the record on the left.
1966 * right_rec: the record to the right of left_rec
1967 * right_child_el: is the child list pointed to by right_rec
1968 *
1969 * By definition, this only works on interior nodes.
1970 */
1971static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1972				  struct ocfs2_extent_rec *right_rec,
1973				  struct ocfs2_extent_list *right_child_el)
1974{
1975	u32 left_clusters, right_end;
1976
1977	/*
1978	 * Interior nodes never have holes. Their cpos is the cpos of
1979	 * the leftmost record in their child list. Their cluster
1980	 * count covers the full theoretical range of their child list
1981	 * - the range between their cpos and the cpos of the record
1982	 * immediately to their right.
1983	 */
1984	left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1985	if (!ocfs2_rec_clusters(right_child_el, &right_child_el->l_recs[0])) {
1986		BUG_ON(right_child_el->l_tree_depth);
1987		BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1988		left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1989	}
1990	left_clusters -= le32_to_cpu(left_rec->e_cpos);
1991	left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1992
1993	/*
1994	 * Calculate the rightmost cluster count boundary before
1995	 * moving cpos - we will need to adjust clusters after
1996	 * updating e_cpos to keep the same highest cluster count.
1997	 */
1998	right_end = le32_to_cpu(right_rec->e_cpos);
1999	right_end += le32_to_cpu(right_rec->e_int_clusters);
2000
2001	right_rec->e_cpos = left_rec->e_cpos;
2002	le32_add_cpu(&right_rec->e_cpos, left_clusters);
2003
2004	right_end -= le32_to_cpu(right_rec->e_cpos);
2005	right_rec->e_int_clusters = cpu_to_le32(right_end);
2006}
2007
2008/*
2009 * Adjust the adjacent root node records involved in a
2010 * rotation. left_el_blkno is passed in as a key so that we can easily
2011 * find it's index in the root list.
2012 */
2013static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
2014				      struct ocfs2_extent_list *left_el,
2015				      struct ocfs2_extent_list *right_el,
2016				      u64 left_el_blkno)
2017{
2018	int i;
2019
2020	BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
2021	       le16_to_cpu(left_el->l_tree_depth));
2022
2023	for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
2024		if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
2025			break;
2026	}
2027
2028	/*
2029	 * The path walking code should have never returned a root and
2030	 * two paths which are not adjacent.
2031	 */
2032	BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
2033
2034	ocfs2_adjust_adjacent_records(&root_el->l_recs[i],
2035				      &root_el->l_recs[i + 1], right_el);
2036}
2037
2038/*
2039 * We've changed a leaf block (in right_path) and need to reflect that
2040 * change back up the subtree.
2041 *
2042 * This happens in multiple places:
2043 *   - When we've moved an extent record from the left path leaf to the right
2044 *     path leaf to make room for an empty extent in the left path leaf.
2045 *   - When our insert into the right path leaf is at the leftmost edge
2046 *     and requires an update of the path immediately to it's left. This
2047 *     can occur at the end of some types of rotation and appending inserts.
2048 *   - When we've adjusted the last extent record in the left path leaf and the
2049 *     1st extent record in the right path leaf during cross extent block merge.
2050 */
2051static void ocfs2_complete_edge_insert(handle_t *handle,
2052				       struct ocfs2_path *left_path,
2053				       struct ocfs2_path *right_path,
2054				       int subtree_index)
2055{
2056	int i, idx;
2057	struct ocfs2_extent_list *el, *left_el, *right_el;
2058	struct ocfs2_extent_rec *left_rec, *right_rec;
2059	struct buffer_head *root_bh;
2060
2061	/*
2062	 * Update the counts and position values within all the
2063	 * interior nodes to reflect the leaf rotation we just did.
2064	 *
2065	 * The root node is handled below the loop.
2066	 *
2067	 * We begin the loop with right_el and left_el pointing to the
2068	 * leaf lists and work our way up.
2069	 *
2070	 * NOTE: within this loop, left_el and right_el always refer
2071	 * to the *child* lists.
2072	 */
2073	left_el = path_leaf_el(left_path);
2074	right_el = path_leaf_el(right_path);
2075	for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
2076		trace_ocfs2_complete_edge_insert(i);
2077
2078		/*
2079		 * One nice property of knowing that all of these
2080		 * nodes are below the root is that we only deal with
2081		 * the leftmost right node record and the rightmost
2082		 * left node record.
2083		 */
2084		el = left_path->p_node[i].el;
2085		idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
2086		left_rec = &el->l_recs[idx];
2087
2088		el = right_path->p_node[i].el;
2089		right_rec = &el->l_recs[0];
2090
2091		ocfs2_adjust_adjacent_records(left_rec, right_rec, right_el);
2092
2093		ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
2094		ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
2095
2096		/*
2097		 * Setup our list pointers now so that the current
2098		 * parents become children in the next iteration.
2099		 */
2100		left_el = left_path->p_node[i].el;
2101		right_el = right_path->p_node[i].el;
2102	}
2103
2104	/*
2105	 * At the root node, adjust the two adjacent records which
2106	 * begin our path to the leaves.
2107	 */
2108
2109	el = left_path->p_node[subtree_index].el;
2110	left_el = left_path->p_node[subtree_index + 1].el;
2111	right_el = right_path->p_node[subtree_index + 1].el;
2112
2113	ocfs2_adjust_root_records(el, left_el, right_el,
2114				  left_path->p_node[subtree_index + 1].bh->b_blocknr);
2115
2116	root_bh = left_path->p_node[subtree_index].bh;
2117
2118	ocfs2_journal_dirty(handle, root_bh);
2119}
2120
2121static int ocfs2_rotate_subtree_right(handle_t *handle,
2122				      struct ocfs2_extent_tree *et,
2123				      struct ocfs2_path *left_path,
2124				      struct ocfs2_path *right_path,
2125				      int subtree_index)
2126{
2127	int ret, i;
2128	struct buffer_head *right_leaf_bh;
2129	struct buffer_head *left_leaf_bh = NULL;
2130	struct buffer_head *root_bh;
2131	struct ocfs2_extent_list *right_el, *left_el;
2132	struct ocfs2_extent_rec move_rec;
2133
2134	left_leaf_bh = path_leaf_bh(left_path);
2135	left_el = path_leaf_el(left_path);
2136
2137	if (left_el->l_next_free_rec != left_el->l_count) {
2138		ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
2139			    "Inode %llu has non-full interior leaf node %llu (next free = %u)\n",
2140			    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2141			    (unsigned long long)left_leaf_bh->b_blocknr,
2142			    le16_to_cpu(left_el->l_next_free_rec));
2143		return -EROFS;
2144	}
2145
2146	/*
2147	 * This extent block may already have an empty record, so we
2148	 * return early if so.
2149	 */
2150	if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
2151		return 0;
2152
2153	root_bh = left_path->p_node[subtree_index].bh;
2154	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2155
2156	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2157					   subtree_index);
2158	if (ret) {
2159		mlog_errno(ret);
2160		goto out;
2161	}
2162
2163	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2164		ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2165						   right_path, i);
2166		if (ret) {
2167			mlog_errno(ret);
2168			goto out;
2169		}
2170
2171		ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2172						   left_path, i);
2173		if (ret) {
2174			mlog_errno(ret);
2175			goto out;
2176		}
2177	}
2178
2179	right_leaf_bh = path_leaf_bh(right_path);
2180	right_el = path_leaf_el(right_path);
2181
2182	/* This is a code error, not a disk corruption. */
2183	mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
2184			"because rightmost leaf block %llu is empty\n",
2185			(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2186			(unsigned long long)right_leaf_bh->b_blocknr);
2187
2188	ocfs2_create_empty_extent(right_el);
2189
2190	ocfs2_journal_dirty(handle, right_leaf_bh);
2191
2192	/* Do the copy now. */
2193	i = le16_to_cpu(left_el->l_next_free_rec) - 1;
2194	move_rec = left_el->l_recs[i];
2195	right_el->l_recs[0] = move_rec;
2196
2197	/*
2198	 * Clear out the record we just copied and shift everything
2199	 * over, leaving an empty extent in the left leaf.
2200	 *
2201	 * We temporarily subtract from next_free_rec so that the
2202	 * shift will lose the tail record (which is now defunct).
2203	 */
2204	le16_add_cpu(&left_el->l_next_free_rec, -1);
2205	ocfs2_shift_records_right(left_el);
2206	memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2207	le16_add_cpu(&left_el->l_next_free_rec, 1);
2208
2209	ocfs2_journal_dirty(handle, left_leaf_bh);
2210
2211	ocfs2_complete_edge_insert(handle, left_path, right_path,
2212				   subtree_index);
2213
2214out:
2215	return ret;
2216}
2217
2218/*
2219 * Given a full path, determine what cpos value would return us a path
2220 * containing the leaf immediately to the left of the current one.
2221 *
2222 * Will return zero if the path passed in is already the leftmost path.
2223 */
2224int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
2225				  struct ocfs2_path *path, u32 *cpos)
2226{
2227	int i, j, ret = 0;
2228	u64 blkno;
2229	struct ocfs2_extent_list *el;
2230
2231	BUG_ON(path->p_tree_depth == 0);
2232
2233	*cpos = 0;
2234
2235	blkno = path_leaf_bh(path)->b_blocknr;
2236
2237	/* Start at the tree node just above the leaf and work our way up. */
2238	i = path->p_tree_depth - 1;
2239	while (i >= 0) {
2240		el = path->p_node[i].el;
2241
2242		/*
2243		 * Find the extent record just before the one in our
2244		 * path.
2245		 */
2246		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2247			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2248				if (j == 0) {
2249					if (i == 0) {
2250						/*
2251						 * We've determined that the
2252						 * path specified is already
2253						 * the leftmost one - return a
2254						 * cpos of zero.
2255						 */
2256						goto out;
2257					}
2258					/*
2259					 * The leftmost record points to our
2260					 * leaf - we need to travel up the
2261					 * tree one level.
2262					 */
2263					goto next_node;
2264				}
2265
2266				*cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
2267				*cpos = *cpos + ocfs2_rec_clusters(el,
2268							   &el->l_recs[j - 1]);
2269				*cpos = *cpos - 1;
2270				goto out;
2271			}
2272		}
2273
2274		/*
2275		 * If we got here, we never found a valid node where
2276		 * the tree indicated one should be.
2277		 */
2278		ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2279			    (unsigned long long)blkno);
2280		ret = -EROFS;
2281		goto out;
2282
2283next_node:
2284		blkno = path->p_node[i].bh->b_blocknr;
2285		i--;
2286	}
2287
2288out:
2289	return ret;
2290}
2291
2292/*
2293 * Extend the transaction by enough credits to complete the rotation,
2294 * and still leave at least the original number of credits allocated
2295 * to this transaction.
2296 */
2297static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
2298					   int op_credits,
2299					   struct ocfs2_path *path)
2300{
2301	int ret = 0;
2302	int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
2303
2304	if (jbd2_handle_buffer_credits(handle) < credits)
2305		ret = ocfs2_extend_trans(handle,
2306				credits - jbd2_handle_buffer_credits(handle));
2307
2308	return ret;
2309}
2310
2311/*
2312 * Trap the case where we're inserting into the theoretical range past
2313 * the _actual_ left leaf range. Otherwise, we'll rotate a record
2314 * whose cpos is less than ours into the right leaf.
2315 *
2316 * It's only necessary to look at the rightmost record of the left
2317 * leaf because the logic that calls us should ensure that the
2318 * theoretical ranges in the path components above the leaves are
2319 * correct.
2320 */
2321static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
2322						 u32 insert_cpos)
2323{
2324	struct ocfs2_extent_list *left_el;
2325	struct ocfs2_extent_rec *rec;
2326	int next_free;
2327
2328	left_el = path_leaf_el(left_path);
2329	next_free = le16_to_cpu(left_el->l_next_free_rec);
2330	rec = &left_el->l_recs[next_free - 1];
2331
2332	if (insert_cpos > le32_to_cpu(rec->e_cpos))
2333		return 1;
2334	return 0;
2335}
2336
2337static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
2338{
2339	int next_free = le16_to_cpu(el->l_next_free_rec);
2340	unsigned int range;
2341	struct ocfs2_extent_rec *rec;
2342
2343	if (next_free == 0)
2344		return 0;
2345
2346	rec = &el->l_recs[0];
2347	if (ocfs2_is_empty_extent(rec)) {
2348		/* Empty list. */
2349		if (next_free == 1)
2350			return 0;
2351		rec = &el->l_recs[1];
2352	}
2353
2354	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2355	if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2356		return 1;
2357	return 0;
2358}
2359
2360/*
2361 * Rotate all the records in a btree right one record, starting at insert_cpos.
2362 *
2363 * The path to the rightmost leaf should be passed in.
2364 *
2365 * The array is assumed to be large enough to hold an entire path (tree depth).
2366 *
2367 * Upon successful return from this function:
2368 *
2369 * - The 'right_path' array will contain a path to the leaf block
2370 *   whose range contains e_cpos.
2371 * - That leaf block will have a single empty extent in list index 0.
2372 * - In the case that the rotation requires a post-insert update,
2373 *   *ret_left_path will contain a valid path which can be passed to
2374 *   ocfs2_insert_path().
2375 */
2376static int ocfs2_rotate_tree_right(handle_t *handle,
2377				   struct ocfs2_extent_tree *et,
2378				   enum ocfs2_split_type split,
2379				   u32 insert_cpos,
2380				   struct ocfs2_path *right_path,
2381				   struct ocfs2_path **ret_left_path)
2382{
2383	int ret, start, orig_credits = jbd2_handle_buffer_credits(handle);
2384	u32 cpos;
2385	struct ocfs2_path *left_path = NULL;
2386	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2387
2388	*ret_left_path = NULL;
2389
2390	left_path = ocfs2_new_path_from_path(right_path);
2391	if (!left_path) {
2392		ret = -ENOMEM;
2393		mlog_errno(ret);
2394		goto out;
2395	}
2396
2397	ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2398	if (ret) {
2399		mlog_errno(ret);
2400		goto out;
2401	}
2402
2403	trace_ocfs2_rotate_tree_right(
2404		(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2405		insert_cpos, cpos);
2406
2407	/*
2408	 * What we want to do here is:
2409	 *
2410	 * 1) Start with the rightmost path.
2411	 *
2412	 * 2) Determine a path to the leaf block directly to the left
2413	 *    of that leaf.
2414	 *
2415	 * 3) Determine the 'subtree root' - the lowest level tree node
2416	 *    which contains a path to both leaves.
2417	 *
2418	 * 4) Rotate the subtree.
2419	 *
2420	 * 5) Find the next subtree by considering the left path to be
2421	 *    the new right path.
2422	 *
2423	 * The check at the top of this while loop also accepts
2424	 * insert_cpos == cpos because cpos is only a _theoretical_
2425	 * value to get us the left path - insert_cpos might very well
2426	 * be filling that hole.
2427	 *
2428	 * Stop at a cpos of '0' because we either started at the
2429	 * leftmost branch (i.e., a tree with one branch and a
2430	 * rotation inside of it), or we've gone as far as we can in
2431	 * rotating subtrees.
2432	 */
2433	while (cpos && insert_cpos <= cpos) {
2434		trace_ocfs2_rotate_tree_right(
2435			(unsigned long long)
2436			ocfs2_metadata_cache_owner(et->et_ci),
2437			insert_cpos, cpos);
2438
2439		ret = ocfs2_find_path(et->et_ci, left_path, cpos);
2440		if (ret) {
2441			mlog_errno(ret);
2442			goto out;
2443		}
2444
2445		mlog_bug_on_msg(path_leaf_bh(left_path) ==
2446				path_leaf_bh(right_path),
2447				"Owner %llu: error during insert of %u "
2448				"(left path cpos %u) results in two identical "
2449				"paths ending at %llu\n",
2450				(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2451				insert_cpos, cpos,
2452				(unsigned long long)
2453				path_leaf_bh(left_path)->b_blocknr);
2454
2455		if (split == SPLIT_NONE &&
2456		    ocfs2_rotate_requires_path_adjustment(left_path,
2457							  insert_cpos)) {
2458
2459			/*
2460			 * We've rotated the tree as much as we
2461			 * should. The rest is up to
2462			 * ocfs2_insert_path() to complete, after the
2463			 * record insertion. We indicate this
2464			 * situation by returning the left path.
2465			 *
2466			 * The reason we don't adjust the records here
2467			 * before the record insert is that an error
2468			 * later might break the rule where a parent
2469			 * record e_cpos will reflect the actual
2470			 * e_cpos of the 1st nonempty record of the
2471			 * child list.
2472			 */
2473			*ret_left_path = left_path;
2474			goto out_ret_path;
2475		}
2476
2477		start = ocfs2_find_subtree_root(et, left_path, right_path);
2478
2479		trace_ocfs2_rotate_subtree(start,
2480			(unsigned long long)
2481			right_path->p_node[start].bh->b_blocknr,
2482			right_path->p_tree_depth);
2483
2484		ret = ocfs2_extend_rotate_transaction(handle, start,
2485						      orig_credits, right_path);
2486		if (ret) {
2487			mlog_errno(ret);
2488			goto out;
2489		}
2490
2491		ret = ocfs2_rotate_subtree_right(handle, et, left_path,
2492						 right_path, start);
2493		if (ret) {
2494			mlog_errno(ret);
2495			goto out;
2496		}
2497
2498		if (split != SPLIT_NONE &&
2499		    ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2500						insert_cpos)) {
2501			/*
2502			 * A rotate moves the rightmost left leaf
2503			 * record over to the leftmost right leaf
2504			 * slot. If we're doing an extent split
2505			 * instead of a real insert, then we have to
2506			 * check that the extent to be split wasn't
2507			 * just moved over. If it was, then we can
2508			 * exit here, passing left_path back -
2509			 * ocfs2_split_extent() is smart enough to
2510			 * search both leaves.
2511			 */
2512			*ret_left_path = left_path;
2513			goto out_ret_path;
2514		}
2515
2516		/*
2517		 * There is no need to re-read the next right path
2518		 * as we know that it'll be our current left
2519		 * path. Optimize by copying values instead.
2520		 */
2521		ocfs2_mv_path(right_path, left_path);
2522
2523		ret = ocfs2_find_cpos_for_left_leaf(sb, right_path, &cpos);
2524		if (ret) {
2525			mlog_errno(ret);
2526			goto out;
2527		}
2528	}
2529
2530out:
2531	ocfs2_free_path(left_path);
2532
2533out_ret_path:
2534	return ret;
2535}
2536
2537static int ocfs2_update_edge_lengths(handle_t *handle,
2538				     struct ocfs2_extent_tree *et,
2539				     struct ocfs2_path *path)
2540{
2541	int i, idx, ret;
2542	struct ocfs2_extent_rec *rec;
2543	struct ocfs2_extent_list *el;
2544	struct ocfs2_extent_block *eb;
2545	u32 range;
2546
2547	ret = ocfs2_journal_access_path(et->et_ci, handle, path);
2548	if (ret) {
2549		mlog_errno(ret);
2550		goto out;
2551	}
2552
2553	/* Path should always be rightmost. */
2554	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2555	BUG_ON(eb->h_next_leaf_blk != 0ULL);
2556
2557	el = &eb->h_list;
2558	BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2559	idx = le16_to_cpu(el->l_next_free_rec) - 1;
2560	rec = &el->l_recs[idx];
2561	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2562
2563	for (i = 0; i < path->p_tree_depth; i++) {
2564		el = path->p_node[i].el;
2565		idx = le16_to_cpu(el->l_next_free_rec) - 1;
2566		rec = &el->l_recs[idx];
2567
2568		rec->e_int_clusters = cpu_to_le32(range);
2569		le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
2570
2571		ocfs2_journal_dirty(handle, path->p_node[i].bh);
2572	}
2573out:
2574	return ret;
2575}
2576
2577static void ocfs2_unlink_path(handle_t *handle,
2578			      struct ocfs2_extent_tree *et,
2579			      struct ocfs2_cached_dealloc_ctxt *dealloc,
2580			      struct ocfs2_path *path, int unlink_start)
2581{
2582	int ret, i;
2583	struct ocfs2_extent_block *eb;
2584	struct ocfs2_extent_list *el;
2585	struct buffer_head *bh;
2586
2587	for(i = unlink_start; i < path_num_items(path); i++) {
2588		bh = path->p_node[i].bh;
2589
2590		eb = (struct ocfs2_extent_block *)bh->b_data;
2591		/*
2592		 * Not all nodes might have had their final count
2593		 * decremented by the caller - handle this here.
2594		 */
2595		el = &eb->h_list;
2596		if (le16_to_cpu(el->l_next_free_rec) > 1) {
2597			mlog(ML_ERROR,
2598			     "Inode %llu, attempted to remove extent block "
2599			     "%llu with %u records\n",
2600			     (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2601			     (unsigned long long)le64_to_cpu(eb->h_blkno),
2602			     le16_to_cpu(el->l_next_free_rec));
2603
2604			ocfs2_journal_dirty(handle, bh);
2605			ocfs2_remove_from_cache(et->et_ci, bh);
2606			continue;
2607		}
2608
2609		el->l_next_free_rec = 0;
2610		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2611
2612		ocfs2_journal_dirty(handle, bh);
2613
2614		ret = ocfs2_cache_extent_block_free(dealloc, eb);
2615		if (ret)
2616			mlog_errno(ret);
2617
2618		ocfs2_remove_from_cache(et->et_ci, bh);
2619	}
2620}
2621
2622static void ocfs2_unlink_subtree(handle_t *handle,
2623				 struct ocfs2_extent_tree *et,
2624				 struct ocfs2_path *left_path,
2625				 struct ocfs2_path *right_path,
2626				 int subtree_index,
2627				 struct ocfs2_cached_dealloc_ctxt *dealloc)
2628{
2629	int i;
2630	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2631	struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2632	struct ocfs2_extent_block *eb;
2633
2634	eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2635
2636	for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2637		if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2638			break;
2639
2640	BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2641
2642	memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2643	le16_add_cpu(&root_el->l_next_free_rec, -1);
2644
2645	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2646	eb->h_next_leaf_blk = 0;
2647
2648	ocfs2_journal_dirty(handle, root_bh);
2649	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2650
2651	ocfs2_unlink_path(handle, et, dealloc, right_path,
2652			  subtree_index + 1);
2653}
2654
2655static int ocfs2_rotate_subtree_left(handle_t *handle,
2656				     struct ocfs2_extent_tree *et,
2657				     struct ocfs2_path *left_path,
2658				     struct ocfs2_path *right_path,
2659				     int subtree_index,
2660				     struct ocfs2_cached_dealloc_ctxt *dealloc,
2661				     int *deleted)
2662{
2663	int ret, i, del_right_subtree = 0, right_has_empty = 0;
2664	struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2665	struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2666	struct ocfs2_extent_block *eb;
2667
2668	*deleted = 0;
2669
2670	right_leaf_el = path_leaf_el(right_path);
2671	left_leaf_el = path_leaf_el(left_path);
2672	root_bh = left_path->p_node[subtree_index].bh;
2673	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2674
2675	if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2676		return 0;
2677
2678	eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2679	if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2680		/*
2681		 * It's legal for us to proceed if the right leaf is
2682		 * the rightmost one and it has an empty extent. There
2683		 * are two cases to handle - whether the leaf will be
2684		 * empty after removal or not. If the leaf isn't empty
2685		 * then just remove the empty extent up front. The
2686		 * next block will handle empty leaves by flagging
2687		 * them for unlink.
2688		 *
2689		 * Non rightmost leaves will throw -EAGAIN and the
2690		 * caller can manually move the subtree and retry.
2691		 */
2692
2693		if (eb->h_next_leaf_blk != 0ULL)
2694			return -EAGAIN;
2695
2696		if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2697			ret = ocfs2_journal_access_eb(handle, et->et_ci,
2698						      path_leaf_bh(right_path),
2699						      OCFS2_JOURNAL_ACCESS_WRITE);
2700			if (ret) {
2701				mlog_errno(ret);
2702				goto out;
2703			}
2704
2705			ocfs2_remove_empty_extent(right_leaf_el);
2706		} else
2707			right_has_empty = 1;
2708	}
2709
2710	if (eb->h_next_leaf_blk == 0ULL &&
2711	    le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2712		/*
2713		 * We have to update i_last_eb_blk during the meta
2714		 * data delete.
2715		 */
2716		ret = ocfs2_et_root_journal_access(handle, et,
2717						   OCFS2_JOURNAL_ACCESS_WRITE);
2718		if (ret) {
2719			mlog_errno(ret);
2720			goto out;
2721		}
2722
2723		del_right_subtree = 1;
2724	}
2725
2726	/*
2727	 * Getting here with an empty extent in the right path implies
2728	 * that it's the rightmost path and will be deleted.
2729	 */
2730	BUG_ON(right_has_empty && !del_right_subtree);
2731
2732	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
2733					   subtree_index);
2734	if (ret) {
2735		mlog_errno(ret);
2736		goto out;
2737	}
2738
2739	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2740		ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2741						   right_path, i);
2742		if (ret) {
2743			mlog_errno(ret);
2744			goto out;
2745		}
2746
2747		ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2748						   left_path, i);
2749		if (ret) {
2750			mlog_errno(ret);
2751			goto out;
2752		}
2753	}
2754
2755	if (!right_has_empty) {
2756		/*
2757		 * Only do this if we're moving a real
2758		 * record. Otherwise, the action is delayed until
2759		 * after removal of the right path in which case we
2760		 * can do a simple shift to remove the empty extent.
2761		 */
2762		ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2763		memset(&right_leaf_el->l_recs[0], 0,
2764		       sizeof(struct ocfs2_extent_rec));
2765	}
2766	if (eb->h_next_leaf_blk == 0ULL) {
2767		/*
2768		 * Move recs over to get rid of empty extent, decrease
2769		 * next_free. This is allowed to remove the last
2770		 * extent in our leaf (setting l_next_free_rec to
2771		 * zero) - the delete code below won't care.
2772		 */
2773		ocfs2_remove_empty_extent(right_leaf_el);
2774	}
2775
2776	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2777	ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2778
2779	if (del_right_subtree) {
2780		ocfs2_unlink_subtree(handle, et, left_path, right_path,
2781				     subtree_index, dealloc);
2782		ret = ocfs2_update_edge_lengths(handle, et, left_path);
2783		if (ret) {
2784			mlog_errno(ret);
2785			goto out;
2786		}
2787
2788		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2789		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2790
2791		/*
2792		 * Removal of the extent in the left leaf was skipped
2793		 * above so we could delete the right path
2794		 * 1st.
2795		 */
2796		if (right_has_empty)
2797			ocfs2_remove_empty_extent(left_leaf_el);
2798
2799		ocfs2_journal_dirty(handle, et_root_bh);
2800
2801		*deleted = 1;
2802	} else
2803		ocfs2_complete_edge_insert(handle, left_path, right_path,
2804					   subtree_index);
2805
2806out:
2807	return ret;
2808}
2809
2810/*
2811 * Given a full path, determine what cpos value would return us a path
2812 * containing the leaf immediately to the right of the current one.
2813 *
2814 * Will return zero if the path passed in is already the rightmost path.
2815 *
2816 * This looks similar, but is subtly different to
2817 * ocfs2_find_cpos_for_left_leaf().
2818 */
2819int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2820				   struct ocfs2_path *path, u32 *cpos)
2821{
2822	int i, j, ret = 0;
2823	u64 blkno;
2824	struct ocfs2_extent_list *el;
2825
2826	*cpos = 0;
2827
2828	if (path->p_tree_depth == 0)
2829		return 0;
2830
2831	blkno = path_leaf_bh(path)->b_blocknr;
2832
2833	/* Start at the tree node just above the leaf and work our way up. */
2834	i = path->p_tree_depth - 1;
2835	while (i >= 0) {
2836		int next_free;
2837
2838		el = path->p_node[i].el;
2839
2840		/*
2841		 * Find the extent record just after the one in our
2842		 * path.
2843		 */
2844		next_free = le16_to_cpu(el->l_next_free_rec);
2845		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2846			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2847				if (j == (next_free - 1)) {
2848					if (i == 0) {
2849						/*
2850						 * We've determined that the
2851						 * path specified is already
2852						 * the rightmost one - return a
2853						 * cpos of zero.
2854						 */
2855						goto out;
2856					}
2857					/*
2858					 * The rightmost record points to our
2859					 * leaf - we need to travel up the
2860					 * tree one level.
2861					 */
2862					goto next_node;
2863				}
2864
2865				*cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2866				goto out;
2867			}
2868		}
2869
2870		/*
2871		 * If we got here, we never found a valid node where
2872		 * the tree indicated one should be.
2873		 */
2874		ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2875			    (unsigned long long)blkno);
2876		ret = -EROFS;
2877		goto out;
2878
2879next_node:
2880		blkno = path->p_node[i].bh->b_blocknr;
2881		i--;
2882	}
2883
2884out:
2885	return ret;
2886}
2887
2888static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle,
2889					    struct ocfs2_extent_tree *et,
2890					    struct ocfs2_path *path)
2891{
2892	int ret;
2893	struct buffer_head *bh = path_leaf_bh(path);
2894	struct ocfs2_extent_list *el = path_leaf_el(path);
2895
2896	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2897		return 0;
2898
2899	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
2900					   path_num_items(path) - 1);
2901	if (ret) {
2902		mlog_errno(ret);
2903		goto out;
2904	}
2905
2906	ocfs2_remove_empty_extent(el);
2907	ocfs2_journal_dirty(handle, bh);
2908
2909out:
2910	return ret;
2911}
2912
2913static int __ocfs2_rotate_tree_left(handle_t *handle,
2914				    struct ocfs2_extent_tree *et,
2915				    int orig_credits,
2916				    struct ocfs2_path *path,
2917				    struct ocfs2_cached_dealloc_ctxt *dealloc,
2918				    struct ocfs2_path **empty_extent_path)
2919{
2920	int ret, subtree_root, deleted;
2921	u32 right_cpos;
2922	struct ocfs2_path *left_path = NULL;
2923	struct ocfs2_path *right_path = NULL;
2924	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
2925
2926	if (!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])))
2927		return 0;
2928
2929	*empty_extent_path = NULL;
2930
2931	ret = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
2932	if (ret) {
2933		mlog_errno(ret);
2934		goto out;
2935	}
2936
2937	left_path = ocfs2_new_path_from_path(path);
2938	if (!left_path) {
2939		ret = -ENOMEM;
2940		mlog_errno(ret);
2941		goto out;
2942	}
2943
2944	ocfs2_cp_path(left_path, path);
2945
2946	right_path = ocfs2_new_path_from_path(path);
2947	if (!right_path) {
2948		ret = -ENOMEM;
2949		mlog_errno(ret);
2950		goto out;
2951	}
2952
2953	while (right_cpos) {
2954		ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
2955		if (ret) {
2956			mlog_errno(ret);
2957			goto out;
2958		}
2959
2960		subtree_root = ocfs2_find_subtree_root(et, left_path,
2961						       right_path);
2962
2963		trace_ocfs2_rotate_subtree(subtree_root,
2964		     (unsigned long long)
2965		     right_path->p_node[subtree_root].bh->b_blocknr,
2966		     right_path->p_tree_depth);
2967
2968		ret = ocfs2_extend_rotate_transaction(handle, 0,
2969						      orig_credits, left_path);
2970		if (ret) {
2971			mlog_errno(ret);
2972			goto out;
2973		}
2974
2975		/*
2976		 * Caller might still want to make changes to the
2977		 * tree root, so re-add it to the journal here.
2978		 */
2979		ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
2980						   left_path, 0);
2981		if (ret) {
2982			mlog_errno(ret);
2983			goto out;
2984		}
2985
2986		ret = ocfs2_rotate_subtree_left(handle, et, left_path,
2987						right_path, subtree_root,
2988						dealloc, &deleted);
2989		if (ret == -EAGAIN) {
2990			/*
2991			 * The rotation has to temporarily stop due to
2992			 * the right subtree having an empty
2993			 * extent. Pass it back to the caller for a
2994			 * fixup.
2995			 */
2996			*empty_extent_path = right_path;
2997			right_path = NULL;
2998			goto out;
2999		}
3000		if (ret) {
3001			mlog_errno(ret);
3002			goto out;
3003		}
3004
3005		/*
3006		 * The subtree rotate might have removed records on
3007		 * the rightmost edge. If so, then rotation is
3008		 * complete.
3009		 */
3010		if (deleted)
3011			break;
3012
3013		ocfs2_mv_path(left_path, right_path);
3014
3015		ret = ocfs2_find_cpos_for_right_leaf(sb, left_path,
3016						     &right_cpos);
3017		if (ret) {
3018			mlog_errno(ret);
3019			goto out;
3020		}
3021	}
3022
3023out:
3024	ocfs2_free_path(right_path);
3025	ocfs2_free_path(left_path);
3026
3027	return ret;
3028}
3029
3030static int ocfs2_remove_rightmost_path(handle_t *handle,
3031				struct ocfs2_extent_tree *et,
3032				struct ocfs2_path *path,
3033				struct ocfs2_cached_dealloc_ctxt *dealloc)
3034{
3035	int ret, subtree_index;
3036	u32 cpos;
3037	struct ocfs2_path *left_path = NULL;
3038	struct ocfs2_extent_block *eb;
3039	struct ocfs2_extent_list *el;
3040
3041	ret = ocfs2_et_sanity_check(et);
3042	if (ret)
3043		goto out;
3044
3045	ret = ocfs2_journal_access_path(et->et_ci, handle, path);
3046	if (ret) {
3047		mlog_errno(ret);
3048		goto out;
3049	}
3050
3051	ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3052					    path, &cpos);
3053	if (ret) {
3054		mlog_errno(ret);
3055		goto out;
3056	}
3057
3058	if (cpos) {
3059		/*
3060		 * We have a path to the left of this one - it needs
3061		 * an update too.
3062		 */
3063		left_path = ocfs2_new_path_from_path(path);
3064		if (!left_path) {
3065			ret = -ENOMEM;
3066			mlog_errno(ret);
3067			goto out;
3068		}
3069
3070		ret = ocfs2_find_path(et->et_ci, left_path, cpos);
3071		if (ret) {
3072			mlog_errno(ret);
3073			goto out;
3074		}
3075
3076		ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
3077		if (ret) {
3078			mlog_errno(ret);
3079			goto out;
3080		}
3081
3082		subtree_index = ocfs2_find_subtree_root(et, left_path, path);
3083
3084		ocfs2_unlink_subtree(handle, et, left_path, path,
3085				     subtree_index, dealloc);
3086		ret = ocfs2_update_edge_lengths(handle, et, left_path);
3087		if (ret) {
3088			mlog_errno(ret);
3089			goto out;
3090		}
3091
3092		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
3093		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
3094	} else {
3095		/*
3096		 * 'path' is also the leftmost path which
3097		 * means it must be the only one. This gets
3098		 * handled differently because we want to
3099		 * revert the root back to having extents
3100		 * in-line.
3101		 */
3102		ocfs2_unlink_path(handle, et, dealloc, path, 1);
3103
3104		el = et->et_root_el;
3105		el->l_tree_depth = 0;
3106		el->l_next_free_rec = 0;
3107		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3108
3109		ocfs2_et_set_last_eb_blk(et, 0);
3110	}
3111
3112	ocfs2_journal_dirty(handle, path_root_bh(path));
3113
3114out:
3115	ocfs2_free_path(left_path);
3116	return ret;
3117}
3118
3119static int ocfs2_remove_rightmost_empty_extent(struct ocfs2_super *osb,
3120				struct ocfs2_extent_tree *et,
3121				struct ocfs2_path *path,
3122				struct ocfs2_cached_dealloc_ctxt *dealloc)
3123{
3124	handle_t *handle;
3125	int ret;
3126	int credits = path->p_tree_depth * 2 + 1;
3127
3128	handle = ocfs2_start_trans(osb, credits);
3129	if (IS_ERR(handle)) {
3130		ret = PTR_ERR(handle);
3131		mlog_errno(ret);
3132		return ret;
3133	}
3134
3135	ret = ocfs2_remove_rightmost_path(handle, et, path, dealloc);
3136	if (ret)
3137		mlog_errno(ret);
3138
3139	ocfs2_commit_trans(osb, handle);
3140	return ret;
3141}
3142
3143/*
3144 * Left rotation of btree records.
3145 *
3146 * In many ways, this is (unsurprisingly) the opposite of right
3147 * rotation. We start at some non-rightmost path containing an empty
3148 * extent in the leaf block. The code works its way to the rightmost
3149 * path by rotating records to the left in every subtree.
3150 *
3151 * This is used by any code which reduces the number of extent records
3152 * in a leaf. After removal, an empty record should be placed in the
3153 * leftmost list position.
3154 *
3155 * This won't handle a length update of the rightmost path records if
3156 * the rightmost tree leaf record is removed so the caller is
3157 * responsible for detecting and correcting that.
3158 */
3159static int ocfs2_rotate_tree_left(handle_t *handle,
3160				  struct ocfs2_extent_tree *et,
3161				  struct ocfs2_path *path,
3162				  struct ocfs2_cached_dealloc_ctxt *dealloc)
3163{
3164	int ret, orig_credits = jbd2_handle_buffer_credits(handle);
3165	struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
3166	struct ocfs2_extent_block *eb;
3167	struct ocfs2_extent_list *el;
3168
3169	el = path_leaf_el(path);
3170	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
3171		return 0;
3172
3173	if (path->p_tree_depth == 0) {
3174rightmost_no_delete:
3175		/*
3176		 * Inline extents. This is trivially handled, so do
3177		 * it up front.
3178		 */
3179		ret = ocfs2_rotate_rightmost_leaf_left(handle, et, path);
3180		if (ret)
3181			mlog_errno(ret);
3182		goto out;
3183	}
3184
3185	/*
3186	 * Handle rightmost branch now. There's several cases:
3187	 *  1) simple rotation leaving records in there. That's trivial.
3188	 *  2) rotation requiring a branch delete - there's no more
3189	 *     records left. Two cases of this:
3190	 *     a) There are branches to the left.
3191	 *     b) This is also the leftmost (the only) branch.
3192	 *
3193	 *  1) is handled via ocfs2_rotate_rightmost_leaf_left()
3194	 *  2a) we need the left branch so that we can update it with the unlink
3195	 *  2b) we need to bring the root back to inline extents.
3196	 */
3197
3198	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
3199	el = &eb->h_list;
3200	if (eb->h_next_leaf_blk == 0) {
3201		/*
3202		 * This gets a bit tricky if we're going to delete the
3203		 * rightmost path. Get the other cases out of the way
3204		 * 1st.
3205		 */
3206		if (le16_to_cpu(el->l_next_free_rec) > 1)
3207			goto rightmost_no_delete;
3208
3209		if (le16_to_cpu(el->l_next_free_rec) == 0) {
3210			ret = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3211					"Owner %llu has empty extent block at %llu\n",
3212					(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
3213					(unsigned long long)le64_to_cpu(eb->h_blkno));
3214			goto out;
3215		}
3216
3217		/*
3218		 * XXX: The caller can not trust "path" any more after
3219		 * this as it will have been deleted. What do we do?
3220		 *
3221		 * In theory the rotate-for-merge code will never get
3222		 * here because it'll always ask for a rotate in a
3223		 * nonempty list.
3224		 */
3225
3226		ret = ocfs2_remove_rightmost_path(handle, et, path,
3227						  dealloc);
3228		if (ret)
3229			mlog_errno(ret);
3230		goto out;
3231	}
3232
3233	/*
3234	 * Now we can loop, remembering the path we get from -EAGAIN
3235	 * and restarting from there.
3236	 */
3237try_rotate:
3238	ret = __ocfs2_rotate_tree_left(handle, et, orig_credits, path,
3239				       dealloc, &restart_path);
3240	if (ret && ret != -EAGAIN) {
3241		mlog_errno(ret);
3242		goto out;
3243	}
3244
3245	while (ret == -EAGAIN) {
3246		tmp_path = restart_path;
3247		restart_path = NULL;
3248
3249		ret = __ocfs2_rotate_tree_left(handle, et, orig_credits,
3250					       tmp_path, dealloc,
3251					       &restart_path);
3252		if (ret && ret != -EAGAIN) {
3253			mlog_errno(ret);
3254			goto out;
3255		}
3256
3257		ocfs2_free_path(tmp_path);
3258		tmp_path = NULL;
3259
3260		if (ret == 0)
3261			goto try_rotate;
3262	}
3263
3264out:
3265	ocfs2_free_path(tmp_path);
3266	ocfs2_free_path(restart_path);
3267	return ret;
3268}
3269
3270static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
3271				int index)
3272{
3273	struct ocfs2_extent_rec *rec = &el->l_recs[index];
3274	unsigned int size;
3275
3276	if (rec->e_leaf_clusters == 0) {
3277		/*
3278		 * We consumed all of the merged-from record. An empty
3279		 * extent cannot exist anywhere but the 1st array
3280		 * position, so move things over if the merged-from
3281		 * record doesn't occupy that position.
3282		 *
3283		 * This creates a new empty extent so the caller
3284		 * should be smart enough to have removed any existing
3285		 * ones.
3286		 */
3287		if (index > 0) {
3288			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3289			size = index * sizeof(struct ocfs2_extent_rec);
3290			memmove(&el->l_recs[1], &el->l_recs[0], size);
3291		}
3292
3293		/*
3294		 * Always memset - the caller doesn't check whether it
3295		 * created an empty extent, so there could be junk in
3296		 * the other fields.
3297		 */
3298		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3299	}
3300}
3301
3302static int ocfs2_get_right_path(struct ocfs2_extent_tree *et,
3303				struct ocfs2_path *left_path,
3304				struct ocfs2_path **ret_right_path)
3305{
3306	int ret;
3307	u32 right_cpos;
3308	struct ocfs2_path *right_path = NULL;
3309	struct ocfs2_extent_list *left_el;
3310
3311	*ret_right_path = NULL;
3312
3313	/* This function shouldn't be called for non-trees. */
3314	BUG_ON(left_path->p_tree_depth == 0);
3315
3316	left_el = path_leaf_el(left_path);
3317	BUG_ON(left_el->l_next_free_rec != left_el->l_count);
3318
3319	ret = ocfs2_find_cpos_for_right_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3320					     left_path, &right_cpos);
3321	if (ret) {
3322		mlog_errno(ret);
3323		goto out;
3324	}
3325
3326	/* This function shouldn't be called for the rightmost leaf. */
3327	BUG_ON(right_cpos == 0);
3328
3329	right_path = ocfs2_new_path_from_path(left_path);
3330	if (!right_path) {
3331		ret = -ENOMEM;
3332		mlog_errno(ret);
3333		goto out;
3334	}
3335
3336	ret = ocfs2_find_path(et->et_ci, right_path, right_cpos);
3337	if (ret) {
3338		mlog_errno(ret);
3339		goto out;
3340	}
3341
3342	*ret_right_path = right_path;
3343out:
3344	if (ret)
3345		ocfs2_free_path(right_path);
3346	return ret;
3347}
3348
3349/*
3350 * Remove split_rec clusters from the record at index and merge them
3351 * onto the beginning of the record "next" to it.
3352 * For index < l_count - 1, the next means the extent rec at index + 1.
3353 * For index == l_count - 1, the "next" means the 1st extent rec of the
3354 * next extent block.
3355 */
3356static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
3357				 handle_t *handle,
3358				 struct ocfs2_extent_tree *et,
3359				 struct ocfs2_extent_rec *split_rec,
3360				 int index)
3361{
3362	int ret, next_free, i;
3363	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3364	struct ocfs2_extent_rec *left_rec;
3365	struct ocfs2_extent_rec *right_rec;
3366	struct ocfs2_extent_list *right_el;
3367	struct ocfs2_path *right_path = NULL;
3368	int subtree_index = 0;
3369	struct ocfs2_extent_list *el = path_leaf_el(left_path);
3370	struct buffer_head *bh = path_leaf_bh(left_path);
3371	struct buffer_head *root_bh = NULL;
3372
3373	BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3374	left_rec = &el->l_recs[index];
3375
3376	if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3377	    le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3378		/* we meet with a cross extent block merge. */
3379		ret = ocfs2_get_right_path(et, left_path, &right_path);
3380		if (ret) {
3381			mlog_errno(ret);
3382			return ret;
3383		}
3384
3385		right_el = path_leaf_el(right_path);
3386		next_free = le16_to_cpu(right_el->l_next_free_rec);
3387		BUG_ON(next_free <= 0);
3388		right_rec = &right_el->l_recs[0];
3389		if (ocfs2_is_empty_extent(right_rec)) {
3390			BUG_ON(next_free <= 1);
3391			right_rec = &right_el->l_recs[1];
3392		}
3393
3394		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3395		       le16_to_cpu(left_rec->e_leaf_clusters) !=
3396		       le32_to_cpu(right_rec->e_cpos));
3397
3398		subtree_index = ocfs2_find_subtree_root(et, left_path,
3399							right_path);
3400
3401		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3402					jbd2_handle_buffer_credits(handle),
3403					right_path);
3404		if (ret) {
3405			mlog_errno(ret);
3406			goto out;
3407		}
3408
3409		root_bh = left_path->p_node[subtree_index].bh;
3410		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3411
3412		ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3413						   subtree_index);
3414		if (ret) {
3415			mlog_errno(ret);
3416			goto out;
3417		}
3418
3419		for (i = subtree_index + 1;
3420		     i < path_num_items(right_path); i++) {
3421			ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3422							   right_path, i);
3423			if (ret) {
3424				mlog_errno(ret);
3425				goto out;
3426			}
3427
3428			ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3429							   left_path, i);
3430			if (ret) {
3431				mlog_errno(ret);
3432				goto out;
3433			}
3434		}
3435
3436	} else {
3437		BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3438		right_rec = &el->l_recs[index + 1];
3439	}
3440
3441	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, left_path,
3442					   path_num_items(left_path) - 1);
3443	if (ret) {
3444		mlog_errno(ret);
3445		goto out;
3446	}
3447
3448	le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
3449
3450	le32_add_cpu(&right_rec->e_cpos, -split_clusters);
3451	le64_add_cpu(&right_rec->e_blkno,
3452		     -ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3453					       split_clusters));
3454	le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
3455
3456	ocfs2_cleanup_merge(el, index);
3457
3458	ocfs2_journal_dirty(handle, bh);
3459	if (right_path) {
3460		ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3461		ocfs2_complete_edge_insert(handle, left_path, right_path,
3462					   subtree_index);
3463	}
3464out:
3465	ocfs2_free_path(right_path);
3466	return ret;
3467}
3468
3469static int ocfs2_get_left_path(struct ocfs2_extent_tree *et,
3470			       struct ocfs2_path *right_path,
3471			       struct ocfs2_path **ret_left_path)
3472{
3473	int ret;
3474	u32 left_cpos;
3475	struct ocfs2_path *left_path = NULL;
3476
3477	*ret_left_path = NULL;
3478
3479	/* This function shouldn't be called for non-trees. */
3480	BUG_ON(right_path->p_tree_depth == 0);
3481
3482	ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
3483					    right_path, &left_cpos);
3484	if (ret) {
3485		mlog_errno(ret);
3486		goto out;
3487	}
3488
3489	/* This function shouldn't be called for the leftmost leaf. */
3490	BUG_ON(left_cpos == 0);
3491
3492	left_path = ocfs2_new_path_from_path(right_path);
3493	if (!left_path) {
3494		ret = -ENOMEM;
3495		mlog_errno(ret);
3496		goto out;
3497	}
3498
3499	ret = ocfs2_find_path(et->et_ci, left_path, left_cpos);
3500	if (ret) {
3501		mlog_errno(ret);
3502		goto out;
3503	}
3504
3505	*ret_left_path = left_path;
3506out:
3507	if (ret)
3508		ocfs2_free_path(left_path);
3509	return ret;
3510}
3511
3512/*
3513 * Remove split_rec clusters from the record at index and merge them
3514 * onto the tail of the record "before" it.
3515 * For index > 0, the "before" means the extent rec at index - 1.
3516 *
3517 * For index == 0, the "before" means the last record of the previous
3518 * extent block. And there is also a situation that we may need to
3519 * remove the rightmost leaf extent block in the right_path and change
3520 * the right path to indicate the new rightmost path.
3521 */
3522static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
3523				handle_t *handle,
3524				struct ocfs2_extent_tree *et,
3525				struct ocfs2_extent_rec *split_rec,
3526				struct ocfs2_cached_dealloc_ctxt *dealloc,
3527				int index)
3528{
3529	int ret, i, subtree_index = 0, has_empty_extent = 0;
3530	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3531	struct ocfs2_extent_rec *left_rec;
3532	struct ocfs2_extent_rec *right_rec;
3533	struct ocfs2_extent_list *el = path_leaf_el(right_path);
3534	struct buffer_head *bh = path_leaf_bh(right_path);
3535	struct buffer_head *root_bh = NULL;
3536	struct ocfs2_path *left_path = NULL;
3537	struct ocfs2_extent_list *left_el;
3538
3539	BUG_ON(index < 0);
3540
3541	right_rec = &el->l_recs[index];
3542	if (index == 0) {
3543		/* we meet with a cross extent block merge. */
3544		ret = ocfs2_get_left_path(et, right_path, &left_path);
3545		if (ret) {
3546			mlog_errno(ret);
3547			return ret;
3548		}
3549
3550		left_el = path_leaf_el(left_path);
3551		BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3552		       le16_to_cpu(left_el->l_count));
3553
3554		left_rec = &left_el->l_recs[
3555				le16_to_cpu(left_el->l_next_free_rec) - 1];
3556		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3557		       le16_to_cpu(left_rec->e_leaf_clusters) !=
3558		       le32_to_cpu(split_rec->e_cpos));
3559
3560		subtree_index = ocfs2_find_subtree_root(et, left_path,
3561							right_path);
3562
3563		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3564					jbd2_handle_buffer_credits(handle),
3565					left_path);
3566		if (ret) {
3567			mlog_errno(ret);
3568			goto out;
3569		}
3570
3571		root_bh = left_path->p_node[subtree_index].bh;
3572		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3573
3574		ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3575						   subtree_index);
3576		if (ret) {
3577			mlog_errno(ret);
3578			goto out;
3579		}
3580
3581		for (i = subtree_index + 1;
3582		     i < path_num_items(right_path); i++) {
3583			ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3584							   right_path, i);
3585			if (ret) {
3586				mlog_errno(ret);
3587				goto out;
3588			}
3589
3590			ret = ocfs2_path_bh_journal_access(handle, et->et_ci,
3591							   left_path, i);
3592			if (ret) {
3593				mlog_errno(ret);
3594				goto out;
3595			}
3596		}
3597	} else {
3598		left_rec = &el->l_recs[index - 1];
3599		if (ocfs2_is_empty_extent(&el->l_recs[0]))
3600			has_empty_extent = 1;
3601	}
3602
3603	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, right_path,
3604					   path_num_items(right_path) - 1);
3605	if (ret) {
3606		mlog_errno(ret);
3607		goto out;
3608	}
3609
3610	if (has_empty_extent && index == 1) {
3611		/*
3612		 * The easy case - we can just plop the record right in.
3613		 */
3614		*left_rec = *split_rec;
3615	} else
3616		le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3617
3618	le32_add_cpu(&right_rec->e_cpos, split_clusters);
3619	le64_add_cpu(&right_rec->e_blkno,
3620		     ocfs2_clusters_to_blocks(ocfs2_metadata_cache_get_super(et->et_ci),
3621					      split_clusters));
3622	le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3623
3624	ocfs2_cleanup_merge(el, index);
3625
3626	ocfs2_journal_dirty(handle, bh);
3627	if (left_path) {
3628		ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3629
3630		/*
3631		 * In the situation that the right_rec is empty and the extent
3632		 * block is empty also,  ocfs2_complete_edge_insert can't handle
3633		 * it and we need to delete the right extent block.
3634		 */
3635		if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3636		    le16_to_cpu(el->l_next_free_rec) == 1) {
3637			/* extend credit for ocfs2_remove_rightmost_path */
3638			ret = ocfs2_extend_rotate_transaction(handle, 0,
3639					jbd2_handle_buffer_credits(handle),
3640					right_path);
3641			if (ret) {
3642				mlog_errno(ret);
3643				goto out;
3644			}
3645
3646			ret = ocfs2_remove_rightmost_path(handle, et,
3647							  right_path,
3648							  dealloc);
3649			if (ret) {
3650				mlog_errno(ret);
3651				goto out;
3652			}
3653
3654			/* Now the rightmost extent block has been deleted.
3655			 * So we use the new rightmost path.
3656			 */
3657			ocfs2_mv_path(right_path, left_path);
3658		} else
3659			ocfs2_complete_edge_insert(handle, left_path,
3660						   right_path, subtree_index);
3661	}
3662out:
3663	ocfs2_free_path(left_path);
3664	return ret;
3665}
3666
3667static int ocfs2_try_to_merge_extent(handle_t *handle,
3668				     struct ocfs2_extent_tree *et,
3669				     struct ocfs2_path *path,
3670				     int split_index,
3671				     struct ocfs2_extent_rec *split_rec,
3672				     struct ocfs2_cached_dealloc_ctxt *dealloc,
3673				     struct ocfs2_merge_ctxt *ctxt)
3674{
3675	int ret = 0;
3676	struct ocfs2_extent_list *el = path_leaf_el(path);
3677	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3678
3679	BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3680
3681	if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3682		/* extend credit for ocfs2_remove_rightmost_path */
3683		ret = ocfs2_extend_rotate_transaction(handle, 0,
3684				jbd2_handle_buffer_credits(handle),
3685				path);
3686		if (ret) {
3687			mlog_errno(ret);
3688			goto out;
3689		}
3690		/*
3691		 * The merge code will need to create an empty
3692		 * extent to take the place of the newly
3693		 * emptied slot. Remove any pre-existing empty
3694		 * extents - having more than one in a leaf is
3695		 * illegal.
3696		 */
3697		ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3698		if (ret) {
3699			mlog_errno(ret);
3700			goto out;
3701		}
3702		split_index--;
3703		rec = &el->l_recs[split_index];
3704	}
3705
3706	if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3707		/*
3708		 * Left-right contig implies this.
3709		 */
3710		BUG_ON(!ctxt->c_split_covers_rec);
3711
3712		/*
3713		 * Since the leftright insert always covers the entire
3714		 * extent, this call will delete the insert record
3715		 * entirely, resulting in an empty extent record added to
3716		 * the extent block.
3717		 *
3718		 * Since the adding of an empty extent shifts
3719		 * everything back to the right, there's no need to
3720		 * update split_index here.
3721		 *
3722		 * When the split_index is zero, we need to merge it to the
3723		 * previous extent block. It is more efficient and easier
3724		 * if we do merge_right first and merge_left later.
3725		 */
3726		ret = ocfs2_merge_rec_right(path, handle, et, split_rec,
3727					    split_index);
3728		if (ret) {
3729			mlog_errno(ret);
3730			goto out;
3731		}
3732
3733		/*
3734		 * We can only get this from logic error above.
3735		 */
3736		BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3737
3738		/* extend credit for ocfs2_remove_rightmost_path */
3739		ret = ocfs2_extend_rotate_transaction(handle, 0,
3740					jbd2_handle_buffer_credits(handle),
3741					path);
3742		if (ret) {
3743			mlog_errno(ret);
3744			goto out;
3745		}
3746
3747		/* The merge left us with an empty extent, remove it. */
3748		ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3749		if (ret) {
3750			mlog_errno(ret);
3751			goto out;
3752		}
3753
3754		rec = &el->l_recs[split_index];
3755
3756		/*
3757		 * Note that we don't pass split_rec here on purpose -
3758		 * we've merged it into the rec already.
3759		 */
3760		ret = ocfs2_merge_rec_left(path, handle, et, rec,
3761					   dealloc, split_index);
3762
3763		if (ret) {
3764			mlog_errno(ret);
3765			goto out;
3766		}
3767
3768		/* extend credit for ocfs2_remove_rightmost_path */
3769		ret = ocfs2_extend_rotate_transaction(handle, 0,
3770				jbd2_handle_buffer_credits(handle),
3771				path);
3772		if (ret) {
3773			mlog_errno(ret);
3774			goto out;
3775		}
3776
3777		ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3778		/*
3779		 * Error from this last rotate is not critical, so
3780		 * print but don't bubble it up.
3781		 */
3782		if (ret)
3783			mlog_errno(ret);
3784		ret = 0;
3785	} else {
3786		/*
3787		 * Merge a record to the left or right.
3788		 *
3789		 * 'contig_type' is relative to the existing record,
3790		 * so for example, if we're "right contig", it's to
3791		 * the record on the left (hence the left merge).
3792		 */
3793		if (ctxt->c_contig_type == CONTIG_RIGHT) {
3794			ret = ocfs2_merge_rec_left(path, handle, et,
3795						   split_rec, dealloc,
3796						   split_index);
3797			if (ret) {
3798				mlog_errno(ret);
3799				goto out;
3800			}
3801		} else {
3802			ret = ocfs2_merge_rec_right(path, handle,
3803						    et, split_rec,
3804						    split_index);
3805			if (ret) {
3806				mlog_errno(ret);
3807				goto out;
3808			}
3809		}
3810
3811		if (ctxt->c_split_covers_rec) {
3812			/* extend credit for ocfs2_remove_rightmost_path */
3813			ret = ocfs2_extend_rotate_transaction(handle, 0,
3814					jbd2_handle_buffer_credits(handle),
3815					path);
3816			if (ret) {
3817				mlog_errno(ret);
3818				ret = 0;
3819				goto out;
3820			}
3821
3822			/*
3823			 * The merge may have left an empty extent in
3824			 * our leaf. Try to rotate it away.
3825			 */
3826			ret = ocfs2_rotate_tree_left(handle, et, path,
3827						     dealloc);
3828			if (ret)
3829				mlog_errno(ret);
3830			ret = 0;
3831		}
3832	}
3833
3834out:
3835	return ret;
3836}
3837
3838static void ocfs2_subtract_from_rec(struct super_block *sb,
3839				    enum ocfs2_split_type split,
3840				    struct ocfs2_extent_rec *rec,
3841				    struct ocfs2_extent_rec *split_rec)
3842{
3843	u64 len_blocks;
3844
3845	len_blocks = ocfs2_clusters_to_blocks(sb,
3846				le16_to_cpu(split_rec->e_leaf_clusters));
3847
3848	if (split == SPLIT_LEFT) {
3849		/*
3850		 * Region is on the left edge of the existing
3851		 * record.
3852		 */
3853		le32_add_cpu(&rec->e_cpos,
3854			     le16_to_cpu(split_rec->e_leaf_clusters));
3855		le64_add_cpu(&rec->e_blkno, len_blocks);
3856		le16_add_cpu(&rec->e_leaf_clusters,
3857			     -le16_to_cpu(split_rec->e_leaf_clusters));
3858	} else {
3859		/*
3860		 * Region is on the right edge of the existing
3861		 * record.
3862		 */
3863		le16_add_cpu(&rec->e_leaf_clusters,
3864			     -le16_to_cpu(split_rec->e_leaf_clusters));
3865	}
3866}
3867
3868/*
3869 * Do the final bits of extent record insertion at the target leaf
3870 * list. If this leaf is part of an allocation tree, it is assumed
3871 * that the tree above has been prepared.
3872 */
3873static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et,
3874				 struct ocfs2_extent_rec *insert_rec,
3875				 struct ocfs2_extent_list *el,
3876				 struct ocfs2_insert_type *insert)
3877{
3878	int i = insert->ins_contig_index;
3879	unsigned int range;
3880	struct ocfs2_extent_rec *rec;
3881
3882	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3883
3884	if (insert->ins_split != SPLIT_NONE) {
3885		i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3886		BUG_ON(i == -1);
3887		rec = &el->l_recs[i];
3888		ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
3889					insert->ins_split, rec,
3890					insert_rec);
3891		goto rotate;
3892	}
3893
3894	/*
3895	 * Contiguous insert - either left or right.
3896	 */
3897	if (insert->ins_contig != CONTIG_NONE) {
3898		rec = &el->l_recs[i];
3899		if (insert->ins_contig == CONTIG_LEFT) {
3900			rec->e_blkno = insert_rec->e_blkno;
3901			rec->e_cpos = insert_rec->e_cpos;
3902		}
3903		le16_add_cpu(&rec->e_leaf_clusters,
3904			     le16_to_cpu(insert_rec->e_leaf_clusters));
3905		return;
3906	}
3907
3908	/*
3909	 * Handle insert into an empty leaf.
3910	 */
3911	if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3912	    ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3913	     ocfs2_is_empty_extent(&el->l_recs[0]))) {
3914		el->l_recs[0] = *insert_rec;
3915		el->l_next_free_rec = cpu_to_le16(1);
3916		return;
3917	}
3918
3919	/*
3920	 * Appending insert.
3921	 */
3922	if (insert->ins_appending == APPEND_TAIL) {
3923		i = le16_to_cpu(el->l_next_free_rec) - 1;
3924		rec = &el->l_recs[i];
3925		range = le32_to_cpu(rec->e_cpos)
3926			+ le16_to_cpu(rec->e_leaf_clusters);
3927		BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3928
3929		mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3930				le16_to_cpu(el->l_count),
3931				"owner %llu, depth %u, count %u, next free %u, "
3932				"rec.cpos %u, rec.clusters %u, "
3933				"insert.cpos %u, insert.clusters %u\n",
3934				ocfs2_metadata_cache_owner(et->et_ci),
3935				le16_to_cpu(el->l_tree_depth),
3936				le16_to_cpu(el->l_count),
3937				le16_to_cpu(el->l_next_free_rec),
3938				le32_to_cpu(el->l_recs[i].e_cpos),
3939				le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3940				le32_to_cpu(insert_rec->e_cpos),
3941				le16_to_cpu(insert_rec->e_leaf_clusters));
3942		i++;
3943		el->l_recs[i] = *insert_rec;
3944		le16_add_cpu(&el->l_next_free_rec, 1);
3945		return;
3946	}
3947
3948rotate:
3949	/*
3950	 * Ok, we have to rotate.
3951	 *
3952	 * At this point, it is safe to assume that inserting into an
3953	 * empty leaf and appending to a leaf have both been handled
3954	 * above.
3955	 *
3956	 * This leaf needs to have space, either by the empty 1st
3957	 * extent record, or by virtue of an l_next_free_rec < l_count.
3958	 */
3959	ocfs2_rotate_leaf(el, insert_rec);
3960}
3961
3962static void ocfs2_adjust_rightmost_records(handle_t *handle,
3963					   struct ocfs2_extent_tree *et,
3964					   struct ocfs2_path *path,
3965					   struct ocfs2_extent_rec *insert_rec)
3966{
3967	int i, next_free;
3968	struct buffer_head *bh;
3969	struct ocfs2_extent_list *el;
3970	struct ocfs2_extent_rec *rec;
3971
3972	/*
3973	 * Update everything except the leaf block.
3974	 */
3975	for (i = 0; i < path->p_tree_depth; i++) {
3976		bh = path->p_node[i].bh;
3977		el = path->p_node[i].el;
3978
3979		next_free = le16_to_cpu(el->l_next_free_rec);
3980		if (next_free == 0) {
3981			ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3982				    "Owner %llu has a bad extent list\n",
3983				    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
3984			return;
3985		}
3986
3987		rec = &el->l_recs[next_free - 1];
3988
3989		rec->e_int_clusters = insert_rec->e_cpos;
3990		le32_add_cpu(&rec->e_int_clusters,
3991			     le16_to_cpu(insert_rec->e_leaf_clusters));
3992		le32_add_cpu(&rec->e_int_clusters,
3993			     -le32_to_cpu(rec->e_cpos));
3994
3995		ocfs2_journal_dirty(handle, bh);
3996	}
3997}
3998
3999static int ocfs2_append_rec_to_path(handle_t *handle,
4000				    struct ocfs2_extent_tree *et,
4001				    struct ocfs2_extent_rec *insert_rec,
4002				    struct ocfs2_path *right_path,
4003				    struct ocfs2_path **ret_left_path)
4004{
4005	int ret, next_free;
4006	struct ocfs2_extent_list *el;
4007	struct ocfs2_path *left_path = NULL;
4008
4009	*ret_left_path = NULL;
4010
4011	/*
4012	 * This shouldn't happen for non-trees. The extent rec cluster
4013	 * count manipulation below only works for interior nodes.
4014	 */
4015	BUG_ON(right_path->p_tree_depth == 0);
4016
4017	/*
4018	 * If our appending insert is at the leftmost edge of a leaf,
4019	 * then we might need to update the rightmost records of the
4020	 * neighboring path.
4021	 */
4022	el = path_leaf_el(right_path);
4023	next_free = le16_to_cpu(el->l_next_free_rec);
4024	if (next_free == 0 ||
4025	    (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
4026		u32 left_cpos;
4027
4028		ret = ocfs2_find_cpos_for_left_leaf(ocfs2_metadata_cache_get_super(et->et_ci),
4029						    right_path, &left_cpos);
4030		if (ret) {
4031			mlog_errno(ret);
4032			goto out;
4033		}
4034
4035		trace_ocfs2_append_rec_to_path(
4036			(unsigned long long)
4037			ocfs2_metadata_cache_owner(et->et_ci),
4038			le32_to_cpu(insert_rec->e_cpos),
4039			left_cpos);
4040
4041		/*
4042		 * No need to worry if the append is already in the
4043		 * leftmost leaf.
4044		 */
4045		if (left_cpos) {
4046			left_path = ocfs2_new_path_from_path(right_path);
4047			if (!left_path) {
4048				ret = -ENOMEM;
4049				mlog_errno(ret);
4050				goto out;
4051			}
4052
4053			ret = ocfs2_find_path(et->et_ci, left_path,
4054					      left_cpos);
4055			if (ret) {
4056				mlog_errno(ret);
4057				goto out;
4058			}
4059
4060			/*
4061			 * ocfs2_insert_path() will pass the left_path to the
4062			 * journal for us.
4063			 */
4064		}
4065	}
4066
4067	ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4068	if (ret) {
4069		mlog_errno(ret);
4070		goto out;
4071	}
4072
4073	ocfs2_adjust_rightmost_records(handle, et, right_path, insert_rec);
4074
4075	*ret_left_path = left_path;
4076	ret = 0;
4077out:
4078	if (ret != 0)
4079		ocfs2_free_path(left_path);
4080
4081	return ret;
4082}
4083
4084static void ocfs2_split_record(struct ocfs2_extent_tree *et,
4085			       struct ocfs2_path *left_path,
4086			       struct ocfs2_path *right_path,
4087			       struct ocfs2_extent_rec *split_rec,
4088			       enum ocfs2_split_type split)
4089{
4090	int index;
4091	u32 cpos = le32_to_cpu(split_rec->e_cpos);
4092	struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
4093	struct ocfs2_extent_rec *rec, *tmprec;
4094
4095	right_el = path_leaf_el(right_path);
4096	if (left_path)
4097		left_el = path_leaf_el(left_path);
4098
4099	el = right_el;
4100	insert_el = right_el;
4101	index = ocfs2_search_extent_list(el, cpos);
4102	if (index != -1) {
4103		if (index == 0 && left_path) {
4104			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
4105
4106			/*
4107			 * This typically means that the record
4108			 * started in the left path but moved to the
4109			 * right as a result of rotation. We either
4110			 * move the existing record to the left, or we
4111			 * do the later insert there.
4112			 *
4113			 * In this case, the left path should always
4114			 * exist as the rotate code will have passed
4115			 * it back for a post-insert update.
4116			 */
4117
4118			if (split == SPLIT_LEFT) {
4119				/*
4120				 * It's a left split. Since we know
4121				 * that the rotate code gave us an
4122				 * empty extent in the left path, we
4123				 * can just do the insert there.
4124				 */
4125				insert_el = left_el;
4126			} else {
4127				/*
4128				 * Right split - we have to move the
4129				 * existing record over to the left
4130				 * leaf. The insert will be into the
4131				 * newly created empty extent in the
4132				 * right leaf.
4133				 */
4134				tmprec = &right_el->l_recs[index];
4135				ocfs2_rotate_leaf(left_el, tmprec);
4136				el = left_el;
4137
4138				memset(tmprec, 0, sizeof(*tmprec));
4139				index = ocfs2_search_extent_list(left_el, cpos);
4140				BUG_ON(index == -1);
4141			}
4142		}
4143	} else {
4144		BUG_ON(!left_path);
4145		BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
4146		/*
4147		 * Left path is easy - we can just allow the insert to
4148		 * happen.
4149		 */
4150		el = left_el;
4151		insert_el = left_el;
4152		index = ocfs2_search_extent_list(el, cpos);
4153		BUG_ON(index == -1);
4154	}
4155
4156	rec = &el->l_recs[index];
4157	ocfs2_subtract_from_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4158				split, rec, split_rec);
4159	ocfs2_rotate_leaf(insert_el, split_rec);
4160}
4161
4162/*
4163 * This function only does inserts on an allocation b-tree. For tree
4164 * depth = 0, ocfs2_insert_at_leaf() is called directly.
4165 *
4166 * right_path is the path we want to do the actual insert
4167 * in. left_path should only be passed in if we need to update that
4168 * portion of the tree after an edge insert.
4169 */
4170static int ocfs2_insert_path(handle_t *handle,
4171			     struct ocfs2_extent_tree *et,
4172			     struct ocfs2_path *left_path,
4173			     struct ocfs2_path *right_path,
4174			     struct ocfs2_extent_rec *insert_rec,
4175			     struct ocfs2_insert_type *insert)
4176{
4177	int ret, subtree_index;
4178	struct buffer_head *leaf_bh = path_leaf_bh(right_path);
4179
4180	if (left_path) {
4181		/*
4182		 * There's a chance that left_path got passed back to
4183		 * us without being accounted for in the
4184		 * journal. Extend our transaction here to be sure we
4185		 * can change those blocks.
4186		 */
4187		ret = ocfs2_extend_trans(handle, left_path->p_tree_depth);
4188		if (ret < 0) {
4189			mlog_errno(ret);
4190			goto out;
4191		}
4192
4193		ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
4194		if (ret < 0) {
4195			mlog_errno(ret);
4196			goto out;
4197		}
4198	}
4199
4200	/*
4201	 * Pass both paths to the journal. The majority of inserts
4202	 * will be touching all components anyway.
4203	 */
4204	ret = ocfs2_journal_access_path(et->et_ci, handle, right_path);
4205	if (ret < 0) {
4206		mlog_errno(ret);
4207		goto out;
4208	}
4209
4210	if (insert->ins_split != SPLIT_NONE) {
4211		/*
4212		 * We could call ocfs2_insert_at_leaf() for some types
4213		 * of splits, but it's easier to just let one separate
4214		 * function sort it all out.
4215		 */
4216		ocfs2_split_record(et, left_path, right_path,
4217				   insert_rec, insert->ins_split);
4218
4219		/*
4220		 * Split might have modified either leaf and we don't
4221		 * have a guarantee that the later edge insert will
4222		 * dirty this for us.
4223		 */
4224		if (left_path)
4225			ocfs2_journal_dirty(handle,
4226					    path_leaf_bh(left_path));
4227	} else
4228		ocfs2_insert_at_leaf(et, insert_rec, path_leaf_el(right_path),
4229				     insert);
4230
4231	ocfs2_journal_dirty(handle, leaf_bh);
4232
4233	if (left_path) {
4234		/*
4235		 * The rotate code has indicated that we need to fix
4236		 * up portions of the tree after the insert.
4237		 *
4238		 * XXX: Should we extend the transaction here?
4239		 */
4240		subtree_index = ocfs2_find_subtree_root(et, left_path,
4241							right_path);
4242		ocfs2_complete_edge_insert(handle, left_path, right_path,
4243					   subtree_index);
4244	}
4245
4246	ret = 0;
4247out:
4248	return ret;
4249}
4250
4251static int ocfs2_do_insert_extent(handle_t *handle,
4252				  struct ocfs2_extent_tree *et,
4253				  struct ocfs2_extent_rec *insert_rec,
4254				  struct ocfs2_insert_type *type)
4255{
4256	int ret, rotate = 0;
4257	u32 cpos;
4258	struct ocfs2_path *right_path = NULL;
4259	struct ocfs2_path *left_path = NULL;
4260	struct ocfs2_extent_list *el;
4261
4262	el = et->et_root_el;
4263
4264	ret = ocfs2_et_root_journal_access(handle, et,
4265					   OCFS2_JOURNAL_ACCESS_WRITE);
4266	if (ret) {
4267		mlog_errno(ret);
4268		goto out;
4269	}
4270
4271	if (le16_to_cpu(el->l_tree_depth) == 0) {
4272		ocfs2_insert_at_leaf(et, insert_rec, el, type);
4273		goto out_update_clusters;
4274	}
4275
4276	right_path = ocfs2_new_path_from_et(et);
4277	if (!right_path) {
4278		ret = -ENOMEM;
4279		mlog_errno(ret);
4280		goto out;
4281	}
4282
4283	/*
4284	 * Determine the path to start with. Rotations need the
4285	 * rightmost path, everything else can go directly to the
4286	 * target leaf.
4287	 */
4288	cpos = le32_to_cpu(insert_rec->e_cpos);
4289	if (type->ins_appending == APPEND_NONE &&
4290	    type->ins_contig == CONTIG_NONE) {
4291		rotate = 1;
4292		cpos = UINT_MAX;
4293	}
4294
4295	ret = ocfs2_find_path(et->et_ci, right_path, cpos);
4296	if (ret) {
4297		mlog_errno(ret);
4298		goto out;
4299	}
4300
4301	/*
4302	 * Rotations and appends need special treatment - they modify
4303	 * parts of the tree's above them.
4304	 *
4305	 * Both might pass back a path immediate to the left of the
4306	 * one being inserted to. This will be cause
4307	 * ocfs2_insert_path() to modify the rightmost records of
4308	 * left_path to account for an edge insert.
4309	 *
4310	 * XXX: When modifying this code, keep in mind that an insert
4311	 * can wind up skipping both of these two special cases...
4312	 */
4313	if (rotate) {
4314		ret = ocfs2_rotate_tree_right(handle, et, type->ins_split,
4315					      le32_to_cpu(insert_rec->e_cpos),
4316					      right_path, &left_path);
4317		if (ret) {
4318			mlog_errno(ret);
4319			goto out;
4320		}
4321
4322		/*
4323		 * ocfs2_rotate_tree_right() might have extended the
4324		 * transaction without re-journaling our tree root.
4325		 */
4326		ret = ocfs2_et_root_journal_access(handle, et,
4327						   OCFS2_JOURNAL_ACCESS_WRITE);
4328		if (ret) {
4329			mlog_errno(ret);
4330			goto out;
4331		}
4332	} else if (type->ins_appending == APPEND_TAIL
4333		   && type->ins_contig != CONTIG_LEFT) {
4334		ret = ocfs2_append_rec_to_path(handle, et, insert_rec,
4335					       right_path, &left_path);
4336		if (ret) {
4337			mlog_errno(ret);
4338			goto out;
4339		}
4340	}
4341
4342	ret = ocfs2_insert_path(handle, et, left_path, right_path,
4343				insert_rec, type);
4344	if (ret) {
4345		mlog_errno(ret);
4346		goto out;
4347	}
4348
4349out_update_clusters:
4350	if (type->ins_split == SPLIT_NONE)
4351		ocfs2_et_update_clusters(et,
4352					 le16_to_cpu(insert_rec->e_leaf_clusters));
4353
4354	ocfs2_journal_dirty(handle, et->et_root_bh);
4355
4356out:
4357	ocfs2_free_path(left_path);
4358	ocfs2_free_path(right_path);
4359
4360	return ret;
4361}
4362
4363static int ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
4364			       struct ocfs2_path *path,
4365			       struct ocfs2_extent_list *el, int index,
4366			       struct ocfs2_extent_rec *split_rec,
4367			       struct ocfs2_merge_ctxt *ctxt)
4368{
4369	int status = 0;
4370	enum ocfs2_contig_type ret = CONTIG_NONE;
4371	u32 left_cpos, right_cpos;
4372	struct ocfs2_extent_rec *rec = NULL;
4373	struct ocfs2_extent_list *new_el;
4374	struct ocfs2_path *left_path = NULL, *right_path = NULL;
4375	struct buffer_head *bh;
4376	struct ocfs2_extent_block *eb;
4377	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
4378
4379	if (index > 0) {
4380		rec = &el->l_recs[index - 1];
4381	} else if (path->p_tree_depth > 0) {
4382		status = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
4383		if (status)
4384			goto exit;
4385
4386		if (left_cpos != 0) {
4387			left_path = ocfs2_new_path_from_path(path);
4388			if (!left_path) {
4389				status = -ENOMEM;
4390				mlog_errno(status);
4391				goto exit;
4392			}
4393
4394			status = ocfs2_find_path(et->et_ci, left_path,
4395						 left_cpos);
4396			if (status)
4397				goto free_left_path;
4398
4399			new_el = path_leaf_el(left_path);
4400
4401			if (le16_to_cpu(new_el->l_next_free_rec) !=
4402			    le16_to_cpu(new_el->l_count)) {
4403				bh = path_leaf_bh(left_path);
4404				eb = (struct ocfs2_extent_block *)bh->b_data;
4405				status = ocfs2_error(sb,
4406						"Extent block #%llu has an invalid l_next_free_rec of %d.  It should have matched the l_count of %d\n",
4407						(unsigned long long)le64_to_cpu(eb->h_blkno),
4408						le16_to_cpu(new_el->l_next_free_rec),
4409						le16_to_cpu(new_el->l_count));
4410				goto free_left_path;
4411			}
4412			rec = &new_el->l_recs[
4413				le16_to_cpu(new_el->l_next_free_rec) - 1];
4414		}
4415	}
4416
4417	/*
4418	 * We're careful to check for an empty extent record here -
4419	 * the merge code will know what to do if it sees one.
4420	 */
4421	if (rec) {
4422		if (index == 1 && ocfs2_is_empty_extent(rec)) {
4423			if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4424				ret = CONTIG_RIGHT;
4425		} else {
4426			ret = ocfs2_et_extent_contig(et, rec, split_rec);
4427		}
4428	}
4429
4430	rec = NULL;
4431	if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4432		rec = &el->l_recs[index + 1];
4433	else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4434		 path->p_tree_depth > 0) {
4435		status = ocfs2_find_cpos_for_right_leaf(sb, path, &right_cpos);
4436		if (status)
4437			goto free_left_path;
4438
4439		if (right_cpos == 0)
4440			goto free_left_path;
4441
4442		right_path = ocfs2_new_path_from_path(path);
4443		if (!right_path) {
4444			status = -ENOMEM;
4445			mlog_errno(status);
4446			goto free_left_path;
4447		}
4448
4449		status = ocfs2_find_path(et->et_ci, right_path, right_cpos);
4450		if (status)
4451			goto free_right_path;
4452
4453		new_el = path_leaf_el(right_path);
4454		rec = &new_el->l_recs[0];
4455		if (ocfs2_is_empty_extent(rec)) {
4456			if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4457				bh = path_leaf_bh(right_path);
4458				eb = (struct ocfs2_extent_block *)bh->b_data;
4459				status = ocfs2_error(sb,
4460						"Extent block #%llu has an invalid l_next_free_rec of %d\n",
4461						(unsigned long long)le64_to_cpu(eb->h_blkno),
4462						le16_to_cpu(new_el->l_next_free_rec));
4463				goto free_right_path;
4464			}
4465			rec = &new_el->l_recs[1];
4466		}
4467	}
4468
4469	if (rec) {
4470		enum ocfs2_contig_type contig_type;
4471
4472		contig_type = ocfs2_et_extent_contig(et, rec, split_rec);
4473
4474		if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4475			ret = CONTIG_LEFTRIGHT;
4476		else if (ret == CONTIG_NONE)
4477			ret = contig_type;
4478	}
4479
4480free_right_path:
4481	ocfs2_free_path(right_path);
4482free_left_path:
4483	ocfs2_free_path(left_path);
4484exit:
4485	if (status == 0)
4486		ctxt->c_contig_type = ret;
4487
4488	return status;
4489}
4490
4491static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et,
4492				     struct ocfs2_insert_type *insert,
4493				     struct ocfs2_extent_list *el,
4494				     struct ocfs2_extent_rec *insert_rec)
4495{
4496	int i;
4497	enum ocfs2_contig_type contig_type = CONTIG_NONE;
4498
4499	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4500
4501	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4502		contig_type = ocfs2_et_extent_contig(et, &el->l_recs[i],
4503						     insert_rec);
4504		if (contig_type != CONTIG_NONE) {
4505			insert->ins_contig_index = i;
4506			break;
4507		}
4508	}
4509	insert->ins_contig = contig_type;
4510
4511	if (insert->ins_contig != CONTIG_NONE) {
4512		struct ocfs2_extent_rec *rec =
4513				&el->l_recs[insert->ins_contig_index];
4514		unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4515				   le16_to_cpu(insert_rec->e_leaf_clusters);
4516
4517		/*
4518		 * Caller might want us to limit the size of extents, don't
4519		 * calculate contiguousness if we might exceed that limit.
4520		 */
4521		if (et->et_max_leaf_clusters &&
4522		    (len > et->et_max_leaf_clusters))
4523			insert->ins_contig = CONTIG_NONE;
4524	}
4525}
4526
4527/*
4528 * This should only be called against the rightmost leaf extent list.
4529 *
4530 * ocfs2_figure_appending_type() will figure out whether we'll have to
4531 * insert at the tail of the rightmost leaf.
4532 *
4533 * This should also work against the root extent list for tree's with 0
4534 * depth. If we consider the root extent list to be the rightmost leaf node
4535 * then the logic here makes sense.
4536 */
4537static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4538					struct ocfs2_extent_list *el,
4539					struct ocfs2_extent_rec *insert_rec)
4540{
4541	int i;
4542	u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4543	struct ocfs2_extent_rec *rec;
4544
4545	insert->ins_appending = APPEND_NONE;
4546
4547	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4548
4549	if (!el->l_next_free_rec)
4550		goto set_tail_append;
4551
4552	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
4553		/* Were all records empty? */
4554		if (le16_to_cpu(el->l_next_free_rec) == 1)
4555			goto set_tail_append;
4556	}
4557
4558	i = le16_to_cpu(el->l_next_free_rec) - 1;
4559	rec = &el->l_recs[i];
4560
4561	if (cpos >=
4562	    (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4563		goto set_tail_append;
4564
4565	return;
4566
4567set_tail_append:
4568	insert->ins_appending = APPEND_TAIL;
4569}
4570
4571/*
4572 * Helper function called at the beginning of an insert.
4573 *
4574 * This computes a few things that are commonly used in the process of
4575 * inserting into the btree:
4576 *   - Whether the new extent is contiguous with an existing one.
4577 *   - The current tree depth.
4578 *   - Whether the insert is an appending one.
4579 *   - The total # of free records in the tree.
4580 *
4581 * All of the information is stored on the ocfs2_insert_type
4582 * structure.
4583 */
4584static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et,
4585				    struct buffer_head **last_eb_bh,
4586				    struct ocfs2_extent_rec *insert_rec,
4587				    int *free_records,
4588				    struct ocfs2_insert_type *insert)
4589{
4590	int ret;
4591	struct ocfs2_extent_block *eb;
4592	struct ocfs2_extent_list *el;
4593	struct ocfs2_path *path = NULL;
4594	struct buffer_head *bh = NULL;
4595
4596	insert->ins_split = SPLIT_NONE;
4597
4598	el = et->et_root_el;
4599	insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4600
4601	if (el->l_tree_depth) {
4602		/*
4603		 * If we have tree depth, we read in the
4604		 * rightmost extent block ahead of time as
4605		 * ocfs2_figure_insert_type() and ocfs2_add_branch()
4606		 * may want it later.
4607		 */
4608		ret = ocfs2_read_extent_block(et->et_ci,
4609					      ocfs2_et_get_last_eb_blk(et),
4610					      &bh);
4611		if (ret) {
4612			mlog_errno(ret);
4613			goto out;
4614		}
4615		eb = (struct ocfs2_extent_block *) bh->b_data;
4616		el = &eb->h_list;
4617	}
4618
4619	/*
4620	 * Unless we have a contiguous insert, we'll need to know if
4621	 * there is room left in our allocation tree for another
4622	 * extent record.
4623	 *
4624	 * XXX: This test is simplistic, we can search for empty
4625	 * extent records too.
4626	 */
4627	*free_records = le16_to_cpu(el->l_count) -
4628		le16_to_cpu(el->l_next_free_rec);
4629
4630	if (!insert->ins_tree_depth) {
4631		ocfs2_figure_contig_type(et, insert, el, insert_rec);
4632		ocfs2_figure_appending_type(insert, el, insert_rec);
4633		return 0;
4634	}
4635
4636	path = ocfs2_new_path_from_et(et);
4637	if (!path) {
4638		ret = -ENOMEM;
4639		mlog_errno(ret);
4640		goto out;
4641	}
4642
4643	/*
4644	 * In the case that we're inserting past what the tree
4645	 * currently accounts for, ocfs2_find_path() will return for
4646	 * us the rightmost tree path. This is accounted for below in
4647	 * the appending code.
4648	 */
4649	ret = ocfs2_find_path(et->et_ci, path, le32_to_cpu(insert_rec->e_cpos));
4650	if (ret) {
4651		mlog_errno(ret);
4652		goto out;
4653	}
4654
4655	el = path_leaf_el(path);
4656
4657	/*
4658	 * Now that we have the path, there's two things we want to determine:
4659	 * 1) Contiguousness (also set contig_index if this is so)
4660	 *
4661	 * 2) Are we doing an append? We can trivially break this up
4662         *     into two types of appends: simple record append, or a
4663         *     rotate inside the tail leaf.
4664	 */
4665	ocfs2_figure_contig_type(et, insert, el, insert_rec);
4666
4667	/*
4668	 * The insert code isn't quite ready to deal with all cases of
4669	 * left contiguousness. Specifically, if it's an insert into
4670	 * the 1st record in a leaf, it will require the adjustment of
4671	 * cluster count on the last record of the path directly to it's
4672	 * left. For now, just catch that case and fool the layers
4673	 * above us. This works just fine for tree_depth == 0, which
4674	 * is why we allow that above.
4675	 */
4676	if (insert->ins_contig == CONTIG_LEFT &&
4677	    insert->ins_contig_index == 0)
4678		insert->ins_contig = CONTIG_NONE;
4679
4680	/*
4681	 * Ok, so we can simply compare against last_eb to figure out
4682	 * whether the path doesn't exist. This will only happen in
4683	 * the case that we're doing a tail append, so maybe we can
4684	 * take advantage of that information somehow.
4685	 */
4686	if (ocfs2_et_get_last_eb_blk(et) ==
4687	    path_leaf_bh(path)->b_blocknr) {
4688		/*
4689		 * Ok, ocfs2_find_path() returned us the rightmost
4690		 * tree path. This might be an appending insert. There are
4691		 * two cases:
4692		 *    1) We're doing a true append at the tail:
4693		 *	-This might even be off the end of the leaf
4694		 *    2) We're "appending" by rotating in the tail
4695		 */
4696		ocfs2_figure_appending_type(insert, el, insert_rec);
4697	}
4698
4699out:
4700	ocfs2_free_path(path);
4701
4702	if (ret == 0)
4703		*last_eb_bh = bh;
4704	else
4705		brelse(bh);
4706	return ret;
4707}
4708
4709/*
4710 * Insert an extent into a btree.
4711 *
4712 * The caller needs to update the owning btree's cluster count.
4713 */
4714int ocfs2_insert_extent(handle_t *handle,
4715			struct ocfs2_extent_tree *et,
4716			u32 cpos,
4717			u64 start_blk,
4718			u32 new_clusters,
4719			u8 flags,
4720			struct ocfs2_alloc_context *meta_ac)
4721{
4722	int status;
4723	int free_records;
4724	struct buffer_head *last_eb_bh = NULL;
4725	struct ocfs2_insert_type insert = {0, };
4726	struct ocfs2_extent_rec rec;
4727
4728	trace_ocfs2_insert_extent_start(
4729		(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4730		cpos, new_clusters);
4731
4732	memset(&rec, 0, sizeof(rec));
4733	rec.e_cpos = cpu_to_le32(cpos);
4734	rec.e_blkno = cpu_to_le64(start_blk);
4735	rec.e_leaf_clusters = cpu_to_le16(new_clusters);
4736	rec.e_flags = flags;
4737	status = ocfs2_et_insert_check(et, &rec);
4738	if (status) {
4739		mlog_errno(status);
4740		goto bail;
4741	}
4742
4743	status = ocfs2_figure_insert_type(et, &last_eb_bh, &rec,
4744					  &free_records, &insert);
4745	if (status < 0) {
4746		mlog_errno(status);
4747		goto bail;
4748	}
4749
4750	trace_ocfs2_insert_extent(insert.ins_appending, insert.ins_contig,
4751				  insert.ins_contig_index, free_records,
4752				  insert.ins_tree_depth);
4753
4754	if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4755		status = ocfs2_grow_tree(handle, et,
4756					 &insert.ins_tree_depth, &last_eb_bh,
4757					 meta_ac);
4758		if (status) {
4759			mlog_errno(status);
4760			goto bail;
4761		}
4762	}
4763
4764	/* Finally, we can add clusters. This might rotate the tree for us. */
4765	status = ocfs2_do_insert_extent(handle, et, &rec, &insert);
4766	if (status < 0)
4767		mlog_errno(status);
4768	else
4769		ocfs2_et_extent_map_insert(et, &rec);
4770
4771bail:
4772	brelse(last_eb_bh);
4773
4774	return status;
4775}
4776
4777/*
4778 * Allocate and add clusters into the extent b-tree.
4779 * The new clusters(clusters_to_add) will be inserted at logical_offset.
4780 * The extent b-tree's root is specified by et, and
4781 * it is not limited to the file storage. Any extent tree can use this
4782 * function if it implements the proper ocfs2_extent_tree.
4783 */
4784int ocfs2_add_clusters_in_btree(handle_t *handle,
4785				struct ocfs2_extent_tree *et,
4786				u32 *logical_offset,
4787				u32 clusters_to_add,
4788				int mark_unwritten,
4789				struct ocfs2_alloc_context *data_ac,
4790				struct ocfs2_alloc_context *meta_ac,
4791				enum ocfs2_alloc_restarted *reason_ret)
4792{
4793	int status = 0, err = 0;
4794	int need_free = 0;
4795	int free_extents;
4796	enum ocfs2_alloc_restarted reason = RESTART_NONE;
4797	u32 bit_off, num_bits;
4798	u64 block;
4799	u8 flags = 0;
4800	struct ocfs2_super *osb =
4801		OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
4802
4803	BUG_ON(!clusters_to_add);
4804
4805	if (mark_unwritten)
4806		flags = OCFS2_EXT_UNWRITTEN;
4807
4808	free_extents = ocfs2_num_free_extents(et);
4809	if (free_extents < 0) {
4810		status = free_extents;
4811		mlog_errno(status);
4812		goto leave;
4813	}
4814
4815	/* there are two cases which could cause us to EAGAIN in the
4816	 * we-need-more-metadata case:
4817	 * 1) we haven't reserved *any*
4818	 * 2) we are so fragmented, we've needed to add metadata too
4819	 *    many times. */
4820	if (!free_extents && !meta_ac) {
4821		err = -1;
4822		status = -EAGAIN;
4823		reason = RESTART_META;
4824		goto leave;
4825	} else if ((!free_extents)
4826		   && (ocfs2_alloc_context_bits_left(meta_ac)
4827		       < ocfs2_extend_meta_needed(et->et_root_el))) {
4828		err = -2;
4829		status = -EAGAIN;
4830		reason = RESTART_META;
4831		goto leave;
4832	}
4833
4834	status = __ocfs2_claim_clusters(handle, data_ac, 1,
4835					clusters_to_add, &bit_off, &num_bits);
4836	if (status < 0) {
4837		if (status != -ENOSPC)
4838			mlog_errno(status);
4839		goto leave;
4840	}
4841
4842	BUG_ON(num_bits > clusters_to_add);
4843
4844	/* reserve our write early -- insert_extent may update the tree root */
4845	status = ocfs2_et_root_journal_access(handle, et,
4846					      OCFS2_JOURNAL_ACCESS_WRITE);
4847	if (status < 0) {
4848		mlog_errno(status);
4849		need_free = 1;
4850		goto bail;
4851	}
4852
4853	block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
4854	trace_ocfs2_add_clusters_in_btree(
4855	     (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
4856	     bit_off, num_bits);
4857	status = ocfs2_insert_extent(handle, et, *logical_offset, block,
4858				     num_bits, flags, meta_ac);
4859	if (status < 0) {
4860		mlog_errno(status);
4861		need_free = 1;
4862		goto bail;
4863	}
4864
4865	ocfs2_journal_dirty(handle, et->et_root_bh);
4866
4867	clusters_to_add -= num_bits;
4868	*logical_offset += num_bits;
4869
4870	if (clusters_to_add) {
4871		err = clusters_to_add;
4872		status = -EAGAIN;
4873		reason = RESTART_TRANS;
4874	}
4875
4876bail:
4877	if (need_free) {
4878		if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
4879			ocfs2_free_local_alloc_bits(osb, handle, data_ac,
4880					bit_off, num_bits);
4881		else
4882			ocfs2_free_clusters(handle,
4883					data_ac->ac_inode,
4884					data_ac->ac_bh,
4885					ocfs2_clusters_to_blocks(osb->sb, bit_off),
4886					num_bits);
4887	}
4888
4889leave:
4890	if (reason_ret)
4891		*reason_ret = reason;
4892	trace_ocfs2_add_clusters_in_btree_ret(status, reason, err);
4893	return status;
4894}
4895
4896static void ocfs2_make_right_split_rec(struct super_block *sb,
4897				       struct ocfs2_extent_rec *split_rec,
4898				       u32 cpos,
4899				       struct ocfs2_extent_rec *rec)
4900{
4901	u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4902	u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4903
4904	memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4905
4906	split_rec->e_cpos = cpu_to_le32(cpos);
4907	split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4908
4909	split_rec->e_blkno = rec->e_blkno;
4910	le64_add_cpu(&split_rec->e_blkno,
4911		     ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4912
4913	split_rec->e_flags = rec->e_flags;
4914}
4915
4916static int ocfs2_split_and_insert(handle_t *handle,
4917				  struct ocfs2_extent_tree *et,
4918				  struct ocfs2_path *path,
4919				  struct buffer_head **last_eb_bh,
4920				  int split_index,
4921				  struct ocfs2_extent_rec *orig_split_rec,
4922				  struct ocfs2_alloc_context *meta_ac)
4923{
4924	int ret = 0, depth;
4925	unsigned int insert_range, rec_range, do_leftright = 0;
4926	struct ocfs2_extent_rec tmprec;
4927	struct ocfs2_extent_list *rightmost_el;
4928	struct ocfs2_extent_rec rec;
4929	struct ocfs2_extent_rec split_rec = *orig_split_rec;
4930	struct ocfs2_insert_type insert;
4931	struct ocfs2_extent_block *eb;
4932
4933leftright:
4934	/*
4935	 * Store a copy of the record on the stack - it might move
4936	 * around as the tree is manipulated below.
4937	 */
4938	rec = path_leaf_el(path)->l_recs[split_index];
4939
4940	rightmost_el = et->et_root_el;
4941
4942	depth = le16_to_cpu(rightmost_el->l_tree_depth);
4943	if (depth) {
4944		BUG_ON(!(*last_eb_bh));
4945		eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4946		rightmost_el = &eb->h_list;
4947	}
4948
4949	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4950	    le16_to_cpu(rightmost_el->l_count)) {
4951		ret = ocfs2_grow_tree(handle, et,
4952				      &depth, last_eb_bh, meta_ac);
4953		if (ret) {
4954			mlog_errno(ret);
4955			goto out;
4956		}
4957	}
4958
4959	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4960	insert.ins_appending = APPEND_NONE;
4961	insert.ins_contig = CONTIG_NONE;
4962	insert.ins_tree_depth = depth;
4963
4964	insert_range = le32_to_cpu(split_rec.e_cpos) +
4965		le16_to_cpu(split_rec.e_leaf_clusters);
4966	rec_range = le32_to_cpu(rec.e_cpos) +
4967		le16_to_cpu(rec.e_leaf_clusters);
4968
4969	if (split_rec.e_cpos == rec.e_cpos) {
4970		insert.ins_split = SPLIT_LEFT;
4971	} else if (insert_range == rec_range) {
4972		insert.ins_split = SPLIT_RIGHT;
4973	} else {
4974		/*
4975		 * Left/right split. We fake this as a right split
4976		 * first and then make a second pass as a left split.
4977		 */
4978		insert.ins_split = SPLIT_RIGHT;
4979
4980		ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
4981					   &tmprec, insert_range, &rec);
4982
4983		split_rec = tmprec;
4984
4985		BUG_ON(do_leftright);
4986		do_leftright = 1;
4987	}
4988
4989	ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
4990	if (ret) {
4991		mlog_errno(ret);
4992		goto out;
4993	}
4994
4995	if (do_leftright == 1) {
4996		u32 cpos;
4997		struct ocfs2_extent_list *el;
4998
4999		do_leftright++;
5000		split_rec = *orig_split_rec;
5001
5002		ocfs2_reinit_path(path, 1);
5003
5004		cpos = le32_to_cpu(split_rec.e_cpos);
5005		ret = ocfs2_find_path(et->et_ci, path, cpos);
5006		if (ret) {
5007			mlog_errno(ret);
5008			goto out;
5009		}
5010
5011		el = path_leaf_el(path);
5012		split_index = ocfs2_search_extent_list(el, cpos);
5013		if (split_index == -1) {
5014			ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5015				    "Owner %llu has an extent at cpos %u which can no longer be found\n",
5016				    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5017				    cpos);
5018			ret = -EROFS;
5019			goto out;
5020		}
5021		goto leftright;
5022	}
5023out:
5024
5025	return ret;
5026}
5027
5028static int ocfs2_replace_extent_rec(handle_t *handle,
5029				    struct ocfs2_extent_tree *et,
5030				    struct ocfs2_path *path,
5031				    struct ocfs2_extent_list *el,
5032				    int split_index,
5033				    struct ocfs2_extent_rec *split_rec)
5034{
5035	int ret;
5036
5037	ret = ocfs2_path_bh_journal_access(handle, et->et_ci, path,
5038					   path_num_items(path) - 1);
5039	if (ret) {
5040		mlog_errno(ret);
5041		goto out;
5042	}
5043
5044	el->l_recs[split_index] = *split_rec;
5045
5046	ocfs2_journal_dirty(handle, path_leaf_bh(path));
5047out:
5048	return ret;
5049}
5050
5051/*
5052 * Split part or all of the extent record at split_index in the leaf
5053 * pointed to by path. Merge with the contiguous extent record if needed.
5054 *
5055 * Care is taken to handle contiguousness so as to not grow the tree.
5056 *
5057 * meta_ac is not strictly necessary - we only truly need it if growth
5058 * of the tree is required. All other cases will degrade into a less
5059 * optimal tree layout.
5060 *
5061 * last_eb_bh should be the rightmost leaf block for any extent
5062 * btree. Since a split may grow the tree or a merge might shrink it,
5063 * the caller cannot trust the contents of that buffer after this call.
5064 *
5065 * This code is optimized for readability - several passes might be
5066 * made over certain portions of the tree. All of those blocks will
5067 * have been brought into cache (and pinned via the journal), so the
5068 * extra overhead is not expressed in terms of disk reads.
5069 */
5070int ocfs2_split_extent(handle_t *handle,
5071		       struct ocfs2_extent_tree *et,
5072		       struct ocfs2_path *path,
5073		       int split_index,
5074		       struct ocfs2_extent_rec *split_rec,
5075		       struct ocfs2_alloc_context *meta_ac,
5076		       struct ocfs2_cached_dealloc_ctxt *dealloc)
5077{
5078	int ret = 0;
5079	struct ocfs2_extent_list *el = path_leaf_el(path);
5080	struct buffer_head *last_eb_bh = NULL;
5081	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
5082	struct ocfs2_merge_ctxt ctxt;
5083
5084	if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
5085	    ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
5086	     (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
5087		ret = -EIO;
5088		mlog_errno(ret);
5089		goto out;
5090	}
5091
5092	ret = ocfs2_figure_merge_contig_type(et, path, el,
5093					     split_index,
5094					     split_rec,
5095					     &ctxt);
5096	if (ret) {
5097		mlog_errno(ret);
5098		goto out;
5099	}
5100
5101	/*
5102	 * The core merge / split code wants to know how much room is
5103	 * left in this allocation tree, so we pass the
5104	 * rightmost extent list.
5105	 */
5106	if (path->p_tree_depth) {
5107		ret = ocfs2_read_extent_block(et->et_ci,
5108					      ocfs2_et_get_last_eb_blk(et),
5109					      &last_eb_bh);
5110		if (ret) {
5111			mlog_errno(ret);
5112			goto out;
5113		}
5114	}
5115
5116	if (rec->e_cpos == split_rec->e_cpos &&
5117	    rec->e_leaf_clusters == split_rec->e_leaf_clusters)
5118		ctxt.c_split_covers_rec = 1;
5119	else
5120		ctxt.c_split_covers_rec = 0;
5121
5122	ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
5123
5124	trace_ocfs2_split_extent(split_index, ctxt.c_contig_type,
5125				 ctxt.c_has_empty_extent,
5126				 ctxt.c_split_covers_rec);
5127
5128	if (ctxt.c_contig_type == CONTIG_NONE) {
5129		if (ctxt.c_split_covers_rec)
5130			ret = ocfs2_replace_extent_rec(handle, et, path, el,
5131						       split_index, split_rec);
5132		else
5133			ret = ocfs2_split_and_insert(handle, et, path,
5134						     &last_eb_bh, split_index,
5135						     split_rec, meta_ac);
5136		if (ret)
5137			mlog_errno(ret);
5138	} else {
5139		ret = ocfs2_try_to_merge_extent(handle, et, path,
5140						split_index, split_rec,
5141						dealloc, &ctxt);
5142		if (ret)
5143			mlog_errno(ret);
5144	}
5145
5146out:
5147	brelse(last_eb_bh);
5148	return ret;
5149}
5150
5151/*
5152 * Change the flags of the already-existing extent at cpos for len clusters.
5153 *
5154 * new_flags: the flags we want to set.
5155 * clear_flags: the flags we want to clear.
5156 * phys: the new physical offset we want this new extent starts from.
5157 *
5158 * If the existing extent is larger than the request, initiate a
5159 * split. An attempt will be made at merging with adjacent extents.
5160 *
5161 * The caller is responsible for passing down meta_ac if we'll need it.
5162 */
5163int ocfs2_change_extent_flag(handle_t *handle,
5164			     struct ocfs2_extent_tree *et,
5165			     u32 cpos, u32 len, u32 phys,
5166			     struct ocfs2_alloc_context *meta_ac,
5167			     struct ocfs2_cached_dealloc_ctxt *dealloc,
5168			     int new_flags, int clear_flags)
5169{
5170	int ret, index;
5171	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5172	u64 start_blkno = ocfs2_clusters_to_blocks(sb, phys);
5173	struct ocfs2_extent_rec split_rec;
5174	struct ocfs2_path *left_path = NULL;
5175	struct ocfs2_extent_list *el;
5176	struct ocfs2_extent_rec *rec;
5177
5178	left_path = ocfs2_new_path_from_et(et);
5179	if (!left_path) {
5180		ret = -ENOMEM;
5181		mlog_errno(ret);
5182		goto out;
5183	}
5184
5185	ret = ocfs2_find_path(et->et_ci, left_path, cpos);
5186	if (ret) {
5187		mlog_errno(ret);
5188		goto out;
5189	}
5190	el = path_leaf_el(left_path);
5191
5192	index = ocfs2_search_extent_list(el, cpos);
5193	if (index == -1) {
5194		ocfs2_error(sb,
5195			    "Owner %llu has an extent at cpos %u which can no longer be found\n",
5196			    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5197			    cpos);
5198		ret = -EROFS;
5199		goto out;
5200	}
5201
5202	ret = -EIO;
5203	rec = &el->l_recs[index];
5204	if (new_flags && (rec->e_flags & new_flags)) {
5205		mlog(ML_ERROR, "Owner %llu tried to set %d flags on an "
5206		     "extent that already had them\n",
5207		     (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5208		     new_flags);
5209		goto out;
5210	}
5211
5212	if (clear_flags && !(rec->e_flags & clear_flags)) {
5213		mlog(ML_ERROR, "Owner %llu tried to clear %d flags on an "
5214		     "extent that didn't have them\n",
5215		     (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5216		     clear_flags);
5217		goto out;
5218	}
5219
5220	memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
5221	split_rec.e_cpos = cpu_to_le32(cpos);
5222	split_rec.e_leaf_clusters = cpu_to_le16(len);
5223	split_rec.e_blkno = cpu_to_le64(start_blkno);
5224	split_rec.e_flags = rec->e_flags;
5225	if (new_flags)
5226		split_rec.e_flags |= new_flags;
5227	if (clear_flags)
5228		split_rec.e_flags &= ~clear_flags;
5229
5230	ret = ocfs2_split_extent(handle, et, left_path,
5231				 index, &split_rec, meta_ac,
5232				 dealloc);
5233	if (ret)
5234		mlog_errno(ret);
5235
5236out:
5237	ocfs2_free_path(left_path);
5238	return ret;
5239
5240}
5241
5242/*
5243 * Mark the already-existing extent at cpos as written for len clusters.
5244 * This removes the unwritten extent flag.
5245 *
5246 * If the existing extent is larger than the request, initiate a
5247 * split. An attempt will be made at merging with adjacent extents.
5248 *
5249 * The caller is responsible for passing down meta_ac if we'll need it.
5250 */
5251int ocfs2_mark_extent_written(struct inode *inode,
5252			      struct ocfs2_extent_tree *et,
5253			      handle_t *handle, u32 cpos, u32 len, u32 phys,
5254			      struct ocfs2_alloc_context *meta_ac,
5255			      struct ocfs2_cached_dealloc_ctxt *dealloc)
5256{
5257	int ret;
5258
5259	trace_ocfs2_mark_extent_written(
5260		(unsigned long long)OCFS2_I(inode)->ip_blkno,
5261		cpos, len, phys);
5262
5263	if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
5264		ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents that are being written to, but the feature bit is not set in the super block\n",
5265			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
5266		ret = -EROFS;
5267		goto out;
5268	}
5269
5270	/*
5271	 * XXX: This should be fixed up so that we just re-insert the
5272	 * next extent records.
5273	 */
5274	ocfs2_et_extent_map_truncate(et, 0);
5275
5276	ret = ocfs2_change_extent_flag(handle, et, cpos,
5277				       len, phys, meta_ac, dealloc,
5278				       0, OCFS2_EXT_UNWRITTEN);
5279	if (ret)
5280		mlog_errno(ret);
5281
5282out:
5283	return ret;
5284}
5285
5286static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et,
5287			    struct ocfs2_path *path,
5288			    int index, u32 new_range,
5289			    struct ocfs2_alloc_context *meta_ac)
5290{
5291	int ret, depth, credits;
5292	struct buffer_head *last_eb_bh = NULL;
5293	struct ocfs2_extent_block *eb;
5294	struct ocfs2_extent_list *rightmost_el, *el;
5295	struct ocfs2_extent_rec split_rec;
5296	struct ocfs2_extent_rec *rec;
5297	struct ocfs2_insert_type insert;
5298
5299	/*
5300	 * Setup the record to split before we grow the tree.
5301	 */
5302	el = path_leaf_el(path);
5303	rec = &el->l_recs[index];
5304	ocfs2_make_right_split_rec(ocfs2_metadata_cache_get_super(et->et_ci),
5305				   &split_rec, new_range, rec);
5306
5307	depth = path->p_tree_depth;
5308	if (depth > 0) {
5309		ret = ocfs2_read_extent_block(et->et_ci,
5310					      ocfs2_et_get_last_eb_blk(et),
5311					      &last_eb_bh);
5312		if (ret < 0) {
5313			mlog_errno(ret);
5314			goto out;
5315		}
5316
5317		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5318		rightmost_el = &eb->h_list;
5319	} else
5320		rightmost_el = path_leaf_el(path);
5321
5322	credits = path->p_tree_depth +
5323		  ocfs2_extend_meta_needed(et->et_root_el);
5324	ret = ocfs2_extend_trans(handle, credits);
5325	if (ret) {
5326		mlog_errno(ret);
5327		goto out;
5328	}
5329
5330	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
5331	    le16_to_cpu(rightmost_el->l_count)) {
5332		ret = ocfs2_grow_tree(handle, et, &depth, &last_eb_bh,
5333				      meta_ac);
5334		if (ret) {
5335			mlog_errno(ret);
5336			goto out;
5337		}
5338	}
5339
5340	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
5341	insert.ins_appending = APPEND_NONE;
5342	insert.ins_contig = CONTIG_NONE;
5343	insert.ins_split = SPLIT_RIGHT;
5344	insert.ins_tree_depth = depth;
5345
5346	ret = ocfs2_do_insert_extent(handle, et, &split_rec, &insert);
5347	if (ret)
5348		mlog_errno(ret);
5349
5350out:
5351	brelse(last_eb_bh);
5352	return ret;
5353}
5354
5355static int ocfs2_truncate_rec(handle_t *handle,
5356			      struct ocfs2_extent_tree *et,
5357			      struct ocfs2_path *path, int index,
5358			      struct ocfs2_cached_dealloc_ctxt *dealloc,
5359			      u32 cpos, u32 len)
5360{
5361	int ret;
5362	u32 left_cpos, rec_range, trunc_range;
5363	int is_rightmost_tree_rec = 0;
5364	struct super_block *sb = ocfs2_metadata_cache_get_super(et->et_ci);
5365	struct ocfs2_path *left_path = NULL;
5366	struct ocfs2_extent_list *el = path_leaf_el(path);
5367	struct ocfs2_extent_rec *rec;
5368	struct ocfs2_extent_block *eb;
5369
5370	if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
5371		/* extend credit for ocfs2_remove_rightmost_path */
5372		ret = ocfs2_extend_rotate_transaction(handle, 0,
5373				jbd2_handle_buffer_credits(handle),
5374				path);
5375		if (ret) {
5376			mlog_errno(ret);
5377			goto out;
5378		}
5379
5380		ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5381		if (ret) {
5382			mlog_errno(ret);
5383			goto out;
5384		}
5385
5386		index--;
5387	}
5388
5389	if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5390	    path->p_tree_depth) {
5391		/*
5392		 * Check whether this is the rightmost tree record. If
5393		 * we remove all of this record or part of its right
5394		 * edge then an update of the record lengths above it
5395		 * will be required.
5396		 */
5397		eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5398		if (eb->h_next_leaf_blk == 0)
5399			is_rightmost_tree_rec = 1;
5400	}
5401
5402	rec = &el->l_recs[index];
5403	if (index == 0 && path->p_tree_depth &&
5404	    le32_to_cpu(rec->e_cpos) == cpos) {
5405		/*
5406		 * Changing the leftmost offset (via partial or whole
5407		 * record truncate) of an interior (or rightmost) path
5408		 * means we have to update the subtree that is formed
5409		 * by this leaf and the one to it's left.
5410		 *
5411		 * There are two cases we can skip:
5412		 *   1) Path is the leftmost one in our btree.
5413		 *   2) The leaf is rightmost and will be empty after
5414		 *      we remove the extent record - the rotate code
5415		 *      knows how to update the newly formed edge.
5416		 */
5417
5418		ret = ocfs2_find_cpos_for_left_leaf(sb, path, &left_cpos);
5419		if (ret) {
5420			mlog_errno(ret);
5421			goto out;
5422		}
5423
5424		if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5425			left_path = ocfs2_new_path_from_path(path);
5426			if (!left_path) {
5427				ret = -ENOMEM;
5428				mlog_errno(ret);
5429				goto out;
5430			}
5431
5432			ret = ocfs2_find_path(et->et_ci, left_path,
5433					      left_cpos);
5434			if (ret) {
5435				mlog_errno(ret);
5436				goto out;
5437			}
5438		}
5439	}
5440
5441	ret = ocfs2_extend_rotate_transaction(handle, 0,
5442					jbd2_handle_buffer_credits(handle),
5443					path);
5444	if (ret) {
5445		mlog_errno(ret);
5446		goto out;
5447	}
5448
5449	ret = ocfs2_journal_access_path(et->et_ci, handle, path);
5450	if (ret) {
5451		mlog_errno(ret);
5452		goto out;
5453	}
5454
5455	ret = ocfs2_journal_access_path(et->et_ci, handle, left_path);
5456	if (ret) {
5457		mlog_errno(ret);
5458		goto out;
5459	}
5460
5461	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5462	trunc_range = cpos + len;
5463
5464	if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5465		int next_free;
5466
5467		memset(rec, 0, sizeof(*rec));
5468		ocfs2_cleanup_merge(el, index);
5469
5470		next_free = le16_to_cpu(el->l_next_free_rec);
5471		if (is_rightmost_tree_rec && next_free > 1) {
5472			/*
5473			 * We skip the edge update if this path will
5474			 * be deleted by the rotate code.
5475			 */
5476			rec = &el->l_recs[next_free - 1];
5477			ocfs2_adjust_rightmost_records(handle, et, path,
5478						       rec);
5479		}
5480	} else if (le32_to_cpu(rec->e_cpos) == cpos) {
5481		/* Remove leftmost portion of the record. */
5482		le32_add_cpu(&rec->e_cpos, len);
5483		le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
5484		le16_add_cpu(&rec->e_leaf_clusters, -len);
5485	} else if (rec_range == trunc_range) {
5486		/* Remove rightmost portion of the record */
5487		le16_add_cpu(&rec->e_leaf_clusters, -len);
5488		if (is_rightmost_tree_rec)
5489			ocfs2_adjust_rightmost_records(handle, et, path, rec);
5490	} else {
5491		/* Caller should have trapped this. */
5492		mlog(ML_ERROR, "Owner %llu: Invalid record truncate: (%u, %u) "
5493		     "(%u, %u)\n",
5494		     (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5495		     le32_to_cpu(rec->e_cpos),
5496		     le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5497		BUG();
5498	}
5499
5500	if (left_path) {
5501		int subtree_index;
5502
5503		subtree_index = ocfs2_find_subtree_root(et, left_path, path);
5504		ocfs2_complete_edge_insert(handle, left_path, path,
5505					   subtree_index);
5506	}
5507
5508	ocfs2_journal_dirty(handle, path_leaf_bh(path));
5509
5510	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5511	if (ret)
5512		mlog_errno(ret);
5513
5514out:
5515	ocfs2_free_path(left_path);
5516	return ret;
5517}
5518
5519int ocfs2_remove_extent(handle_t *handle,
5520			struct ocfs2_extent_tree *et,
5521			u32 cpos, u32 len,
5522			struct ocfs2_alloc_context *meta_ac,
5523			struct ocfs2_cached_dealloc_ctxt *dealloc)
5524{
5525	int ret, index;
5526	u32 rec_range, trunc_range;
5527	struct ocfs2_extent_rec *rec;
5528	struct ocfs2_extent_list *el;
5529	struct ocfs2_path *path = NULL;
5530
5531	/*
5532	 * XXX: Why are we truncating to 0 instead of wherever this
5533	 * affects us?
5534	 */
5535	ocfs2_et_extent_map_truncate(et, 0);
5536
5537	path = ocfs2_new_path_from_et(et);
5538	if (!path) {
5539		ret = -ENOMEM;
5540		mlog_errno(ret);
5541		goto out;
5542	}
5543
5544	ret = ocfs2_find_path(et->et_ci, path, cpos);
5545	if (ret) {
5546		mlog_errno(ret);
5547		goto out;
5548	}
5549
5550	el = path_leaf_el(path);
5551	index = ocfs2_search_extent_list(el, cpos);
5552	if (index == -1) {
5553		ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5554			    "Owner %llu has an extent at cpos %u which can no longer be found\n",
5555			    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5556			    cpos);
5557		ret = -EROFS;
5558		goto out;
5559	}
5560
5561	/*
5562	 * We have 3 cases of extent removal:
5563	 *   1) Range covers the entire extent rec
5564	 *   2) Range begins or ends on one edge of the extent rec
5565	 *   3) Range is in the middle of the extent rec (no shared edges)
5566	 *
5567	 * For case 1 we remove the extent rec and left rotate to
5568	 * fill the hole.
5569	 *
5570	 * For case 2 we just shrink the existing extent rec, with a
5571	 * tree update if the shrinking edge is also the edge of an
5572	 * extent block.
5573	 *
5574	 * For case 3 we do a right split to turn the extent rec into
5575	 * something case 2 can handle.
5576	 */
5577	rec = &el->l_recs[index];
5578	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5579	trunc_range = cpos + len;
5580
5581	BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5582
5583	trace_ocfs2_remove_extent(
5584		(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5585		cpos, len, index, le32_to_cpu(rec->e_cpos),
5586		ocfs2_rec_clusters(el, rec));
5587
5588	if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5589		ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5590					 cpos, len);
5591		if (ret) {
5592			mlog_errno(ret);
5593			goto out;
5594		}
5595	} else {
5596		ret = ocfs2_split_tree(handle, et, path, index,
5597				       trunc_range, meta_ac);
5598		if (ret) {
5599			mlog_errno(ret);
5600			goto out;
5601		}
5602
5603		/*
5604		 * The split could have manipulated the tree enough to
5605		 * move the record location, so we have to look for it again.
5606		 */
5607		ocfs2_reinit_path(path, 1);
5608
5609		ret = ocfs2_find_path(et->et_ci, path, cpos);
5610		if (ret) {
5611			mlog_errno(ret);
5612			goto out;
5613		}
5614
5615		el = path_leaf_el(path);
5616		index = ocfs2_search_extent_list(el, cpos);
5617		if (index == -1) {
5618			ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5619				    "Owner %llu: split at cpos %u lost record\n",
5620				    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5621				    cpos);
5622			ret = -EROFS;
5623			goto out;
5624		}
5625
5626		/*
5627		 * Double check our values here. If anything is fishy,
5628		 * it's easier to catch it at the top level.
5629		 */
5630		rec = &el->l_recs[index];
5631		rec_range = le32_to_cpu(rec->e_cpos) +
5632			ocfs2_rec_clusters(el, rec);
5633		if (rec_range != trunc_range) {
5634			ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5635				    "Owner %llu: error after split at cpos %u trunc len %u, existing record is (%u,%u)\n",
5636				    (unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5637				    cpos, len, le32_to_cpu(rec->e_cpos),
5638				    ocfs2_rec_clusters(el, rec));
5639			ret = -EROFS;
5640			goto out;
5641		}
5642
5643		ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5644					 cpos, len);
5645		if (ret)
5646			mlog_errno(ret);
5647	}
5648
5649out:
5650	ocfs2_free_path(path);
5651	return ret;
5652}
5653
5654/*
5655 * ocfs2_reserve_blocks_for_rec_trunc() would look basically the
5656 * same as ocfs2_lock_alloctors(), except for it accepts a blocks
5657 * number to reserve some extra blocks, and it only handles meta
5658 * data allocations.
5659 *
5660 * Currently, only ocfs2_remove_btree_range() uses it for truncating
5661 * and punching holes.
5662 */
5663static int ocfs2_reserve_blocks_for_rec_trunc(struct inode *inode,
5664					      struct ocfs2_extent_tree *et,
5665					      u32 extents_to_split,
5666					      struct ocfs2_alloc_context **ac,
5667					      int extra_blocks)
5668{
5669	int ret = 0, num_free_extents;
5670	unsigned int max_recs_needed = 2 * extents_to_split;
5671	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5672
5673	*ac = NULL;
5674
5675	num_free_extents = ocfs2_num_free_extents(et);
5676	if (num_free_extents < 0) {
5677		ret = num_free_extents;
5678		mlog_errno(ret);
5679		goto out;
5680	}
5681
5682	if (!num_free_extents ||
5683	    (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed))
5684		extra_blocks += ocfs2_extend_meta_needed(et->et_root_el);
5685
5686	if (extra_blocks) {
5687		ret = ocfs2_reserve_new_metadata_blocks(osb, extra_blocks, ac);
5688		if (ret < 0) {
5689			if (ret != -ENOSPC)
5690				mlog_errno(ret);
5691		}
5692	}
5693
5694out:
5695	if (ret) {
5696		if (*ac) {
5697			ocfs2_free_alloc_context(*ac);
5698			*ac = NULL;
5699		}
5700	}
5701
5702	return ret;
5703}
5704
5705int ocfs2_remove_btree_range(struct inode *inode,
5706			     struct ocfs2_extent_tree *et,
5707			     u32 cpos, u32 phys_cpos, u32 len, int flags,
5708			     struct ocfs2_cached_dealloc_ctxt *dealloc,
5709			     u64 refcount_loc, bool refcount_tree_locked)
5710{
5711	int ret, credits = 0, extra_blocks = 0;
5712	u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
5713	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5714	struct inode *tl_inode = osb->osb_tl_inode;
5715	handle_t *handle;
5716	struct ocfs2_alloc_context *meta_ac = NULL;
5717	struct ocfs2_refcount_tree *ref_tree = NULL;
5718
5719	if ((flags & OCFS2_EXT_REFCOUNTED) && len) {
5720		BUG_ON(!ocfs2_is_refcount_inode(inode));
5721
5722		if (!refcount_tree_locked) {
5723			ret = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
5724						       &ref_tree, NULL);
5725			if (ret) {
5726				mlog_errno(ret);
5727				goto bail;
5728			}
5729		}
5730
5731		ret = ocfs2_prepare_refcount_change_for_del(inode,
5732							    refcount_loc,
5733							    phys_blkno,
5734							    len,
5735							    &credits,
5736							    &extra_blocks);
5737		if (ret < 0) {
5738			mlog_errno(ret);
5739			goto bail;
5740		}
5741	}
5742
5743	ret = ocfs2_reserve_blocks_for_rec_trunc(inode, et, 1, &meta_ac,
5744						 extra_blocks);
5745	if (ret) {
5746		mlog_errno(ret);
5747		goto bail;
5748	}
5749
5750	inode_lock(tl_inode);
5751
5752	if (ocfs2_truncate_log_needs_flush(osb)) {
5753		ret = __ocfs2_flush_truncate_log(osb);
5754		if (ret < 0) {
5755			mlog_errno(ret);
5756			goto out;
5757		}
5758	}
5759
5760	handle = ocfs2_start_trans(osb,
5761			ocfs2_remove_extent_credits(osb->sb) + credits);
5762	if (IS_ERR(handle)) {
5763		ret = PTR_ERR(handle);
5764		mlog_errno(ret);
5765		goto out;
5766	}
5767
5768	ret = ocfs2_et_root_journal_access(handle, et,
5769					   OCFS2_JOURNAL_ACCESS_WRITE);
5770	if (ret) {
5771		mlog_errno(ret);
5772		goto out_commit;
5773	}
5774
5775	dquot_free_space_nodirty(inode,
5776				  ocfs2_clusters_to_bytes(inode->i_sb, len));
5777
5778	ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
5779	if (ret) {
5780		mlog_errno(ret);
5781		goto out_commit;
5782	}
5783
5784	ocfs2_et_update_clusters(et, -len);
5785	ocfs2_update_inode_fsync_trans(handle, inode, 1);
5786
5787	ocfs2_journal_dirty(handle, et->et_root_bh);
5788
5789	if (phys_blkno) {
5790		if (flags & OCFS2_EXT_REFCOUNTED)
5791			ret = ocfs2_decrease_refcount(inode, handle,
5792					ocfs2_blocks_to_clusters(osb->sb,
5793								 phys_blkno),
5794					len, meta_ac,
5795					dealloc, 1);
5796		else
5797			ret = ocfs2_truncate_log_append(osb, handle,
5798							phys_blkno, len);
5799		if (ret)
5800			mlog_errno(ret);
5801
5802	}
5803
5804out_commit:
5805	ocfs2_commit_trans(osb, handle);
5806out:
5807	inode_unlock(tl_inode);
5808bail:
5809	if (meta_ac)
5810		ocfs2_free_alloc_context(meta_ac);
5811
5812	if (ref_tree)
5813		ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
5814
5815	return ret;
5816}
5817
5818int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5819{
5820	struct buffer_head *tl_bh = osb->osb_tl_bh;
5821	struct ocfs2_dinode *di;
5822	struct ocfs2_truncate_log *tl;
5823
5824	di = (struct ocfs2_dinode *) tl_bh->b_data;
5825	tl = &di->id2.i_dealloc;
5826
5827	mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5828			"slot %d, invalid truncate log parameters: used = "
5829			"%u, count = %u\n", osb->slot_num,
5830			le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5831	return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5832}
5833
5834static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5835					   unsigned int new_start)
5836{
5837	unsigned int tail_index;
5838	unsigned int current_tail;
5839
5840	/* No records, nothing to coalesce */
5841	if (!le16_to_cpu(tl->tl_used))
5842		return 0;
5843
5844	tail_index = le16_to_cpu(tl->tl_used) - 1;
5845	current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5846	current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5847
5848	return current_tail == new_start;
5849}
5850
5851int ocfs2_truncate_log_append(struct ocfs2_super *osb,
5852			      handle_t *handle,
5853			      u64 start_blk,
5854			      unsigned int num_clusters)
5855{
5856	int status, index;
5857	unsigned int start_cluster, tl_count;
5858	struct inode *tl_inode = osb->osb_tl_inode;
5859	struct buffer_head *tl_bh = osb->osb_tl_bh;
5860	struct ocfs2_dinode *di;
5861	struct ocfs2_truncate_log *tl;
5862
5863	BUG_ON(inode_trylock(tl_inode));
5864
5865	start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
5866
5867	di = (struct ocfs2_dinode *) tl_bh->b_data;
5868
5869	/* tl_bh is loaded from ocfs2_truncate_log_init().  It's validated
5870	 * by the underlying call to ocfs2_read_inode_block(), so any
5871	 * corruption is a code bug */
5872	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5873
5874	tl = &di->id2.i_dealloc;
5875	tl_count = le16_to_cpu(tl->tl_count);
5876	mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5877			tl_count == 0,
5878			"Truncate record count on #%llu invalid "
5879			"wanted %u, actual %u\n",
5880			(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5881			ocfs2_truncate_recs_per_inode(osb->sb),
5882			le16_to_cpu(tl->tl_count));
5883
5884	/* Caller should have known to flush before calling us. */
5885	index = le16_to_cpu(tl->tl_used);
5886	if (index >= tl_count) {
5887		status = -ENOSPC;
5888		mlog_errno(status);
5889		goto bail;
5890	}
5891
5892	status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5893					 OCFS2_JOURNAL_ACCESS_WRITE);
5894	if (status < 0) {
5895		mlog_errno(status);
5896		goto bail;
5897	}
5898
5899	trace_ocfs2_truncate_log_append(
5900		(unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index,
5901		start_cluster, num_clusters);
5902	if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
5903		/*
5904		 * Move index back to the record we are coalescing with.
5905		 * ocfs2_truncate_log_can_coalesce() guarantees nonzero
5906		 */
5907		index--;
5908
5909		num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5910		trace_ocfs2_truncate_log_append(
5911			(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5912			index, le32_to_cpu(tl->tl_recs[index].t_start),
5913			num_clusters);
5914	} else {
5915		tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5916		tl->tl_used = cpu_to_le16(index + 1);
5917	}
5918	tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5919
5920	ocfs2_journal_dirty(handle, tl_bh);
5921
5922	osb->truncated_clusters += num_clusters;
5923bail:
5924	return status;
5925}
5926
5927static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
5928					 struct inode *data_alloc_inode,
5929					 struct buffer_head *data_alloc_bh)
5930{
5931	int status = 0;
5932	int i;
5933	unsigned int num_clusters;
5934	u64 start_blk;
5935	struct ocfs2_truncate_rec rec;
5936	struct ocfs2_dinode *di;
5937	struct ocfs2_truncate_log *tl;
5938	struct inode *tl_inode = osb->osb_tl_inode;
5939	struct buffer_head *tl_bh = osb->osb_tl_bh;
5940	handle_t *handle;
5941
5942	di = (struct ocfs2_dinode *) tl_bh->b_data;
5943	tl = &di->id2.i_dealloc;
5944	i = le16_to_cpu(tl->tl_used) - 1;
5945	while (i >= 0) {
5946		handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5947		if (IS_ERR(handle)) {
5948			status = PTR_ERR(handle);
5949			mlog_errno(status);
5950			goto bail;
5951		}
5952
5953		/* Caller has given us at least enough credits to
5954		 * update the truncate log dinode */
5955		status = ocfs2_journal_access_di(handle, INODE_CACHE(tl_inode), tl_bh,
5956						 OCFS2_JOURNAL_ACCESS_WRITE);
5957		if (status < 0) {
5958			ocfs2_commit_trans(osb, handle);
5959			mlog_errno(status);
5960			goto bail;
5961		}
5962
5963		tl->tl_used = cpu_to_le16(i);
5964
5965		ocfs2_journal_dirty(handle, tl_bh);
5966
5967		rec = tl->tl_recs[i];
5968		start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5969						    le32_to_cpu(rec.t_start));
5970		num_clusters = le32_to_cpu(rec.t_clusters);
5971
5972		/* if start_blk is not set, we ignore the record as
5973		 * invalid. */
5974		if (start_blk) {
5975			trace_ocfs2_replay_truncate_records(
5976				(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5977				i, le32_to_cpu(rec.t_start), num_clusters);
5978
5979			status = ocfs2_free_clusters(handle, data_alloc_inode,
5980						     data_alloc_bh, start_blk,
5981						     num_clusters);
5982			if (status < 0) {
5983				ocfs2_commit_trans(osb, handle);
5984				mlog_errno(status);
5985				goto bail;
5986			}
5987		}
5988
5989		ocfs2_commit_trans(osb, handle);
5990		i--;
5991	}
5992
5993	osb->truncated_clusters = 0;
5994
5995bail:
5996	return status;
5997}
5998
5999/* Expects you to already be holding tl_inode->i_rwsem */
6000int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6001{
6002	int status;
6003	unsigned int num_to_flush;
6004	struct inode *tl_inode = osb->osb_tl_inode;
6005	struct inode *data_alloc_inode = NULL;
6006	struct buffer_head *tl_bh = osb->osb_tl_bh;
6007	struct buffer_head *data_alloc_bh = NULL;
6008	struct ocfs2_dinode *di;
6009	struct ocfs2_truncate_log *tl;
6010	struct ocfs2_journal *journal = osb->journal;
6011
6012	BUG_ON(inode_trylock(tl_inode));
6013
6014	di = (struct ocfs2_dinode *) tl_bh->b_data;
6015
6016	/* tl_bh is loaded from ocfs2_truncate_log_init().  It's validated
6017	 * by the underlying call to ocfs2_read_inode_block(), so any
6018	 * corruption is a code bug */
6019	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6020
6021	tl = &di->id2.i_dealloc;
6022	num_to_flush = le16_to_cpu(tl->tl_used);
6023	trace_ocfs2_flush_truncate_log(
6024		(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
6025		num_to_flush);
6026	if (!num_to_flush) {
6027		status = 0;
6028		goto out;
6029	}
6030
6031	/* Appending truncate log(TA) and flushing truncate log(TF) are
6032	 * two separated transactions. They can be both committed but not
6033	 * checkpointed. If crash occurs then, both two transaction will be
6034	 * replayed with several already released to global bitmap clusters.
6035	 * Then truncate log will be replayed resulting in cluster double free.
6036	 */
6037	jbd2_journal_lock_updates(journal->j_journal);
6038	status = jbd2_journal_flush(journal->j_journal, 0);
6039	jbd2_journal_unlock_updates(journal->j_journal);
6040	if (status < 0) {
6041		mlog_errno(status);
6042		goto out;
6043	}
6044
6045	data_alloc_inode = ocfs2_get_system_file_inode(osb,
6046						       GLOBAL_BITMAP_SYSTEM_INODE,
6047						       OCFS2_INVALID_SLOT);
6048	if (!data_alloc_inode) {
6049		status = -EINVAL;
6050		mlog(ML_ERROR, "Could not get bitmap inode!\n");
6051		goto out;
6052	}
6053
6054	inode_lock(data_alloc_inode);
6055
6056	status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
6057	if (status < 0) {
6058		mlog_errno(status);
6059		goto out_mutex;
6060	}
6061
6062	status = ocfs2_replay_truncate_records(osb, data_alloc_inode,
6063					       data_alloc_bh);
6064	if (status < 0)
6065		mlog_errno(status);
6066
6067	brelse(data_alloc_bh);
6068	ocfs2_inode_unlock(data_alloc_inode, 1);
6069
6070out_mutex:
6071	inode_unlock(data_alloc_inode);
6072	iput(data_alloc_inode);
6073
6074out:
6075	return status;
6076}
6077
6078int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6079{
6080	int status;
6081	struct inode *tl_inode = osb->osb_tl_inode;
6082
6083	inode_lock(tl_inode);
6084	status = __ocfs2_flush_truncate_log(osb);
6085	inode_unlock(tl_inode);
6086
6087	return status;
6088}
6089
6090static void ocfs2_truncate_log_worker(struct work_struct *work)
6091{
6092	int status;
6093	struct ocfs2_super *osb =
6094		container_of(work, struct ocfs2_super,
6095			     osb_truncate_log_wq.work);
6096
6097	status = ocfs2_flush_truncate_log(osb);
6098	if (status < 0)
6099		mlog_errno(status);
6100	else
6101		ocfs2_init_steal_slots(osb);
6102}
6103
6104#define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
6105void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
6106				       int cancel)
6107{
6108	if (osb->osb_tl_inode &&
6109			atomic_read(&osb->osb_tl_disable) == 0) {
6110		/* We want to push off log flushes while truncates are
6111		 * still running. */
6112		if (cancel)
6113			cancel_delayed_work(&osb->osb_truncate_log_wq);
6114
6115		queue_delayed_work(osb->ocfs2_wq, &osb->osb_truncate_log_wq,
6116				   OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
6117	}
6118}
6119
6120/*
6121 * Try to flush truncate logs if we can free enough clusters from it.
6122 * As for return value, "< 0" means error, "0" no space and "1" means
6123 * we have freed enough spaces and let the caller try to allocate again.
6124 */
6125int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb,
6126					unsigned int needed)
6127{
6128	tid_t target;
6129	int ret = 0;
6130	unsigned int truncated_clusters;
6131
6132	inode_lock(osb->osb_tl_inode);
6133	truncated_clusters = osb->truncated_clusters;
6134	inode_unlock(osb->osb_tl_inode);
6135
6136	/*
6137	 * Check whether we can succeed in allocating if we free
6138	 * the truncate log.
6139	 */
6140	if (truncated_clusters < needed)
6141		goto out;
6142
6143	ret = ocfs2_flush_truncate_log(osb);
6144	if (ret) {
6145		mlog_errno(ret);
6146		goto out;
6147	}
6148
6149	if (jbd2_journal_start_commit(osb->journal->j_journal, &target)) {
6150		jbd2_log_wait_commit(osb->journal->j_journal, target);
6151		ret = 1;
6152	}
6153out:
6154	return ret;
6155}
6156
6157static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
6158				       int slot_num,
6159				       struct inode **tl_inode,
6160				       struct buffer_head **tl_bh)
6161{
6162	int status;
6163	struct inode *inode = NULL;
6164	struct buffer_head *bh = NULL;
6165	struct ocfs2_dinode *di;
6166	struct ocfs2_truncate_log *tl;
6167	unsigned int tl_count, tl_used;
6168
6169	inode = ocfs2_get_system_file_inode(osb,
6170					   TRUNCATE_LOG_SYSTEM_INODE,
6171					   slot_num);
6172	if (!inode) {
6173		status = -EINVAL;
6174		mlog(ML_ERROR, "Could not get load truncate log inode!\n");
6175		goto bail;
6176	}
6177
6178	status = ocfs2_read_inode_block(inode, &bh);
6179	if (status < 0) {
6180		iput(inode);
6181		mlog_errno(status);
6182		goto bail;
6183	}
6184
6185	di = (struct ocfs2_dinode *)bh->b_data;
6186	tl = &di->id2.i_dealloc;
6187	tl_count = le16_to_cpu(tl->tl_count);
6188	tl_used = le16_to_cpu(tl->tl_used);
6189	if (unlikely(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
6190		     tl_count == 0 ||
6191		     tl_used > tl_count)) {
6192		status = -EFSCORRUPTED;
6193		iput(inode);
6194		brelse(bh);
6195		mlog_errno(status);
6196		goto bail;
6197	}
6198
6199	*tl_inode = inode;
6200	*tl_bh    = bh;
6201bail:
6202	return status;
6203}
6204
6205/* called during the 1st stage of node recovery. we stamp a clean
6206 * truncate log and pass back a copy for processing later. if the
6207 * truncate log does not require processing, a *tl_copy is set to
6208 * NULL. */
6209int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
6210				      int slot_num,
6211				      struct ocfs2_dinode **tl_copy)
6212{
6213	int status;
6214	struct inode *tl_inode = NULL;
6215	struct buffer_head *tl_bh = NULL;
6216	struct ocfs2_dinode *di;
6217	struct ocfs2_truncate_log *tl;
6218
6219	*tl_copy = NULL;
6220
6221	trace_ocfs2_begin_truncate_log_recovery(slot_num);
6222
6223	status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
6224	if (status < 0) {
6225		mlog_errno(status);
6226		goto bail;
6227	}
6228
6229	di = (struct ocfs2_dinode *) tl_bh->b_data;
6230
6231	/* tl_bh is loaded from ocfs2_get_truncate_log_info().  It's
6232	 * validated by the underlying call to ocfs2_read_inode_block(),
6233	 * so any corruption is a code bug */
6234	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6235
6236	tl = &di->id2.i_dealloc;
6237	if (le16_to_cpu(tl->tl_used)) {
6238		trace_ocfs2_truncate_log_recovery_num(le16_to_cpu(tl->tl_used));
6239
6240		/*
6241		 * Assuming the write-out below goes well, this copy will be
6242		 * passed back to recovery for processing.
6243		 */
6244		*tl_copy = kmemdup(tl_bh->b_data, tl_bh->b_size, GFP_KERNEL);
6245		if (!(*tl_copy)) {
6246			status = -ENOMEM;
6247			mlog_errno(status);
6248			goto bail;
6249		}
6250
6251		/* All we need to do to clear the truncate log is set
6252		 * tl_used. */
6253		tl->tl_used = 0;
6254
6255		ocfs2_compute_meta_ecc(osb->sb, tl_bh->b_data, &di->i_check);
6256		status = ocfs2_write_block(osb, tl_bh, INODE_CACHE(tl_inode));
6257		if (status < 0) {
6258			mlog_errno(status);
6259			goto bail;
6260		}
6261	}
6262
6263bail:
6264	iput(tl_inode);
6265	brelse(tl_bh);
6266
6267	if (status < 0) {
6268		kfree(*tl_copy);
6269		*tl_copy = NULL;
6270		mlog_errno(status);
6271	}
6272
6273	return status;
6274}
6275
6276int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
6277					 struct ocfs2_dinode *tl_copy)
6278{
6279	int status = 0;
6280	int i;
6281	unsigned int clusters, num_recs, start_cluster;
6282	u64 start_blk;
6283	handle_t *handle;
6284	struct inode *tl_inode = osb->osb_tl_inode;
6285	struct ocfs2_truncate_log *tl;
6286
6287	if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
6288		mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
6289		return -EINVAL;
6290	}
6291
6292	tl = &tl_copy->id2.i_dealloc;
6293	num_recs = le16_to_cpu(tl->tl_used);
6294	trace_ocfs2_complete_truncate_log_recovery(
6295		(unsigned long long)le64_to_cpu(tl_copy->i_blkno),
6296		num_recs);
6297
6298	inode_lock(tl_inode);
6299	for(i = 0; i < num_recs; i++) {
6300		if (ocfs2_truncate_log_needs_flush(osb)) {
6301			status = __ocfs2_flush_truncate_log(osb);
6302			if (status < 0) {
6303				mlog_errno(status);
6304				goto bail_up;
6305			}
6306		}
6307
6308		handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6309		if (IS_ERR(handle)) {
6310			status = PTR_ERR(handle);
6311			mlog_errno(status);
6312			goto bail_up;
6313		}
6314
6315		clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
6316		start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
6317		start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
6318
6319		status = ocfs2_truncate_log_append(osb, handle,
6320						   start_blk, clusters);
6321		ocfs2_commit_trans(osb, handle);
6322		if (status < 0) {
6323			mlog_errno(status);
6324			goto bail_up;
6325		}
6326	}
6327
6328bail_up:
6329	inode_unlock(tl_inode);
6330
6331	return status;
6332}
6333
6334void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
6335{
6336	int status;
6337	struct inode *tl_inode = osb->osb_tl_inode;
6338
6339	atomic_set(&osb->osb_tl_disable, 1);
6340
6341	if (tl_inode) {
6342		cancel_delayed_work(&osb->osb_truncate_log_wq);
6343		flush_workqueue(osb->ocfs2_wq);
6344
6345		status = ocfs2_flush_truncate_log(osb);
6346		if (status < 0)
6347			mlog_errno(status);
6348
6349		brelse(osb->osb_tl_bh);
6350		iput(osb->osb_tl_inode);
6351	}
6352}
6353
6354int ocfs2_truncate_log_init(struct ocfs2_super *osb)
6355{
6356	int status;
6357	struct inode *tl_inode = NULL;
6358	struct buffer_head *tl_bh = NULL;
6359
6360	status = ocfs2_get_truncate_log_info(osb,
6361					     osb->slot_num,
6362					     &tl_inode,
6363					     &tl_bh);
6364	if (status < 0)
6365		mlog_errno(status);
6366
6367	/* ocfs2_truncate_log_shutdown keys on the existence of
6368	 * osb->osb_tl_inode so we don't set any of the osb variables
6369	 * until we're sure all is well. */
6370	INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
6371			  ocfs2_truncate_log_worker);
6372	atomic_set(&osb->osb_tl_disable, 0);
6373	osb->osb_tl_bh    = tl_bh;
6374	osb->osb_tl_inode = tl_inode;
6375
6376	return status;
6377}
6378
6379/*
6380 * Delayed de-allocation of suballocator blocks.
6381 *
6382 * Some sets of block de-allocations might involve multiple suballocator inodes.
6383 *
6384 * The locking for this can get extremely complicated, especially when
6385 * the suballocator inodes to delete from aren't known until deep
6386 * within an unrelated codepath.
6387 *
6388 * ocfs2_extent_block structures are a good example of this - an inode
6389 * btree could have been grown by any number of nodes each allocating
6390 * out of their own suballoc inode.
6391 *
6392 * These structures allow the delay of block de-allocation until a
6393 * later time, when locking of multiple cluster inodes won't cause
6394 * deadlock.
6395 */
6396
6397/*
6398 * Describe a single bit freed from a suballocator.  For the block
6399 * suballocators, it represents one block.  For the global cluster
6400 * allocator, it represents some clusters and free_bit indicates
6401 * clusters number.
6402 */
6403struct ocfs2_cached_block_free {
6404	struct ocfs2_cached_block_free		*free_next;
6405	u64					free_bg;
6406	u64					free_blk;
6407	unsigned int				free_bit;
6408};
6409
6410struct ocfs2_per_slot_free_list {
6411	struct ocfs2_per_slot_free_list		*f_next_suballocator;
6412	int					f_inode_type;
6413	int					f_slot;
6414	struct ocfs2_cached_block_free		*f_first;
6415};
6416
6417static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
6418				    int sysfile_type,
6419				    int slot,
6420				    struct ocfs2_cached_block_free *head)
6421{
6422	int ret;
6423	u64 bg_blkno;
6424	handle_t *handle;
6425	struct inode *inode;
6426	struct buffer_head *di_bh = NULL;
6427	struct ocfs2_cached_block_free *tmp;
6428
6429	inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
6430	if (!inode) {
6431		ret = -EINVAL;
6432		mlog_errno(ret);
6433		goto out;
6434	}
6435
6436	inode_lock(inode);
6437
6438	ret = ocfs2_inode_lock(inode, &di_bh, 1);
6439	if (ret) {
6440		mlog_errno(ret);
6441		goto out_mutex;
6442	}
6443
6444	while (head) {
6445		if (head->free_bg)
6446			bg_blkno = head->free_bg;
6447		else
6448			bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
6449							      head->free_bit);
6450		handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
6451		if (IS_ERR(handle)) {
6452			ret = PTR_ERR(handle);
6453			mlog_errno(ret);
6454			goto out_unlock;
6455		}
6456
6457		trace_ocfs2_free_cached_blocks(
6458		     (unsigned long long)head->free_blk, head->free_bit);
6459
6460		ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
6461					       head->free_bit, bg_blkno, 1);
6462		if (ret)
6463			mlog_errno(ret);
6464
6465		ocfs2_commit_trans(osb, handle);
6466
6467		tmp = head;
6468		head = head->free_next;
6469		kfree(tmp);
6470	}
6471
6472out_unlock:
6473	ocfs2_inode_unlock(inode, 1);
6474	brelse(di_bh);
6475out_mutex:
6476	inode_unlock(inode);
6477	iput(inode);
6478out:
6479	while(head) {
6480		/* Premature exit may have left some dangling items. */
6481		tmp = head;
6482		head = head->free_next;
6483		kfree(tmp);
6484	}
6485
6486	return ret;
6487}
6488
6489int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6490				u64 blkno, unsigned int bit)
6491{
6492	int ret = 0;
6493	struct ocfs2_cached_block_free *item;
6494
6495	item = kzalloc(sizeof(*item), GFP_NOFS);
6496	if (item == NULL) {
6497		ret = -ENOMEM;
6498		mlog_errno(ret);
6499		return ret;
6500	}
6501
6502	trace_ocfs2_cache_cluster_dealloc((unsigned long long)blkno, bit);
6503
6504	item->free_blk = blkno;
6505	item->free_bit = bit;
6506	item->free_next = ctxt->c_global_allocator;
6507
6508	ctxt->c_global_allocator = item;
6509	return ret;
6510}
6511
6512static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
6513				      struct ocfs2_cached_block_free *head)
6514{
6515	struct ocfs2_cached_block_free *tmp;
6516	struct inode *tl_inode = osb->osb_tl_inode;
6517	handle_t *handle;
6518	int ret = 0;
6519
6520	inode_lock(tl_inode);
6521
6522	while (head) {
6523		if (ocfs2_truncate_log_needs_flush(osb)) {
6524			ret = __ocfs2_flush_truncate_log(osb);
6525			if (ret < 0) {
6526				mlog_errno(ret);
6527				break;
6528			}
6529		}
6530
6531		handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6532		if (IS_ERR(handle)) {
6533			ret = PTR_ERR(handle);
6534			mlog_errno(ret);
6535			break;
6536		}
6537
6538		ret = ocfs2_truncate_log_append(osb, handle, head->free_blk,
6539						head->free_bit);
6540
6541		ocfs2_commit_trans(osb, handle);
6542		tmp = head;
6543		head = head->free_next;
6544		kfree(tmp);
6545
6546		if (ret < 0) {
6547			mlog_errno(ret);
6548			break;
6549		}
6550	}
6551
6552	inode_unlock(tl_inode);
6553
6554	while (head) {
6555		/* Premature exit may have left some dangling items. */
6556		tmp = head;
6557		head = head->free_next;
6558		kfree(tmp);
6559	}
6560
6561	return ret;
6562}
6563
6564int ocfs2_run_deallocs(struct ocfs2_super *osb,
6565		       struct ocfs2_cached_dealloc_ctxt *ctxt)
6566{
6567	int ret = 0, ret2;
6568	struct ocfs2_per_slot_free_list *fl;
6569
6570	if (!ctxt)
6571		return 0;
6572
6573	while (ctxt->c_first_suballocator) {
6574		fl = ctxt->c_first_suballocator;
6575
6576		if (fl->f_first) {
6577			trace_ocfs2_run_deallocs(fl->f_inode_type,
6578						 fl->f_slot);
6579			ret2 = ocfs2_free_cached_blocks(osb,
6580							fl->f_inode_type,
6581							fl->f_slot,
6582							fl->f_first);
6583			if (ret2)
6584				mlog_errno(ret2);
6585			if (!ret)
6586				ret = ret2;
6587		}
6588
6589		ctxt->c_first_suballocator = fl->f_next_suballocator;
6590		kfree(fl);
6591	}
6592
6593	if (ctxt->c_global_allocator) {
6594		ret2 = ocfs2_free_cached_clusters(osb,
6595						  ctxt->c_global_allocator);
6596		if (ret2)
6597			mlog_errno(ret2);
6598		if (!ret)
6599			ret = ret2;
6600
6601		ctxt->c_global_allocator = NULL;
6602	}
6603
6604	return ret;
6605}
6606
6607static struct ocfs2_per_slot_free_list *
6608ocfs2_find_per_slot_free_list(int type,
6609			      int slot,
6610			      struct ocfs2_cached_dealloc_ctxt *ctxt)
6611{
6612	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6613
6614	while (fl) {
6615		if (fl->f_inode_type == type && fl->f_slot == slot)
6616			return fl;
6617
6618		fl = fl->f_next_suballocator;
6619	}
6620
6621	fl = kmalloc(sizeof(*fl), GFP_NOFS);
6622	if (fl) {
6623		fl->f_inode_type = type;
6624		fl->f_slot = slot;
6625		fl->f_first = NULL;
6626		fl->f_next_suballocator = ctxt->c_first_suballocator;
6627
6628		ctxt->c_first_suballocator = fl;
6629	}
6630	return fl;
6631}
6632
6633static struct ocfs2_per_slot_free_list *
6634ocfs2_find_preferred_free_list(int type,
6635			       int preferred_slot,
6636			       int *real_slot,
6637			       struct ocfs2_cached_dealloc_ctxt *ctxt)
6638{
6639	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6640
6641	while (fl) {
6642		if (fl->f_inode_type == type && fl->f_slot == preferred_slot) {
6643			*real_slot = fl->f_slot;
6644			return fl;
6645		}
6646
6647		fl = fl->f_next_suballocator;
6648	}
6649
6650	/* If we can't find any free list matching preferred slot, just use
6651	 * the first one.
6652	 */
6653	fl = ctxt->c_first_suballocator;
6654	*real_slot = fl->f_slot;
6655
6656	return fl;
6657}
6658
6659/* Return Value 1 indicates empty */
6660static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et)
6661{
6662	struct ocfs2_per_slot_free_list *fl = NULL;
6663
6664	if (!et->et_dealloc)
6665		return 1;
6666
6667	fl = et->et_dealloc->c_first_suballocator;
6668	if (!fl)
6669		return 1;
6670
6671	if (!fl->f_first)
6672		return 1;
6673
6674	return 0;
6675}
6676
6677/* If extent was deleted from tree due to extent rotation and merging, and
6678 * no metadata is reserved ahead of time. Try to reuse some extents
6679 * just deleted. This is only used to reuse extent blocks.
6680 * It is supposed to find enough extent blocks in dealloc if our estimation
6681 * on metadata is accurate.
6682 */
6683static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
6684					struct ocfs2_extent_tree *et,
6685					struct buffer_head **new_eb_bh,
6686					int blk_wanted, int *blk_given)
6687{
6688	int i, status = 0, real_slot;
6689	struct ocfs2_cached_dealloc_ctxt *dealloc;
6690	struct ocfs2_per_slot_free_list *fl;
6691	struct ocfs2_cached_block_free *bf;
6692	struct ocfs2_extent_block *eb;
6693	struct ocfs2_super *osb =
6694		OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
6695
6696	*blk_given = 0;
6697
6698	/* If extent tree doesn't have a dealloc, this is not faulty. Just
6699	 * tell upper caller dealloc can't provide any block and it should
6700	 * ask for alloc to claim more space.
6701	 */
6702	dealloc = et->et_dealloc;
6703	if (!dealloc)
6704		goto bail;
6705
6706	for (i = 0; i < blk_wanted; i++) {
6707		/* Prefer to use local slot */
6708		fl = ocfs2_find_preferred_free_list(EXTENT_ALLOC_SYSTEM_INODE,
6709						    osb->slot_num, &real_slot,
6710						    dealloc);
6711		/* If no more block can be reused, we should claim more
6712		 * from alloc. Just return here normally.
6713		 */
6714		if (!fl) {
6715			status = 0;
6716			break;
6717		}
6718
6719		bf = fl->f_first;
6720		fl->f_first = bf->free_next;
6721
6722		new_eb_bh[i] = sb_getblk(osb->sb, bf->free_blk);
6723		if (new_eb_bh[i] == NULL) {
6724			status = -ENOMEM;
6725			mlog_errno(status);
6726			goto bail;
6727		}
6728
6729		mlog(0, "Reusing block(%llu) from "
6730		     "dealloc(local slot:%d, real slot:%d)\n",
6731		     bf->free_blk, osb->slot_num, real_slot);
6732
6733		ocfs2_set_new_buffer_uptodate(et->et_ci, new_eb_bh[i]);
6734
6735		status = ocfs2_journal_access_eb(handle, et->et_ci,
6736						 new_eb_bh[i],
6737						 OCFS2_JOURNAL_ACCESS_CREATE);
6738		if (status < 0) {
6739			mlog_errno(status);
6740			goto bail;
6741		}
6742
6743		memset(new_eb_bh[i]->b_data, 0, osb->sb->s_blocksize);
6744		eb = (struct ocfs2_extent_block *) new_eb_bh[i]->b_data;
6745
6746		/* We can't guarantee that buffer head is still cached, so
6747		 * polutlate the extent block again.
6748		 */
6749		strscpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
6750		eb->h_blkno = cpu_to_le64(bf->free_blk);
6751		eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
6752		eb->h_suballoc_slot = cpu_to_le16(real_slot);
6753		eb->h_suballoc_loc = cpu_to_le64(bf->free_bg);
6754		eb->h_suballoc_bit = cpu_to_le16(bf->free_bit);
6755		eb->h_list.l_count =
6756			cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
6757
6758		/* We'll also be dirtied by the caller, so
6759		 * this isn't absolutely necessary.
6760		 */
6761		ocfs2_journal_dirty(handle, new_eb_bh[i]);
6762
6763		if (!fl->f_first) {
6764			dealloc->c_first_suballocator = fl->f_next_suballocator;
6765			kfree(fl);
6766		}
6767		kfree(bf);
6768	}
6769
6770	*blk_given = i;
6771
6772bail:
6773	if (unlikely(status < 0)) {
6774		for (i = 0; i < blk_wanted; i++)
6775			brelse(new_eb_bh[i]);
6776	}
6777
6778	return status;
6779}
6780
6781int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6782			      int type, int slot, u64 suballoc,
6783			      u64 blkno, unsigned int bit)
6784{
6785	int ret;
6786	struct ocfs2_per_slot_free_list *fl;
6787	struct ocfs2_cached_block_free *item;
6788
6789	fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
6790	if (fl == NULL) {
6791		ret = -ENOMEM;
6792		mlog_errno(ret);
6793		goto out;
6794	}
6795
6796	item = kzalloc(sizeof(*item), GFP_NOFS);
6797	if (item == NULL) {
6798		ret = -ENOMEM;
6799		mlog_errno(ret);
6800		goto out;
6801	}
6802
6803	trace_ocfs2_cache_block_dealloc(type, slot,
6804					(unsigned long long)suballoc,
6805					(unsigned long long)blkno, bit);
6806
6807	item->free_bg = suballoc;
6808	item->free_blk = blkno;
6809	item->free_bit = bit;
6810	item->free_next = fl->f_first;
6811
6812	fl->f_first = item;
6813
6814	ret = 0;
6815out:
6816	return ret;
6817}
6818
6819static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
6820					 struct ocfs2_extent_block *eb)
6821{
6822	return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
6823					 le16_to_cpu(eb->h_suballoc_slot),
6824					 le64_to_cpu(eb->h_suballoc_loc),
6825					 le64_to_cpu(eb->h_blkno),
6826					 le16_to_cpu(eb->h_suballoc_bit));
6827}
6828
6829static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
6830{
6831	set_buffer_uptodate(bh);
6832	mark_buffer_dirty(bh);
6833	return 0;
6834}
6835
6836void ocfs2_map_and_dirty_folio(struct inode *inode, handle_t *handle,
6837		size_t from, size_t to, struct folio *folio, int zero,
6838		u64 *phys)
6839{
6840	int ret, partial = 0;
6841	loff_t start_byte = folio_pos(folio) + from;
6842	loff_t length = to - from;
6843
6844	ret = ocfs2_map_folio_blocks(folio, phys, inode, from, to, 0);
6845	if (ret)
6846		mlog_errno(ret);
6847
6848	if (zero)
6849		folio_zero_segment(folio, from, to);
6850
6851	/*
6852	 * Need to set the buffers we zero'd into uptodate
6853	 * here if they aren't - ocfs2_map_page_blocks()
6854	 * might've skipped some
6855	 */
6856	ret = walk_page_buffers(handle, folio_buffers(folio),
6857				from, to, &partial,
6858				ocfs2_zero_func);
6859	if (ret < 0)
6860		mlog_errno(ret);
6861	else if (ocfs2_should_order_data(inode)) {
6862		ret = ocfs2_jbd2_inode_add_write(handle, inode,
6863						 start_byte, length);
6864		if (ret < 0)
6865			mlog_errno(ret);
6866	}
6867
6868	if (!partial)
6869		folio_mark_uptodate(folio);
6870
6871	flush_dcache_folio(folio);
6872}
6873
6874static void ocfs2_zero_cluster_folios(struct inode *inode, loff_t start,
6875		loff_t end, struct folio **folios, int numfolios,
6876		u64 phys, handle_t *handle)
6877{
6878	int i;
6879	struct super_block *sb = inode->i_sb;
6880
6881	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
6882
6883	if (numfolios == 0)
6884		goto out;
6885
6886	for (i = 0; i < numfolios; i++) {
6887		struct folio *folio = folios[i];
6888		size_t to = folio_size(folio);
6889		size_t from = offset_in_folio(folio, start);
6890
6891		if (to > end - folio_pos(folio))
6892			to = end - folio_pos(folio);
6893
6894		ocfs2_map_and_dirty_folio(inode, handle, from, to, folio, 1,
6895				&phys);
6896
6897		start = folio_next_pos(folio);
6898	}
6899out:
6900	if (folios)
6901		ocfs2_unlock_and_free_folios(folios, numfolios);
6902}
6903
6904static int ocfs2_grab_folios(struct inode *inode, loff_t start, loff_t end,
6905		struct folio **folios, int *num)
6906{
6907	int numfolios, ret = 0;
6908	struct address_space *mapping = inode->i_mapping;
6909	unsigned long index;
6910	loff_t last_page_bytes;
6911
6912	BUG_ON(start > end);
6913
6914	numfolios = 0;
6915	last_page_bytes = PAGE_ALIGN(end);
6916	index = start >> PAGE_SHIFT;
6917	do {
6918		folios[numfolios] = __filemap_get_folio(mapping, index,
6919				FGP_LOCK | FGP_ACCESSED | FGP_CREAT, GFP_NOFS);
6920		if (IS_ERR(folios[numfolios])) {
6921			ret = PTR_ERR(folios[numfolios]);
6922			mlog_errno(ret);
6923			folios[numfolios] = NULL;
6924			goto out;
6925		}
6926
6927		index = folio_next_index(folios[numfolios]);
6928		numfolios++;
6929	} while (index < (last_page_bytes >> PAGE_SHIFT));
6930
6931out:
6932	if (ret != 0) {
6933		ocfs2_unlock_and_free_folios(folios, numfolios);
6934		numfolios = 0;
6935	}
6936
6937	*num = numfolios;
6938
6939	return ret;
6940}
6941
6942static int ocfs2_grab_eof_folios(struct inode *inode, loff_t start, loff_t end,
6943				struct folio **folios, int *num)
6944{
6945	struct super_block *sb = inode->i_sb;
6946
6947	BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
6948	       (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
6949
6950	return ocfs2_grab_folios(inode, start, end, folios, num);
6951}
6952
6953/*
6954 * Zero partial cluster for a hole punch or truncate. This avoids exposing
6955 * nonzero data on subsequent file extends.
6956 *
6957 * We need to call this before i_size is updated on the inode because
6958 * otherwise block_write_full_folio() will skip writeout of pages past
6959 * i_size.
6960 */
6961int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
6962				  u64 range_start, u64 range_end)
6963{
6964	int ret = 0, numfolios;
6965	struct folio **folios = NULL;
6966	u64 phys;
6967	unsigned int ext_flags;
6968	struct super_block *sb = inode->i_sb;
6969
6970	/*
6971	 * File systems which don't support sparse files zero on every
6972	 * extend.
6973	 */
6974	if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
6975		return 0;
6976
6977	/*
6978	 * Avoid zeroing folios fully beyond current i_size. It is pointless as
6979	 * underlying blocks of those folios should be already zeroed out and
6980	 * page writeback will skip them anyway.
6981	 */
6982	range_end = min_t(u64, range_end, i_size_read(inode));
6983	if (range_start >= range_end)
6984		return 0;
6985
6986	folios = kcalloc(ocfs2_pages_per_cluster(sb),
6987			sizeof(struct folio *), GFP_NOFS);
6988	if (folios == NULL) {
6989		ret = -ENOMEM;
6990		mlog_errno(ret);
6991		goto out;
6992	}
6993
6994	ret = ocfs2_extent_map_get_blocks(inode,
6995					  range_start >> sb->s_blocksize_bits,
6996					  &phys, NULL, &ext_flags);
6997	if (ret) {
6998		mlog_errno(ret);
6999		goto out;
7000	}
7001
7002	/*
7003	 * Tail is a hole, or is marked unwritten. In either case, we
7004	 * can count on read and write to return/push zero's.
7005	 */
7006	if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
7007		goto out;
7008
7009	ret = ocfs2_grab_eof_folios(inode, range_start, range_end, folios,
7010				   &numfolios);
7011	if (ret) {
7012		mlog_errno(ret);
7013		goto out;
7014	}
7015
7016	ocfs2_zero_cluster_folios(inode, range_start, range_end, folios,
7017				 numfolios, phys, handle);
7018
7019	/*
7020	 * Initiate writeout of the folios we zero'd here. We don't
7021	 * wait on them - the truncate_inode_pages() call later will
7022	 * do that for us.
7023	 */
7024	ret = filemap_fdatawrite_range(inode->i_mapping, range_start,
7025				       range_end - 1);
7026	if (ret)
7027		mlog_errno(ret);
7028
7029out:
7030	kfree(folios);
7031
7032	return ret;
7033}
7034
7035static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
7036					     struct ocfs2_dinode *di)
7037{
7038	unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
7039	unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
7040
7041	if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
7042		memset(&di->id2, 0, blocksize -
7043				    offsetof(struct ocfs2_dinode, id2) -
7044				    xattrsize);
7045	else
7046		memset(&di->id2, 0, blocksize -
7047				    offsetof(struct ocfs2_dinode, id2));
7048}
7049
7050void ocfs2_dinode_new_extent_list(struct inode *inode,
7051				  struct ocfs2_dinode *di)
7052{
7053	ocfs2_zero_dinode_id2_with_xattr(inode, di);
7054	di->id2.i_list.l_tree_depth = 0;
7055	di->id2.i_list.l_next_free_rec = 0;
7056	di->id2.i_list.l_count = cpu_to_le16(
7057		ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
7058}
7059
7060void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
7061{
7062	struct ocfs2_inode_info *oi = OCFS2_I(inode);
7063	struct ocfs2_inline_data *idata = &di->id2.i_data;
7064
7065	spin_lock(&oi->ip_lock);
7066	oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
7067	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7068	spin_unlock(&oi->ip_lock);
7069
7070	/*
7071	 * We clear the entire i_data structure here so that all
7072	 * fields can be properly initialized.
7073	 */
7074	ocfs2_zero_dinode_id2_with_xattr(inode, di);
7075
7076	idata->id_count = cpu_to_le16(
7077			ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
7078}
7079
7080int ocfs2_convert_inline_data_to_extents(struct inode *inode,
7081					 struct buffer_head *di_bh)
7082{
7083	int ret, has_data, num_folios = 0;
7084	int need_free = 0;
7085	u32 bit_off, num;
7086	handle_t *handle;
7087	u64 block;
7088	struct ocfs2_inode_info *oi = OCFS2_I(inode);
7089	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7090	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7091	struct ocfs2_alloc_context *data_ac = NULL;
7092	struct folio *folio = NULL;
7093	struct ocfs2_extent_tree et;
7094	int did_quota = 0;
7095
7096	has_data = i_size_read(inode) ? 1 : 0;
7097
7098	if (has_data) {
7099		ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
7100		if (ret) {
7101			mlog_errno(ret);
7102			goto out;
7103		}
7104	}
7105
7106	handle = ocfs2_start_trans(osb,
7107				   ocfs2_inline_to_extents_credits(osb->sb));
7108	if (IS_ERR(handle)) {
7109		ret = PTR_ERR(handle);
7110		mlog_errno(ret);
7111		goto out;
7112	}
7113
7114	ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7115				      OCFS2_JOURNAL_ACCESS_WRITE);
7116	if (ret) {
7117		mlog_errno(ret);
7118		goto out_commit;
7119	}
7120
7121	if (has_data) {
7122		unsigned int page_end = min_t(unsigned, PAGE_SIZE,
7123							osb->s_clustersize);
7124		u64 phys;
7125
7126		ret = dquot_alloc_space_nodirty(inode,
7127				       ocfs2_clusters_to_bytes(osb->sb, 1));
7128		if (ret)
7129			goto out_commit;
7130		did_quota = 1;
7131
7132		data_ac->ac_resv = &oi->ip_la_data_resv;
7133
7134		ret = ocfs2_claim_clusters(handle, data_ac, 1, &bit_off,
7135					   &num);
7136		if (ret) {
7137			mlog_errno(ret);
7138			goto out_commit;
7139		}
7140
7141		/*
7142		 * Save two copies, one for insert, and one that can
7143		 * be changed by ocfs2_map_and_dirty_folio() below.
7144		 */
7145		block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
7146
7147		ret = ocfs2_grab_eof_folios(inode, 0, page_end, &folio,
7148					   &num_folios);
7149		if (ret) {
7150			mlog_errno(ret);
7151			need_free = 1;
7152			goto out_commit;
7153		}
7154
7155		/*
7156		 * This should populate the 1st page for us and mark
7157		 * it up to date.
7158		 */
7159		ret = ocfs2_read_inline_data(inode, folio, di_bh);
7160		if (ret) {
7161			mlog_errno(ret);
7162			need_free = 1;
7163			goto out_unlock;
7164		}
7165
7166		ocfs2_map_and_dirty_folio(inode, handle, 0, page_end, folio, 0,
7167				&phys);
7168	}
7169
7170	spin_lock(&oi->ip_lock);
7171	oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
7172	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7173	spin_unlock(&oi->ip_lock);
7174
7175	ocfs2_update_inode_fsync_trans(handle, inode, 1);
7176	ocfs2_dinode_new_extent_list(inode, di);
7177
7178	ocfs2_journal_dirty(handle, di_bh);
7179
7180	if (has_data) {
7181		/*
7182		 * An error at this point should be extremely rare. If
7183		 * this proves to be false, we could always re-build
7184		 * the in-inode data from our pages.
7185		 */
7186		ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7187		ret = ocfs2_insert_extent(handle, &et, 0, block, 1, 0, NULL);
7188		if (ret) {
7189			mlog_errno(ret);
7190			need_free = 1;
7191			goto out_unlock;
7192		}
7193
7194		inode->i_blocks = ocfs2_inode_sector_count(inode);
7195	}
7196
7197out_unlock:
7198	if (folio)
7199		ocfs2_unlock_and_free_folios(&folio, num_folios);
7200
7201out_commit:
7202	if (ret < 0 && did_quota)
7203		dquot_free_space_nodirty(inode,
7204					  ocfs2_clusters_to_bytes(osb->sb, 1));
7205
7206	if (need_free) {
7207		if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
7208			ocfs2_free_local_alloc_bits(osb, handle, data_ac,
7209					bit_off, num);
7210		else
7211			ocfs2_free_clusters(handle,
7212					data_ac->ac_inode,
7213					data_ac->ac_bh,
7214					ocfs2_clusters_to_blocks(osb->sb, bit_off),
7215					num);
7216	}
7217
7218	ocfs2_commit_trans(osb, handle);
7219
7220out:
7221	if (data_ac)
7222		ocfs2_free_alloc_context(data_ac);
7223	return ret;
7224}
7225
7226/*
7227 * It is expected, that by the time you call this function,
7228 * inode->i_size and fe->i_size have been adjusted.
7229 *
7230 * WARNING: This will kfree the truncate context
7231 */
7232int ocfs2_commit_truncate(struct ocfs2_super *osb,
7233			  struct inode *inode,
7234			  struct buffer_head *di_bh)
7235{
7236	int status = 0, i, flags = 0;
7237	u32 new_highest_cpos, range, trunc_cpos, trunc_len, phys_cpos, coff;
7238	u64 blkno = 0;
7239	struct ocfs2_extent_list *el;
7240	struct ocfs2_extent_rec *rec;
7241	struct ocfs2_path *path = NULL;
7242	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7243	struct ocfs2_extent_list *root_el = &(di->id2.i_list);
7244	u64 refcount_loc = le64_to_cpu(di->i_refcount_loc);
7245	struct ocfs2_extent_tree et;
7246	struct ocfs2_cached_dealloc_ctxt dealloc;
7247	struct ocfs2_refcount_tree *ref_tree = NULL;
7248
7249	ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
7250	ocfs2_init_dealloc_ctxt(&dealloc);
7251
7252	new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
7253						     i_size_read(inode));
7254
7255	path = ocfs2_new_path(di_bh, &di->id2.i_list,
7256			      ocfs2_journal_access_di);
7257	if (!path) {
7258		status = -ENOMEM;
7259		mlog_errno(status);
7260		goto bail;
7261	}
7262
7263	ocfs2_extent_map_trunc(inode, new_highest_cpos);
7264
7265start:
7266	/*
7267	 * Check that we still have allocation to delete.
7268	 */
7269	if (OCFS2_I(inode)->ip_clusters == 0) {
7270		status = 0;
7271		goto bail;
7272	}
7273
7274	/*
7275	 * Truncate always works against the rightmost tree branch.
7276	 */
7277	status = ocfs2_find_path(INODE_CACHE(inode), path, UINT_MAX);
7278	if (status) {
7279		mlog_errno(status);
7280		goto bail;
7281	}
7282
7283	trace_ocfs2_commit_truncate(
7284		(unsigned long long)OCFS2_I(inode)->ip_blkno,
7285		new_highest_cpos,
7286		OCFS2_I(inode)->ip_clusters,
7287		path->p_tree_depth);
7288
7289	/*
7290	 * By now, el will point to the extent list on the bottom most
7291	 * portion of this tree. Only the tail record is considered in
7292	 * each pass.
7293	 *
7294	 * We handle the following cases, in order:
7295	 * - empty extent: delete the remaining branch
7296	 * - remove the entire record
7297	 * - remove a partial record
7298	 * - no record needs to be removed (truncate has completed)
7299	 */
7300	el = path_leaf_el(path);
7301	if (le16_to_cpu(el->l_next_free_rec) == 0) {
7302		ocfs2_error(inode->i_sb,
7303			    "Inode %llu has empty extent block at %llu\n",
7304			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
7305			    (unsigned long long)path_leaf_bh(path)->b_blocknr);
7306		status = -EROFS;
7307		goto bail;
7308	}
7309
7310	i = le16_to_cpu(el->l_next_free_rec) - 1;
7311	rec = &el->l_recs[i];
7312	flags = rec->e_flags;
7313	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
7314
7315	if (i == 0 && ocfs2_is_empty_extent(rec)) {
7316		/*
7317		 * Lower levels depend on this never happening, but it's best
7318		 * to check it up here before changing the tree.
7319		*/
7320		if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
7321			mlog(ML_ERROR, "Inode %lu has an empty "
7322				    "extent record, depth %u\n", inode->i_ino,
7323				    le16_to_cpu(root_el->l_tree_depth));
7324			status = ocfs2_remove_rightmost_empty_extent(osb,
7325					&et, path, &dealloc);
7326			if (status) {
7327				mlog_errno(status);
7328				goto bail;
7329			}
7330
7331			ocfs2_reinit_path(path, 1);
7332			goto start;
7333		} else {
7334			trunc_cpos = le32_to_cpu(rec->e_cpos);
7335			trunc_len = 0;
7336			blkno = 0;
7337		}
7338	} else if (le32_to_cpu(rec->e_cpos) >= new_highest_cpos) {
7339		/*
7340		 * Truncate entire record.
7341		 */
7342		trunc_cpos = le32_to_cpu(rec->e_cpos);
7343		trunc_len = ocfs2_rec_clusters(el, rec);
7344		blkno = le64_to_cpu(rec->e_blkno);
7345	} else if (range > new_highest_cpos) {
7346		/*
7347		 * Partial truncate. it also should be
7348		 * the last truncate we're doing.
7349		 */
7350		trunc_cpos = new_highest_cpos;
7351		trunc_len = range - new_highest_cpos;
7352		coff = new_highest_cpos - le32_to_cpu(rec->e_cpos);
7353		blkno = le64_to_cpu(rec->e_blkno) +
7354				ocfs2_clusters_to_blocks(inode->i_sb, coff);
7355	} else {
7356		/*
7357		 * Truncate completed, leave happily.
7358		 */
7359		status = 0;
7360		goto bail;
7361	}
7362
7363	phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
7364
7365	if ((flags & OCFS2_EXT_REFCOUNTED) && trunc_len && !ref_tree) {
7366		status = ocfs2_lock_refcount_tree(osb, refcount_loc, 1,
7367				&ref_tree, NULL);
7368		if (status) {
7369			mlog_errno(status);
7370			goto bail;
7371		}
7372	}
7373
7374	status = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
7375					  phys_cpos, trunc_len, flags, &dealloc,
7376					  refcount_loc, true);
7377	if (status < 0) {
7378		mlog_errno(status);
7379		goto bail;
7380	}
7381
7382	ocfs2_reinit_path(path, 1);
7383
7384	/*
7385	 * The check above will catch the case where we've truncated
7386	 * away all allocation.
7387	 */
7388	goto start;
7389
7390bail:
7391	if (ref_tree)
7392		ocfs2_unlock_refcount_tree(osb, ref_tree, 1);
7393
7394	ocfs2_schedule_truncate_log_flush(osb, 1);
7395
7396	ocfs2_run_deallocs(osb, &dealloc);
7397
7398	ocfs2_free_path(path);
7399
7400	return status;
7401}
7402
7403/*
7404 * 'start' is inclusive, 'end' is not.
7405 */
7406int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
7407			  unsigned int start, unsigned int end, int trunc)
7408{
7409	int ret;
7410	unsigned int numbytes;
7411	handle_t *handle;
7412	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7413	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7414	struct ocfs2_inline_data *idata = &di->id2.i_data;
7415
7416	/* No need to punch hole beyond i_size. */
7417	if (start >= i_size_read(inode))
7418		return 0;
7419
7420	if (end > i_size_read(inode))
7421		end = i_size_read(inode);
7422
7423	BUG_ON(start > end);
7424
7425	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
7426	    !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
7427	    !ocfs2_supports_inline_data(osb)) {
7428		ocfs2_error(inode->i_sb,
7429			    "Inline data flags for inode %llu don't agree! Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
7430			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
7431			    le16_to_cpu(di->i_dyn_features),
7432			    OCFS2_I(inode)->ip_dyn_features,
7433			    osb->s_feature_incompat);
7434		ret = -EROFS;
7435		goto out;
7436	}
7437
7438	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
7439	if (IS_ERR(handle)) {
7440		ret = PTR_ERR(handle);
7441		mlog_errno(ret);
7442		goto out;
7443	}
7444
7445	ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
7446				      OCFS2_JOURNAL_ACCESS_WRITE);
7447	if (ret) {
7448		mlog_errno(ret);
7449		goto out_commit;
7450	}
7451
7452	numbytes = end - start;
7453	memset(idata->id_data + start, 0, numbytes);
7454
7455	/*
7456	 * No need to worry about the data page here - it's been
7457	 * truncated already and inline data doesn't need it for
7458	 * pushing zero's to disk, so we'll let read_folio pick it up
7459	 * later.
7460	 */
7461	if (trunc) {
7462		i_size_write(inode, start);
7463		di->i_size = cpu_to_le64(start);
7464	}
7465
7466	inode->i_blocks = ocfs2_inode_sector_count(inode);
7467	inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
7468
7469	di->i_ctime = di->i_mtime = cpu_to_le64(inode_get_ctime_sec(inode));
7470	di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
7471
7472	ocfs2_update_inode_fsync_trans(handle, inode, 1);
7473	ocfs2_journal_dirty(handle, di_bh);
7474
7475out_commit:
7476	ocfs2_commit_trans(osb, handle);
7477
7478out:
7479	return ret;
7480}
7481
7482static int ocfs2_trim_extent(struct super_block *sb,
7483			     struct ocfs2_group_desc *gd,
7484			     u64 group, u32 start, u32 count)
7485{
7486	u64 discard, bcount;
7487	struct ocfs2_super *osb = OCFS2_SB(sb);
7488
7489	bcount = ocfs2_clusters_to_blocks(sb, count);
7490	discard = ocfs2_clusters_to_blocks(sb, start);
7491
7492	/*
7493	 * For the first cluster group, the gd->bg_blkno is not at the start
7494	 * of the group, but at an offset from the start. If we add it while
7495	 * calculating discard for first group, we will wrongly start fstrim a
7496	 * few blocks after the desried start block and the range can cross
7497	 * over into the next cluster group. So, add it only if this is not
7498	 * the first cluster group.
7499	 */
7500	if (group != osb->first_cluster_group_blkno)
7501		discard += le64_to_cpu(gd->bg_blkno);
7502
7503	trace_ocfs2_trim_extent(sb, (unsigned long long)discard, bcount);
7504
7505	return sb_issue_discard(sb, discard, bcount, GFP_NOFS, 0);
7506}
7507
7508static int ocfs2_trim_group(struct super_block *sb,
7509			    struct ocfs2_group_desc *gd, u64 group,
7510			    u32 start, u32 max, u32 minbits)
7511{
7512	int ret = 0, count = 0, next;
7513	void *bitmap = gd->bg_bitmap;
7514
7515	if (le16_to_cpu(gd->bg_free_bits_count) < minbits)
7516		return 0;
7517
7518	trace_ocfs2_trim_group((unsigned long long)le64_to_cpu(gd->bg_blkno),
7519			       start, max, minbits);
7520
7521	while (start < max) {
7522		start = ocfs2_find_next_zero_bit(bitmap, max, start);
7523		if (start >= max)
7524			break;
7525		next = ocfs2_find_next_bit(bitmap, max, start);
7526
7527		if ((next - start) >= minbits) {
7528			ret = ocfs2_trim_extent(sb, gd, group,
7529						start, next - start);
7530			if (ret < 0) {
7531				mlog_errno(ret);
7532				break;
7533			}
7534			count += next - start;
7535		}
7536		start = next + 1;
7537
7538		if (fatal_signal_pending(current)) {
7539			count = -ERESTARTSYS;
7540			break;
7541		}
7542
7543		if ((le16_to_cpu(gd->bg_free_bits_count) - count) < minbits)
7544			break;
7545	}
7546
7547	if (ret < 0)
7548		count = ret;
7549
7550	return count;
7551}
7552
7553static
7554int ocfs2_trim_mainbm(struct super_block *sb, struct fstrim_range *range)
7555{
7556	struct ocfs2_super *osb = OCFS2_SB(sb);
7557	u64 start, len, trimmed = 0, first_group, last_group = 0, group = 0;
7558	int ret, cnt;
7559	u32 first_bit, last_bit, minlen;
7560	struct buffer_head *main_bm_bh = NULL;
7561	struct inode *main_bm_inode = NULL;
7562	struct buffer_head *gd_bh = NULL;
7563	struct ocfs2_dinode *main_bm;
7564	struct ocfs2_group_desc *gd = NULL;
7565
7566	start = range->start >> osb->s_clustersize_bits;
7567	len = range->len >> osb->s_clustersize_bits;
7568	minlen = range->minlen >> osb->s_clustersize_bits;
7569
7570	if (minlen >= osb->bitmap_cpg || range->len < sb->s_blocksize)
7571		return -EINVAL;
7572
7573	trace_ocfs2_trim_mainbm(start, len, minlen);
7574
7575next_group:
7576	main_bm_inode = ocfs2_get_system_file_inode(osb,
7577						    GLOBAL_BITMAP_SYSTEM_INODE,
7578						    OCFS2_INVALID_SLOT);
7579	if (!main_bm_inode) {
7580		ret = -EIO;
7581		mlog_errno(ret);
7582		goto out;
7583	}
7584
7585	inode_lock(main_bm_inode);
7586
7587	ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 0);
7588	if (ret < 0) {
7589		mlog_errno(ret);
7590		goto out_mutex;
7591	}
7592	main_bm = (struct ocfs2_dinode *)main_bm_bh->b_data;
7593
7594	/*
7595	 * Do some check before trim the first group.
7596	 */
7597	if (!group) {
7598		if (start >= le32_to_cpu(main_bm->i_clusters)) {
7599			ret = -EINVAL;
7600			goto out_unlock;
7601		}
7602
7603		if (start + len > le32_to_cpu(main_bm->i_clusters))
7604			len = le32_to_cpu(main_bm->i_clusters) - start;
7605
7606		/*
7607		 * Determine first and last group to examine based on
7608		 * start and len
7609		 */
7610		first_group = ocfs2_which_cluster_group(main_bm_inode, start);
7611		if (first_group == osb->first_cluster_group_blkno)
7612			first_bit = start;
7613		else
7614			first_bit = start - ocfs2_blocks_to_clusters(sb,
7615								first_group);
7616		last_group = ocfs2_which_cluster_group(main_bm_inode,
7617						       start + len - 1);
7618		group = first_group;
7619	}
7620
7621	do {
7622		if (first_bit + len >= osb->bitmap_cpg)
7623			last_bit = osb->bitmap_cpg;
7624		else
7625			last_bit = first_bit + len;
7626
7627		ret = ocfs2_read_group_descriptor(main_bm_inode,
7628						  main_bm, group,
7629						  &gd_bh);
7630		if (ret < 0) {
7631			mlog_errno(ret);
7632			break;
7633		}
7634
7635		gd = (struct ocfs2_group_desc *)gd_bh->b_data;
7636		cnt = ocfs2_trim_group(sb, gd, group,
7637				       first_bit, last_bit, minlen);
7638		brelse(gd_bh);
7639		gd_bh = NULL;
7640		if (cnt < 0) {
7641			ret = cnt;
7642			mlog_errno(ret);
7643			break;
7644		}
7645
7646		trimmed += cnt;
7647		len -= osb->bitmap_cpg - first_bit;
7648		first_bit = 0;
7649		if (group == osb->first_cluster_group_blkno)
7650			group = ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7651		else
7652			group += ocfs2_clusters_to_blocks(sb, osb->bitmap_cpg);
7653	} while (0);
7654
7655out_unlock:
7656	ocfs2_inode_unlock(main_bm_inode, 0);
7657	brelse(main_bm_bh);
7658	main_bm_bh = NULL;
7659out_mutex:
7660	inode_unlock(main_bm_inode);
7661	iput(main_bm_inode);
7662
7663	/*
7664	 * If all the groups trim are not done or failed, but we should release
7665	 * main_bm related locks for avoiding the current IO starve, then go to
7666	 * trim the next group
7667	 */
7668	if (ret >= 0 && group <= last_group) {
7669		cond_resched();
7670		goto next_group;
7671	}
7672out:
7673	range->len = trimmed * osb->s_clustersize;
7674	return ret;
7675}
7676
7677int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range)
7678{
7679	int ret;
7680	struct ocfs2_super *osb = OCFS2_SB(sb);
7681	struct ocfs2_trim_fs_info info, *pinfo = NULL;
7682
7683	ocfs2_trim_fs_lock_res_init(osb);
7684
7685	trace_ocfs2_trim_fs(range->start, range->len, range->minlen);
7686
7687	ret = ocfs2_trim_fs_lock(osb, NULL, 1);
7688	if (ret < 0) {
7689		if (ret != -EAGAIN) {
7690			mlog_errno(ret);
7691			ocfs2_trim_fs_lock_res_uninit(osb);
7692			return ret;
7693		}
7694
7695		mlog(ML_NOTICE, "Wait for trim on device (%s) to "
7696		     "finish, which is running from another node.\n",
7697		     osb->dev_str);
7698		ret = ocfs2_trim_fs_lock(osb, &info, 0);
7699		if (ret < 0) {
7700			mlog_errno(ret);
7701			ocfs2_trim_fs_lock_res_uninit(osb);
7702			return ret;
7703		}
7704
7705		if (info.tf_valid && info.tf_success &&
7706		    info.tf_start == range->start &&
7707		    info.tf_len == range->len &&
7708		    info.tf_minlen == range->minlen) {
7709			/* Avoid sending duplicated trim to a shared device */
7710			mlog(ML_NOTICE, "The same trim on device (%s) was "
7711			     "just done from node (%u), return.\n",
7712			     osb->dev_str, info.tf_nodenum);
7713			range->len = info.tf_trimlen;
7714			goto out;
7715		}
7716	}
7717
7718	info.tf_nodenum = osb->node_num;
7719	info.tf_start = range->start;
7720	info.tf_len = range->len;
7721	info.tf_minlen = range->minlen;
7722
7723	ret = ocfs2_trim_mainbm(sb, range);
7724
7725	info.tf_trimlen = range->len;
7726	info.tf_success = (ret < 0 ? 0 : 1);
7727	pinfo = &info;
7728out:
7729	ocfs2_trim_fs_unlock(osb, pinfo);
7730	ocfs2_trim_fs_lock_res_uninit(osb);
7731	return ret;
7732}