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