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	iput(inode);
 362
 363	trace_ocfs2_load_local_alloc(osb->local_alloc_bits);
 364
 365	if (status)
 366		mlog_errno(status);
 367	return status;
 368}
 369
 370/*
 371 * return any unused bits to the bitmap and write out a clean
 372 * local_alloc.
 373 *
 374 * local_alloc_bh is optional. If not passed, we will simply use the
 375 * one off osb. If you do pass it however, be warned that it *will* be
 376 * returned brelse'd and NULL'd out.*/
 377void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
 378{
 379	int status;
 380	handle_t *handle;
 381	struct inode *local_alloc_inode = NULL;
 382	struct buffer_head *bh = NULL;
 383	struct buffer_head *main_bm_bh = NULL;
 384	struct inode *main_bm_inode = NULL;
 385	struct ocfs2_dinode *alloc_copy = NULL;
 386	struct ocfs2_dinode *alloc = NULL;
 387
 388	cancel_delayed_work(&osb->la_enable_wq);
 389	flush_workqueue(osb->ocfs2_wq);
 390
 391	if (osb->local_alloc_state == OCFS2_LA_UNUSED)
 392		goto out;
 393
 394	local_alloc_inode =
 395		ocfs2_get_system_file_inode(osb,
 396					    LOCAL_ALLOC_SYSTEM_INODE,
 397					    osb->slot_num);
 398	if (!local_alloc_inode) {
 399		status = -ENOENT;
 400		mlog_errno(status);
 401		goto out;
 402	}
 403
 404	osb->local_alloc_state = OCFS2_LA_DISABLED;
 405
 406	ocfs2_resmap_uninit(&osb->osb_la_resmap);
 407
 408	main_bm_inode = ocfs2_get_system_file_inode(osb,
 409						    GLOBAL_BITMAP_SYSTEM_INODE,
 410						    OCFS2_INVALID_SLOT);
 411	if (!main_bm_inode) {
 412		status = -EINVAL;
 413		mlog_errno(status);
 414		goto out;
 415	}
 416
 417	inode_lock(main_bm_inode);
 418
 419	status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
 420	if (status < 0) {
 421		mlog_errno(status);
 422		goto out_mutex;
 423	}
 424
 425	/* WINDOW_MOVE_CREDITS is a bit heavy... */
 426	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
 427	if (IS_ERR(handle)) {
 428		mlog_errno(PTR_ERR(handle));
 429		handle = NULL;
 430		goto out_unlock;
 431	}
 432
 433	bh = osb->local_alloc_bh;
 434	alloc = (struct ocfs2_dinode *) bh->b_data;
 435
 436	alloc_copy = kmalloc(bh->b_size, GFP_NOFS);
 437	if (!alloc_copy) {
 438		status = -ENOMEM;
 439		goto out_commit;
 440	}
 441	memcpy(alloc_copy, alloc, bh->b_size);
 442
 443	status = ocfs2_journal_access_di(handle, INODE_CACHE(local_alloc_inode),
 444					 bh, OCFS2_JOURNAL_ACCESS_WRITE);
 445	if (status < 0) {
 446		mlog_errno(status);
 447		goto out_commit;
 448	}
 449
 450	ocfs2_clear_local_alloc(alloc);
 451	ocfs2_journal_dirty(handle, bh);
 452
 453	brelse(bh);
 454	osb->local_alloc_bh = NULL;
 455	osb->local_alloc_state = OCFS2_LA_UNUSED;
 456
 457	status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
 458					  main_bm_inode, main_bm_bh);
 459	if (status < 0)
 460		mlog_errno(status);
 461
 462out_commit:
 463	ocfs2_commit_trans(osb, handle);
 464
 465out_unlock:
 466	brelse(main_bm_bh);
 467
 468	ocfs2_inode_unlock(main_bm_inode, 1);
 469
 470out_mutex:
 471	inode_unlock(main_bm_inode);
 472	iput(main_bm_inode);
 473
 474out:
 475	iput(local_alloc_inode);
 476
 477	kfree(alloc_copy);
 478}
 479
 480/*
 481 * We want to free the bitmap bits outside of any recovery context as
 482 * we'll need a cluster lock to do so, but we must clear the local
 483 * alloc before giving up the recovered nodes journal. To solve this,
 484 * we kmalloc a copy of the local alloc before it's change for the
 485 * caller to process with ocfs2_complete_local_alloc_recovery
 486 */
 487int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
 488				     int slot_num,
 489				     struct ocfs2_dinode **alloc_copy)
 490{
 491	int status = 0;
 492	struct buffer_head *alloc_bh = NULL;
 493	struct inode *inode = NULL;
 494	struct ocfs2_dinode *alloc;
 495
 496	trace_ocfs2_begin_local_alloc_recovery(slot_num);
 497
 498	*alloc_copy = NULL;
 499
 500	inode = ocfs2_get_system_file_inode(osb,
 501					    LOCAL_ALLOC_SYSTEM_INODE,
 502					    slot_num);
 503	if (!inode) {
 504		status = -EINVAL;
 505		mlog_errno(status);
 506		goto bail;
 507	}
 508
 509	inode_lock(inode);
 510
 511	status = ocfs2_read_inode_block_full(inode, &alloc_bh,
 512					     OCFS2_BH_IGNORE_CACHE);
 513	if (status < 0) {
 514		mlog_errno(status);
 515		goto bail;
 516	}
 517
 518	*alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL);
 519	if (!(*alloc_copy)) {
 520		status = -ENOMEM;
 521		goto bail;
 522	}
 523	memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size);
 524
 525	alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
 526	ocfs2_clear_local_alloc(alloc);
 527
 528	ocfs2_compute_meta_ecc(osb->sb, alloc_bh->b_data, &alloc->i_check);
 529	status = ocfs2_write_block(osb, alloc_bh, INODE_CACHE(inode));
 530	if (status < 0)
 531		mlog_errno(status);
 532
 533bail:
 534	if (status < 0) {
 535		kfree(*alloc_copy);
 536		*alloc_copy = NULL;
 537	}
 538
 539	brelse(alloc_bh);
 540
 541	if (inode) {
 542		inode_unlock(inode);
 543		iput(inode);
 544	}
 545
 546	if (status)
 547		mlog_errno(status);
 548	return status;
 549}
 550
 551/*
 552 * Step 2: By now, we've completed the journal recovery, we've stamped
 553 * a clean local alloc on disk and dropped the node out of the
 554 * recovery map. Dlm locks will no longer stall, so lets clear out the
 555 * main bitmap.
 556 */
 557int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
 558					struct ocfs2_dinode *alloc)
 559{
 560	int status;
 561	handle_t *handle;
 562	struct buffer_head *main_bm_bh = NULL;
 563	struct inode *main_bm_inode;
 564
 565	main_bm_inode = ocfs2_get_system_file_inode(osb,
 566						    GLOBAL_BITMAP_SYSTEM_INODE,
 567						    OCFS2_INVALID_SLOT);
 568	if (!main_bm_inode) {
 569		status = -EINVAL;
 570		mlog_errno(status);
 571		goto out;
 572	}
 573
 574	inode_lock(main_bm_inode);
 575
 576	status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
 577	if (status < 0) {
 578		mlog_errno(status);
 579		goto out_mutex;
 580	}
 581
 582	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
 583	if (IS_ERR(handle)) {
 584		status = PTR_ERR(handle);
 585		handle = NULL;
 586		mlog_errno(status);
 587		goto out_unlock;
 588	}
 589
 590	/* we want the bitmap change to be recorded on disk asap */
 591	handle->h_sync = 1;
 592
 593	status = ocfs2_sync_local_to_main(osb, handle, alloc,
 594					  main_bm_inode, main_bm_bh);
 595	if (status < 0)
 596		mlog_errno(status);
 597
 598	ocfs2_commit_trans(osb, handle);
 599
 600out_unlock:
 601	ocfs2_inode_unlock(main_bm_inode, 1);
 602
 603out_mutex:
 604	inode_unlock(main_bm_inode);
 605
 606	brelse(main_bm_bh);
 607
 608	iput(main_bm_inode);
 609
 610out:
 611	if (!status)
 612		ocfs2_init_steal_slots(osb);
 613	if (status)
 614		mlog_errno(status);
 615	return status;
 616}
 617
 618/*
 619 * make sure we've got at least bits_wanted contiguous bits in the
 620 * local alloc. You lose them when you drop i_mutex.
 621 *
 622 * We will add ourselves to the transaction passed in, but may start
 623 * our own in order to shift windows.
 624 */
 625int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
 626				   u32 bits_wanted,
 627				   struct ocfs2_alloc_context *ac)
 628{
 629	int status;
 630	struct ocfs2_dinode *alloc;
 631	struct inode *local_alloc_inode;
 632	unsigned int free_bits;
 633
 634	BUG_ON(!ac);
 635
 636	local_alloc_inode =
 637		ocfs2_get_system_file_inode(osb,
 638					    LOCAL_ALLOC_SYSTEM_INODE,
 639					    osb->slot_num);
 640	if (!local_alloc_inode) {
 641		status = -ENOENT;
 642		mlog_errno(status);
 643		goto bail;
 644	}
 645
 646	inode_lock(local_alloc_inode);
 647
 648	/*
 649	 * We must double check state and allocator bits because
 650	 * another process may have changed them while holding i_mutex.
 651	 */
 652	spin_lock(&osb->osb_lock);
 653	if (!ocfs2_la_state_enabled(osb) ||
 654	    (bits_wanted > osb->local_alloc_bits)) {
 655		spin_unlock(&osb->osb_lock);
 656		status = -ENOSPC;
 657		goto bail;
 658	}
 659	spin_unlock(&osb->osb_lock);
 660
 661	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
 662
 663#ifdef CONFIG_OCFS2_DEBUG_FS
 664	if (le32_to_cpu(alloc->id1.bitmap1.i_used) !=
 665	    ocfs2_local_alloc_count_bits(alloc)) {
 666		ocfs2_error(osb->sb, "local alloc inode %llu says it has %u used bits, but a count shows %u\n",
 667			    (unsigned long long)le64_to_cpu(alloc->i_blkno),
 668			    le32_to_cpu(alloc->id1.bitmap1.i_used),
 669			    ocfs2_local_alloc_count_bits(alloc));
 670		status = -EIO;
 671		goto bail;
 672	}
 673#endif
 674
 675	free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
 676		le32_to_cpu(alloc->id1.bitmap1.i_used);
 677	if (bits_wanted > free_bits) {
 678		/* uhoh, window change time. */
 679		status =
 680			ocfs2_local_alloc_slide_window(osb, local_alloc_inode);
 681		if (status < 0) {
 682			if (status != -ENOSPC)
 683				mlog_errno(status);
 684			goto bail;
 685		}
 686
 687		/*
 688		 * Under certain conditions, the window slide code
 689		 * might have reduced the number of bits available or
 690		 * disabled the the local alloc entirely. Re-check
 691		 * here and return -ENOSPC if necessary.
 692		 */
 693		status = -ENOSPC;
 694		if (!ocfs2_la_state_enabled(osb))
 695			goto bail;
 696
 697		free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
 698			le32_to_cpu(alloc->id1.bitmap1.i_used);
 699		if (bits_wanted > free_bits)
 700			goto bail;
 701	}
 702
 703	ac->ac_inode = local_alloc_inode;
 704	/* We should never use localalloc from another slot */
 705	ac->ac_alloc_slot = osb->slot_num;
 706	ac->ac_which = OCFS2_AC_USE_LOCAL;
 707	get_bh(osb->local_alloc_bh);
 708	ac->ac_bh = osb->local_alloc_bh;
 709	status = 0;
 710bail:
 711	if (status < 0 && local_alloc_inode) {
 712		inode_unlock(local_alloc_inode);
 713		iput(local_alloc_inode);
 714	}
 715
 716	trace_ocfs2_reserve_local_alloc_bits(
 717		(unsigned long long)ac->ac_max_block,
 718		bits_wanted, osb->slot_num, status);
 719
 720	if (status)
 721		mlog_errno(status);
 722	return status;
 723}
 724
 725int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
 726				 handle_t *handle,
 727				 struct ocfs2_alloc_context *ac,
 728				 u32 bits_wanted,
 729				 u32 *bit_off,
 730				 u32 *num_bits)
 731{
 732	int status, start;
 733	struct inode *local_alloc_inode;
 734	void *bitmap;
 735	struct ocfs2_dinode *alloc;
 736	struct ocfs2_local_alloc *la;
 737
 738	BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
 739
 740	local_alloc_inode = ac->ac_inode;
 741	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
 742	la = OCFS2_LOCAL_ALLOC(alloc);
 743
 744	start = ocfs2_local_alloc_find_clear_bits(osb, alloc, &bits_wanted,
 745						  ac->ac_resv);
 746	if (start == -1) {
 747		/* TODO: Shouldn't we just BUG here? */
 748		status = -ENOSPC;
 749		mlog_errno(status);
 750		goto bail;
 751	}
 752
 753	bitmap = la->la_bitmap;
 754	*bit_off = le32_to_cpu(la->la_bm_off) + start;
 755	*num_bits = bits_wanted;
 756
 757	status = ocfs2_journal_access_di(handle,
 758					 INODE_CACHE(local_alloc_inode),
 759					 osb->local_alloc_bh,
 760					 OCFS2_JOURNAL_ACCESS_WRITE);
 761	if (status < 0) {
 762		mlog_errno(status);
 763		goto bail;
 764	}
 765
 766	ocfs2_resmap_claimed_bits(&osb->osb_la_resmap, ac->ac_resv, start,
 767				  bits_wanted);
 768
 769	while(bits_wanted--)
 770		ocfs2_set_bit(start++, bitmap);
 771
 772	le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits);
 773	ocfs2_journal_dirty(handle, osb->local_alloc_bh);
 774
 775bail:
 776	if (status)
 777		mlog_errno(status);
 778	return status;
 779}
 780
 781int ocfs2_free_local_alloc_bits(struct ocfs2_super *osb,
 782				handle_t *handle,
 783				struct ocfs2_alloc_context *ac,
 784				u32 bit_off,
 785				u32 num_bits)
 786{
 787	int status, start;
 788	u32 clear_bits;
 789	struct inode *local_alloc_inode;
 790	void *bitmap;
 791	struct ocfs2_dinode *alloc;
 792	struct ocfs2_local_alloc *la;
 793
 794	BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
 795
 796	local_alloc_inode = ac->ac_inode;
 797	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
 798	la = OCFS2_LOCAL_ALLOC(alloc);
 799
 800	bitmap = la->la_bitmap;
 801	start = bit_off - le32_to_cpu(la->la_bm_off);
 802	clear_bits = num_bits;
 803
 804	status = ocfs2_journal_access_di(handle,
 805			INODE_CACHE(local_alloc_inode),
 806			osb->local_alloc_bh,
 807			OCFS2_JOURNAL_ACCESS_WRITE);
 808	if (status < 0) {
 809		mlog_errno(status);
 810		goto bail;
 811	}
 812
 813	while (clear_bits--)
 814		ocfs2_clear_bit(start++, bitmap);
 815
 816	le32_add_cpu(&alloc->id1.bitmap1.i_used, -num_bits);
 817	ocfs2_journal_dirty(handle, osb->local_alloc_bh);
 818
 819bail:
 820	return status;
 821}
 822
 823static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc)
 824{
 825	u32 count;
 826	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 827
 828	count = memweight(la->la_bitmap, le16_to_cpu(la->la_size));
 829
 830	trace_ocfs2_local_alloc_count_bits(count);
 831	return count;
 832}
 833
 834static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
 835				     struct ocfs2_dinode *alloc,
 836				     u32 *numbits,
 837				     struct ocfs2_alloc_reservation *resv)
 838{
 839	int numfound = 0, bitoff, left, startoff, lastzero;
 840	int local_resv = 0;
 841	struct ocfs2_alloc_reservation r;
 842	void *bitmap = NULL;
 843	struct ocfs2_reservation_map *resmap = &osb->osb_la_resmap;
 844
 845	if (!alloc->id1.bitmap1.i_total) {
 846		bitoff = -1;
 847		goto bail;
 848	}
 849
 850	if (!resv) {
 851		local_resv = 1;
 852		ocfs2_resv_init_once(&r);
 853		ocfs2_resv_set_type(&r, OCFS2_RESV_FLAG_TMP);
 854		resv = &r;
 855	}
 856
 857	numfound = *numbits;
 858	if (ocfs2_resmap_resv_bits(resmap, resv, &bitoff, &numfound) == 0) {
 859		if (numfound < *numbits)
 860			*numbits = numfound;
 861		goto bail;
 862	}
 863
 864	/*
 865	 * Code error. While reservations are enabled, local
 866	 * allocation should _always_ go through them.
 867	 */
 868	BUG_ON(osb->osb_resv_level != 0);
 869
 870	/*
 871	 * Reservations are disabled. Handle this the old way.
 872	 */
 873
 874	bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;
 875
 876	numfound = bitoff = startoff = 0;
 877	lastzero = -1;
 878	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
 879	while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {
 880		if (bitoff == left) {
 881			/* mlog(0, "bitoff (%d) == left", bitoff); */
 882			break;
 883		}
 884		/* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
 885		   "numfound = %d\n", bitoff, startoff, numfound);*/
 886
 887		/* Ok, we found a zero bit... is it contig. or do we
 888		 * start over?*/
 889		if (bitoff == startoff) {
 890			/* we found a zero */
 891			numfound++;
 892			startoff++;
 893		} else {
 894			/* got a zero after some ones */
 895			numfound = 1;
 896			startoff = bitoff+1;
 897		}
 898		/* we got everything we needed */
 899		if (numfound == *numbits) {
 900			/* mlog(0, "Found it all!\n"); */
 901			break;
 902		}
 903	}
 904
 905	trace_ocfs2_local_alloc_find_clear_bits_search_bitmap(bitoff, numfound);
 906
 907	if (numfound == *numbits)
 908		bitoff = startoff - numfound;
 909	else
 910		bitoff = -1;
 911
 912bail:
 913	if (local_resv)
 914		ocfs2_resv_discard(resmap, resv);
 915
 916	trace_ocfs2_local_alloc_find_clear_bits(*numbits,
 917		le32_to_cpu(alloc->id1.bitmap1.i_total),
 918		bitoff, numfound);
 919
 920	return bitoff;
 921}
 922
 923static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc)
 924{
 925	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 926	int i;
 927
 928	alloc->id1.bitmap1.i_total = 0;
 929	alloc->id1.bitmap1.i_used = 0;
 930	la->la_bm_off = 0;
 931	for(i = 0; i < le16_to_cpu(la->la_size); i++)
 932		la->la_bitmap[i] = 0;
 933}
 934
 935#if 0
 936/* turn this on and uncomment below to aid debugging window shifts. */
 937static void ocfs2_verify_zero_bits(unsigned long *bitmap,
 938				   unsigned int start,
 939				   unsigned int count)
 940{
 941	unsigned int tmp = count;
 942	while(tmp--) {
 943		if (ocfs2_test_bit(start + tmp, bitmap)) {
 944			printk("ocfs2_verify_zero_bits: start = %u, count = "
 945			       "%u\n", start, count);
 946			printk("ocfs2_verify_zero_bits: bit %u is set!",
 947			       start + tmp);
 948			BUG();
 949		}
 950	}
 951}
 952#endif
 953
 954/*
 955 * sync the local alloc to main bitmap.
 956 *
 957 * assumes you've already locked the main bitmap -- the bitmap inode
 958 * passed is used for caching.
 959 */
 960static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
 961				    handle_t *handle,
 962				    struct ocfs2_dinode *alloc,
 963				    struct inode *main_bm_inode,
 964				    struct buffer_head *main_bm_bh)
 965{
 966	int status = 0;
 967	int bit_off, left, count, start;
 968	u64 la_start_blk;
 969	u64 blkno;
 970	void *bitmap;
 971	struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
 972
 973	trace_ocfs2_sync_local_to_main(
 974	     le32_to_cpu(alloc->id1.bitmap1.i_total),
 975	     le32_to_cpu(alloc->id1.bitmap1.i_used));
 976
 977	if (!alloc->id1.bitmap1.i_total) {
 978		goto bail;
 979	}
 980
 981	if (le32_to_cpu(alloc->id1.bitmap1.i_used) ==
 982	    le32_to_cpu(alloc->id1.bitmap1.i_total)) {
 983		goto bail;
 984	}
 985
 986	la_start_blk = ocfs2_clusters_to_blocks(osb->sb,
 987						le32_to_cpu(la->la_bm_off));
 988	bitmap = la->la_bitmap;
 989	start = count = bit_off = 0;
 990	left = le32_to_cpu(alloc->id1.bitmap1.i_total);
 991
 992	while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))
 993	       != -1) {
 994		if ((bit_off < left) && (bit_off == start)) {
 995			count++;
 996			start++;
 997			continue;
 998		}
 999		if (count) {
1000			blkno = la_start_blk +
1001				ocfs2_clusters_to_blocks(osb->sb,
1002							 start - count);
1003
1004			trace_ocfs2_sync_local_to_main_free(
1005			     count, start - count,
1006			     (unsigned long long)la_start_blk,
1007			     (unsigned long long)blkno);
1008
1009			status = ocfs2_release_clusters(handle,
1010							main_bm_inode,
1011							main_bm_bh, blkno,
1012							count);
1013			if (status < 0) {
1014				mlog_errno(status);
1015				goto bail;
1016			}
1017		}
1018		if (bit_off >= left)
1019			break;
1020		count = 1;
1021		start = bit_off + 1;
1022	}
1023
1024bail:
1025	if (status)
1026		mlog_errno(status);
1027	return status;
1028}
1029
1030enum ocfs2_la_event {
1031	OCFS2_LA_EVENT_SLIDE,		/* Normal window slide. */
1032	OCFS2_LA_EVENT_FRAGMENTED,	/* The global bitmap has
1033					 * enough bits theoretically
1034					 * free, but a contiguous
1035					 * allocation could not be
1036					 * found. */
1037	OCFS2_LA_EVENT_ENOSPC,		/* Global bitmap doesn't have
1038					 * enough bits free to satisfy
1039					 * our request. */
1040};
1041#define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
1042/*
1043 * Given an event, calculate the size of our next local alloc window.
1044 *
1045 * This should always be called under i_mutex of the local alloc inode
1046 * so that local alloc disabling doesn't race with processes trying to
1047 * use the allocator.
1048 *
1049 * Returns the state which the local alloc was left in. This value can
1050 * be ignored by some paths.
1051 */
1052static int ocfs2_recalc_la_window(struct ocfs2_super *osb,
1053				  enum ocfs2_la_event event)
1054{
1055	unsigned int bits;
1056	int state;
1057
1058	spin_lock(&osb->osb_lock);
1059	if (osb->local_alloc_state == OCFS2_LA_DISABLED) {
1060		WARN_ON_ONCE(osb->local_alloc_state == OCFS2_LA_DISABLED);
1061		goto out_unlock;
1062	}
1063
1064	/*
1065	 * ENOSPC and fragmentation are treated similarly for now.
1066	 */
1067	if (event == OCFS2_LA_EVENT_ENOSPC ||
1068	    event == OCFS2_LA_EVENT_FRAGMENTED) {
1069		/*
1070		 * We ran out of contiguous space in the primary
1071		 * bitmap. Drastically reduce the number of bits used
1072		 * by local alloc until we have to disable it.
1073		 */
1074		bits = osb->local_alloc_bits >> 1;
1075		if (bits > ocfs2_megabytes_to_clusters(osb->sb, 1)) {
1076			/*
1077			 * By setting state to THROTTLED, we'll keep
1078			 * the number of local alloc bits used down
1079			 * until an event occurs which would give us
1080			 * reason to assume the bitmap situation might
1081			 * have changed.
1082			 */
1083			osb->local_alloc_state = OCFS2_LA_THROTTLED;
1084			osb->local_alloc_bits = bits;
1085		} else {
1086			osb->local_alloc_state = OCFS2_LA_DISABLED;
1087		}
1088		queue_delayed_work(osb->ocfs2_wq, &osb->la_enable_wq,
1089				   OCFS2_LA_ENABLE_INTERVAL);
1090		goto out_unlock;
1091	}
1092
1093	/*
1094	 * Don't increase the size of the local alloc window until we
1095	 * know we might be able to fulfill the request. Otherwise, we
1096	 * risk bouncing around the global bitmap during periods of
1097	 * low space.
1098	 */
1099	if (osb->local_alloc_state != OCFS2_LA_THROTTLED)
1100		osb->local_alloc_bits = osb->local_alloc_default_bits;
1101
1102out_unlock:
1103	state = osb->local_alloc_state;
1104	spin_unlock(&osb->osb_lock);
1105
1106	return state;
1107}
1108
1109static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
1110						struct ocfs2_alloc_context **ac,
1111						struct inode **bitmap_inode,
1112						struct buffer_head **bitmap_bh)
1113{
1114	int status;
1115
1116	*ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1117	if (!(*ac)) {
1118		status = -ENOMEM;
1119		mlog_errno(status);
1120		goto bail;
1121	}
1122
1123retry_enospc:
1124	(*ac)->ac_bits_wanted = osb->local_alloc_bits;
1125	status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1126	if (status == -ENOSPC) {
1127		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_ENOSPC) ==
1128		    OCFS2_LA_DISABLED)
1129			goto bail;
1130
1131		ocfs2_free_ac_resource(*ac);
1132		memset(*ac, 0, sizeof(struct ocfs2_alloc_context));
1133		goto retry_enospc;
1134	}
1135	if (status < 0) {
1136		mlog_errno(status);
1137		goto bail;
1138	}
1139
1140	*bitmap_inode = (*ac)->ac_inode;
1141	igrab(*bitmap_inode);
1142	*bitmap_bh = (*ac)->ac_bh;
1143	get_bh(*bitmap_bh);
1144	status = 0;
1145bail:
1146	if ((status < 0) && *ac) {
1147		ocfs2_free_alloc_context(*ac);
1148		*ac = NULL;
1149	}
1150
1151	if (status)
1152		mlog_errno(status);
1153	return status;
1154}
1155
1156/*
1157 * pass it the bitmap lock in lock_bh if you have it.
1158 */
1159static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
1160					handle_t *handle,
1161					struct ocfs2_alloc_context *ac)
1162{
1163	int status = 0;
1164	u32 cluster_off, cluster_count;
1165	struct ocfs2_dinode *alloc = NULL;
1166	struct ocfs2_local_alloc *la;
1167
1168	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1169	la = OCFS2_LOCAL_ALLOC(alloc);
1170
1171	trace_ocfs2_local_alloc_new_window(
1172		le32_to_cpu(alloc->id1.bitmap1.i_total),
1173		osb->local_alloc_bits);
1174
1175	/* Instruct the allocation code to try the most recently used
1176	 * cluster group. We'll re-record the group used this pass
1177	 * below. */
1178	ac->ac_last_group = osb->la_last_gd;
1179
1180	/* we used the generic suballoc reserve function, but we set
1181	 * everything up nicely, so there's no reason why we can't use
1182	 * the more specific cluster api to claim bits. */
1183	status = ocfs2_claim_clusters(handle, ac, osb->local_alloc_bits,
1184				      &cluster_off, &cluster_count);
1185	if (status == -ENOSPC) {
1186retry_enospc:
1187		/*
1188		 * Note: We could also try syncing the journal here to
1189		 * allow use of any free bits which the current
1190		 * transaction can't give us access to. --Mark
1191		 */
1192		if (ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_FRAGMENTED) ==
1193		    OCFS2_LA_DISABLED)
1194			goto bail;
1195
1196		ac->ac_bits_wanted = osb->local_alloc_bits;
1197		status = ocfs2_claim_clusters(handle, ac,
1198					      osb->local_alloc_bits,
1199					      &cluster_off,
1200					      &cluster_count);
1201		if (status == -ENOSPC)
1202			goto retry_enospc;
1203		/*
1204		 * We only shrunk the *minimum* number of in our
1205		 * request - it's entirely possible that the allocator
1206		 * might give us more than we asked for.
1207		 */
1208		if (status == 0) {
1209			spin_lock(&osb->osb_lock);
1210			osb->local_alloc_bits = cluster_count;
1211			spin_unlock(&osb->osb_lock);
1212		}
1213	}
1214	if (status < 0) {
1215		if (status != -ENOSPC)
1216			mlog_errno(status);
1217		goto bail;
1218	}
1219
1220	osb->la_last_gd = ac->ac_last_group;
1221
1222	la->la_bm_off = cpu_to_le32(cluster_off);
1223	alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count);
1224	/* just in case... In the future when we find space ourselves,
1225	 * we don't have to get all contiguous -- but we'll have to
1226	 * set all previously used bits in bitmap and update
1227	 * la_bits_set before setting the bits in the main bitmap. */
1228	alloc->id1.bitmap1.i_used = 0;
1229	memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0,
1230	       le16_to_cpu(la->la_size));
1231
1232	ocfs2_resmap_restart(&osb->osb_la_resmap, cluster_count,
1233			     OCFS2_LOCAL_ALLOC(alloc)->la_bitmap);
1234
1235	trace_ocfs2_local_alloc_new_window_result(
1236		OCFS2_LOCAL_ALLOC(alloc)->la_bm_off,
1237		le32_to_cpu(alloc->id1.bitmap1.i_total));
1238
1239bail:
1240	if (status)
1241		mlog_errno(status);
1242	return status;
1243}
1244
1245/* Note that we do *NOT* lock the local alloc inode here as
1246 * it's been locked already for us. */
1247static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
1248					  struct inode *local_alloc_inode)
1249{
1250	int status = 0;
1251	struct buffer_head *main_bm_bh = NULL;
1252	struct inode *main_bm_inode = NULL;
1253	handle_t *handle = NULL;
1254	struct ocfs2_dinode *alloc;
1255	struct ocfs2_dinode *alloc_copy = NULL;
1256	struct ocfs2_alloc_context *ac = NULL;
1257
1258	ocfs2_recalc_la_window(osb, OCFS2_LA_EVENT_SLIDE);
1259
1260	/* This will lock the main bitmap for us. */
1261	status = ocfs2_local_alloc_reserve_for_window(osb,
1262						      &ac,
1263						      &main_bm_inode,
1264						      &main_bm_bh);
1265	if (status < 0) {
1266		if (status != -ENOSPC)
1267			mlog_errno(status);
1268		goto bail;
1269	}
1270
1271	handle = ocfs2_start_trans(osb, OCFS2_WINDOW_MOVE_CREDITS);
1272	if (IS_ERR(handle)) {
1273		status = PTR_ERR(handle);
1274		handle = NULL;
1275		mlog_errno(status);
1276		goto bail;
1277	}
1278
1279	alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
1280
1281	/* We want to clear the local alloc before doing anything
1282	 * else, so that if we error later during this operation,
1283	 * local alloc shutdown won't try to double free main bitmap
1284	 * bits. Make a copy so the sync function knows which bits to
1285	 * free. */
1286	alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_NOFS);
1287	if (!alloc_copy) {
1288		status = -ENOMEM;
1289		mlog_errno(status);
1290		goto bail;
1291	}
1292	memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
1293
1294	status = ocfs2_journal_access_di(handle,
1295					 INODE_CACHE(local_alloc_inode),
1296					 osb->local_alloc_bh,
1297					 OCFS2_JOURNAL_ACCESS_WRITE);
1298	if (status < 0) {
1299		mlog_errno(status);
1300		goto bail;
1301	}
1302
1303	ocfs2_clear_local_alloc(alloc);
1304	ocfs2_journal_dirty(handle, osb->local_alloc_bh);
1305
1306	status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
1307					  main_bm_inode, main_bm_bh);
1308	if (status < 0) {
1309		mlog_errno(status);
1310		goto bail;
1311	}
1312
1313	status = ocfs2_local_alloc_new_window(osb, handle, ac);
1314	if (status < 0) {
1315		if (status != -ENOSPC)
1316			mlog_errno(status);
1317		goto bail;
1318	}
1319
1320	atomic_inc(&osb->alloc_stats.moves);
1321
1322bail:
1323	if (handle)
1324		ocfs2_commit_trans(osb, handle);
1325
1326	brelse(main_bm_bh);
1327
1328	iput(main_bm_inode);
1329	kfree(alloc_copy);
1330
1331	if (ac)
1332		ocfs2_free_alloc_context(ac);
1333
1334	if (status)
1335		mlog_errno(status);
1336	return status;
1337}
1338