fs/ocfs2/suballoc.c

   1 /* -*- mode: c; c-basic-offset: 8; -*-
   2  * vim: noexpandtab sw=8 ts=8 sts=0:
   3  *
   4  * suballoc.c
   5  *
   6  * metadata alloc and free
   7  * Inspired by ext3 block groups.
   8  *
   9  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public
  22  * License along with this program; if not, write to the
  23  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24  * Boston, MA 021110-1307, USA.
  25  */
  26
  27 #include <linux/fs.h>
  28 #include <linux/types.h>
  29 #include <linux/slab.h>
  30 #include <linux/highmem.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 "uptodate.h"
  46 #include "ocfs2_trace.h"
  47
  48 #include "buffer_head_io.h"
  49
  50 #define NOT_ALLOC_NEW_GROUP             0
  51 #define ALLOC_NEW_GROUP                 0x1
  52 #define ALLOC_GROUPS_FROM_GLOBAL        0x2
  53
  54 #define OCFS2_MAX_TO_STEAL              1024
  55
  56 struct ocfs2_suballoc_result {
  57         u64             sr_bg_blkno;    /* The bg we allocated from.  Set
  58                                            to 0 when a block group is
  59                                            contiguous. */
  60         u64             sr_bg_stable_blkno; /*
  61                                              * Doesn't change, always
  62                                              * set to target block
  63                                              * group descriptor
  64                                              * block.
  65                                              */
  66         u64             sr_blkno;       /* The first allocated block */
  67         unsigned int    sr_bit_offset;  /* The bit in the bg */
  68         unsigned int    sr_bits;        /* How many bits we claimed */
  69 };
  70
  71 static u64 ocfs2_group_from_res(struct ocfs2_suballoc_result *res)
  72 {
  73         if (res->sr_blkno == 0)
  74                 return 0;
  75
  76         if (res->sr_bg_blkno)
  77                 return res->sr_bg_blkno;
  78
  79         return ocfs2_which_suballoc_group(res->sr_blkno, res->sr_bit_offset);
  80 }
  81
  82 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl);
  83 static int ocfs2_block_group_fill(handle_t *handle,
  84                                   struct inode *alloc_inode,
  85                                   struct buffer_head *bg_bh,
  86                                   u64 group_blkno,
  87                                   unsigned int group_clusters,
  88                                   u16 my_chain,
  89                                   struct ocfs2_chain_list *cl);
  90 static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
  91                                    struct inode *alloc_inode,
  92                                    struct buffer_head *bh,
  93                                    u64 max_block,
  94                                    u64 *last_alloc_group,
  95                                    int flags);
  96
  97 static int ocfs2_cluster_group_search(struct inode *inode,
  98                                       struct buffer_head *group_bh,
  99                                       u32 bits_wanted, u32 min_bits,
 100                                       u64 max_block,
 101                                       struct ocfs2_suballoc_result *res);
 102 static int ocfs2_block_group_search(struct inode *inode,
 103                                     struct buffer_head *group_bh,
 104                                     u32 bits_wanted, u32 min_bits,
 105                                     u64 max_block,
 106                                     struct ocfs2_suballoc_result *res);
 107 static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
 108                                      handle_t *handle,
 109                                      u32 bits_wanted,
 110                                      u32 min_bits,
 111                                      struct ocfs2_suballoc_result *res);
 112 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh,
 113                                          int nr);
 114 static int ocfs2_relink_block_group(handle_t *handle,
 115                                     struct inode *alloc_inode,
 116                                     struct buffer_head *fe_bh,
 117                                     struct buffer_head *bg_bh,
 118                                     struct buffer_head *prev_bg_bh,
 119                                     u16 chain);
 120 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
 121                                                      u32 wanted);
 122 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode,
 123                                                    u64 bg_blkno,
 124                                                    u16 bg_bit_off);
 125 static inline void ocfs2_block_to_cluster_group(struct inode *inode,
 126                                                 u64 data_blkno,
 127                                                 u64 *bg_blkno,
 128                                                 u16 *bg_bit_off);
 129 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
 130                                              u32 bits_wanted, u64 max_block,
 131                                              int flags,
 132                                              struct ocfs2_alloc_context **ac);
 133
 134 void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
 135 {
 136         struct inode *inode = ac->ac_inode;
 137
 138         if (inode) {
 139                 if (ac->ac_which != OCFS2_AC_USE_LOCAL)
 140                         ocfs2_inode_unlock(inode, 1);
 141
 142                 inode_unlock(inode);
 143
 144                 iput(inode);
 145                 ac->ac_inode = NULL;
 146         }
 147         brelse(ac->ac_bh);
 148         ac->ac_bh = NULL;
 149         ac->ac_resv = NULL;
 150         kfree(ac->ac_find_loc_priv);
 151         ac->ac_find_loc_priv = NULL;
 152 }
 153
 154 void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
 155 {
 156         ocfs2_free_ac_resource(ac);
 157         kfree(ac);
 158 }
 159
 160 static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl)
 161 {
 162         return (u32)le16_to_cpu(cl->cl_cpg) * (u32)le16_to_cpu(cl->cl_bpc);
 163 }
 164
 165 #define do_error(fmt, ...)                                              \
 166 do {                                                                    \
 167         if (resize)                                                     \
 168                 mlog(ML_ERROR, fmt, ##__VA_ARGS__);                     \
 169         else                                                            \
 170                 return ocfs2_error(sb, fmt, ##__VA_ARGS__);             \
 171 } while (0)
 172
 173 static int ocfs2_validate_gd_self(struct super_block *sb,
 174                                   struct buffer_head *bh,
 175                                   int resize)
 176 {
 177         struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
 178
 179         if (!OCFS2_IS_VALID_GROUP_DESC(gd)) {
 180                 do_error("Group descriptor #%llu has bad signature %.*s\n",
 181                          (unsigned long long)bh->b_blocknr, 7,
 182                          gd->bg_signature);
 183         }
 184
 185         if (le64_to_cpu(gd->bg_blkno) != bh->b_blocknr) {
 186                 do_error("Group descriptor #%llu has an invalid bg_blkno of %llu\n",
 187                          (unsigned long long)bh->b_blocknr,
 188                          (unsigned long long)le64_to_cpu(gd->bg_blkno));
 189         }
 190
 191         if (le32_to_cpu(gd->bg_generation) != OCFS2_SB(sb)->fs_generation) {
 192                 do_error("Group descriptor #%llu has an invalid fs_generation of #%u\n",
 193                          (unsigned long long)bh->b_blocknr,
 194                          le32_to_cpu(gd->bg_generation));
 195         }
 196
 197         if (le16_to_cpu(gd->bg_free_bits_count) > le16_to_cpu(gd->bg_bits)) {
 198                 do_error("Group descriptor #%llu has bit count %u but claims that %u are free\n",
 199                          (unsigned long long)bh->b_blocknr,
 200                          le16_to_cpu(gd->bg_bits),
 201                          le16_to_cpu(gd->bg_free_bits_count));
 202         }
 203
 204         if (le16_to_cpu(gd->bg_bits) > (8 * le16_to_cpu(gd->bg_size))) {
 205                 do_error("Group descriptor #%llu has bit count %u but max bitmap bits of %u\n",
 206                          (unsigned long long)bh->b_blocknr,
 207                          le16_to_cpu(gd->bg_bits),
 208                          8 * le16_to_cpu(gd->bg_size));
 209         }
 210
 211         return 0;
 212 }
 213
 214 static int ocfs2_validate_gd_parent(struct super_block *sb,
 215                                     struct ocfs2_dinode *di,
 216                                     struct buffer_head *bh,
 217                                     int resize)
 218 {
 219         unsigned int max_bits;
 220         struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
 221
 222         if (di->i_blkno != gd->bg_parent_dinode) {
 223                 do_error("Group descriptor #%llu has bad parent pointer (%llu, expected %llu)\n",
 224                          (unsigned long long)bh->b_blocknr,
 225                          (unsigned long long)le64_to_cpu(gd->bg_parent_dinode),
 226                          (unsigned long long)le64_to_cpu(di->i_blkno));
 227         }
 228
 229         max_bits = le16_to_cpu(di->id2.i_chain.cl_cpg) * le16_to_cpu(di->id2.i_chain.cl_bpc);
 230         if (le16_to_cpu(gd->bg_bits) > max_bits) {
 231                 do_error("Group descriptor #%llu has bit count of %u\n",
 232                          (unsigned long long)bh->b_blocknr,
 233                          le16_to_cpu(gd->bg_bits));
 234         }
 235
 236         /* In resize, we may meet the case bg_chain == cl_next_free_rec. */
 237         if ((le16_to_cpu(gd->bg_chain) >
 238              le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) ||
 239             ((le16_to_cpu(gd->bg_chain) ==
 240              le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) && !resize)) {
 241                 do_error("Group descriptor #%llu has bad chain %u\n",
 242                          (unsigned long long)bh->b_blocknr,
 243                          le16_to_cpu(gd->bg_chain));
 244         }
 245
 246         return 0;
 247 }
 248
 249 #undef do_error
 250
 251 /*
 252  * This version only prints errors.  It does not fail the filesystem, and
 253  * exists only for resize.
 254  */
 255 int ocfs2_check_group_descriptor(struct super_block *sb,
 256                                  struct ocfs2_dinode *di,
 257                                  struct buffer_head *bh)
 258 {
 259         int rc;
 260         struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
 261
 262         BUG_ON(!buffer_uptodate(bh));
 263
 264         /*
 265          * If the ecc fails, we return the error but otherwise
 266          * leave the filesystem running.  We know any error is
 267          * local to this block.
 268          */
 269         rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check);
 270         if (rc) {
 271                 mlog(ML_ERROR,
 272                      "Checksum failed for group descriptor %llu\n",
 273                      (unsigned long long)bh->b_blocknr);
 274         } else
 275                 rc = ocfs2_validate_gd_self(sb, bh, 1);
 276         if (!rc)
 277                 rc = ocfs2_validate_gd_parent(sb, di, bh, 1);
 278
 279         return rc;
 280 }
 281
 282 static int ocfs2_validate_group_descriptor(struct super_block *sb,
 283                                            struct buffer_head *bh)
 284 {
 285         int rc;
 286         struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
 287
 288         trace_ocfs2_validate_group_descriptor(
 289                                         (unsigned long long)bh->b_blocknr);
 290
 291         BUG_ON(!buffer_uptodate(bh));
 292
 293         /*
 294          * If the ecc fails, we return the error but otherwise
 295          * leave the filesystem running.  We know any error is
 296          * local to this block.
 297          */
 298         rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check);
 299         if (rc)
 300                 return rc;
 301
 302         /*
 303          * Errors after here are fatal.
 304          */
 305
 306         return ocfs2_validate_gd_self(sb, bh, 0);
 307 }
 308
 309 int ocfs2_read_group_descriptor(struct inode *inode, struct ocfs2_dinode *di,
 310                                 u64 gd_blkno, struct buffer_head **bh)
 311 {
 312         int rc;
 313         struct buffer_head *tmp = *bh;
 314
 315         rc = ocfs2_read_block(INODE_CACHE(inode), gd_blkno, &tmp,
 316                               ocfs2_validate_group_descriptor);
 317         if (rc)
 318                 goto out;
 319
 320         rc = ocfs2_validate_gd_parent(inode->i_sb, di, tmp, 0);
 321         if (rc) {
 322                 brelse(tmp);
 323                 goto out;
 324         }
 325
 326         /* If ocfs2_read_block() got us a new bh, pass it up. */
 327         if (!*bh)
 328                 *bh = tmp;
 329
 330 out:
 331         return rc;
 332 }
 333
 334 static void ocfs2_bg_discontig_add_extent(struct ocfs2_super *osb,
 335                                           struct ocfs2_group_desc *bg,
 336                                           struct ocfs2_chain_list *cl,
 337                                           u64 p_blkno, unsigned int clusters)
 338 {
 339         struct ocfs2_extent_list *el = &bg->bg_list;
 340         struct ocfs2_extent_rec *rec;
 341
 342         BUG_ON(!ocfs2_supports_discontig_bg(osb));
 343         if (!el->l_next_free_rec)
 344                 el->l_count = cpu_to_le16(ocfs2_extent_recs_per_gd(osb->sb));
 345         rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec)];
 346         rec->e_blkno = cpu_to_le64(p_blkno);
 347         rec->e_cpos = cpu_to_le32(le16_to_cpu(bg->bg_bits) /
 348                                   le16_to_cpu(cl->cl_bpc));
 349         rec->e_leaf_clusters = cpu_to_le16(clusters);
 350         le16_add_cpu(&bg->bg_bits, clusters * le16_to_cpu(cl->cl_bpc));
 351         le16_add_cpu(&bg->bg_free_bits_count,
 352                      clusters * le16_to_cpu(cl->cl_bpc));
 353         le16_add_cpu(&el->l_next_free_rec, 1);
 354 }
 355
 356 static int ocfs2_block_group_fill(handle_t *handle,
 357                                   struct inode *alloc_inode,
 358                                   struct buffer_head *bg_bh,
 359                                   u64 group_blkno,
 360                                   unsigned int group_clusters,
 361                                   u16 my_chain,
 362                                   struct ocfs2_chain_list *cl)
 363 {
 364         int status = 0;
 365         struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
 366         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
 367         struct super_block * sb = alloc_inode->i_sb;
 368
 369         if (((unsigned long long) bg_bh->b_blocknr) != group_blkno) {
 370                 status = ocfs2_error(alloc_inode->i_sb,
 371                                      "group block (%llu) != b_blocknr (%llu)\n",
 372                                      (unsigned long long)group_blkno,
 373                                      (unsigned long long) bg_bh->b_blocknr);
 374                 goto bail;
 375         }
 376
 377         status = ocfs2_journal_access_gd(handle,
 378                                          INODE_CACHE(alloc_inode),
 379                                          bg_bh,
 380                                          OCFS2_JOURNAL_ACCESS_CREATE);
 381         if (status < 0) {
 382                 mlog_errno(status);
 383                 goto bail;
 384         }
 385
 386         memset(bg, 0, sb->s_blocksize);
 387         strcpy(bg->bg_signature, OCFS2_GROUP_DESC_SIGNATURE);
 388         bg->bg_generation = cpu_to_le32(osb->fs_generation);
 389         bg->bg_size = cpu_to_le16(ocfs2_group_bitmap_size(sb, 1,
 390                                                 osb->s_feature_incompat));
 391         bg->bg_chain = cpu_to_le16(my_chain);
 392         bg->bg_next_group = cl->cl_recs[my_chain].c_blkno;
 393         bg->bg_parent_dinode = cpu_to_le64(OCFS2_I(alloc_inode)->ip_blkno);
 394         bg->bg_blkno = cpu_to_le64(group_blkno);
 395         if (group_clusters == le16_to_cpu(cl->cl_cpg))
 396                 bg->bg_bits = cpu_to_le16(ocfs2_bits_per_group(cl));
 397         else
 398                 ocfs2_bg_discontig_add_extent(osb, bg, cl, group_blkno,
 399                                               group_clusters);
 400
 401         /* set the 1st bit in the bitmap to account for the descriptor block */
 402         ocfs2_set_bit(0, (unsigned long *)bg->bg_bitmap);
 403         bg->bg_free_bits_count = cpu_to_le16(le16_to_cpu(bg->bg_bits) - 1);
 404
 405         ocfs2_journal_dirty(handle, bg_bh);
 406
 407         /* There is no need to zero out or otherwise initialize the
 408          * other blocks in a group - All valid FS metadata in a block
 409          * group stores the superblock fs_generation value at
 410          * allocation time. */
 411
 412 bail:
 413         if (status)
 414                 mlog_errno(status);
 415         return status;
 416 }
 417
 418 static inline u16 ocfs2_find_smallest_chain(struct ocfs2_chain_list *cl)
 419 {
 420         u16 curr, best;
 421
 422         best = curr = 0;
 423         while (curr < le16_to_cpu(cl->cl_count)) {
 424                 if (le32_to_cpu(cl->cl_recs[best].c_total) >
 425                     le32_to_cpu(cl->cl_recs[curr].c_total))
 426                         best = curr;
 427                 curr++;
 428         }
 429         return best;
 430 }
 431
 432 static struct buffer_head *
 433 ocfs2_block_group_alloc_contig(struct ocfs2_super *osb, handle_t *handle,
 434                                struct inode *alloc_inode,
 435                                struct ocfs2_alloc_context *ac,
 436                                struct ocfs2_chain_list *cl)
 437 {
 438         int status;
 439         u32 bit_off, num_bits;
 440         u64 bg_blkno;
 441         struct buffer_head *bg_bh;
 442         unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);
 443
 444         status = ocfs2_claim_clusters(handle, ac,
 445                                       le16_to_cpu(cl->cl_cpg), &bit_off,
 446                                       &num_bits);
 447         if (status < 0) {
 448                 if (status != -ENOSPC)
 449                         mlog_errno(status);
 450                 goto bail;
 451         }
 452
 453         /* setup the group */
 454         bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off);
 455         trace_ocfs2_block_group_alloc_contig(
 456              (unsigned long long)bg_blkno, alloc_rec);
 457
 458         bg_bh = sb_getblk(osb->sb, bg_blkno);
 459         if (!bg_bh) {
 460                 status = -ENOMEM;
 461                 mlog_errno(status);
 462                 goto bail;
 463         }
 464         ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh);
 465
 466         status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh,
 467                                         bg_blkno, num_bits, alloc_rec, cl);
 468         if (status < 0) {
 469                 brelse(bg_bh);
 470                 mlog_errno(status);
 471         }
 472
 473 bail:
 474         return status ? ERR_PTR(status) : bg_bh;
 475 }
 476
 477 static int ocfs2_block_group_claim_bits(struct ocfs2_super *osb,
 478                                         handle_t *handle,
 479                                         struct ocfs2_alloc_context *ac,
 480                                         unsigned int min_bits,
 481                                         u32 *bit_off, u32 *num_bits)
 482 {
 483         int status = 0;
 484
 485         while (min_bits) {
 486                 status = ocfs2_claim_clusters(handle, ac, min_bits,
 487                                               bit_off, num_bits);
 488                 if (status != -ENOSPC)
 489                         break;
 490
 491                 min_bits >>= 1;
 492         }
 493
 494         return status;
 495 }
 496
 497 static int ocfs2_block_group_grow_discontig(handle_t *handle,
 498                                             struct inode *alloc_inode,
 499                                             struct buffer_head *bg_bh,
 500                                             struct ocfs2_alloc_context *ac,
 501                                             struct ocfs2_chain_list *cl,
 502                                             unsigned int min_bits)
 503 {
 504         int status;
 505         struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
 506         struct ocfs2_group_desc *bg =
 507                 (struct ocfs2_group_desc *)bg_bh->b_data;
 508         unsigned int needed = le16_to_cpu(cl->cl_cpg) -
 509                          le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);
 510         u32 p_cpos, clusters;
 511         u64 p_blkno;
 512         struct ocfs2_extent_list *el = &bg->bg_list;
 513
 514         status = ocfs2_journal_access_gd(handle,
 515                                          INODE_CACHE(alloc_inode),
 516                                          bg_bh,
 517                                          OCFS2_JOURNAL_ACCESS_CREATE);
 518         if (status < 0) {
 519                 mlog_errno(status);
 520                 goto bail;
 521         }
 522
 523         while ((needed > 0) && (le16_to_cpu(el->l_next_free_rec) <
 524                                 le16_to_cpu(el->l_count))) {
 525                 if (min_bits > needed)
 526                         min_bits = needed;
 527                 status = ocfs2_block_group_claim_bits(osb, handle, ac,
 528                                                       min_bits, &p_cpos,
 529                                                       &clusters);
 530                 if (status < 0) {
 531                         if (status != -ENOSPC)
 532                                 mlog_errno(status);
 533                         goto bail;
 534                 }
 535                 p_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cpos);
 536                 ocfs2_bg_discontig_add_extent(osb, bg, cl, p_blkno,
 537                                               clusters);
 538
 539                 min_bits = clusters;
 540                 needed = le16_to_cpu(cl->cl_cpg) -
 541                          le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);
 542         }
 543
 544         if (needed > 0) {
 545                 /*
 546                  * We have used up all the extent rec but can't fill up
 547                  * the cpg. So bail out.
 548                  */
 549                 status = -ENOSPC;
 550                 goto bail;
 551         }
 552
 553         ocfs2_journal_dirty(handle, bg_bh);
 554
 555 bail:
 556         return status;
 557 }
 558
 559 static void ocfs2_bg_alloc_cleanup(handle_t *handle,
 560                                    struct ocfs2_alloc_context *cluster_ac,
 561                                    struct inode *alloc_inode,
 562                                    struct buffer_head *bg_bh)
 563 {
 564         int i, ret;
 565         struct ocfs2_group_desc *bg;
 566         struct ocfs2_extent_list *el;
 567         struct ocfs2_extent_rec *rec;
 568
 569         if (!bg_bh)
 570                 return;
 571
 572         bg = (struct ocfs2_group_desc *)bg_bh->b_data;
 573         el = &bg->bg_list;
 574         for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
 575                 rec = &el->l_recs[i];
 576                 ret = ocfs2_free_clusters(handle, cluster_ac->ac_inode,
 577                                           cluster_ac->ac_bh,
 578                                           le64_to_cpu(rec->e_blkno),
 579                                           le16_to_cpu(rec->e_leaf_clusters));
 580                 if (ret)
 581                         mlog_errno(ret);
 582                 /* Try all the clusters to free */
 583         }
 584
 585         ocfs2_remove_from_cache(INODE_CACHE(alloc_inode), bg_bh);
 586         brelse(bg_bh);
 587 }
 588
 589 static struct buffer_head *
 590 ocfs2_block_group_alloc_discontig(handle_t *handle,
 591                                   struct inode *alloc_inode,
 592                                   struct ocfs2_alloc_context *ac,
 593                                   struct ocfs2_chain_list *cl)
 594 {
 595         int status;
 596         u32 bit_off, num_bits;
 597         u64 bg_blkno;
 598         unsigned int min_bits = le16_to_cpu(cl->cl_cpg) >> 1;
 599         struct buffer_head *bg_bh = NULL;
 600         unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);
 601         struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
 602
 603         if (!ocfs2_supports_discontig_bg(osb)) {
 604                 status = -ENOSPC;
 605                 goto bail;
 606         }
 607
 608         status = ocfs2_extend_trans(handle,
 609                                     ocfs2_calc_bg_discontig_credits(osb->sb));
 610         if (status) {
 611                 mlog_errno(status);
 612                 goto bail;
 613         }
 614
 615         /*
 616          * We're going to be grabbing from multiple cluster groups.
 617          * We don't have enough credits to relink them all, and the
 618          * cluster groups will be staying in cache for the duration of
 619          * this operation.
 620          */
 621         ac->ac_disable_chain_relink = 1;
 622
 623         /* Claim the first region */
 624         status = ocfs2_block_group_claim_bits(osb, handle, ac, min_bits,
 625                                               &bit_off, &num_bits);
 626         if (status < 0) {
 627                 if (status != -ENOSPC)
 628                         mlog_errno(status);
 629                 goto bail;
 630         }
 631         min_bits = num_bits;
 632
 633         /* setup the group */
 634         bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off);
 635         trace_ocfs2_block_group_alloc_discontig(
 636                                 (unsigned long long)bg_blkno, alloc_rec);
 637
 638         bg_bh = sb_getblk(osb->sb, bg_blkno);
 639         if (!bg_bh) {
 640                 status = -ENOMEM;
 641                 mlog_errno(status);
 642                 goto bail;
 643         }
 644         ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh);
 645
 646         status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh,
 647                                         bg_blkno, num_bits, alloc_rec, cl);
 648         if (status < 0) {
 649                 mlog_errno(status);
 650                 goto bail;
 651         }
 652
 653         status = ocfs2_block_group_grow_discontig(handle, alloc_inode,
 654                                                   bg_bh, ac, cl, min_bits);
 655         if (status)
 656                 mlog_errno(status);
 657
 658 bail:
 659         if (status)
 660                 ocfs2_bg_alloc_cleanup(handle, ac, alloc_inode, bg_bh);
 661         return status ? ERR_PTR(status) : bg_bh;
 662 }
 663
 664 /*
 665  * We expect the block group allocator to already be locked.
 666  */
 667 static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
 668                                    struct inode *alloc_inode,
 669                                    struct buffer_head *bh,
 670                                    u64 max_block,
 671                                    u64 *last_alloc_group,
 672                                    int flags)
 673 {
 674         int status, credits;
 675         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
 676         struct ocfs2_chain_list *cl;
 677         struct ocfs2_alloc_context *ac = NULL;
 678         handle_t *handle = NULL;
 679         u16 alloc_rec;
 680         struct buffer_head *bg_bh = NULL;
 681         struct ocfs2_group_desc *bg;
 682
 683         BUG_ON(ocfs2_is_cluster_bitmap(alloc_inode));
 684
 685         cl = &fe->id2.i_chain;
 686         status = ocfs2_reserve_clusters_with_limit(osb,
 687                                                    le16_to_cpu(cl->cl_cpg),
 688                                                    max_block, flags, &ac);
 689         if (status < 0) {
 690                 if (status != -ENOSPC)
 691                         mlog_errno(status);
 692                 goto bail;
 693         }
 694
 695         credits = ocfs2_calc_group_alloc_credits(osb->sb,
 696                                                  le16_to_cpu(cl->cl_cpg));
 697         handle = ocfs2_start_trans(osb, credits);
 698         if (IS_ERR(handle)) {
 699                 status = PTR_ERR(handle);
 700                 handle = NULL;
 701                 mlog_errno(status);
 702                 goto bail;
 703         }
 704
 705         if (last_alloc_group && *last_alloc_group != 0) {
 706                 trace_ocfs2_block_group_alloc(
 707                                 (unsigned long long)*last_alloc_group);
 708                 ac->ac_last_group = *last_alloc_group;
 709         }
 710
 711         bg_bh = ocfs2_block_group_alloc_contig(osb, handle, alloc_inode,
 712                                                ac, cl);
 713         if (IS_ERR(bg_bh) && (PTR_ERR(bg_bh) == -ENOSPC))
 714                 bg_bh = ocfs2_block_group_alloc_discontig(handle,
 715                                                           alloc_inode,
 716                                                           ac, cl);
 717         if (IS_ERR(bg_bh)) {
 718                 status = PTR_ERR(bg_bh);
 719                 bg_bh = NULL;
 720                 if (status != -ENOSPC)
 721                         mlog_errno(status);
 722                 goto bail;
 723         }
 724         bg = (struct ocfs2_group_desc *) bg_bh->b_data;
 725
 726         status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
 727                                          bh, OCFS2_JOURNAL_ACCESS_WRITE);
 728         if (status < 0) {
 729                 mlog_errno(status);
 730                 goto bail;
 731         }
 732
 733         alloc_rec = le16_to_cpu(bg->bg_chain);
 734         le32_add_cpu(&cl->cl_recs[alloc_rec].c_free,
 735                      le16_to_cpu(bg->bg_free_bits_count));
 736         le32_add_cpu(&cl->cl_recs[alloc_rec].c_total,
 737                      le16_to_cpu(bg->bg_bits));
 738         cl->cl_recs[alloc_rec].c_blkno = bg->bg_blkno;
 739         if (le16_to_cpu(cl->cl_next_free_rec) < le16_to_cpu(cl->cl_count))
 740                 le16_add_cpu(&cl->cl_next_free_rec, 1);
 741
 742         le32_add_cpu(&fe->id1.bitmap1.i_used, le16_to_cpu(bg->bg_bits) -
 743                                         le16_to_cpu(bg->bg_free_bits_count));
 744         le32_add_cpu(&fe->id1.bitmap1.i_total, le16_to_cpu(bg->bg_bits));
 745         le32_add_cpu(&fe->i_clusters, le16_to_cpu(cl->cl_cpg));
 746
 747         ocfs2_journal_dirty(handle, bh);
 748
 749         spin_lock(&OCFS2_I(alloc_inode)->ip_lock);
 750         OCFS2_I(alloc_inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
 751         fe->i_size = cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode->i_sb,
 752                                              le32_to_cpu(fe->i_clusters)));
 753         spin_unlock(&OCFS2_I(alloc_inode)->ip_lock);
 754         i_size_write(alloc_inode, le64_to_cpu(fe->i_size));
 755         alloc_inode->i_blocks = ocfs2_inode_sector_count(alloc_inode);
 756         ocfs2_update_inode_fsync_trans(handle, alloc_inode, 0);
 757
 758         status = 0;
 759
 760         /* save the new last alloc group so that the caller can cache it. */
 761         if (last_alloc_group)
 762                 *last_alloc_group = ac->ac_last_group;
 763
 764 bail:
 765         if (handle)
 766                 ocfs2_commit_trans(osb, handle);
 767
 768         if (ac)
 769                 ocfs2_free_alloc_context(ac);
 770
 771         brelse(bg_bh);
 772
 773         if (status)
 774                 mlog_errno(status);
 775         return status;
 776 }
 777
 778 static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
 779                                        struct ocfs2_alloc_context *ac,
 780                                        int type,
 781                                        u32 slot,
 782                                        u64 *last_alloc_group,
 783                                        int flags)
 784 {
 785         int status;
 786         u32 bits_wanted = ac->ac_bits_wanted;
 787         struct inode *alloc_inode;
 788         struct buffer_head *bh = NULL;
 789         struct ocfs2_dinode *fe;
 790         u32 free_bits;
 791
 792         alloc_inode = ocfs2_get_system_file_inode(osb, type, slot);
 793         if (!alloc_inode) {
 794                 mlog_errno(-EINVAL);
 795                 return -EINVAL;
 796         }
 797
 798         inode_lock(alloc_inode);
 799
 800         status = ocfs2_inode_lock(alloc_inode, &bh, 1);
 801         if (status < 0) {
 802                 inode_unlock(alloc_inode);
 803                 iput(alloc_inode);
 804
 805                 mlog_errno(status);
 806                 return status;
 807         }
 808
 809         ac->ac_inode = alloc_inode;
 810         ac->ac_alloc_slot = slot;
 811
 812         fe = (struct ocfs2_dinode *) bh->b_data;
 813
 814         /* The bh was validated by the inode read inside
 815          * ocfs2_inode_lock().  Any corruption is a code bug. */
 816         BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
 817
 818         if (!(fe->i_flags & cpu_to_le32(OCFS2_CHAIN_FL))) {
 819                 status = ocfs2_error(alloc_inode->i_sb,
 820                                      "Invalid chain allocator %llu\n",
 821                                      (unsigned long long)le64_to_cpu(fe->i_blkno));
 822                 goto bail;
 823         }
 824
 825         free_bits = le32_to_cpu(fe->id1.bitmap1.i_total) -
 826                 le32_to_cpu(fe->id1.bitmap1.i_used);
 827
 828         if (bits_wanted > free_bits) {
 829                 /* cluster bitmap never grows */
 830                 if (ocfs2_is_cluster_bitmap(alloc_inode)) {
 831                         trace_ocfs2_reserve_suballoc_bits_nospc(bits_wanted,
 832                                                                 free_bits);
 833                         status = -ENOSPC;
 834                         goto bail;
 835                 }
 836
 837                 if (!(flags & ALLOC_NEW_GROUP)) {
 838                         trace_ocfs2_reserve_suballoc_bits_no_new_group(
 839                                                 slot, bits_wanted, free_bits);
 840                         status = -ENOSPC;
 841                         goto bail;
 842                 }
 843
 844                 status = ocfs2_block_group_alloc(osb, alloc_inode, bh,
 845                                                  ac->ac_max_block,
 846                                                  last_alloc_group, flags);
 847                 if (status < 0) {
 848                         if (status != -ENOSPC)
 849                                 mlog_errno(status);
 850                         goto bail;
 851                 }
 852                 atomic_inc(&osb->alloc_stats.bg_extends);
 853
 854                 /* You should never ask for this much metadata */
 855                 BUG_ON(bits_wanted >
 856                        (le32_to_cpu(fe->id1.bitmap1.i_total)
 857                         - le32_to_cpu(fe->id1.bitmap1.i_used)));
 858         }
 859
 860         get_bh(bh);
 861         ac->ac_bh = bh;
 862 bail:
 863         brelse(bh);
 864
 865         if (status)
 866                 mlog_errno(status);
 867         return status;
 868 }
 869
 870 static void ocfs2_init_inode_steal_slot(struct ocfs2_super *osb)
 871 {
 872         spin_lock(&osb->osb_lock);
 873         osb->s_inode_steal_slot = OCFS2_INVALID_SLOT;
 874         spin_unlock(&osb->osb_lock);
 875         atomic_set(&osb->s_num_inodes_stolen, 0);
 876 }
 877
 878 static void ocfs2_init_meta_steal_slot(struct ocfs2_super *osb)
 879 {
 880         spin_lock(&osb->osb_lock);
 881         osb->s_meta_steal_slot = OCFS2_INVALID_SLOT;
 882         spin_unlock(&osb->osb_lock);
 883         atomic_set(&osb->s_num_meta_stolen, 0);
 884 }
 885
 886 void ocfs2_init_steal_slots(struct ocfs2_super *osb)
 887 {
 888         ocfs2_init_inode_steal_slot(osb);
 889         ocfs2_init_meta_steal_slot(osb);
 890 }
 891
 892 static void __ocfs2_set_steal_slot(struct ocfs2_super *osb, int slot, int type)
 893 {
 894         spin_lock(&osb->osb_lock);
 895         if (type == INODE_ALLOC_SYSTEM_INODE)
 896                 osb->s_inode_steal_slot = slot;
 897         else if (type == EXTENT_ALLOC_SYSTEM_INODE)
 898                 osb->s_meta_steal_slot = slot;
 899         spin_unlock(&osb->osb_lock);
 900 }
 901
 902 static int __ocfs2_get_steal_slot(struct ocfs2_super *osb, int type)
 903 {
 904         int slot = OCFS2_INVALID_SLOT;
 905
 906         spin_lock(&osb->osb_lock);
 907         if (type == INODE_ALLOC_SYSTEM_INODE)
 908                 slot = osb->s_inode_steal_slot;
 909         else if (type == EXTENT_ALLOC_SYSTEM_INODE)
 910                 slot = osb->s_meta_steal_slot;
 911         spin_unlock(&osb->osb_lock);
 912
 913         return slot;
 914 }
 915
 916 static int ocfs2_get_inode_steal_slot(struct ocfs2_super *osb)
 917 {
 918         return __ocfs2_get_steal_slot(osb, INODE_ALLOC_SYSTEM_INODE);
 919 }
 920
 921 static int ocfs2_get_meta_steal_slot(struct ocfs2_super *osb)
 922 {
 923         return __ocfs2_get_steal_slot(osb, EXTENT_ALLOC_SYSTEM_INODE);
 924 }
 925
 926 static int ocfs2_steal_resource(struct ocfs2_super *osb,
 927                                 struct ocfs2_alloc_context *ac,
 928                                 int type)
 929 {
 930         int i, status = -ENOSPC;
 931         int slot = __ocfs2_get_steal_slot(osb, type);
 932
 933         /* Start to steal resource from the first slot after ours. */
 934         if (slot == OCFS2_INVALID_SLOT)
 935                 slot = osb->slot_num + 1;
 936
 937         for (i = 0; i < osb->max_slots; i++, slot++) {
 938                 if (slot == osb->max_slots)
 939                         slot = 0;
 940
 941                 if (slot == osb->slot_num)
 942                         continue;
 943
 944                 status = ocfs2_reserve_suballoc_bits(osb, ac,
 945                                                      type,
 946                                                      (u32)slot, NULL,
 947                                                      NOT_ALLOC_NEW_GROUP);
 948                 if (status >= 0) {
 949                         __ocfs2_set_steal_slot(osb, slot, type);
 950                         break;
 951                 }
 952
 953                 ocfs2_free_ac_resource(ac);
 954         }
 955
 956         return status;
 957 }
 958
 959 static int ocfs2_steal_inode(struct ocfs2_super *osb,
 960                              struct ocfs2_alloc_context *ac)
 961 {
 962         return ocfs2_steal_resource(osb, ac, INODE_ALLOC_SYSTEM_INODE);
 963 }
 964
 965 static int ocfs2_steal_meta(struct ocfs2_super *osb,
 966                             struct ocfs2_alloc_context *ac)
 967 {
 968         return ocfs2_steal_resource(osb, ac, EXTENT_ALLOC_SYSTEM_INODE);
 969 }
 970
 971 int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb,
 972                                       int blocks,
 973                                       struct ocfs2_alloc_context **ac)
 974 {
 975         int status;
 976         int slot = ocfs2_get_meta_steal_slot(osb);
 977
 978         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
 979         if (!(*ac)) {
 980                 status = -ENOMEM;
 981                 mlog_errno(status);
 982                 goto bail;
 983         }
 984
 985         (*ac)->ac_bits_wanted = blocks;
 986         (*ac)->ac_which = OCFS2_AC_USE_META;
 987         (*ac)->ac_group_search = ocfs2_block_group_search;
 988
 989         if (slot != OCFS2_INVALID_SLOT &&
 990                 atomic_read(&osb->s_num_meta_stolen) < OCFS2_MAX_TO_STEAL)
 991                 goto extent_steal;
 992
 993         atomic_set(&osb->s_num_meta_stolen, 0);
 994         status = ocfs2_reserve_suballoc_bits(osb, (*ac),
 995                                              EXTENT_ALLOC_SYSTEM_INODE,
 996                                              (u32)osb->slot_num, NULL,
 997                                              ALLOC_GROUPS_FROM_GLOBAL|ALLOC_NEW_GROUP);
 998
 999
1000         if (status >= 0) {
1001                 status = 0;
1002                 if (slot != OCFS2_INVALID_SLOT)
1003                         ocfs2_init_meta_steal_slot(osb);
1004                 goto bail;
1005         } else if (status < 0 && status != -ENOSPC) {
1006                 mlog_errno(status);
1007                 goto bail;
1008         }
1009
1010         ocfs2_free_ac_resource(*ac);
1011
1012 extent_steal:
1013         status = ocfs2_steal_meta(osb, *ac);
1014         atomic_inc(&osb->s_num_meta_stolen);
1015         if (status < 0) {
1016                 if (status != -ENOSPC)
1017                         mlog_errno(status);
1018                 goto bail;
1019         }
1020
1021         status = 0;
1022 bail:
1023         if ((status < 0) && *ac) {
1024                 ocfs2_free_alloc_context(*ac);
1025                 *ac = NULL;
1026         }
1027
1028         if (status)
1029                 mlog_errno(status);
1030         return status;
1031 }
1032
1033 int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
1034                                struct ocfs2_extent_list *root_el,
1035                                struct ocfs2_alloc_context **ac)
1036 {
1037         return ocfs2_reserve_new_metadata_blocks(osb,
1038                                         ocfs2_extend_meta_needed(root_el),
1039                                         ac);
1040 }
1041
1042 int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
1043                             struct ocfs2_alloc_context **ac)
1044 {
1045         int status;
1046         int slot = ocfs2_get_inode_steal_slot(osb);
1047         u64 alloc_group;
1048
1049         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1050         if (!(*ac)) {
1051                 status = -ENOMEM;
1052                 mlog_errno(status);
1053                 goto bail;
1054         }
1055
1056         (*ac)->ac_bits_wanted = 1;
1057         (*ac)->ac_which = OCFS2_AC_USE_INODE;
1058
1059         (*ac)->ac_group_search = ocfs2_block_group_search;
1060
1061         /*
1062          * stat(2) can't handle i_ino > 32bits, so we tell the
1063          * lower levels not to allocate us a block group past that
1064          * limit.  The 'inode64' mount option avoids this behavior.
1065          */
1066         if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64))
1067                 (*ac)->ac_max_block = (u32)~0U;
1068
1069         /*
1070          * slot is set when we successfully steal inode from other nodes.
1071          * It is reset in 3 places:
1072          * 1. when we flush the truncate log
1073          * 2. when we complete local alloc recovery.
1074          * 3. when we successfully allocate from our own slot.
1075          * After it is set, we will go on stealing inodes until we find the
1076          * need to check our slots to see whether there is some space for us.
1077          */
1078         if (slot != OCFS2_INVALID_SLOT &&
1079             atomic_read(&osb->s_num_inodes_stolen) < OCFS2_MAX_TO_STEAL)
1080                 goto inode_steal;
1081
1082         atomic_set(&osb->s_num_inodes_stolen, 0);
1083         alloc_group = osb->osb_inode_alloc_group;
1084         status = ocfs2_reserve_suballoc_bits(osb, *ac,
1085                                              INODE_ALLOC_SYSTEM_INODE,
1086                                              (u32)osb->slot_num,
1087                                              &alloc_group,
1088                                              ALLOC_NEW_GROUP |
1089                                              ALLOC_GROUPS_FROM_GLOBAL);
1090         if (status >= 0) {
1091                 status = 0;
1092
1093                 spin_lock(&osb->osb_lock);
1094                 osb->osb_inode_alloc_group = alloc_group;
1095                 spin_unlock(&osb->osb_lock);
1096                 trace_ocfs2_reserve_new_inode_new_group(
1097                         (unsigned long long)alloc_group);
1098
1099                 /*
1100                  * Some inodes must be freed by us, so try to allocate
1101                  * from our own next time.
1102                  */
1103                 if (slot != OCFS2_INVALID_SLOT)
1104                         ocfs2_init_inode_steal_slot(osb);
1105                 goto bail;
1106         } else if (status < 0 && status != -ENOSPC) {
1107                 mlog_errno(status);
1108                 goto bail;
1109         }
1110
1111         ocfs2_free_ac_resource(*ac);
1112
1113 inode_steal:
1114         status = ocfs2_steal_inode(osb, *ac);
1115         atomic_inc(&osb->s_num_inodes_stolen);
1116         if (status < 0) {
1117                 if (status != -ENOSPC)
1118                         mlog_errno(status);
1119                 goto bail;
1120         }
1121
1122         status = 0;
1123 bail:
1124         if ((status < 0) && *ac) {
1125                 ocfs2_free_alloc_context(*ac);
1126                 *ac = NULL;
1127         }
1128
1129         if (status)
1130                 mlog_errno(status);
1131         return status;
1132 }
1133
1134 /* local alloc code has to do the same thing, so rather than do this
1135  * twice.. */
1136 int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
1137                                       struct ocfs2_alloc_context *ac)
1138 {
1139         int status;
1140
1141         ac->ac_which = OCFS2_AC_USE_MAIN;
1142         ac->ac_group_search = ocfs2_cluster_group_search;
1143
1144         status = ocfs2_reserve_suballoc_bits(osb, ac,
1145                                              GLOBAL_BITMAP_SYSTEM_INODE,
1146                                              OCFS2_INVALID_SLOT, NULL,
1147                                              ALLOC_NEW_GROUP);
1148         if (status < 0 && status != -ENOSPC)
1149                 mlog_errno(status);
1150
1151         return status;
1152 }
1153
1154 /* Callers don't need to care which bitmap (local alloc or main) to
1155  * use so we figure it out for them, but unfortunately this clutters
1156  * things a bit. */
1157 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
1158                                              u32 bits_wanted, u64 max_block,
1159                                              int flags,
1160                                              struct ocfs2_alloc_context **ac)
1161 {
1162         int status, ret = 0;
1163         int retried = 0;
1164
1165         *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1166         if (!(*ac)) {
1167                 status = -ENOMEM;
1168                 mlog_errno(status);
1169                 goto bail;
1170         }
1171
1172         (*ac)->ac_bits_wanted = bits_wanted;
1173         (*ac)->ac_max_block = max_block;
1174
1175         status = -ENOSPC;
1176         if (!(flags & ALLOC_GROUPS_FROM_GLOBAL) &&
1177             ocfs2_alloc_should_use_local(osb, bits_wanted)) {
1178                 status = ocfs2_reserve_local_alloc_bits(osb,
1179                                                         bits_wanted,
1180                                                         *ac);
1181                 if ((status < 0) && (status != -ENOSPC)) {
1182                         mlog_errno(status);
1183                         goto bail;
1184                 }
1185         }
1186
1187         if (status == -ENOSPC) {
1188 retry:
1189                 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1190                 /* Retry if there is sufficient space cached in truncate log */
1191                 if (status == -ENOSPC && !retried) {
1192                         retried = 1;
1193                         ocfs2_inode_unlock((*ac)->ac_inode, 1);
1194                         inode_unlock((*ac)->ac_inode);
1195
1196                         ret = ocfs2_try_to_free_truncate_log(osb, bits_wanted);
1197                         if (ret == 1) {
1198                                 iput((*ac)->ac_inode);
1199                                 (*ac)->ac_inode = NULL;
1200                                 goto retry;
1201                         }
1202
1203                         if (ret < 0)
1204                                 mlog_errno(ret);
1205
1206                         inode_lock((*ac)->ac_inode);
1207                         ret = ocfs2_inode_lock((*ac)->ac_inode, NULL, 1);
1208                         if (ret < 0) {
1209                                 mlog_errno(ret);
1210                                 inode_unlock((*ac)->ac_inode);
1211                                 iput((*ac)->ac_inode);
1212                                 (*ac)->ac_inode = NULL;
1213                                 goto bail;
1214                         }
1215                 }
1216                 if (status < 0) {
1217                         if (status != -ENOSPC)
1218                                 mlog_errno(status);
1219                         goto bail;
1220                 }
1221         }
1222
1223         status = 0;
1224 bail:
1225         if ((status < 0) && *ac) {
1226                 ocfs2_free_alloc_context(*ac);
1227                 *ac = NULL;
1228         }
1229
1230         if (status)
1231                 mlog_errno(status);
1232         return status;
1233 }
1234
1235 int ocfs2_reserve_clusters(struct ocfs2_super *osb,
1236                            u32 bits_wanted,
1237                            struct ocfs2_alloc_context **ac)
1238 {
1239         return ocfs2_reserve_clusters_with_limit(osb, bits_wanted, 0,
1240                                                  ALLOC_NEW_GROUP, ac);
1241 }
1242
1243 /*
1244  * More or less lifted from ext3. I'll leave their description below:
1245  *
1246  * "For ext3 allocations, we must not reuse any blocks which are
1247  * allocated in the bitmap buffer's "last committed data" copy.  This
1248  * prevents deletes from freeing up the page for reuse until we have
1249  * committed the delete transaction.
1250  *
1251  * If we didn't do this, then deleting something and reallocating it as
1252  * data would allow the old block to be overwritten before the
1253  * transaction committed (because we force data to disk before commit).
1254  * This would lead to corruption if we crashed between overwriting the
1255  * data and committing the delete.
1256  *
1257  * @@@ We may want to make this allocation behaviour conditional on
1258  * data-writes at some point, and disable it for metadata allocations or
1259  * sync-data inodes."
1260  *
1261  * Note: OCFS2 already does this differently for metadata vs data
1262  * allocations, as those bitmaps are separate and undo access is never
1263  * called on a metadata group descriptor.
1264  */
1265 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh,
1266                                          int nr)
1267 {
1268         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1269         int ret;
1270
1271         if (ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap))
1272                 return 0;
1273
1274         if (!buffer_jbd(bg_bh))
1275                 return 1;
1276
1277         jbd_lock_bh_state(bg_bh);
1278         bg = (struct ocfs2_group_desc *) bh2jh(bg_bh)->b_committed_data;
1279         if (bg)
1280                 ret = !ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap);
1281         else
1282                 ret = 1;
1283         jbd_unlock_bh_state(bg_bh);
1284
1285         return ret;
1286 }
1287
1288 static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb,
1289                                              struct buffer_head *bg_bh,
1290                                              unsigned int bits_wanted,
1291                                              unsigned int total_bits,
1292                                              struct ocfs2_suballoc_result *res)
1293 {
1294         void *bitmap;
1295         u16 best_offset, best_size;
1296         int offset, start, found, status = 0;
1297         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1298
1299         /* Callers got this descriptor from
1300          * ocfs2_read_group_descriptor().  Any corruption is a code bug. */
1301         BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1302
1303         found = start = best_offset = best_size = 0;
1304         bitmap = bg->bg_bitmap;
1305
1306         while((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) != -1) {
1307                 if (offset == total_bits)
1308                         break;
1309
1310                 if (!ocfs2_test_bg_bit_allocatable(bg_bh, offset)) {
1311                         /* We found a zero, but we can't use it as it
1312                          * hasn't been put to disk yet! */
1313                         found = 0;
1314                         start = offset + 1;
1315                 } else if (offset == start) {
1316                         /* we found a zero */
1317                         found++;
1318                         /* move start to the next bit to test */
1319                         start++;
1320                 } else {
1321                         /* got a zero after some ones */
1322                         found = 1;
1323                         start = offset + 1;
1324                 }
1325                 if (found > best_size) {
1326                         best_size = found;
1327                         best_offset = start - found;
1328                 }
1329                 /* we got everything we needed */
1330                 if (found == bits_wanted) {
1331                         /* mlog(0, "Found it all!\n"); */
1332                         break;
1333                 }
1334         }
1335
1336         if (best_size) {
1337                 res->sr_bit_offset = best_offset;
1338                 res->sr_bits = best_size;
1339         } else {
1340                 status = -ENOSPC;
1341                 /* No error log here -- see the comment above
1342                  * ocfs2_test_bg_bit_allocatable */
1343         }
1344
1345         return status;
1346 }
1347
1348 int ocfs2_block_group_set_bits(handle_t *handle,
1349                                              struct inode *alloc_inode,
1350                                              struct ocfs2_group_desc *bg,
1351                                              struct buffer_head *group_bh,
1352                                              unsigned int bit_off,
1353                                              unsigned int num_bits)
1354 {
1355         int status;
1356         void *bitmap = bg->bg_bitmap;
1357         int journal_type = OCFS2_JOURNAL_ACCESS_WRITE;
1358
1359         /* All callers get the descriptor via
1360          * ocfs2_read_group_descriptor().  Any corruption is a code bug. */
1361         BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1362         BUG_ON(le16_to_cpu(bg->bg_free_bits_count) < num_bits);
1363
1364         trace_ocfs2_block_group_set_bits(bit_off, num_bits);
1365
1366         if (ocfs2_is_cluster_bitmap(alloc_inode))
1367                 journal_type = OCFS2_JOURNAL_ACCESS_UNDO;
1368
1369         status = ocfs2_journal_access_gd(handle,
1370                                          INODE_CACHE(alloc_inode),
1371                                          group_bh,
1372                                          journal_type);
1373         if (status < 0) {
1374                 mlog_errno(status);
1375                 goto bail;
1376         }
1377
1378         le16_add_cpu(&bg->bg_free_bits_count, -num_bits);
1379         if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) {
1380                 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n",
1381                                    (unsigned long long)le64_to_cpu(bg->bg_blkno),
1382                                    le16_to_cpu(bg->bg_bits),
1383                                    le16_to_cpu(bg->bg_free_bits_count),
1384                                    num_bits);
1385         }
1386         while(num_bits--)
1387                 ocfs2_set_bit(bit_off++, bitmap);
1388
1389         ocfs2_journal_dirty(handle, group_bh);
1390
1391 bail:
1392         return status;
1393 }
1394
1395 /* find the one with the most empty bits */
1396 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl)
1397 {
1398         u16 curr, best;
1399
1400         BUG_ON(!cl->cl_next_free_rec);
1401
1402         best = curr = 0;
1403         while (curr < le16_to_cpu(cl->cl_next_free_rec)) {
1404                 if (le32_to_cpu(cl->cl_recs[curr].c_free) >
1405                     le32_to_cpu(cl->cl_recs[best].c_free))
1406                         best = curr;
1407                 curr++;
1408         }
1409
1410         BUG_ON(best >= le16_to_cpu(cl->cl_next_free_rec));
1411         return best;
1412 }
1413
1414 static int ocfs2_relink_block_group(handle_t *handle,
1415                                     struct inode *alloc_inode,
1416                                     struct buffer_head *fe_bh,
1417                                     struct buffer_head *bg_bh,
1418                                     struct buffer_head *prev_bg_bh,
1419                                     u16 chain)
1420 {
1421         int status;
1422         /* there is a really tiny chance the journal calls could fail,
1423          * but we wouldn't want inconsistent blocks in *any* case. */
1424         u64 bg_ptr, prev_bg_ptr;
1425         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
1426         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1427         struct ocfs2_group_desc *prev_bg = (struct ocfs2_group_desc *) prev_bg_bh->b_data;
1428
1429         /* The caller got these descriptors from
1430          * ocfs2_read_group_descriptor().  Any corruption is a code bug. */
1431         BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1432         BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(prev_bg));
1433
1434         trace_ocfs2_relink_block_group(
1435                 (unsigned long long)le64_to_cpu(fe->i_blkno), chain,
1436                 (unsigned long long)le64_to_cpu(bg->bg_blkno),
1437                 (unsigned long long)le64_to_cpu(prev_bg->bg_blkno));
1438
1439         bg_ptr = le64_to_cpu(bg->bg_next_group);
1440         prev_bg_ptr = le64_to_cpu(prev_bg->bg_next_group);
1441
1442         status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
1443                                          prev_bg_bh,
1444                                          OCFS2_JOURNAL_ACCESS_WRITE);
1445         if (status < 0)
1446                 goto out;
1447
1448         prev_bg->bg_next_group = bg->bg_next_group;
1449         ocfs2_journal_dirty(handle, prev_bg_bh);
1450
1451         status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
1452                                          bg_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1453         if (status < 0)
1454                 goto out_rollback_prev_bg;
1455
1456         bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno;
1457         ocfs2_journal_dirty(handle, bg_bh);
1458
1459         status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
1460                                          fe_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1461         if (status < 0)
1462                 goto out_rollback_bg;
1463
1464         fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno;
1465         ocfs2_journal_dirty(handle, fe_bh);
1466
1467 out:
1468         if (status < 0)
1469                 mlog_errno(status);
1470         return status;
1471
1472 out_rollback_bg:
1473         bg->bg_next_group = cpu_to_le64(bg_ptr);
1474 out_rollback_prev_bg:
1475         prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr);
1476         goto out;
1477 }
1478
1479 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
1480                                                      u32 wanted)
1481 {
1482         return le16_to_cpu(bg->bg_free_bits_count) > wanted;
1483 }
1484
1485 /* return 0 on success, -ENOSPC to keep searching and any other < 0
1486  * value on error. */
1487 static int ocfs2_cluster_group_search(struct inode *inode,
1488                                       struct buffer_head *group_bh,
1489                                       u32 bits_wanted, u32 min_bits,
1490                                       u64 max_block,
1491                                       struct ocfs2_suballoc_result *res)
1492 {
1493         int search = -ENOSPC;
1494         int ret;
1495         u64 blkoff;
1496         struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *) group_bh->b_data;
1497         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1498         unsigned int max_bits, gd_cluster_off;
1499
1500         BUG_ON(!ocfs2_is_cluster_bitmap(inode));
1501
1502         if (gd->bg_free_bits_count) {
1503                 max_bits = le16_to_cpu(gd->bg_bits);
1504
1505                 /* Tail groups in cluster bitmaps which aren't cpg
1506                  * aligned are prone to partial extension by a failed
1507                  * fs resize. If the file system resize never got to
1508                  * update the dinode cluster count, then we don't want
1509                  * to trust any clusters past it, regardless of what
1510                  * the group descriptor says. */
1511                 gd_cluster_off = ocfs2_blocks_to_clusters(inode->i_sb,
1512                                                           le64_to_cpu(gd->bg_blkno));
1513                 if ((gd_cluster_off + max_bits) >
1514                     OCFS2_I(inode)->ip_clusters) {
1515                         max_bits = OCFS2_I(inode)->ip_clusters - gd_cluster_off;
1516                         trace_ocfs2_cluster_group_search_wrong_max_bits(
1517                                 (unsigned long long)le64_to_cpu(gd->bg_blkno),
1518                                 le16_to_cpu(gd->bg_bits),
1519                                 OCFS2_I(inode)->ip_clusters, max_bits);
1520                 }
1521
1522                 ret = ocfs2_block_group_find_clear_bits(osb,
1523                                                         group_bh, bits_wanted,
1524                                                         max_bits, res);
1525                 if (ret)
1526                         return ret;
1527
1528                 if (max_block) {
1529                         blkoff = ocfs2_clusters_to_blocks(inode->i_sb,
1530                                                           gd_cluster_off +
1531                                                           res->sr_bit_offset +
1532                                                           res->sr_bits);
1533                         trace_ocfs2_cluster_group_search_max_block(
1534                                 (unsigned long long)blkoff,
1535                                 (unsigned long long)max_block);
1536                         if (blkoff > max_block)
1537                                 return -ENOSPC;
1538                 }
1539
1540                 /* ocfs2_block_group_find_clear_bits() might
1541                  * return success, but we still want to return
1542                  * -ENOSPC unless it found the minimum number
1543                  * of bits. */
1544                 if (min_bits <= res->sr_bits)
1545                         search = 0; /* success */
1546                 else if (res->sr_bits) {
1547                         /*
1548                          * Don't show bits which we'll be returning
1549                          * for allocation to the local alloc bitmap.
1550                          */
1551                         ocfs2_local_alloc_seen_free_bits(osb, res->sr_bits);
1552                 }
1553         }
1554
1555         return search;
1556 }
1557
1558 static int ocfs2_block_group_search(struct inode *inode,
1559                                     struct buffer_head *group_bh,
1560                                     u32 bits_wanted, u32 min_bits,
1561                                     u64 max_block,
1562                                     struct ocfs2_suballoc_result *res)
1563 {
1564         int ret = -ENOSPC;
1565         u64 blkoff;
1566         struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) group_bh->b_data;
1567
1568         BUG_ON(min_bits != 1);
1569         BUG_ON(ocfs2_is_cluster_bitmap(inode));
1570
1571         if (bg->bg_free_bits_count) {
1572                 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb),
1573                                                         group_bh, bits_wanted,
1574                                                         le16_to_cpu(bg->bg_bits),
1575                                                         res);
1576                 if (!ret && max_block) {
1577                         blkoff = le64_to_cpu(bg->bg_blkno) +
1578                                 res->sr_bit_offset + res->sr_bits;
1579                         trace_ocfs2_block_group_search_max_block(
1580                                 (unsigned long long)blkoff,
1581                                 (unsigned long long)max_block);
1582                         if (blkoff > max_block)
1583                                 ret = -ENOSPC;
1584                 }
1585         }
1586
1587         return ret;
1588 }
1589
1590 int ocfs2_alloc_dinode_update_counts(struct inode *inode,
1591                                        handle_t *handle,
1592                                        struct buffer_head *di_bh,
1593                                        u32 num_bits,
1594                                        u16 chain)
1595 {
1596         int ret;
1597         u32 tmp_used;
1598         struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
1599         struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &di->id2.i_chain;
1600
1601         ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
1602                                       OCFS2_JOURNAL_ACCESS_WRITE);
1603         if (ret < 0) {
1604                 mlog_errno(ret);
1605                 goto out;
1606         }
1607
1608         tmp_used = le32_to_cpu(di->id1.bitmap1.i_used);
1609         di->id1.bitmap1.i_used = cpu_to_le32(num_bits + tmp_used);
1610         le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits);
1611         ocfs2_journal_dirty(handle, di_bh);
1612
1613 out:
1614         return ret;
1615 }
1616
1617 void ocfs2_rollback_alloc_dinode_counts(struct inode *inode,
1618                                        struct buffer_head *di_bh,
1619                                        u32 num_bits,
1620                                        u16 chain)
1621 {
1622         u32 tmp_used;
1623         struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
1624         struct ocfs2_chain_list *cl;
1625
1626         cl = (struct ocfs2_chain_list *)&di->id2.i_chain;
1627         tmp_used = le32_to_cpu(di->id1.bitmap1.i_used);
1628         di->id1.bitmap1.i_used = cpu_to_le32(tmp_used - num_bits);
1629         le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits);
1630 }
1631
1632 static int ocfs2_bg_discontig_fix_by_rec(struct ocfs2_suballoc_result *res,
1633                                          struct ocfs2_extent_rec *rec,
1634                                          struct ocfs2_chain_list *cl)
1635 {
1636         unsigned int bpc = le16_to_cpu(cl->cl_bpc);
1637         unsigned int bitoff = le32_to_cpu(rec->e_cpos) * bpc;
1638         unsigned int bitcount = le16_to_cpu(rec->e_leaf_clusters) * bpc;
1639
1640         if (res->sr_bit_offset < bitoff)
1641                 return 0;
1642         if (res->sr_bit_offset >= (bitoff + bitcount))
1643                 return 0;
1644         res->sr_blkno = le64_to_cpu(rec->e_blkno) +
1645                 (res->sr_bit_offset - bitoff);
1646         if ((res->sr_bit_offset + res->sr_bits) > (bitoff + bitcount))
1647                 res->sr_bits = (bitoff + bitcount) - res->sr_bit_offset;
1648         return 1;
1649 }
1650
1651 static void ocfs2_bg_discontig_fix_result(struct ocfs2_alloc_context *ac,
1652                                           struct ocfs2_group_desc *bg,
1653                                           struct ocfs2_suballoc_result *res)
1654 {
1655         int i;
1656         u64 bg_blkno = res->sr_bg_blkno;  /* Save off */
1657         struct ocfs2_extent_rec *rec;
1658         struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data;
1659         struct ocfs2_chain_list *cl = &di->id2.i_chain;
1660
1661         if (ocfs2_is_cluster_bitmap(ac->ac_inode)) {
1662                 res->sr_blkno = 0;
1663                 return;
1664         }
1665
1666         res->sr_blkno = res->sr_bg_blkno + res->sr_bit_offset;
1667         res->sr_bg_blkno = 0;  /* Clear it for contig block groups */
1668         if (!ocfs2_supports_discontig_bg(OCFS2_SB(ac->ac_inode->i_sb)) ||
1669             !bg->bg_list.l_next_free_rec)
1670                 return;
1671
1672         for (i = 0; i < le16_to_cpu(bg->bg_list.l_next_free_rec); i++) {
1673                 rec = &bg->bg_list.l_recs[i];
1674                 if (ocfs2_bg_discontig_fix_by_rec(res, rec, cl)) {
1675                         res->sr_bg_blkno = bg_blkno;  /* Restore */
1676                         break;
1677                 }
1678         }
1679 }
1680
1681 static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
1682                                   handle_t *handle,
1683                                   u32 bits_wanted,
1684                                   u32 min_bits,
1685                                   struct ocfs2_suballoc_result *res,
1686                                   u16 *bits_left)
1687 {
1688         int ret;
1689         struct buffer_head *group_bh = NULL;
1690         struct ocfs2_group_desc *gd;
1691         struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data;
1692         struct inode *alloc_inode = ac->ac_inode;
1693
1694         ret = ocfs2_read_group_descriptor(alloc_inode, di,
1695                                           res->sr_bg_blkno, &group_bh);
1696         if (ret < 0) {
1697                 mlog_errno(ret);
1698                 return ret;
1699         }
1700
1701         gd = (struct ocfs2_group_desc *) group_bh->b_data;
1702         ret = ac->ac_group_search(alloc_inode, group_bh, bits_wanted, min_bits,
1703                                   ac->ac_max_block, res);
1704         if (ret < 0) {
1705                 if (ret != -ENOSPC)
1706                         mlog_errno(ret);
1707                 goto out;
1708         }
1709
1710         if (!ret)
1711                 ocfs2_bg_discontig_fix_result(ac, gd, res);
1712
1713         /*
1714          * sr_bg_blkno might have been changed by
1715          * ocfs2_bg_discontig_fix_result
1716          */
1717         res->sr_bg_stable_blkno = group_bh->b_blocknr;
1718
1719         if (ac->ac_find_loc_only)
1720                 goto out_loc_only;
1721
1722         ret = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, ac->ac_bh,
1723                                                res->sr_bits,
1724                                                le16_to_cpu(gd->bg_chain));
1725         if (ret < 0) {
1726                 mlog_errno(ret);
1727                 goto out;
1728         }
1729
1730         ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh,
1731                                          res->sr_bit_offset, res->sr_bits);
1732         if (ret < 0) {
1733                 ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh,
1734                                                res->sr_bits,
1735                                                le16_to_cpu(gd->bg_chain));
1736                 mlog_errno(ret);
1737         }
1738
1739 out_loc_only:
1740         *bits_left = le16_to_cpu(gd->bg_free_bits_count);
1741
1742 out:
1743         brelse(group_bh);
1744
1745         return ret;
1746 }
1747
1748 static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
1749                               handle_t *handle,
1750                               u32 bits_wanted,
1751                               u32 min_bits,
1752                               struct ocfs2_suballoc_result *res,
1753                               u16 *bits_left)
1754 {
1755         int status;
1756         u16 chain;
1757         u64 next_group;
1758         struct inode *alloc_inode = ac->ac_inode;
1759         struct buffer_head *group_bh = NULL;
1760         struct buffer_head *prev_group_bh = NULL;
1761         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) ac->ac_bh->b_data;
1762         struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;
1763         struct ocfs2_group_desc *bg;
1764
1765         chain = ac->ac_chain;
1766         trace_ocfs2_search_chain_begin(
1767                 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno,
1768                 bits_wanted, chain);
1769
1770         status = ocfs2_read_group_descriptor(alloc_inode, fe,
1771                                              le64_to_cpu(cl->cl_recs[chain].c_blkno),
1772                                              &group_bh);
1773         if (status < 0) {
1774                 mlog_errno(status);
1775                 goto bail;
1776         }
1777         bg = (struct ocfs2_group_desc *) group_bh->b_data;
1778
1779         status = -ENOSPC;
1780         /* for now, the chain search is a bit simplistic. We just use
1781          * the 1st group with any empty bits. */
1782         while ((status = ac->ac_group_search(alloc_inode, group_bh,
1783                                              bits_wanted, min_bits,
1784                                              ac->ac_max_block,
1785                                              res)) == -ENOSPC) {
1786                 if (!bg->bg_next_group)
1787                         break;
1788
1789                 brelse(prev_group_bh);
1790                 prev_group_bh = NULL;
1791
1792                 next_group = le64_to_cpu(bg->bg_next_group);
1793                 prev_group_bh = group_bh;
1794                 group_bh = NULL;
1795                 status = ocfs2_read_group_descriptor(alloc_inode, fe,
1796                                                      next_group, &group_bh);
1797                 if (status < 0) {
1798                         mlog_errno(status);
1799                         goto bail;
1800                 }
1801                 bg = (struct ocfs2_group_desc *) group_bh->b_data;
1802         }
1803         if (status < 0) {
1804                 if (status != -ENOSPC)
1805                         mlog_errno(status);
1806                 goto bail;
1807         }
1808
1809         trace_ocfs2_search_chain_succ(
1810                 (unsigned long long)le64_to_cpu(bg->bg_blkno), res->sr_bits);
1811
1812         res->sr_bg_blkno = le64_to_cpu(bg->bg_blkno);
1813
1814         BUG_ON(res->sr_bits == 0);
1815         if (!status)
1816                 ocfs2_bg_discontig_fix_result(ac, bg, res);
1817
1818         /*
1819          * sr_bg_blkno might have been changed by
1820          * ocfs2_bg_discontig_fix_result
1821          */
1822         res->sr_bg_stable_blkno = group_bh->b_blocknr;
1823
1824         /*
1825          * Keep track of previous block descriptor read. When
1826          * we find a target, if we have read more than X
1827          * number of descriptors, and the target is reasonably
1828          * empty, relink him to top of his chain.
1829          *
1830          * We've read 0 extra blocks and only send one more to
1831          * the transaction, yet the next guy to search has a
1832          * much easier time.
1833          *
1834          * Do this *after* figuring out how many bits we're taking out
1835          * of our target group.
1836          */
1837         if (!ac->ac_disable_chain_relink &&
1838             (prev_group_bh) &&
1839             (ocfs2_block_group_reasonably_empty(bg, res->sr_bits))) {
1840                 status = ocfs2_relink_block_group(handle, alloc_inode,
1841                                                   ac->ac_bh, group_bh,
1842                                                   prev_group_bh, chain);
1843                 if (status < 0) {
1844                         mlog_errno(status);
1845                         goto bail;
1846                 }
1847         }
1848
1849         if (ac->ac_find_loc_only)
1850                 goto out_loc_only;
1851
1852         status = ocfs2_alloc_dinode_update_counts(alloc_inode, handle,
1853                                                   ac->ac_bh, res->sr_bits,
1854                                                   chain);
1855         if (status) {
1856                 mlog_errno(status);
1857                 goto bail;
1858         }
1859
1860         status = ocfs2_block_group_set_bits(handle,
1861                                             alloc_inode,
1862                                             bg,
1863                                             group_bh,
1864                                             res->sr_bit_offset,
1865                                             res->sr_bits);
1866         if (status < 0) {
1867                 ocfs2_rollback_alloc_dinode_counts(alloc_inode,
1868                                         ac->ac_bh, res->sr_bits, chain);
1869                 mlog_errno(status);
1870                 goto bail;
1871         }
1872
1873         trace_ocfs2_search_chain_end(
1874                         (unsigned long long)le64_to_cpu(fe->i_blkno),
1875                         res->sr_bits);
1876
1877 out_loc_only:
1878         *bits_left = le16_to_cpu(bg->bg_free_bits_count);
1879 bail:
1880         brelse(group_bh);
1881         brelse(prev_group_bh);
1882
1883         if (status)
1884                 mlog_errno(status);
1885         return status;
1886 }
1887
1888 /* will give out up to bits_wanted contiguous bits. */
1889 static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
1890                                      handle_t *handle,
1891                                      u32 bits_wanted,
1892                                      u32 min_bits,
1893                                      struct ocfs2_suballoc_result *res)
1894 {
1895         int status;
1896         u16 victim, i;
1897         u16 bits_left = 0;
1898         u64 hint = ac->ac_last_group;
1899         struct ocfs2_chain_list *cl;
1900         struct ocfs2_dinode *fe;
1901
1902         BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
1903         BUG_ON(bits_wanted > (ac->ac_bits_wanted - ac->ac_bits_given));
1904         BUG_ON(!ac->ac_bh);
1905
1906         fe = (struct ocfs2_dinode *) ac->ac_bh->b_data;
1907
1908         /* The bh was validated by the inode read during
1909          * ocfs2_reserve_suballoc_bits().  Any corruption is a code bug. */
1910         BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
1911
1912         if (le32_to_cpu(fe->id1.bitmap1.i_used) >=
1913             le32_to_cpu(fe->id1.bitmap1.i_total)) {
1914                 status = ocfs2_error(ac->ac_inode->i_sb,
1915                                      "Chain allocator dinode %llu has %u used bits but only %u total\n",
1916                                      (unsigned long long)le64_to_cpu(fe->i_blkno),
1917                                      le32_to_cpu(fe->id1.bitmap1.i_used),
1918                                      le32_to_cpu(fe->id1.bitmap1.i_total));
1919                 goto bail;
1920         }
1921
1922         res->sr_bg_blkno = hint;
1923         if (res->sr_bg_blkno) {
1924                 /* Attempt to short-circuit the usual search mechanism
1925                  * by jumping straight to the most recently used
1926                  * allocation group. This helps us maintain some
1927                  * contiguousness across allocations. */
1928                 status = ocfs2_search_one_group(ac, handle, bits_wanted,
1929                                                 min_bits, res, &bits_left);
1930                 if (!status)
1931                         goto set_hint;
1932                 if (status < 0 && status != -ENOSPC) {
1933                         mlog_errno(status);
1934                         goto bail;
1935                 }
1936         }
1937
1938         cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;
1939
1940         victim = ocfs2_find_victim_chain(cl);
1941         ac->ac_chain = victim;
1942
1943         status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
1944                                     res, &bits_left);
1945         if (!status) {
1946                 if (ocfs2_is_cluster_bitmap(ac->ac_inode))
1947                         hint = res->sr_bg_blkno;
1948                 else
1949                         hint = ocfs2_group_from_res(res);
1950                 goto set_hint;
1951         }
1952         if (status < 0 && status != -ENOSPC) {
1953                 mlog_errno(status);
1954                 goto bail;
1955         }
1956
1957         trace_ocfs2_claim_suballoc_bits(victim);
1958
1959         /* If we didn't pick a good victim, then just default to
1960          * searching each chain in order. Don't allow chain relinking
1961          * because we only calculate enough journal credits for one
1962          * relink per alloc. */
1963         ac->ac_disable_chain_relink = 1;
1964         for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) {
1965                 if (i == victim)
1966                         continue;
1967                 if (!cl->cl_recs[i].c_free)
1968                         continue;
1969
1970                 ac->ac_chain = i;
1971                 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
1972                                             res, &bits_left);
1973                 if (!status) {
1974                         hint = ocfs2_group_from_res(res);
1975                         break;
1976                 }
1977                 if (status < 0 && status != -ENOSPC) {
1978                         mlog_errno(status);
1979                         goto bail;
1980                 }
1981         }
1982
1983 set_hint:
1984         if (status != -ENOSPC) {
1985                 /* If the next search of this group is not likely to
1986                  * yield a suitable extent, then we reset the last
1987                  * group hint so as to not waste a disk read */
1988                 if (bits_left < min_bits)
1989                         ac->ac_last_group = 0;
1990                 else
1991                         ac->ac_last_group = hint;
1992         }
1993
1994 bail:
1995         if (status)
1996                 mlog_errno(status);
1997         return status;
1998 }
1999
2000 int ocfs2_claim_metadata(handle_t *handle,
2001                          struct ocfs2_alloc_context *ac,
2002                          u32 bits_wanted,
2003                          u64 *suballoc_loc,
2004                          u16 *suballoc_bit_start,
2005                          unsigned int *num_bits,
2006                          u64 *blkno_start)
2007 {
2008         int status;
2009         struct ocfs2_suballoc_result res = { .sr_blkno = 0, };
2010
2011         BUG_ON(!ac);
2012         BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted));
2013         BUG_ON(ac->ac_which != OCFS2_AC_USE_META);
2014
2015         status = ocfs2_claim_suballoc_bits(ac,
2016                                            handle,
2017                                            bits_wanted,
2018                                            1,
2019                                            &res);
2020         if (status < 0) {
2021                 mlog_errno(status);
2022                 goto bail;
2023         }
2024         atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2025
2026         *suballoc_loc = res.sr_bg_blkno;
2027         *suballoc_bit_start = res.sr_bit_offset;
2028         *blkno_start = res.sr_blkno;
2029         ac->ac_bits_given += res.sr_bits;
2030         *num_bits = res.sr_bits;
2031         status = 0;
2032 bail:
2033         if (status)
2034                 mlog_errno(status);
2035         return status;
2036 }
2037
2038 static void ocfs2_init_inode_ac_group(struct inode *dir,
2039                                       struct buffer_head *parent_di_bh,
2040                                       struct ocfs2_alloc_context *ac)
2041 {
2042         struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_di_bh->b_data;
2043         /*
2044          * Try to allocate inodes from some specific group.
2045          *
2046          * If the parent dir has recorded the last group used in allocation,
2047          * cool, use it. Otherwise if we try to allocate new inode from the
2048          * same slot the parent dir belongs to, use the same chunk.
2049          *
2050          * We are very careful here to avoid the mistake of setting
2051          * ac_last_group to a group descriptor from a different (unlocked) slot.
2052          */
2053         if (OCFS2_I(dir)->ip_last_used_group &&
2054             OCFS2_I(dir)->ip_last_used_slot == ac->ac_alloc_slot)
2055                 ac->ac_last_group = OCFS2_I(dir)->ip_last_used_group;
2056         else if (le16_to_cpu(di->i_suballoc_slot) == ac->ac_alloc_slot) {
2057                 if (di->i_suballoc_loc)
2058                         ac->ac_last_group = le64_to_cpu(di->i_suballoc_loc);
2059                 else
2060                         ac->ac_last_group = ocfs2_which_suballoc_group(
2061                                         le64_to_cpu(di->i_blkno),
2062                                         le16_to_cpu(di->i_suballoc_bit));
2063         }
2064 }
2065
2066 static inline void ocfs2_save_inode_ac_group(struct inode *dir,
2067                                              struct ocfs2_alloc_context *ac)
2068 {
2069         OCFS2_I(dir)->ip_last_used_group = ac->ac_last_group;
2070         OCFS2_I(dir)->ip_last_used_slot = ac->ac_alloc_slot;
2071 }
2072
2073 int ocfs2_find_new_inode_loc(struct inode *dir,
2074                              struct buffer_head *parent_fe_bh,
2075                              struct ocfs2_alloc_context *ac,
2076                              u64 *fe_blkno)
2077 {
2078         int ret;
2079         handle_t *handle = NULL;
2080         struct ocfs2_suballoc_result *res;
2081
2082         BUG_ON(!ac);
2083         BUG_ON(ac->ac_bits_given != 0);
2084         BUG_ON(ac->ac_bits_wanted != 1);
2085         BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
2086
2087         res = kzalloc(sizeof(*res), GFP_NOFS);
2088         if (res == NULL) {
2089                 ret = -ENOMEM;
2090                 mlog_errno(ret);
2091                 goto out;
2092         }
2093
2094         ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac);
2095
2096         /*
2097          * The handle started here is for chain relink. Alternatively,
2098          * we could just disable relink for these calls.
2099          */
2100         handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC);
2101         if (IS_ERR(handle)) {
2102                 ret = PTR_ERR(handle);
2103                 handle = NULL;
2104                 mlog_errno(ret);
2105                 goto out;
2106         }
2107
2108         /*
2109          * This will instruct ocfs2_claim_suballoc_bits and
2110          * ocfs2_search_one_group to search but save actual allocation
2111          * for later.
2112          */
2113         ac->ac_find_loc_only = 1;
2114
2115         ret = ocfs2_claim_suballoc_bits(ac, handle, 1, 1, res);
2116         if (ret < 0) {
2117                 mlog_errno(ret);
2118                 goto out;
2119         }
2120
2121         ac->ac_find_loc_priv = res;
2122         *fe_blkno = res->sr_blkno;
2123         ocfs2_update_inode_fsync_trans(handle, dir, 0);
2124 out:
2125         if (handle)
2126                 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle);
2127
2128         if (ret)
2129                 kfree(res);
2130
2131         return ret;
2132 }
2133
2134 int ocfs2_claim_new_inode_at_loc(handle_t *handle,
2135                                  struct inode *dir,
2136                                  struct ocfs2_alloc_context *ac,
2137                                  u64 *suballoc_loc,
2138                                  u16 *suballoc_bit,
2139                                  u64 di_blkno)
2140 {
2141         int ret;
2142         u16 chain;
2143         struct ocfs2_suballoc_result *res = ac->ac_find_loc_priv;
2144         struct buffer_head *bg_bh = NULL;
2145         struct ocfs2_group_desc *bg;
2146         struct ocfs2_dinode *di = (struct ocfs2_dinode *) ac->ac_bh->b_data;
2147
2148         /*
2149          * Since di_blkno is being passed back in, we check for any
2150          * inconsistencies which may have happened between
2151          * calls. These are code bugs as di_blkno is not expected to
2152          * change once returned from ocfs2_find_new_inode_loc()
2153          */
2154         BUG_ON(res->sr_blkno != di_blkno);
2155
2156         ret = ocfs2_read_group_descriptor(ac->ac_inode, di,
2157                                           res->sr_bg_stable_blkno, &bg_bh);
2158         if (ret) {
2159                 mlog_errno(ret);
2160                 goto out;
2161         }
2162
2163         bg = (struct ocfs2_group_desc *) bg_bh->b_data;
2164         chain = le16_to_cpu(bg->bg_chain);
2165
2166         ret = ocfs2_alloc_dinode_update_counts(ac->ac_inode, handle,
2167                                                ac->ac_bh, res->sr_bits,
2168                                                chain);
2169         if (ret) {
2170                 mlog_errno(ret);
2171                 goto out;
2172         }
2173
2174         ret = ocfs2_block_group_set_bits(handle,
2175                                          ac->ac_inode,
2176                                          bg,
2177                                          bg_bh,
2178                                          res->sr_bit_offset,
2179                                          res->sr_bits);
2180         if (ret < 0) {
2181                 ocfs2_rollback_alloc_dinode_counts(ac->ac_inode,
2182                                                ac->ac_bh, res->sr_bits, chain);
2183                 mlog_errno(ret);
2184                 goto out;
2185         }
2186
2187         trace_ocfs2_claim_new_inode_at_loc((unsigned long long)di_blkno,
2188                                            res->sr_bits);
2189
2190         atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2191
2192         BUG_ON(res->sr_bits != 1);
2193
2194         *suballoc_loc = res->sr_bg_blkno;
2195         *suballoc_bit = res->sr_bit_offset;
2196         ac->ac_bits_given++;
2197         ocfs2_save_inode_ac_group(dir, ac);
2198
2199 out:
2200         brelse(bg_bh);
2201
2202         return ret;
2203 }
2204
2205 int ocfs2_claim_new_inode(handle_t *handle,
2206                           struct inode *dir,
2207                           struct buffer_head *parent_fe_bh,
2208                           struct ocfs2_alloc_context *ac,
2209                           u64 *suballoc_loc,
2210                           u16 *suballoc_bit,
2211                           u64 *fe_blkno)
2212 {
2213         int status;
2214         struct ocfs2_suballoc_result res;
2215
2216         BUG_ON(!ac);
2217         BUG_ON(ac->ac_bits_given != 0);
2218         BUG_ON(ac->ac_bits_wanted != 1);
2219         BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
2220
2221         ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac);
2222
2223         status = ocfs2_claim_suballoc_bits(ac,
2224                                            handle,
2225                                            1,
2226                                            1,
2227                                            &res);
2228         if (status < 0) {
2229                 mlog_errno(status);
2230                 goto bail;
2231         }
2232         atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2233
2234         BUG_ON(res.sr_bits != 1);
2235
2236         *suballoc_loc = res.sr_bg_blkno;
2237         *suballoc_bit = res.sr_bit_offset;
2238         *fe_blkno = res.sr_blkno;
2239         ac->ac_bits_given++;
2240         ocfs2_save_inode_ac_group(dir, ac);
2241         status = 0;
2242 bail:
2243         if (status)
2244                 mlog_errno(status);
2245         return status;
2246 }
2247
2248 /* translate a group desc. blkno and it's bitmap offset into
2249  * disk cluster offset. */
2250 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode,
2251                                                    u64 bg_blkno,
2252                                                    u16 bg_bit_off)
2253 {
2254         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2255         u32 cluster = 0;
2256
2257         BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2258
2259         if (bg_blkno != osb->first_cluster_group_blkno)
2260                 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno);
2261         cluster += (u32) bg_bit_off;
2262         return cluster;
2263 }
2264
2265 /* given a cluster offset, calculate which block group it belongs to
2266  * and return that block offset. */
2267 u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster)
2268 {
2269         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2270         u32 group_no;
2271
2272         BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2273
2274         group_no = cluster / osb->bitmap_cpg;
2275         if (!group_no)
2276                 return osb->first_cluster_group_blkno;
2277         return ocfs2_clusters_to_blocks(inode->i_sb,
2278                                         group_no * osb->bitmap_cpg);
2279 }
2280
2281 /* given the block number of a cluster start, calculate which cluster
2282  * group and descriptor bitmap offset that corresponds to. */
2283 static inline void ocfs2_block_to_cluster_group(struct inode *inode,
2284                                                 u64 data_blkno,
2285                                                 u64 *bg_blkno,
2286                                                 u16 *bg_bit_off)
2287 {
2288         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2289         u32 data_cluster = ocfs2_blocks_to_clusters(osb->sb, data_blkno);
2290
2291         BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2292
2293         *bg_blkno = ocfs2_which_cluster_group(inode,
2294                                               data_cluster);
2295
2296         if (*bg_blkno == osb->first_cluster_group_blkno)
2297                 *bg_bit_off = (u16) data_cluster;
2298         else
2299                 *bg_bit_off = (u16) ocfs2_blocks_to_clusters(osb->sb,
2300                                                              data_blkno - *bg_blkno);
2301 }
2302
2303 /*
2304  * min_bits - minimum contiguous chunk from this total allocation we
2305  * can handle. set to what we asked for originally for a full
2306  * contig. allocation, set to '1' to indicate we can deal with extents
2307  * of any size.
2308  */
2309 int __ocfs2_claim_clusters(handle_t *handle,
2310                            struct ocfs2_alloc_context *ac,
2311                            u32 min_clusters,
2312                            u32 max_clusters,
2313                            u32 *cluster_start,
2314                            u32 *num_clusters)
2315 {
2316         int status;
2317         unsigned int bits_wanted = max_clusters;
2318         struct ocfs2_suballoc_result res = { .sr_blkno = 0, };
2319         struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb);
2320
2321         BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
2322
2323         BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL
2324                && ac->ac_which != OCFS2_AC_USE_MAIN);
2325
2326         if (ac->ac_which == OCFS2_AC_USE_LOCAL) {
2327                 WARN_ON(min_clusters > 1);
2328
2329                 status = ocfs2_claim_local_alloc_bits(osb,
2330                                                       handle,
2331                                                       ac,
2332                                                       bits_wanted,
2333                                                       cluster_start,
2334                                                       num_clusters);
2335                 if (!status)
2336                         atomic_inc(&osb->alloc_stats.local_data);
2337         } else {
2338                 if (min_clusters > (osb->bitmap_cpg - 1)) {
2339                         /* The only paths asking for contiguousness
2340                          * should know about this already. */
2341                         mlog(ML_ERROR, "minimum allocation requested %u exceeds "
2342                              "group bitmap size %u!\n", min_clusters,
2343                              osb->bitmap_cpg);
2344                         status = -ENOSPC;
2345                         goto bail;
2346                 }
2347                 /* clamp the current request down to a realistic size. */
2348                 if (bits_wanted > (osb->bitmap_cpg - 1))
2349                         bits_wanted = osb->bitmap_cpg - 1;
2350
2351                 status = ocfs2_claim_suballoc_bits(ac,
2352                                                    handle,
2353                                                    bits_wanted,
2354                                                    min_clusters,
2355                                                    &res);
2356                 if (!status) {
2357                         BUG_ON(res.sr_blkno); /* cluster alloc can't set */
2358                         *cluster_start =
2359                                 ocfs2_desc_bitmap_to_cluster_off(ac->ac_inode,
2360                                                                  res.sr_bg_blkno,
2361                                                                  res.sr_bit_offset);
2362                         atomic_inc(&osb->alloc_stats.bitmap_data);
2363                         *num_clusters = res.sr_bits;
2364                 }
2365         }
2366         if (status < 0) {
2367                 if (status != -ENOSPC)
2368                         mlog_errno(status);
2369                 goto bail;
2370         }
2371
2372         ac->ac_bits_given += *num_clusters;
2373
2374 bail:
2375         if (status)
2376                 mlog_errno(status);
2377         return status;
2378 }
2379
2380 int ocfs2_claim_clusters(handle_t *handle,
2381                          struct ocfs2_alloc_context *ac,
2382                          u32 min_clusters,
2383                          u32 *cluster_start,
2384                          u32 *num_clusters)
2385 {
2386         unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
2387
2388         return __ocfs2_claim_clusters(handle, ac, min_clusters,
2389                                       bits_wanted, cluster_start, num_clusters);
2390 }
2391
2392 static int ocfs2_block_group_clear_bits(handle_t *handle,
2393                                         struct inode *alloc_inode,
2394                                         struct ocfs2_group_desc *bg,
2395                                         struct buffer_head *group_bh,
2396                                         unsigned int bit_off,
2397                                         unsigned int num_bits,
2398                                         void (*undo_fn)(unsigned int bit,
2399                                                         unsigned long *bmap))
2400 {
2401         int status;
2402         unsigned int tmp;
2403         struct ocfs2_group_desc *undo_bg = NULL;
2404
2405         /* The caller got this descriptor from
2406          * ocfs2_read_group_descriptor().  Any corruption is a code bug. */
2407         BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
2408
2409         trace_ocfs2_block_group_clear_bits(bit_off, num_bits);
2410
2411         BUG_ON(undo_fn && !ocfs2_is_cluster_bitmap(alloc_inode));
2412         status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
2413                                          group_bh,
2414                                          undo_fn ?
2415                                          OCFS2_JOURNAL_ACCESS_UNDO :
2416                                          OCFS2_JOURNAL_ACCESS_WRITE);
2417         if (status < 0) {
2418                 mlog_errno(status);
2419                 goto bail;
2420         }
2421
2422         if (undo_fn) {
2423                 jbd_lock_bh_state(group_bh);
2424                 undo_bg = (struct ocfs2_group_desc *)
2425                                         bh2jh(group_bh)->b_committed_data;
2426                 BUG_ON(!undo_bg);
2427         }
2428
2429         tmp = num_bits;
2430         while(tmp--) {
2431                 ocfs2_clear_bit((bit_off + tmp),
2432                                 (unsigned long *) bg->bg_bitmap);
2433                 if (undo_fn)
2434                         undo_fn(bit_off + tmp,
2435                                 (unsigned long *) undo_bg->bg_bitmap);
2436         }
2437         le16_add_cpu(&bg->bg_free_bits_count, num_bits);
2438         if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) {
2439                 if (undo_fn)
2440                         jbd_unlock_bh_state(group_bh);
2441                 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n",
2442                                    (unsigned long long)le64_to_cpu(bg->bg_blkno),
2443                                    le16_to_cpu(bg->bg_bits),
2444                                    le16_to_cpu(bg->bg_free_bits_count),
2445                                    num_bits);
2446         }
2447
2448         if (undo_fn)
2449                 jbd_unlock_bh_state(group_bh);
2450
2451         ocfs2_journal_dirty(handle, group_bh);
2452 bail:
2453         return status;
2454 }
2455
2456 /*
2457  * expects the suballoc inode to already be locked.
2458  */
2459 static int _ocfs2_free_suballoc_bits(handle_t *handle,
2460                                      struct inode *alloc_inode,
2461                                      struct buffer_head *alloc_bh,
2462                                      unsigned int start_bit,
2463                                      u64 bg_blkno,
2464                                      unsigned int count,
2465                                      void (*undo_fn)(unsigned int bit,
2466                                                      unsigned long *bitmap))
2467 {
2468         int status = 0;
2469         u32 tmp_used;
2470         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data;
2471         struct ocfs2_chain_list *cl = &fe->id2.i_chain;
2472         struct buffer_head *group_bh = NULL;
2473         struct ocfs2_group_desc *group;
2474
2475         /* The alloc_bh comes from ocfs2_free_dinode() or
2476          * ocfs2_free_clusters().  The callers have all locked the
2477          * allocator and gotten alloc_bh from the lock call.  This
2478          * validates the dinode buffer.  Any corruption that has happened
2479          * is a code bug. */
2480         BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
2481         BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl));
2482
2483         trace_ocfs2_free_suballoc_bits(
2484                 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno,
2485                 (unsigned long long)bg_blkno,
2486                 start_bit, count);
2487
2488         status = ocfs2_read_group_descriptor(alloc_inode, fe, bg_blkno,
2489                                              &group_bh);
2490         if (status < 0) {
2491                 mlog_errno(status);
2492                 goto bail;
2493         }
2494         group = (struct ocfs2_group_desc *) group_bh->b_data;
2495
2496         BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits));
2497
2498         status = ocfs2_block_group_clear_bits(handle, alloc_inode,
2499                                               group, group_bh,
2500                                               start_bit, count, undo_fn);
2501         if (status < 0) {
2502                 mlog_errno(status);
2503                 goto bail;
2504         }
2505
2506         status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
2507                                          alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2508         if (status < 0) {
2509                 mlog_errno(status);
2510                 ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh,
2511                                 start_bit, count);
2512                 goto bail;
2513         }
2514
2515         le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free,
2516                      count);
2517         tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used);
2518         fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count);
2519         ocfs2_journal_dirty(handle, alloc_bh);
2520
2521 bail:
2522         brelse(group_bh);
2523
2524         if (status)
2525                 mlog_errno(status);
2526         return status;
2527 }
2528
2529 int ocfs2_free_suballoc_bits(handle_t *handle,
2530                              struct inode *alloc_inode,
2531                              struct buffer_head *alloc_bh,
2532                              unsigned int start_bit,
2533                              u64 bg_blkno,
2534                              unsigned int count)
2535 {
2536         return _ocfs2_free_suballoc_bits(handle, alloc_inode, alloc_bh,
2537                                          start_bit, bg_blkno, count, NULL);
2538 }
2539
2540 int ocfs2_free_dinode(handle_t *handle,
2541                       struct inode *inode_alloc_inode,
2542                       struct buffer_head *inode_alloc_bh,
2543                       struct ocfs2_dinode *di)
2544 {
2545         u64 blk = le64_to_cpu(di->i_blkno);
2546         u16 bit = le16_to_cpu(di->i_suballoc_bit);
2547         u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
2548
2549         if (di->i_suballoc_loc)
2550                 bg_blkno = le64_to_cpu(di->i_suballoc_loc);
2551         return ocfs2_free_suballoc_bits(handle, inode_alloc_inode,
2552                                         inode_alloc_bh, bit, bg_blkno, 1);
2553 }
2554
2555 static int _ocfs2_free_clusters(handle_t *handle,
2556                                 struct inode *bitmap_inode,
2557                                 struct buffer_head *bitmap_bh,
2558                                 u64 start_blk,
2559                                 unsigned int num_clusters,
2560                                 void (*undo_fn)(unsigned int bit,
2561                                                 unsigned long *bitmap))
2562 {
2563         int status;
2564         u16 bg_start_bit;
2565         u64 bg_blkno;
2566
2567         /* You can't ever have a contiguous set of clusters
2568          * bigger than a block group bitmap so we never have to worry
2569          * about looping on them.
2570          * This is expensive. We can safely remove once this stuff has
2571          * gotten tested really well. */
2572         BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb,
2573                                 ocfs2_blocks_to_clusters(bitmap_inode->i_sb,
2574                                                          start_blk)));
2575
2576
2577         ocfs2_block_to_cluster_group(bitmap_inode, start_blk, &bg_blkno,
2578                                      &bg_start_bit);
2579
2580         trace_ocfs2_free_clusters((unsigned long long)bg_blkno,
2581                         (unsigned long long)start_blk,
2582                         bg_start_bit, num_clusters);
2583
2584         status = _ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh,
2585                                            bg_start_bit, bg_blkno,
2586                                            num_clusters, undo_fn);
2587         if (status < 0) {
2588                 mlog_errno(status);
2589                 goto out;
2590         }
2591
2592         ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb),
2593                                          num_clusters);
2594
2595 out:
2596         if (status)
2597                 mlog_errno(status);
2598         return status;
2599 }
2600
2601 int ocfs2_free_clusters(handle_t *handle,
2602                         struct inode *bitmap_inode,
2603                         struct buffer_head *bitmap_bh,
2604                         u64 start_blk,
2605                         unsigned int num_clusters)
2606 {
2607         return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh,
2608                                     start_blk, num_clusters,
2609                                     _ocfs2_set_bit);
2610 }
2611
2612 /*
2613  * Give never-used clusters back to the global bitmap.  We don't need
2614  * to protect these bits in the undo buffer.
2615  */
2616 int ocfs2_release_clusters(handle_t *handle,
2617                            struct inode *bitmap_inode,
2618                            struct buffer_head *bitmap_bh,
2619                            u64 start_blk,
2620                            unsigned int num_clusters)
2621 {
2622         return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh,
2623                                     start_blk, num_clusters,
2624                                     _ocfs2_clear_bit);
2625 }
2626
2627 /*
2628  * For a given allocation, determine which allocators will need to be
2629  * accessed, and lock them, reserving the appropriate number of bits.
2630  *
2631  * Sparse file systems call this from ocfs2_write_begin_nolock()
2632  * and ocfs2_allocate_unwritten_extents().
2633  *
2634  * File systems which don't support holes call this from
2635  * ocfs2_extend_allocation().
2636  */
2637 int ocfs2_lock_allocators(struct inode *inode,
2638                           struct ocfs2_extent_tree *et,
2639                           u32 clusters_to_add, u32 extents_to_split,
2640                           struct ocfs2_alloc_context **data_ac,
2641                           struct ocfs2_alloc_context **meta_ac)
2642 {
2643         int ret = 0, num_free_extents;
2644         unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
2645         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2646
2647         *meta_ac = NULL;
2648         if (data_ac)
2649                 *data_ac = NULL;
2650
2651         BUG_ON(clusters_to_add != 0 && data_ac == NULL);
2652
2653         num_free_extents = ocfs2_num_free_extents(et);
2654         if (num_free_extents < 0) {
2655                 ret = num_free_extents;
2656                 mlog_errno(ret);
2657                 goto out;
2658         }
2659
2660         /*
2661          * Sparse allocation file systems need to be more conservative
2662          * with reserving room for expansion - the actual allocation
2663          * happens while we've got a journal handle open so re-taking
2664          * a cluster lock (because we ran out of room for another
2665          * extent) will violate ordering rules.
2666          *
2667          * Most of the time we'll only be seeing this 1 cluster at a time
2668          * anyway.
2669          *
2670          * Always lock for any unwritten extents - we might want to
2671          * add blocks during a split.
2672          */
2673         if (!num_free_extents ||
2674             (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
2675                 ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac);
2676                 if (ret < 0) {
2677                         if (ret != -ENOSPC)
2678                                 mlog_errno(ret);
2679                         goto out;
2680                 }
2681         }
2682
2683         if (clusters_to_add == 0)
2684                 goto out;
2685
2686         ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
2687         if (ret < 0) {
2688                 if (ret != -ENOSPC)
2689                         mlog_errno(ret);
2690                 goto out;
2691         }
2692
2693 out:
2694         if (ret) {
2695                 if (*meta_ac) {
2696                         ocfs2_free_alloc_context(*meta_ac);
2697                         *meta_ac = NULL;
2698                 }
2699
2700                 /*
2701                  * We cannot have an error and a non null *data_ac.
2702                  */
2703         }
2704
2705         return ret;
2706 }
2707
2708 /*
2709  * Read the inode specified by blkno to get suballoc_slot and
2710  * suballoc_bit.
2711  */
2712 static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super *osb, u64 blkno,
2713                                        u16 *suballoc_slot, u64 *group_blkno,
2714                                        u16 *suballoc_bit)
2715 {
2716         int status;
2717         struct buffer_head *inode_bh = NULL;
2718         struct ocfs2_dinode *inode_fe;
2719
2720         trace_ocfs2_get_suballoc_slot_bit((unsigned long long)blkno);
2721
2722         /* dirty read disk */
2723         status = ocfs2_read_blocks_sync(osb, blkno, 1, &inode_bh);
2724         if (status < 0) {
2725                 mlog(ML_ERROR, "read block %llu failed %d\n",
2726                      (unsigned long long)blkno, status);
2727                 goto bail;
2728         }
2729
2730         inode_fe = (struct ocfs2_dinode *) inode_bh->b_data;
2731         if (!OCFS2_IS_VALID_DINODE(inode_fe)) {
2732                 mlog(ML_ERROR, "invalid inode %llu requested\n",
2733                      (unsigned long long)blkno);
2734                 status = -EINVAL;
2735                 goto bail;
2736         }
2737
2738         if (le16_to_cpu(inode_fe->i_suballoc_slot) != (u16)OCFS2_INVALID_SLOT &&
2739             (u32)le16_to_cpu(inode_fe->i_suballoc_slot) > osb->max_slots - 1) {
2740                 mlog(ML_ERROR, "inode %llu has invalid suballoc slot %u\n",
2741                      (unsigned long long)blkno,
2742                      (u32)le16_to_cpu(inode_fe->i_suballoc_slot));
2743                 status = -EINVAL;
2744                 goto bail;
2745         }
2746
2747         if (suballoc_slot)
2748                 *suballoc_slot = le16_to_cpu(inode_fe->i_suballoc_slot);
2749         if (suballoc_bit)
2750                 *suballoc_bit = le16_to_cpu(inode_fe->i_suballoc_bit);
2751         if (group_blkno)
2752                 *group_blkno = le64_to_cpu(inode_fe->i_suballoc_loc);
2753
2754 bail:
2755         brelse(inode_bh);
2756
2757         if (status)
2758                 mlog_errno(status);
2759         return status;
2760 }
2761
2762 /*
2763  * test whether bit is SET in allocator bitmap or not.  on success, 0
2764  * is returned and *res is 1 for SET; 0 otherwise.  when fails, errno
2765  * is returned and *res is meaningless.  Call this after you have
2766  * cluster locked against suballoc, or you may get a result based on
2767  * non-up2date contents
2768  */
2769 static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb,
2770                                    struct inode *suballoc,
2771                                    struct buffer_head *alloc_bh,
2772                                    u64 group_blkno, u64 blkno,
2773                                    u16 bit, int *res)
2774 {
2775         struct ocfs2_dinode *alloc_di;
2776         struct ocfs2_group_desc *group;
2777         struct buffer_head *group_bh = NULL;
2778         u64 bg_blkno;
2779         int status;
2780
2781         trace_ocfs2_test_suballoc_bit((unsigned long long)blkno,
2782                                       (unsigned int)bit);
2783
2784         alloc_di = (struct ocfs2_dinode *)alloc_bh->b_data;
2785         if ((bit + 1) > ocfs2_bits_per_group(&alloc_di->id2.i_chain)) {
2786                 mlog(ML_ERROR, "suballoc bit %u out of range of %u\n",
2787                      (unsigned int)bit,
2788                      ocfs2_bits_per_group(&alloc_di->id2.i_chain));
2789                 status = -EINVAL;
2790                 goto bail;
2791         }
2792
2793         bg_blkno = group_blkno ? group_blkno :
2794                    ocfs2_which_suballoc_group(blkno, bit);
2795         status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno,
2796                                              &group_bh);
2797         if (status < 0) {
2798                 mlog(ML_ERROR, "read group %llu failed %d\n",
2799                      (unsigned long long)bg_blkno, status);
2800                 goto bail;
2801         }
2802
2803         group = (struct ocfs2_group_desc *) group_bh->b_data;
2804         *res = ocfs2_test_bit(bit, (unsigned long *)group->bg_bitmap);
2805
2806 bail:
2807         brelse(group_bh);
2808
2809         if (status)
2810                 mlog_errno(status);
2811         return status;
2812 }
2813
2814 /*
2815  * Test if the bit representing this inode (blkno) is set in the
2816  * suballocator.
2817  *
2818  * On success, 0 is returned and *res is 1 for SET; 0 otherwise.
2819  *
2820  * In the event of failure, a negative value is returned and *res is
2821  * meaningless.
2822  *
2823  * Callers must make sure to hold nfs_sync_lock to prevent
2824  * ocfs2_delete_inode() on another node from accessing the same
2825  * suballocator concurrently.
2826  */
2827 int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
2828 {
2829         int status;
2830         u64 group_blkno = 0;
2831         u16 suballoc_bit = 0, suballoc_slot = 0;
2832         struct inode *inode_alloc_inode;
2833         struct buffer_head *alloc_bh = NULL;
2834
2835         trace_ocfs2_test_inode_bit((unsigned long long)blkno);
2836
2837         status = ocfs2_get_suballoc_slot_bit(osb, blkno, &suballoc_slot,
2838                                              &group_blkno, &suballoc_bit);
2839         if (status < 0) {
2840                 mlog(ML_ERROR, "get alloc slot and bit failed %d\n", status);
2841                 goto bail;
2842         }
2843
2844         inode_alloc_inode =
2845                 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE,
2846                                             suballoc_slot);
2847         if (!inode_alloc_inode) {
2848                 /* the error code could be inaccurate, but we are not able to
2849                  * get the correct one. */
2850                 status = -EINVAL;
2851                 mlog(ML_ERROR, "unable to get alloc inode in slot %u\n",
2852                      (u32)suballoc_slot);
2853                 goto bail;
2854         }
2855
2856         inode_lock(inode_alloc_inode);
2857         status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0);
2858         if (status < 0) {
2859                 inode_unlock(inode_alloc_inode);
2860                 iput(inode_alloc_inode);
2861                 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n",
2862                      (u32)suballoc_slot, status);
2863                 goto bail;
2864         }
2865
2866         status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh,
2867                                          group_blkno, blkno, suballoc_bit, res);
2868         if (status < 0)
2869                 mlog(ML_ERROR, "test suballoc bit failed %d\n", status);
2870
2871         ocfs2_inode_unlock(inode_alloc_inode, 0);
2872         inode_unlock(inode_alloc_inode);
2873
2874         iput(inode_alloc_inode);
2875         brelse(alloc_bh);
2876 bail:
2877         if (status)
2878                 mlog_errno(status);
2879         return status;
2880 }