1/* -*- mode: c; c-basic-offset: 8; -*-
   2 * vim: noexpandtab sw=8 ts=8 sts=0:
   3 *
   4 * localalloc.c
   5 *
   6 * Node local data allocation
   7 *
   8 * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   9 *
  10 * This program is free software; you can redistribute it and/or
  11 * modify it under the terms of the GNU General Public
  12 * License as published by the Free Software Foundation; either
  13 * version 2 of the License, or (at your option) any later version.
  14 *
  15 * This program is distributed in the hope that it will be useful,
  16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 * General Public License for more details.
  19 *
  20 * You should have received a copy of the GNU General Public
  21 * License along with this program; if not, write to the
  22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 * Boston, MA 021110-1307, USA.
  24 */
  25
  26#include <linux/fs.h>
  27#include <linux/types.h>
  28#include <linux/slab.h>
  29#include <linux/highmem.h>
  30#include <linux/bitops.h>
  31
  32#include <cluster/masklog.h>
  33
  34#include "ocfs2.h"
  35
  36#include "alloc.h"
  37#include "blockcheck.h"
  38#include "dlmglue.h"
  39#include "inode.h"
  40#include "journal.h"
  41#include "localalloc.h"
  42#include "suballoc.h"
  43#include "super.h"
  44#include "sysfile.h"
  45#include "ocfs2_trace.h"
  46
  47#include "buffer_head_io.h"
  48
  49#define OCFS2_LOCAL_ALLOC(dinode)	(&((dinode)->id2.i_lab))
  50
  51static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc);
  52
  53static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
  54					     struct ocfs2_dinode *alloc,
  55					     u32 *numbits,
  56					     struct ocfs2_alloc_reservation *resv);
  57
  58static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc);
  59
  60static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
  61				    handle_t *handle,
  62				    struct ocfs2_dinode *alloc,
  63				    struct inode *main_bm_inode,
  64				    struct buffer_head *main_bm_bh);
  65
  66static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
  67						struct ocfs2_alloc_context **ac,
  68						struct inode **bitmap_inode,
  69						struct buffer_head **bitmap_bh);
  70
  71static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
  72					handle_t *handle,
  73					struct ocfs2_alloc_context *ac);
  74
  75static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
  76					  struct inode *local_alloc_inode);
  77
  78/*
  79 * ocfs2_la_default_mb() - determine a default size, in megabytes of
  80 * the local alloc.
  81 *
  82 * Generally, we'd like to pick as large a local alloc as
  83 * possible. Performance on large workloads tends to scale
  84 * proportionally to la size. In addition to that, the reservations
  85 * code functions more efficiently as it can reserve more windows for
  86 * write.
  87 *
  88 * Some things work against us when trying to choose a large local alloc:
  89 *
  90 * - We need to ensure our sizing is picked to leave enough space in
  91 *   group descriptors for other allocations (such as block groups,
  92 *   etc). Picking default sizes which are a multiple of 4 could help
  93 *   - block groups are allocated in 2mb and 4mb chunks.
  94 *
  95 * - Likewise, we don't want to starve other nodes of bits on small
  96 *   file systems. This can easily be taken care of by limiting our
  97 *   default to a reasonable size (256M) on larger cluster sizes.
  98 *
  99 * - Some file systems can't support very large sizes - 4k and 8k in
 100 *   particular are limited to less than 128 and 256 megabytes respectively.
 101 *
 102 * The following reference table shows group descriptor and local
 103 * alloc maximums at various cluster sizes (4k blocksize)
 104 *
 105 * csize: 4K	group: 126M	la: 121M
 106 * csize: 8K	group: 252M	la: 243M
 107 * csize: 16K	group: 504M	la: 486M
 108 * csize: 32K	group: 1008M	la: 972M
 109 * csize: 64K	group: 2016M	la: 1944M
 110 * csize: 128K	group: 4032M	la: 3888M
 111 * csize: 256K	group: 8064M	la: 7776M
 112 * csize: 512K	group: 16128M	la: 15552M
 113 * csize: 1024K	group: 32256M	la: 31104M
 114 */
 115#define	OCFS2_LA_MAX_DEFAULT_MB	256
 116#define	OCFS2_LA_OLD_DEFAULT	8
 117unsigned int ocfs2_la_default_mb(struct ocfs2_super *osb)
 118{
 119	unsigned int la_mb;
 120	unsigned int gd_mb;
 121	unsigned int la_max_mb;
 122	unsigned int megs_per_slot;
 123	struct super_block *sb = osb->sb;
 124
 125	gd_mb = ocfs2_clusters_to_megabytes(osb->sb,
 126		8 * ocfs2_group_bitmap_size(sb, 0, osb->s_feature_incompat));
 127
 128	/*
 129	 * This takes care of files systems with very small group
 130	 * descriptors - 512 byte blocksize at cluster sizes lower
 131	 * than 16K and also 1k blocksize with 4k cluster size.
 132	 */
 133	if ((sb->s_blocksize == 512 && osb->s_clustersize <= 8192)
 134	    || (sb->s_blocksize == 1024 && osb->s_clustersize == 4096))
 135		return OCFS2_LA_OLD_DEFAULT;
 136
 137	/*
 138	 * Leave enough room for some block groups and make the final
 139	 * value we work from a multiple of 4.
 140	 */
 141	gd_mb -= 16;
 142	gd_mb &= 0xFFFFFFFB;
 143
 144	la_mb = gd_mb;
 145
 146	/*
 147	 * Keep window sizes down to a reasonable default
 148	 */
 149	if (la_mb > OCFS2_LA_MAX_DEFAULT_MB) {
 150		/*
 151		 * Some clustersize / blocksize combinations will have
 152		 * given us a larger than OCFS2_LA_MAX_DEFAULT_MB
 153		 * default size, but get poor distribution when
 154		 * limited to exactly 256 megabytes.
 155		 *
 156		 * As an example, 16K clustersize at 4K blocksize
 157		 * gives us a cluster group size of 504M. Paring the
 158		 * local alloc size down to 256 however, would give us
 159		 * only one window and around 200MB left in the
 160		 * cluster group. Instead, find the first size below
 161		 * 256 which would give us an even distribution.
 162		 *
 163		 * Larger cluster group sizes actually work out pretty
 164		 * well when pared to 256, so we don't have to do this
 165		 * for any group that fits more than two
 166		 * OCFS2_LA_MAX_DEFAULT_MB windows.
 167		 */
 168		if (gd_mb > (2 * OCFS2_LA_MAX_DEFAULT_MB))
 169			la_mb = 256;
 170		else {
 171			unsigned int gd_mult = gd_mb;
 172
 173			while (gd_mult > 256)
 174				gd_mult = gd_mult >> 1;
 175
 176			la_mb = gd_mult;
 177		}
 178	}
 179
 180	megs_per_slot = osb->osb_clusters_at_boot / osb->max_slots;
 181	megs_per_slot = ocfs2_clusters_to_megabytes(osb->sb, megs_per_slot);
 182	/* Too many nodes, too few disk clusters. */
 183	if (megs_per_slot < la_mb)
 184		la_mb = megs_per_slot;
 185
 186	/* We can't store more bits than we can in a block. */
 187	la_max_mb = ocfs2_clusters_to_megabytes(osb->sb,
 188						ocfs2_local_alloc_size(sb) * 8);
 189	if (la_mb > la_max_mb)
 190		la_mb = la_max_mb;
 191
 192	return la_mb;
 193}
 194
 195void ocfs2_la_set_sizes(struct ocfs2_super *osb, int requested_mb)
 196{
 197	struct super_block *sb = osb->sb;
 198	unsigned int la_default_mb = ocfs2_la_default_mb(osb);
 199	unsigned int la_max_mb;
 200
 201	la_max_mb = ocfs2_clusters_to_megabytes(sb,
 202						ocfs2_local_alloc_size(sb) * 8);
 203
 204	trace_ocfs2_la_set_sizes(requested_mb, la_max_mb, la_default_mb);
 205
 206	if (requested_mb == -1) {
 207		/* No user request - use defaults */
 208		osb->local_alloc_default_bits =
 209			ocfs2_megabytes_to_clusters(sb, la_default_mb);
 210	} else if (requested_mb > la_max_mb) {
 211		/* Request is too big, we give the maximum available */
 212		osb->local_alloc_default_bits =
 213			ocfs2_megabytes_to_clusters(sb, la_max_mb);
 214	} else {
 215		osb->local_alloc_default_bits =
 216			ocfs2_megabytes_to_clusters(sb, requested_mb);
 217	}
 218
 219	osb->local_alloc_bits = osb->local_alloc_default_bits;
 220}
 221
 222static inline int ocfs2_la_state_enabled(struct ocfs2_super *osb)
 223{
 224	return (osb->local_alloc_state == OCFS2_LA_THROTTLED ||
 225		osb->local_alloc_state == OCFS2_LA_ENABLED);
 226}
 227
 228void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super *osb,
 229				      unsigned int num_clusters)
 230{
 231	spin_lock(&osb->osb_lock);
 232	if (osb->local_alloc_state == OCFS2_LA_DISABLED ||
 233	    osb->local_alloc_state == OCFS2_LA_THROTTLED)
 234		if (num_clusters >= osb->local_alloc_default_bits) {
 235			cancel_delayed_work(&osb->la_enable_wq);
 236			osb->local_alloc_state = OCFS2_LA_ENABLED;
 237		}
 238	spin_unlock(&osb->osb_lock);
 239}
 240
 241void ocfs2_la_enable_worker(struct work_struct *work)
 242{
 243	struct ocfs2_super *osb =
 244		container_of(work, struct ocfs2_super,
 245			     la_enable_wq.work);
 246	spin_lock(&osb->osb_lock);
 247	osb->local_alloc_state = OCFS2_LA_ENABLED;
 248	spin_unlock(&osb->osb_lock);
 249}
 250
 251/*
 252 * Tell us whether a given allocation should use the local alloc
 253 * file. Otherwise, it has to go to the main bitmap.
 254 *
 255 * This function does semi-dirty reads of local alloc size and state!
 256 * This is ok however, as the values are re-checked once under mutex.
 257 */
 258int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
 259{
 260	int ret = 0;
 261	int la_bits;
 262
 263	spin_lock(&osb->osb_lock);
 264	la_bits = osb->local_alloc_bits;
 265
 266	if (!ocfs2_la_state_enabled(osb))
 267		goto bail;
 268
 269	/* la_bits should be at least twice the size (in clusters) of
 270	 * a new block group. We want to be sure block group
 271	 * allocations go through the local alloc, so allow an
 272	 * allocation to take up to half the bitmap. */
 273	if (bits > (la_bits / 2))
 274		goto bail;
 275
 276	ret = 1;
 277bail:
 278	trace_ocfs2_alloc_should_use_local(
 279	     (unsigned long long)bits, osb->local_alloc_state, la_bits, ret);
 280	spin_unlock(&osb->osb_lock);
 281	return ret;
 282}
 283
 284int ocfs2_load_local_alloc(struct ocfs2_super *osb)
 285{
 286	int status = 0;
 287	struct ocfs2_dinode *alloc = NULL;
 288	struct buffer_head *alloc_bh = NULL;
 289	u32 num_used;
 290	struct inode *inode = NULL;
 291	struct ocfs2_local_alloc *la;
 292
 293	if (osb->local_alloc_bits == 0)
 294		goto bail;
 295
 296	if (osb->local_alloc_bits >= osb->bitmap_cpg) {
 297		mlog(ML_NOTICE, "Requested local alloc window %d is larger "
 298		     "than max possible %u. Using defaults.\n",
 299		     osb->local_alloc_bits, (osb->bitmap_cpg - 1));
 300		osb->local_alloc_bits =
 301			ocfs2_megabytes_to_clusters(osb->sb,
 302						    ocfs2_la_default_mb(osb));
 303	}
 304
 305	/* read the alloc off disk */
 306	inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE,
 307					    osb->slot_num);
 308	if (!inode) {
 309		status = -EINVAL;
 310		mlog_errno(status);
 311		goto bail;
 312	}
 313
 314	status = ocfs2_read_inode_block_full(inode, &alloc_bh,
 315					     OCFS2_BH_IGNORE_CACHE);
 316	if (status < 0) {
 317		mlog_errno(status);
 318		goto bail;
 319	}
 320
 321	alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
 322	la = OCFS2_LOCAL_ALLOC(alloc);
 323
 324	if (!(le32_to_cpu(alloc->i_flags) &
 325	    (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) {
 326		mlog(ML_ERROR, "Invalid local alloc inode, %llu\n",
 327		     (unsigned long long)OCFS2_I(inode)->ip_blkno);
 328		status = -EINVAL;
 329		goto bail;
 330	}
 331
 332	if ((la->la_size == 0) ||
 333	    (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) {
 334		mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n",
 335		     le16_to_cpu(la->la_size));
 336		status = -EINVAL;
 337		goto bail;
 338	}
 339
 340	/* do a little verification. */
 341	num_used = ocfs2_local_alloc_count_bits(alloc);
 342
 343	/* hopefully the local alloc has always been recovered before
 344	 * we load it. */
 345	if (num_used
 346	    || alloc->id1.bitmap1.i_used
 347	    || alloc->id1.bitmap1.i_total
 348	    || la->la_bm_off)
 349		mlog(ML_ERROR, "Local alloc hasn't been recovered!\n"
 350		     "found = %u, set = %u, taken = %u, off = %u\n",
 351		     num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),
 352		     le32_to_cpu(alloc->id1.bitmap1.i_total),
 353		     OCFS2_LOCAL_ALLOC(alloc)->la_bm_off);
 354
 355	osb->local_alloc_bh = alloc_bh;
 356	osb->local_alloc_state = OCFS2_LA_ENABLED;
 357
 358bail:
 359	if (status < 0)
 360		brelse(alloc_bh);
 361	if (inode)
 362		iput(inode);
 363
 364	trace_ocfs2_load_local_alloc(osb->local_alloc_bits);
 365
 366	if (status)
 367		mlog_errno(status);
 368	return status;
 369}
 370
 371/*
 372 * return any unused bits to the bitmap and write out a clean
 373 * local_alloc.
 374 *
 375 * local_alloc_bh is optional. If not passed, we will simply use the
 376 * one off osb. If you do pass it however, be warned that it *will* be
 377 * returned brelse'd and NULL'd out.*/
 378void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
 379{
 380	int status;
 381	handle_t *handle;
 382	struct inode *local_alloc_inode = NULL;
 383	struct buffer_head *bh = NULL;
 384	struct buffer_head *main_bm_bh = NULL;
 385	struct inode *main_bm_inode = NULL;
 386	struct ocfs2_dinode *alloc_copy = NULL;
 387	struct ocfs2_dinode *alloc = NULL;
 388
 389	cancel_delayed_work(&osb->la_enable_wq);
 390	flush_workqueue(ocfs2_wq);
 391
 392	if (osb->local_alloc_state == OCFS2_LA_UNUSED)
 393		goto out;
 394
 395	local_alloc_inode =
 396		ocfs2_get_system_file_inode(osb,
 397					    LOCAL_ALLOC_SYSTEM_INODE,
 398					    osb->slot_num);
 399	if (!local_alloc_inode) {
 400		status = -ENOENT;
 401		mlog_errno(status);
 402		goto out;
 403	}
 404
 405	osb->local_alloc_state = OCFS2_LA_DISABLED;
 406
 407	ocfs2_resmap_uninit(&osb->osb_la_resmap);
 408
 409	main_bm_inode = ocfs2_get_system_file_inode(osb,
 410						    GLOBAL_BITMAP_SYSTEM_INODE,
 411						    OCFS2_INVALID_SLOT);
 412	if (!main_bm_inode) {
 413		status = -EINVAL;
 414		mlog_errno(status);
 415		goto out;
 416	}
 417
 418	mutex_lock(&main_bm_inode->i_mutex);
 419
 420	status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
 421	if (status < 0) {
 422		mlog_errno(status);
 423		goto out_mutex;
 424	}
 425
 426	/* WINDOW_MOVE_CREDITS is a bit heavy... */
 427	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
 428	if (IS_ERR(handle)) {
 429		mlog_errno(PTR_ERR(handle));
 430		handle = NULL;
 431		goto out_unlock;
 432	}
 433
 434	bh = osb->local_alloc_bh;
 435	alloc = (struct ocfs2_dinode *) bh->b_data;
 436
 437	alloc_copy = kmalloc(bh->b_size, GFP_NOFS);
 438	if (!alloc_copy) {
 439		status = -ENOMEM;
 440		goto out_commit;
 441	}
 442	memcpy(alloc_copy, alloc, bh->b_size);
 443
 444	status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode),
 445					 bh, OCFS2_JOURNAL_ACCESS_WRITE);
 446	if (status < 0) {
 447		mlog_errno(status);
 448		goto out_commit;
 449	}
 450
 451	ocfs2_clear_local_alloc(alloc);
 452	ocfs2_journal_dirty(handle, bh);
 453
 454	brelse(bh);
 455	osb->local_alloc_bh = NULL;
 456	osb->local_alloc_state = OCFS2_LA_UNUSED;
 457
 458	status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
 459					  main_bm_inode, main_bm_bh);
 460	if (status < 0)
 461		mlog_errno(status);
 462
 463out_commit:
 464	ocfs2_commit_trans(osb, handle);
 465
 466out_unlock:
 467	brelse(main_bm_bh);
 468
 469	ocfs2_inode_unlock(main_bm_inode, 1);
 470
 471out_mutex:
 472	mutex_unlock(&main_bm_inode->i_mutex);
 473	iput(main_bm_inode);
 474
 475out:
 476	if (local_alloc_inode)
 477		iput(local_alloc_inode);
 478
 479	if (alloc_copy)
 480		kfree(alloc_copy);
 481}
 482
 483/*
 484 * We want to free the bitmap bits outside of any recovery context as
 485 * we'll need a cluster lock to do so, but we must clear the local
 486 * alloc before giving up the recovered nodes journal. To solve this,
 487 * we kmalloc a copy of the local alloc before it's change for the
 488 * caller to process with ocfs2_complete_local_alloc_recovery
 489 */
 490int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
 491				     int slot_num,
 492				     struct ocfs2_dinode **alloc_copy)
 493{
 494	int status = 0;
 495	struct buffer_head *alloc_bh = NULL;
 496	struct inode *inode = NULL;
 497	struct ocfs2_dinode *alloc;
 498
 499	trace_ocfs2_begin_local_alloc_recovery(slot_num);
 500
 501	*alloc_copy = NULL;
 502
 503	inode = ocfs2_get_system_file_inode(osb,
 504					    LOCAL_ALLOC_SYSTEM_INODE,
 505					    slot_num);
 506	if (!inode) {
 507		status = -EINVAL;
 508		mlog_errno(status);
 509		goto bail;
 510	}
 511
 512	mutex_lock(&inode->i_mutex);
 513
 514	status = ocfs2_read_inode_block_full(inode, &alloc_bh,
 515					     OCFS2_BH_IGNORE_CACHE);
 516	if (status < 0) {
 517		mlog_errno(status);
 518		goto bail;
 519	}
 520
 521	*alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL);
 522	if (!(*alloc_copy)) {
 523		status = -ENOMEM;
 524		goto bail;
 525	}
 526	memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size);
 527
 528	alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
 529	ocfs2_clear_local_alloc(alloc);
 530
 531	ocfs2_compute_meta_ecc(osb->sb, alloc_bh->b_data, &alloc->i_check);
 532	status = ocfs2_write_block(osb, alloc_bh, INODE_CACHE(inode));
 533	if (status < 0)
 534		mlog_errno(status);
 535
 536bail:
 537	if ((status < 0) && (*alloc_copy)) {
 538		kfree(*alloc_copy);
 539		*alloc_copy = NULL;
 540	}
 541
 542	brelse(alloc_bh);
 543
 544	if (inode) {
 545		mutex_unlock(&inode->i_mutex);
 546		iput(inode);
 547	}
 548
 549	if (status)
 550		mlog_errno(status);
 551	return status;
 552}
 553
 554/*
 555 * Step 2: By now, we've completed the journal recovery, we've stamped
 556 * a clean local alloc on disk and dropped the node out of the
 557 * recovery map. Dlm locks will no longer stall, so lets clear out the
 558 * main bitmap.
 559 */
 560int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
 561					struct ocfs2_dinode *alloc)
 562{
 563	int status;
 564	handle_t *handle;
 565	struct buffer_head *main_bm_bh = NULL;
 566	struct inode *main_bm_inode;
 567
 568	main_bm_inode = ocfs2_get_system_file_inode(osb,
 569						    GLOBAL_BITMAP_SYSTEM_INODE,
 570						    OCFS2_INVALID_SLOT);
 571	if (!main_bm_inode) {
 572		status = -EINVAL;
 573		mlog_errno(status);
 574		goto out;
 575	}
 576
 577	mutex_lock(&main_bm_inode->i_mutex);
 578
 579	status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
 580	if (status < 0) {
 581		mlog_errno(status);
 582		goto out_mutex;
 583	}
 584
 585	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
 586	if (IS_ERR(handle)) {
 587		status = PTR_ERR(handle);
 588		handle = NULL;
 589		mlog_errno(status);
 590		goto out_unlock;
 591	}
 592
 593	/* we want the bitmap change to be recorded on disk asap */
 594	handle->h_sync = 1;
 595
 596	status = ocfs2_sync_local_to_main(osb, handle, alloc,
 597					  main_bm_inode, main_bm_bh);
 598	if (status < 0)
 599		mlog_errno(status);
 600
 601	ocfs2_commit_trans(osb, handle);
 602
 603out_unlock:
 604	ocfs2_inode_unlock(main_bm_inode, 1);
 605
 606out_mutex:
 607	mutex_unlock(&main_bm_inode->i_mutex);
 608
 609	brelse(main_bm_bh);
 610
 611	iput(main_bm_inode);
 612
 613out:
 614	if (!status)
 615		ocfs2_init_steal_slots(osb);
 616	if (status)
 617		mlog_errno(status);
 618	return status;
 619}
 620
 621/*
 622 * make sure we've got at least bits_wanted contiguous bits in the
 623 * local alloc. You lose them when you drop i_mutex.
 624 *
 625 * We will add ourselves to the transaction passed in, but may start
 626 * our own in order to shift windows.
 627 */
 628int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
 629				   u32 bits_wanted,
 630				   struct ocfs2_alloc_context *ac)
 631{
 632	int status;
 633	struct ocfs2_dinode *alloc;
 634	struct inode *local_alloc_inode;
 635	unsigned int free_bits;
 636
 637	BUG_ON(!ac);
 638
 639	local_alloc_inode =
 640		ocfs2_get_system_file_inode(osb,
 641					    LOCAL_ALLOC_SYSTEM_INODE,
 642					    osb->slot_num);
 643	if (!local_alloc_inode) {
 644		status = -ENOENT;
 645		mlog_errno(status);
 646		goto bail;
 647	}
 648
 649	mutex_lock(&local_alloc_inode->i_mutex);
 650
 651	/*
 652	 * We must double check state and allocator bits because
 653	 * another process may have changed them while holding i_mutex.
 654	 */
 655	spin_lock(&osb->osb_lock);
 656	if (!ocfs2_la_state_enabled(osb) ||
 657	    (bits_wanted > osb->local_alloc_bits)) {
 658		spin_unlock(&osb->osb_lock);
 659		status = -ENOSPC;
 660		goto bail;
 661	}
 662	spin_unlock(&osb->osb_lock);
 663
 664	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
 665
 666#ifdef CONFIG_OCFS2_DEBUG_FS
 667	if (le32_to_cpu(alloc->id1.bitmap1.i_used) !=
 668	    ocfs2_local_alloc_count_bits(alloc)) {
 669		ocfs2_error(osb->sb, "local alloc inode %llu says it has "
 670			    "%u free bits, but a count shows %u",
 671			    (unsigned long long)le64_to_cpu(alloc->i_blkno),
 672			    le32_to_cpu(alloc->id1.bitmap1.i_used),
 673			    ocfs2_local_alloc_count_bits(alloc));
 674		status = -EIO;
 675		goto bail;
 676	}
 677#endif
 678
 679	free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
 680		le32_to_cpu(alloc->id1.bitmap1.i_used);
 681	if (bits_wanted > free_bits) {
 682		/* uhoh, window change time. */
 683		status =
 684			ocfs2_local_alloc_slide_window(osb, local_alloc_inode);
 685		if (status < 0) {
 686			if (status != -ENOSPC)
 687				mlog_errno(status);
 688			goto bail;
 689		}
 690
 691		/*
 692		 * Under certain conditions, the window slide code
 693		 * might have reduced the number of bits available or
 694		 * disabled the the local alloc entirely. Re-check
 695		 * here and return -ENOSPC if necessary.
 696		 */
 697		status = -ENOSPC;
 698		if (!ocfs2_la_state_enabled(osb))
 699			goto bail;
 700
 701		free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
 702			le32_to_cpu(alloc->id1.bitmap1.i_used);
 703		if (bits_wanted > free_bits)
 704			goto bail;
 705	}
 706
 707	ac->ac_inode = local_alloc_inode;
 708	/* We should never use localalloc from another slot */
 709	ac->ac_alloc_slot = osb->slot_num;
 710	ac->ac_which = OCFS2_AC_USE_LOCAL;
 711	get_bh(osb->local_alloc_bh);
 712	ac->ac_bh = osb->local_alloc_bh;
 713	status = 0;
 714bail:
 715	if (status < 0 && local_alloc_inode) {
 716		mutex_unlock(&local_alloc_inode->i_mutex);
 717		iput(local_alloc_inode);
 718	}
 719
 720	trace_ocfs2_reserve_local_alloc_bits(
 721		(unsigned long long)ac->ac_max_block,
 722		bits_wanted, osb->slot_num, status);
 723
 724	if (status)
 725		mlog_errno(status);
 726	return status;
 727}
 728
 729int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
 730				 handle_t *handle,
 731				 struct ocfs2_alloc_context *ac,
 732				 u32 bits_wanted,
 733				 u32 *bit_off,
 734				 u32 *num_bits)
 735{
 736	int status, start;
 737	struct inode *local_alloc_inode;
 738	void *bitmap;
 739	struct ocfs2_dinode *alloc;
 740	struct ocfs2_local_alloc *la;
 741
 742	BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
 743
 744	local_alloc_inode = ac->ac_inode;
 745	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
 746	la = OCFS2_LOCAL_ALLOC(alloc);
 747
 748	start = ocfs2_local_alloc_find_clear_bits(osb, alloc, &bits_wanted,
 749						  ac->ac_resv);
 750	if (start == -1) {
 751		/* TODO: Shouldn't we just BUG here? */
 752		status = -ENOSPC;
 753		mlog_errno(status);
 754		goto bail;
 755	}
 756
 757	bitmap = la->la_bitmap;
 758	*bit_off = le32_to_cpu(la->la_bm_off) + start;
 759	*num_bits = bits_wanted;
 760
 761	status = ocfs2_journal_access_di(handle,
 762					 INODE_CACHE(local_alloc_inode),
 763					 osb->local_alloc_bh,
 764					 OCFS2_JOURNAL_ACCESS_WRITE);
 765	if (status < 0) {
 766		mlog_errno(status);
 767		goto bail;
 768	}
 769
 770	ocfs2_resmap_claimed_bits(&osb->osb_la_resmap, ac->ac_resv, start,
 771				  bits_wanted);
 772
 773	while(bits_wanted--)
 774		ocfs2_set_bit(start++, bitmap);
 775
 776	le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits);
 777	ocfs2_journal_dirty(handle, osb->local_alloc_bh);
 778
 779bail:
 780	if (status)
 781		mlog_errno(status);
 782	return status;
 783}
 784
 785static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc)
 786{
 787	int i;
 788	u8 *buffer;
 789	u32 count = 0;
 790	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 791
 792	buffer = la->la_bitmap;
 793	for (i = 0; i < le16_to_cpu(la->la_size); i++)
 794		count += hweight8(buffer[i]);
 795
 796	trace_ocfs2_local_alloc_count_bits(count);
 797	return count;
 798}
 799
 800static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
 801				     struct ocfs2_dinode *alloc,
 802				     u32 *numbits,
 803				     struct ocfs2_alloc_reservation *resv)
 804{
 805	int numfound, bitoff, left, startoff, lastzero;
 806	int local_resv = 0;
 807	struct ocfs2_alloc_reservation r;
 808	void *bitmap = NULL;
 809	struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap;
 810
 811	if (!alloc->id1.bitmap1.i_total) {
 812		bitoff = -1;
 813		goto bail;
 814	}
 815
 816	if (!resv) {
 817		local_resv = 1;
 818		ocfs2_resv_init_once(&r);
 819		ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP);
 820		resv = &r;
 821	}
 822
 823	numfound = *numbits;
 824	if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) {
 825		if (numfound < *numbits)
 826			*numbits = numfound;
 827		goto bail;
 828	}
 829
 830	/*
 831	 * Code error. While reservations are enabled, local
 832	 * allocation should _always_ go through them.
 833	 */
 834	BUG_ON(osb->osb_resv_level != 0);
 835
 836	/*
 837	 * Reservations are disabled. Handle this the old way.
 838	 */
 839
 840	bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;
 841
 842	numfound = bitoff = startoff = 0;
 843	lastzero = -1;
 844	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
 845	while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {
 846		if (bitoff == left) {
 847			/* mlog(0, "bitoff (%d) == left", bitoff); */
 848			break;
 849		}
 850		/* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
 851		   "numfound = %d\n", bitoff, startoff, numfound);*/
 852
 853		/* Ok, we found a zero bit... is it contig. or do we
 854		 * start over?*/
 855		if (bitoff == startoff) {
 856			/* we found a zero */
 857			numfound++;
 858			startoff++;
 859		} else {
 860			/* got a zero after some ones */
 861			numfound = 1;
 862			startoff = bitoff+1;
 863		}
 864		/* we got everything we needed */
 865		if (numfound == *numbits) {
 866			/* mlog(0, "Found it all!\n"); */
 867			break;
 868		}
 869	}
 870
 871	trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound);
 872
 873	if (numfound == *numbits)
 874		bitoff = startoff - numfound;
 875	else
 876		bitoff = -1;
 877
 878bail:
 879	if (local_resv)
 880		ocfs2_resv_discard(resmap, resv);
 881
 882	trace_ocfs2_local_alloc_find_clear_bits(*numbits,
 883		le32_to_cpu(alloc->id1.bitmap1.i_total),
 884		bitoff, numfound);
 885
 886	return bitoff;
 887}
 888
 889static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc)
 890{
 891	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 892	int i;
 893
 894	alloc->id1.bitmap1.i_total = 0;
 895	alloc->id1.bitmap1.i_used = 0;
 896	la->la_bm_off = 0;
 897	for(i = 0; i < le16_to_cpu(la->la_size); i++)
 898		la->la_bitmap[i] = 0;
 899}
 900
 901#if 0
 902/* turn this on and uncomment below to aid debugging window shifts. */
 903static void ocfs2_verify_zero_bits(unsigned long *bitmap,
 904				   unsigned int start,
 905				   unsigned int count)
 906{
 907	unsigned int tmp = count;
 908	while(tmp--) {
 909		if (ocfs2_test_bit(start + tmp, bitmap)) {
 910			printk("ocfs2_verify_zero_bits: start = %u, count = "
 911			       "%u\n", start, count);
 912			printk("ocfs2_verify_zero_bits: bit %u is set!",
 913			       start + tmp);
 914			BUG();
 915		}
 916	}
 917}
 918#endif
 919
 920/*
 921 * sync the local alloc to main bitmap.
 922 *
 923 * assumes you've already locked the main bitmap -- the bitmap inode
 924 * passed is used for caching.
 925 */
 926static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
 927				    handle_t *handle,
 928				    struct ocfs2_dinode *alloc,
 929				    struct inode *main_bm_inode,
 930				    struct buffer_head *main_bm_bh)
 931{
 932	int status = 0;
 933	int bit_off, left, count, start;
 934	u64 la_start_blk;
 935	u64 blkno;
 936	void *bitmap;
 937	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 938
 939	trace_ocfs2_sync_local_to_main(
 940	     le32_to_cpu(alloc->id1.bitmap1.i_total),
 941	     le32_to_cpu(alloc->id1.bitmap1.i_used));
 942
 943	if (!alloc->id1.bitmap1.i_total) {
 944		goto bail;
 945	}
 946
 947	if (le32_to_cpu(alloc->id1.bitmap1.i_used) ==
 948	    le32_to_cpu(alloc->id1.bitmap1.i_total)) {
 949		goto bail;
 950	}
 951
 952	la_start_blk = ocfs2_clusters_to_blocks(osb->sb,
 953						le32_to_cpu(la->la_bm_off));
 954	bitmap = la->la_bitmap;
 955	start = count = bit_off = 0;
 956	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
 957
 958	while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))
 959	       != -1) {
 960		if ((bit_off < left) && (bit_off == start)) {
 961			count++;
 962			start++;
 963			continue;
 964		}
 965		if (count) {
 966			blkno = la_start_blk +
 967				ocfs2_clusters_to_blocks(osb->sb,
 968							 start - count);
 969
 970			trace_ocfs2_sync_local_to_main_free(
 971			     count, start - count,
 972			     (unsigned long long)la_start_blk,
 973			     (unsigned long long)blkno);
 974
 975			status = ocfs2_release_clusters(handle,
 976							main_bm_inode,
 977							main_bm_bh, blkno,
 978							count);
 979			if (status < 0) {
 980				mlog_errno(status);
 981				goto bail;
 982			}
 983		}
 984		if (bit_off >= left)
 985			break;
 986		count = 1;
 987		start = bit_off + 1;
 988	}
 989
 990bail:
 991	if (status)
 992		mlog_errno(status);
 993	return status;
 994}
 995
 996enum ocfs2_la_event {
 997	OCFS2_LA_EVENT_SLIDE,		/* Normal window slide. */
 998	OCFS2_LA_EVENT_FRAGMENTED,	/* The global bitmap has
 999					 * enough bits theoretically
1000					 * free, but a contiguous
1001					 * allocation could not be
1002					 * found. */
1003	OCFS2_LA_EVENT_ENOSPC,		/* Global bitmap doesn't have
1004					 * enough bits free to satisfy
1005					 * our request. */
1006};
1007#define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
1008/*
1009 * Given an event, calculate the size of our next local alloc window.
1010 *
1011 * This should always be called under i_mutex of the local alloc inode
1012 * so that local alloc disabling doesn't race with processes trying to
1013 * use the allocator.
1014 *
1015 * Returns the state which the local alloc was left in. This value can
1016 * be ignored by some paths.
1017 */
1018static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
1019				  enum ocfs2_la_event event)
1020{
1021	unsigned int bits;
1022	int state;
1023
1024	spin_lock(&osb->osb_lock);
1025	if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
1026		WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
1027		goto out_unlock;
1028	}
1029
1030	/*
1031	 * ENOSPC and fragmentation are treated similarly for now.
1032	 */
1033	if (event == OCFS2_LA_EVENT_ENOSPC ||
1034	    event == OCFS2_LA_EVENT_FRAGMENTED) {
1035		/*
1036		 * We ran out of contiguous space in the primary
1037		 * bitmap. Drastically reduce the number of bits used
1038		 * by local alloc until we have to disable it.
1039		 */
1040		bits = osb->local_alloc_bits >> 1;
1041		if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
1042			/*
1043			 * By setting state to THROTTLED, we'll keep
1044			 * the number of local alloc bits used down
1045			 * until an event occurs which would give us
1046			 * reason to assume the bitmap situation might
1047			 * have changed.
1048			 */
1049			osb->local_alloc_state = OCFS2_LA_THROTTLED;
1050			osb->local_alloc_bits = bits;
1051		} else {
1052			osb->local_alloc_state = OCFS2_LA_DISABLED;
1053		}
1054		queue_delayed_work(ocfs2_wq, &osb->la_enable_wq,
1055				   OCFS2_LA_ENABLE_INTERVAL);
1056		goto out_unlock;
1057	}
1058
1059	/*
1060	 * Don't increase the size of the local alloc window until we
1061	 * know we might be able to fulfill the request. Otherwise, we
1062	 * risk bouncing around the global bitmap during periods of
1063	 * low space.
1064	 */
1065	if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
1066		osb->local_alloc_bits = osb->local_alloc_default_bits;
1067
1068out_unlock:
1069	state = osb->local_alloc_state;
1070	spin_unlock(&osb->osb_lock);
1071
1072	return state;
1073}
1074
1075static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
1076						struct ocfs2_alloc_context **ac,
1077						struct inode **bitmap_inode,
1078						struct buffer_head **bitmap_bh)
1079{
1080	int status;
1081
1082	*ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1083	if (!(*ac)) {
1084		status = -ENOMEM;
1085		mlog_errno(status);
1086		goto bail;
1087	}
1088
1089retry_enospc:
1090	(*ac)->ac_bits_wanted = osb->local_alloc_default_bits;
1091	status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1092	if (status == -ENOSPC) {
1093		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
1094		    OCFS2_LA_DISABLED)
1095			goto bail;
1096
1097		ocfs2_free_ac_resource(*ac);
1098		memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
1099		goto retry_enospc;
1100	}
1101	if (status < 0) {
1102		mlog_errno(status);
1103		goto bail;
1104	}
1105
1106	*bitmap_inode = (*ac)->ac_inode;
1107	igrab(*bitmap_inode);
1108	*bitmap_bh = (*ac)->ac_bh;
1109	get_bh(*bitmap_bh);
1110	status = 0;
1111bail:
1112	if ((status < 0) && *ac) {
1113		ocfs2_free_alloc_context(*ac);
1114		*ac = NULL;
1115	}
1116
1117	if (status)
1118		mlog_errno(status);
1119	return status;
1120}
1121
1122/*
1123 * pass it the bitmap lock in lock_bh if you have it.
1124 */
1125static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
1126					handle_t *handle,
1127					struct ocfs2_alloc_context *ac)
1128{
1129	int status = 0;
1130	u32 cluster_off, cluster_count;
1131	struct ocfs2_dinode *alloc = NULL;
1132	struct ocfs2_local_alloc *la;
1133
1134	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1135	la = OCFS2_LOCAL_ALLOC(alloc);
1136
1137	trace_ocfs2_local_alloc_new_window(
1138		le32_to_cpu(alloc->id1.bitmap1.i_total),
1139		osb->local_alloc_bits);
1140
1141	/* Instruct the allocation code to try the most recently used
1142	 * cluster group. We'll re-record the group used this pass
1143	 * below. */
1144	ac->ac_last_group = osb->la_last_gd;
1145
1146	/* we used the generic suballoc reserve function, but we set
1147	 * everything up nicely, so there's no reason why we can't use
1148	 * the more specific cluster api to claim bits. */
1149	status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits,
1150				      &cluster_off, &cluster_count);
1151	if (status == -ENOSPC) {
1152retry_enospc:
1153		/*
1154		 * Note: We could also try syncing the journal here to
1155		 * allow use of any free bits which the current
1156		 * transaction can't give us access to. --Mark
1157		 */
1158		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
1159		    OCFS2_LA_DISABLED)
1160			goto bail;
1161
1162		ac->ac_bits_wanted = osb->local_alloc_default_bits;
1163		status = ocfs2_claim_clusters(handle, ac,
1164					      osb->local_alloc_bits,
1165					      &cluster_off,
1166					      &cluster_count);
1167		if (status == -ENOSPC)
1168			goto retry_enospc;
1169		/*
1170		 * We only shrunk the *minimum* number of in our
1171		 * request - it's entirely possible that the allocator
1172		 * might give us more than we asked for.
1173		 */
1174		if (status == 0) {
1175			spin_lock(&osb->osb_lock);
1176			osb->local_alloc_bits = cluster_count;
1177			spin_unlock(&osb->osb_lock);
1178		}
1179	}
1180	if (status < 0) {
1181		if (status != -ENOSPC)
1182			mlog_errno(status);
1183		goto bail;
1184	}
1185
1186	osb->la_last_gd = ac->ac_last_group;
1187
1188	la->la_bm_off = cpu_to_le32(cluster_off);
1189	alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count);
1190	/* just in case... In the future when we find space ourselves,
1191	 * we don't have to get all contiguous -- but we'll have to
1192	 * set all previously used bits in bitmap and update
1193	 * la_bits_set before setting the bits in the main bitmap. */
1194	alloc->id1.bitmap1.i_used = 0;
1195	memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0,
1196	       le16_to_cpu(la->la_size));
1197
1198	ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count,
1199			     OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);
1200
1201	trace_ocfs2_local_alloc_new_window_result(
1202		OCFS2_LOCAL_ALLOC(alloc)->la_bm_off,
1203		le32_to_cpu(alloc->id1.bitmap1.i_total));
1204
1205bail:
1206	if (status)
1207		mlog_errno(status);
1208	return status;
1209}
1210
1211/* Note that we do *NOT* lock the local alloc inode here as
1212 * it's been locked already for us. */
1213static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
1214					  struct inode *local_alloc_inode)
1215{
1216	int status = 0;
1217	struct buffer_head *main_bm_bh = NULL;
1218	struct inode *main_bm_inode = NULL;
1219	handle_t *handle = NULL;
1220	struct ocfs2_dinode *alloc;
1221	struct ocfs2_dinode *alloc_copy = NULL;
1222	struct ocfs2_alloc_context *ac = NULL;
1223
1224	ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);
1225
1226	/* This will lock the main bitmap for us. */
1227	status = ocfs2_local_alloc_reserve_for_window(osb,
1228						      &ac,
1229						      &main_bm_inode,
1230						      &main_bm_bh);
1231	if (status < 0) {
1232		if (status != -ENOSPC)
1233			mlog_errno(status);
1234		goto bail;
1235	}
1236
1237	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
1238	if (IS_ERR(handle)) {
1239		status = PTR_ERR(handle);
1240		handle = NULL;
1241		mlog_errno(status);
1242		goto bail;
1243	}
1244
1245	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1246
1247	/* We want to clear the local alloc before doing anything
1248	 * else, so that if we error later during this operation,
1249	 * local alloc shutdown won't try to double free main bitmap
1250	 * bits. Make a copy so the sync function knows which bits to
1251	 * free. */
1252	alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS);
1253	if (!alloc_copy) {
1254		status = -ENOMEM;
1255		mlog_errno(status);
1256		goto bail;
1257	}
1258	memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
1259
1260	status = ocfs2_journal_access_di(handle,
1261					 INODE_CACHE(local_alloc_inode),
1262					 osb->local_alloc_bh,
1263					 OCFS2_JOURNAL_ACCESS_WRITE);
1264	if (status < 0) {
1265		mlog_errno(status);
1266		goto bail;
1267	}
1268
1269	ocfs2_clear_local_alloc(alloc);
1270	ocfs2_journal_dirty(handle, osb->local_alloc_bh);
1271
1272	status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
1273					  main_bm_inode, main_bm_bh);
1274	if (status < 0) {
1275		mlog_errno(status);
1276		goto bail;
1277	}
1278
1279	status = ocfs2_local_alloc_new_window(osb, handle, ac);
1280	if (status < 0) {
1281		if (status != -ENOSPC)
1282			mlog_errno(status);
1283		goto bail;
1284	}
1285
1286	atomic_inc(&osb->alloc_stats.moves);
1287
1288bail:
1289	if (handle)
1290		ocfs2_commit_trans(osb, handle);
1291
1292	brelse(main_bm_bh);
1293
1294	if (main_bm_inode)
1295		iput(main_bm_inode);
1296
1297	if (alloc_copy)
1298		kfree(alloc_copy);
1299
1300	if (ac)
1301		ocfs2_free_alloc_context(ac);
1302
1303	if (status)
1304		mlog_errno(status);
1305	return status;
1306}
1307