fs/gfs2/rgrp.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/slab.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/completion.h>
  15 #include <linux/buffer_head.h>
  16 #include <linux/fs.h>
  17 #include <linux/gfs2_ondisk.h>
  18 #include <linux/prefetch.h>
  19 #include <linux/blkdev.h>
  20 #include <linux/rbtree.h>
  21 #include <linux/random.h>
  22
  23 #include "gfs2.h"
  24 #include "incore.h"
  25 #include "glock.h"
  26 #include "glops.h"
  27 #include "lops.h"
  28 #include "meta_io.h"
  29 #include "quota.h"
  30 #include "rgrp.h"
  31 #include "super.h"
  32 #include "trans.h"
  33 #include "util.h"
  34 #include "log.h"
  35 #include "inode.h"
  36 #include "trace_gfs2.h"
  37
  38 #define BFITNOENT ((u32)~0)
  39 #define NO_BLOCK ((u64)~0)
  40
  41 #if BITS_PER_LONG == 32
  42 #define LBITMASK   (0x55555555UL)
  43 #define LBITSKIP55 (0x55555555UL)
  44 #define LBITSKIP00 (0x00000000UL)
  45 #else
  46 #define LBITMASK   (0x5555555555555555UL)
  47 #define LBITSKIP55 (0x5555555555555555UL)
  48 #define LBITSKIP00 (0x0000000000000000UL)
  49 #endif
  50
  51 /*
  52  * These routines are used by the resource group routines (rgrp.c)
  53  * to keep track of block allocation.  Each block is represented by two
  54  * bits.  So, each byte represents GFS2_NBBY (i.e. 4) blocks.
  55  *
  56  * 0 = Free
  57  * 1 = Used (not metadata)
  58  * 2 = Unlinked (still in use) inode
  59  * 3 = Used (metadata)
  60  */
  61
  62 struct gfs2_extent {
  63         struct gfs2_rbm rbm;
  64         u32 len;
  65 };
  66
  67 static const char valid_change[16] = {
  68                 /* current */
  69         /* n */ 0, 1, 1, 1,
  70         /* e */ 1, 0, 0, 0,
  71         /* w */ 0, 0, 0, 1,
  72                 1, 0, 0, 0
  73 };
  74
  75 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
  76                          const struct gfs2_inode *ip, bool nowrap);
  77
  78
  79 /**
  80  * gfs2_setbit - Set a bit in the bitmaps
  81  * @rbm: The position of the bit to set
  82  * @do_clone: Also set the clone bitmap, if it exists
  83  * @new_state: the new state of the block
  84  *
  85  */
  86
  87 static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
  88                                unsigned char new_state)
  89 {
  90         unsigned char *byte1, *byte2, *end, cur_state;
  91         struct gfs2_bitmap *bi = rbm_bi(rbm);
  92         unsigned int buflen = bi->bi_len;
  93         const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
  94
  95         byte1 = bi->bi_bh->b_data + bi->bi_offset + (rbm->offset / GFS2_NBBY);
  96         end = bi->bi_bh->b_data + bi->bi_offset + buflen;
  97
  98         BUG_ON(byte1 >= end);
  99
 100         cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
 101
 102         if (unlikely(!valid_change[new_state * 4 + cur_state])) {
 103                 pr_warn("buf_blk = 0x%x old_state=%d, new_state=%d\n",
 104                         rbm->offset, cur_state, new_state);
 105                 pr_warn("rgrp=0x%llx bi_start=0x%x\n",
 106                         (unsigned long long)rbm->rgd->rd_addr, bi->bi_start);
 107                 pr_warn("bi_offset=0x%x bi_len=0x%x\n",
 108                         bi->bi_offset, bi->bi_len);
 109                 dump_stack();
 110                 gfs2_consist_rgrpd(rbm->rgd);
 111                 return;
 112         }
 113         *byte1 ^= (cur_state ^ new_state) << bit;
 114
 115         if (do_clone && bi->bi_clone) {
 116                 byte2 = bi->bi_clone + bi->bi_offset + (rbm->offset / GFS2_NBBY);
 117                 cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
 118                 *byte2 ^= (cur_state ^ new_state) << bit;
 119         }
 120 }
 121
 122 /**
 123  * gfs2_testbit - test a bit in the bitmaps
 124  * @rbm: The bit to test
 125  *
 126  * Returns: The two bit block state of the requested bit
 127  */
 128
 129 static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm)
 130 {
 131         struct gfs2_bitmap *bi = rbm_bi(rbm);
 132         const u8 *buffer = bi->bi_bh->b_data + bi->bi_offset;
 133         const u8 *byte;
 134         unsigned int bit;
 135
 136         byte = buffer + (rbm->offset / GFS2_NBBY);
 137         bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
 138
 139         return (*byte >> bit) & GFS2_BIT_MASK;
 140 }
 141
 142 /**
 143  * gfs2_bit_search
 144  * @ptr: Pointer to bitmap data
 145  * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
 146  * @state: The state we are searching for
 147  *
 148  * We xor the bitmap data with a patter which is the bitwise opposite
 149  * of what we are looking for, this gives rise to a pattern of ones
 150  * wherever there is a match. Since we have two bits per entry, we
 151  * take this pattern, shift it down by one place and then and it with
 152  * the original. All the even bit positions (0,2,4, etc) then represent
 153  * successful matches, so we mask with 0x55555..... to remove the unwanted
 154  * odd bit positions.
 155  *
 156  * This allows searching of a whole u64 at once (32 blocks) with a
 157  * single test (on 64 bit arches).
 158  */
 159
 160 static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
 161 {
 162         u64 tmp;
 163         static const u64 search[] = {
 164                 [0] = 0xffffffffffffffffULL,
 165                 [1] = 0xaaaaaaaaaaaaaaaaULL,
 166                 [2] = 0x5555555555555555ULL,
 167                 [3] = 0x0000000000000000ULL,
 168         };
 169         tmp = le64_to_cpu(*ptr) ^ search[state];
 170         tmp &= (tmp >> 1);
 171         tmp &= mask;
 172         return tmp;
 173 }
 174
 175 /**
 176  * rs_cmp - multi-block reservation range compare
 177  * @blk: absolute file system block number of the new reservation
 178  * @len: number of blocks in the new reservation
 179  * @rs: existing reservation to compare against
 180  *
 181  * returns: 1 if the block range is beyond the reach of the reservation
 182  *         -1 if the block range is before the start of the reservation
 183  *          0 if the block range overlaps with the reservation
 184  */
 185 static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
 186 {
 187         u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
 188
 189         if (blk >= startblk + rs->rs_free)
 190                 return 1;
 191         if (blk + len - 1 < startblk)
 192                 return -1;
 193         return 0;
 194 }
 195
 196 /**
 197  * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 198  *       a block in a given allocation state.
 199  * @buf: the buffer that holds the bitmaps
 200  * @len: the length (in bytes) of the buffer
 201  * @goal: start search at this block's bit-pair (within @buffer)
 202  * @state: GFS2_BLKST_XXX the state of the block we're looking for.
 203  *
 204  * Scope of @goal and returned block number is only within this bitmap buffer,
 205  * not entire rgrp or filesystem.  @buffer will be offset from the actual
 206  * beginning of a bitmap block buffer, skipping any header structures, but
 207  * headers are always a multiple of 64 bits long so that the buffer is
 208  * always aligned to a 64 bit boundary.
 209  *
 210  * The size of the buffer is in bytes, but is it assumed that it is
 211  * always ok to read a complete multiple of 64 bits at the end
 212  * of the block in case the end is no aligned to a natural boundary.
 213  *
 214  * Return: the block number (bitmap buffer scope) that was found
 215  */
 216
 217 static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
 218                        u32 goal, u8 state)
 219 {
 220         u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
 221         const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
 222         const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
 223         u64 tmp;
 224         u64 mask = 0x5555555555555555ULL;
 225         u32 bit;
 226
 227         /* Mask off bits we don't care about at the start of the search */
 228         mask <<= spoint;
 229         tmp = gfs2_bit_search(ptr, mask, state);
 230         ptr++;
 231         while(tmp == 0 && ptr < end) {
 232                 tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
 233                 ptr++;
 234         }
 235         /* Mask off any bits which are more than len bytes from the start */
 236         if (ptr == end && (len & (sizeof(u64) - 1)))
 237                 tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
 238         /* Didn't find anything, so return */
 239         if (tmp == 0)
 240                 return BFITNOENT;
 241         ptr--;
 242         bit = __ffs64(tmp);
 243         bit /= 2;       /* two bits per entry in the bitmap */
 244         return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
 245 }
 246
 247 /**
 248  * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
 249  * @rbm: The rbm with rgd already set correctly
 250  * @block: The block number (filesystem relative)
 251  *
 252  * This sets the bi and offset members of an rbm based on a
 253  * resource group and a filesystem relative block number. The
 254  * resource group must be set in the rbm on entry, the bi and
 255  * offset members will be set by this function.
 256  *
 257  * Returns: 0 on success, or an error code
 258  */
 259
 260 static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
 261 {
 262         u64 rblock = block - rbm->rgd->rd_data0;
 263
 264         if (WARN_ON_ONCE(rblock > UINT_MAX))
 265                 return -EINVAL;
 266         if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data)
 267                 return -E2BIG;
 268
 269         rbm->bii = 0;
 270         rbm->offset = (u32)(rblock);
 271         /* Check if the block is within the first block */
 272         if (rbm->offset < rbm_bi(rbm)->bi_blocks)
 273                 return 0;
 274
 275         /* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
 276         rbm->offset += (sizeof(struct gfs2_rgrp) -
 277                         sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
 278         rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
 279         rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
 280         return 0;
 281 }
 282
 283 /**
 284  * gfs2_rbm_incr - increment an rbm structure
 285  * @rbm: The rbm with rgd already set correctly
 286  *
 287  * This function takes an existing rbm structure and increments it to the next
 288  * viable block offset.
 289  *
 290  * Returns: If incrementing the offset would cause the rbm to go past the
 291  *          end of the rgrp, true is returned, otherwise false.
 292  *
 293  */
 294
 295 static bool gfs2_rbm_incr(struct gfs2_rbm *rbm)
 296 {
 297         if (rbm->offset + 1 < rbm_bi(rbm)->bi_blocks) { /* in the same bitmap */
 298                 rbm->offset++;
 299                 return false;
 300         }
 301         if (rbm->bii == rbm->rgd->rd_length - 1) /* at the last bitmap */
 302                 return true;
 303
 304         rbm->offset = 0;
 305         rbm->bii++;
 306         return false;
 307 }
 308
 309 /**
 310  * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
 311  * @rbm: Position to search (value/result)
 312  * @n_unaligned: Number of unaligned blocks to check
 313  * @len: Decremented for each block found (terminate on zero)
 314  *
 315  * Returns: true if a non-free block is encountered
 316  */
 317
 318 static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
 319 {
 320         u32 n;
 321         u8 res;
 322
 323         for (n = 0; n < n_unaligned; n++) {
 324                 res = gfs2_testbit(rbm);
 325                 if (res != GFS2_BLKST_FREE)
 326                         return true;
 327                 (*len)--;
 328                 if (*len == 0)
 329                         return true;
 330                 if (gfs2_rbm_incr(rbm))
 331                         return true;
 332         }
 333
 334         return false;
 335 }
 336
 337 /**
 338  * gfs2_free_extlen - Return extent length of free blocks
 339  * @rrbm: Starting position
 340  * @len: Max length to check
 341  *
 342  * Starting at the block specified by the rbm, see how many free blocks
 343  * there are, not reading more than len blocks ahead. This can be done
 344  * using memchr_inv when the blocks are byte aligned, but has to be done
 345  * on a block by block basis in case of unaligned blocks. Also this
 346  * function can cope with bitmap boundaries (although it must stop on
 347  * a resource group boundary)
 348  *
 349  * Returns: Number of free blocks in the extent
 350  */
 351
 352 static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
 353 {
 354         struct gfs2_rbm rbm = *rrbm;
 355         u32 n_unaligned = rbm.offset & 3;
 356         u32 size = len;
 357         u32 bytes;
 358         u32 chunk_size;
 359         u8 *ptr, *start, *end;
 360         u64 block;
 361         struct gfs2_bitmap *bi;
 362
 363         if (n_unaligned &&
 364             gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
 365                 goto out;
 366
 367         n_unaligned = len & 3;
 368         /* Start is now byte aligned */
 369         while (len > 3) {
 370                 bi = rbm_bi(&rbm);
 371                 start = bi->bi_bh->b_data;
 372                 if (bi->bi_clone)
 373                         start = bi->bi_clone;
 374                 end = start + bi->bi_bh->b_size;
 375                 start += bi->bi_offset;
 376                 BUG_ON(rbm.offset & 3);
 377                 start += (rbm.offset / GFS2_NBBY);
 378                 bytes = min_t(u32, len / GFS2_NBBY, (end - start));
 379                 ptr = memchr_inv(start, 0, bytes);
 380                 chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
 381                 chunk_size *= GFS2_NBBY;
 382                 BUG_ON(len < chunk_size);
 383                 len -= chunk_size;
 384                 block = gfs2_rbm_to_block(&rbm);
 385                 if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
 386                         n_unaligned = 0;
 387                         break;
 388                 }
 389                 if (ptr) {
 390                         n_unaligned = 3;
 391                         break;
 392                 }
 393                 n_unaligned = len & 3;
 394         }
 395
 396         /* Deal with any bits left over at the end */
 397         if (n_unaligned)
 398                 gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
 399 out:
 400         return size - len;
 401 }
 402
 403 /**
 404  * gfs2_bitcount - count the number of bits in a certain state
 405  * @rgd: the resource group descriptor
 406  * @buffer: the buffer that holds the bitmaps
 407  * @buflen: the length (in bytes) of the buffer
 408  * @state: the state of the block we're looking for
 409  *
 410  * Returns: The number of bits
 411  */
 412
 413 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
 414                          unsigned int buflen, u8 state)
 415 {
 416         const u8 *byte = buffer;
 417         const u8 *end = buffer + buflen;
 418         const u8 state1 = state << 2;
 419         const u8 state2 = state << 4;
 420         const u8 state3 = state << 6;
 421         u32 count = 0;
 422
 423         for (; byte < end; byte++) {
 424                 if (((*byte) & 0x03) == state)
 425                         count++;
 426                 if (((*byte) & 0x0C) == state1)
 427                         count++;
 428                 if (((*byte) & 0x30) == state2)
 429                         count++;
 430                 if (((*byte) & 0xC0) == state3)
 431                         count++;
 432         }
 433
 434         return count;
 435 }
 436
 437 /**
 438  * gfs2_rgrp_verify - Verify that a resource group is consistent
 439  * @rgd: the rgrp
 440  *
 441  */
 442
 443 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
 444 {
 445         struct gfs2_sbd *sdp = rgd->rd_sbd;
 446         struct gfs2_bitmap *bi = NULL;
 447         u32 length = rgd->rd_length;
 448         u32 count[4], tmp;
 449         int buf, x;
 450
 451         memset(count, 0, 4 * sizeof(u32));
 452
 453         /* Count # blocks in each of 4 possible allocation states */
 454         for (buf = 0; buf < length; buf++) {
 455                 bi = rgd->rd_bits + buf;
 456                 for (x = 0; x < 4; x++)
 457                         count[x] += gfs2_bitcount(rgd,
 458                                                   bi->bi_bh->b_data +
 459                                                   bi->bi_offset,
 460                                                   bi->bi_len, x);
 461         }
 462
 463         if (count[0] != rgd->rd_free) {
 464                 if (gfs2_consist_rgrpd(rgd))
 465                         fs_err(sdp, "free data mismatch:  %u != %u\n",
 466                                count[0], rgd->rd_free);
 467                 return;
 468         }
 469
 470         tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
 471         if (count[1] != tmp) {
 472                 if (gfs2_consist_rgrpd(rgd))
 473                         fs_err(sdp, "used data mismatch:  %u != %u\n",
 474                                count[1], tmp);
 475                 return;
 476         }
 477
 478         if (count[2] + count[3] != rgd->rd_dinodes) {
 479                 if (gfs2_consist_rgrpd(rgd))
 480                         fs_err(sdp, "used metadata mismatch:  %u != %u\n",
 481                                count[2] + count[3], rgd->rd_dinodes);
 482                 return;
 483         }
 484 }
 485
 486 static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
 487 {
 488         u64 first = rgd->rd_data0;
 489         u64 last = first + rgd->rd_data;
 490         return first <= block && block < last;
 491 }
 492
 493 /**
 494  * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 495  * @sdp: The GFS2 superblock
 496  * @blk: The data block number
 497  * @exact: True if this needs to be an exact match
 498  *
 499  * Returns: The resource group, or NULL if not found
 500  */
 501
 502 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
 503 {
 504         struct rb_node *n, *next;
 505         struct gfs2_rgrpd *cur;
 506
 507         spin_lock(&sdp->sd_rindex_spin);
 508         n = sdp->sd_rindex_tree.rb_node;
 509         while (n) {
 510                 cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
 511                 next = NULL;
 512                 if (blk < cur->rd_addr)
 513                         next = n->rb_left;
 514                 else if (blk >= cur->rd_data0 + cur->rd_data)
 515                         next = n->rb_right;
 516                 if (next == NULL) {
 517                         spin_unlock(&sdp->sd_rindex_spin);
 518                         if (exact) {
 519                                 if (blk < cur->rd_addr)
 520                                         return NULL;
 521                                 if (blk >= cur->rd_data0 + cur->rd_data)
 522                                         return NULL;
 523                         }
 524                         return cur;
 525                 }
 526                 n = next;
 527         }
 528         spin_unlock(&sdp->sd_rindex_spin);
 529
 530         return NULL;
 531 }
 532
 533 /**
 534  * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
 535  * @sdp: The GFS2 superblock
 536  *
 537  * Returns: The first rgrp in the filesystem
 538  */
 539
 540 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
 541 {
 542         const struct rb_node *n;
 543         struct gfs2_rgrpd *rgd;
 544
 545         spin_lock(&sdp->sd_rindex_spin);
 546         n = rb_first(&sdp->sd_rindex_tree);
 547         rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 548         spin_unlock(&sdp->sd_rindex_spin);
 549
 550         return rgd;
 551 }
 552
 553 /**
 554  * gfs2_rgrpd_get_next - get the next RG
 555  * @rgd: the resource group descriptor
 556  *
 557  * Returns: The next rgrp
 558  */
 559
 560 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
 561 {
 562         struct gfs2_sbd *sdp = rgd->rd_sbd;
 563         const struct rb_node *n;
 564
 565         spin_lock(&sdp->sd_rindex_spin);
 566         n = rb_next(&rgd->rd_node);
 567         if (n == NULL)
 568                 n = rb_first(&sdp->sd_rindex_tree);
 569
 570         if (unlikely(&rgd->rd_node == n)) {
 571                 spin_unlock(&sdp->sd_rindex_spin);
 572                 return NULL;
 573         }
 574         rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 575         spin_unlock(&sdp->sd_rindex_spin);
 576         return rgd;
 577 }
 578
 579 void check_and_update_goal(struct gfs2_inode *ip)
 580 {
 581         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 582         if (!ip->i_goal || gfs2_blk2rgrpd(sdp, ip->i_goal, 1) == NULL)
 583                 ip->i_goal = ip->i_no_addr;
 584 }
 585
 586 void gfs2_free_clones(struct gfs2_rgrpd *rgd)
 587 {
 588         int x;
 589
 590         for (x = 0; x < rgd->rd_length; x++) {
 591                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
 592                 kfree(bi->bi_clone);
 593                 bi->bi_clone = NULL;
 594         }
 595 }
 596
 597 /**
 598  * gfs2_rsqa_alloc - make sure we have a reservation assigned to the inode
 599  *                 plus a quota allocations data structure, if necessary
 600  * @ip: the inode for this reservation
 601  */
 602 int gfs2_rsqa_alloc(struct gfs2_inode *ip)
 603 {
 604         return gfs2_qa_alloc(ip);
 605 }
 606
 607 static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs)
 608 {
 609         gfs2_print_dbg(seq, "  B: n:%llu s:%llu b:%u f:%u\n",
 610                        (unsigned long long)rs->rs_inum,
 611                        (unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
 612                        rs->rs_rbm.offset, rs->rs_free);
 613 }
 614
 615 /**
 616  * __rs_deltree - remove a multi-block reservation from the rgd tree
 617  * @rs: The reservation to remove
 618  *
 619  */
 620 static void __rs_deltree(struct gfs2_blkreserv *rs)
 621 {
 622         struct gfs2_rgrpd *rgd;
 623
 624         if (!gfs2_rs_active(rs))
 625                 return;
 626
 627         rgd = rs->rs_rbm.rgd;
 628         trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
 629         rb_erase(&rs->rs_node, &rgd->rd_rstree);
 630         RB_CLEAR_NODE(&rs->rs_node);
 631
 632         if (rs->rs_free) {
 633                 u64 last_block = gfs2_rbm_to_block(&rs->rs_rbm) +
 634                                  rs->rs_free - 1;
 635                 struct gfs2_rbm last_rbm = { .rgd = rs->rs_rbm.rgd, };
 636                 struct gfs2_bitmap *start, *last;
 637
 638                 /* return reserved blocks to the rgrp */
 639                 BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
 640                 rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
 641                 /* The rgrp extent failure point is likely not to increase;
 642                    it will only do so if the freed blocks are somehow
 643                    contiguous with a span of free blocks that follows. Still,
 644                    it will force the number to be recalculated later. */
 645                 rgd->rd_extfail_pt += rs->rs_free;
 646                 rs->rs_free = 0;
 647                 if (gfs2_rbm_from_block(&last_rbm, last_block))
 648                         return;
 649                 start = rbm_bi(&rs->rs_rbm);
 650                 last = rbm_bi(&last_rbm);
 651                 do
 652                         clear_bit(GBF_FULL, &start->bi_flags);
 653                 while (start++ != last);
 654         }
 655 }
 656
 657 /**
 658  * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
 659  * @rs: The reservation to remove
 660  *
 661  */
 662 void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
 663 {
 664         struct gfs2_rgrpd *rgd;
 665
 666         rgd = rs->rs_rbm.rgd;
 667         if (rgd) {
 668                 spin_lock(&rgd->rd_rsspin);
 669                 __rs_deltree(rs);
 670                 BUG_ON(rs->rs_free);
 671                 spin_unlock(&rgd->rd_rsspin);
 672         }
 673 }
 674
 675 /**
 676  * gfs2_rsqa_delete - delete a multi-block reservation and quota allocation
 677  * @ip: The inode for this reservation
 678  * @wcount: The inode's write count, or NULL
 679  *
 680  */
 681 void gfs2_rsqa_delete(struct gfs2_inode *ip, atomic_t *wcount)
 682 {
 683         down_write(&ip->i_rw_mutex);
 684         if ((wcount == NULL) || (atomic_read(wcount) <= 1))
 685                 gfs2_rs_deltree(&ip->i_res);
 686         up_write(&ip->i_rw_mutex);
 687         gfs2_qa_delete(ip, wcount);
 688 }
 689
 690 /**
 691  * return_all_reservations - return all reserved blocks back to the rgrp.
 692  * @rgd: the rgrp that needs its space back
 693  *
 694  * We previously reserved a bunch of blocks for allocation. Now we need to
 695  * give them back. This leave the reservation structures in tact, but removes
 696  * all of their corresponding "no-fly zones".
 697  */
 698 static void return_all_reservations(struct gfs2_rgrpd *rgd)
 699 {
 700         struct rb_node *n;
 701         struct gfs2_blkreserv *rs;
 702
 703         spin_lock(&rgd->rd_rsspin);
 704         while ((n = rb_first(&rgd->rd_rstree))) {
 705                 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
 706                 __rs_deltree(rs);
 707         }
 708         spin_unlock(&rgd->rd_rsspin);
 709 }
 710
 711 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
 712 {
 713         struct rb_node *n;
 714         struct gfs2_rgrpd *rgd;
 715         struct gfs2_glock *gl;
 716
 717         while ((n = rb_first(&sdp->sd_rindex_tree))) {
 718                 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 719                 gl = rgd->rd_gl;
 720
 721                 rb_erase(n, &sdp->sd_rindex_tree);
 722
 723                 if (gl) {
 724                         spin_lock(&gl->gl_lockref.lock);
 725                         gl->gl_object = NULL;
 726                         spin_unlock(&gl->gl_lockref.lock);
 727                         gfs2_rgrp_brelse(rgd);
 728                         gfs2_glock_add_to_lru(gl);
 729                         gfs2_glock_put(gl);
 730                 }
 731
 732                 gfs2_free_clones(rgd);
 733                 return_all_reservations(rgd);
 734                 kfree(rgd->rd_bits);
 735                 rgd->rd_bits = NULL;
 736                 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
 737         }
 738 }
 739
 740 static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
 741 {
 742         pr_info("ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
 743         pr_info("ri_length = %u\n", rgd->rd_length);
 744         pr_info("ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
 745         pr_info("ri_data = %u\n", rgd->rd_data);
 746         pr_info("ri_bitbytes = %u\n", rgd->rd_bitbytes);
 747 }
 748
 749 /**
 750  * gfs2_compute_bitstructs - Compute the bitmap sizes
 751  * @rgd: The resource group descriptor
 752  *
 753  * Calculates bitmap descriptors, one for each block that contains bitmap data
 754  *
 755  * Returns: errno
 756  */
 757
 758 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
 759 {
 760         struct gfs2_sbd *sdp = rgd->rd_sbd;
 761         struct gfs2_bitmap *bi;
 762         u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
 763         u32 bytes_left, bytes;
 764         int x;
 765
 766         if (!length)
 767                 return -EINVAL;
 768
 769         rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
 770         if (!rgd->rd_bits)
 771                 return -ENOMEM;
 772
 773         bytes_left = rgd->rd_bitbytes;
 774
 775         for (x = 0; x < length; x++) {
 776                 bi = rgd->rd_bits + x;
 777
 778                 bi->bi_flags = 0;
 779                 /* small rgrp; bitmap stored completely in header block */
 780                 if (length == 1) {
 781                         bytes = bytes_left;
 782                         bi->bi_offset = sizeof(struct gfs2_rgrp);
 783                         bi->bi_start = 0;
 784                         bi->bi_len = bytes;
 785                         bi->bi_blocks = bytes * GFS2_NBBY;
 786                 /* header block */
 787                 } else if (x == 0) {
 788                         bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
 789                         bi->bi_offset = sizeof(struct gfs2_rgrp);
 790                         bi->bi_start = 0;
 791                         bi->bi_len = bytes;
 792                         bi->bi_blocks = bytes * GFS2_NBBY;
 793                 /* last block */
 794                 } else if (x + 1 == length) {
 795                         bytes = bytes_left;
 796                         bi->bi_offset = sizeof(struct gfs2_meta_header);
 797                         bi->bi_start = rgd->rd_bitbytes - bytes_left;
 798                         bi->bi_len = bytes;
 799                         bi->bi_blocks = bytes * GFS2_NBBY;
 800                 /* other blocks */
 801                 } else {
 802                         bytes = sdp->sd_sb.sb_bsize -
 803                                 sizeof(struct gfs2_meta_header);
 804                         bi->bi_offset = sizeof(struct gfs2_meta_header);
 805                         bi->bi_start = rgd->rd_bitbytes - bytes_left;
 806                         bi->bi_len = bytes;
 807                         bi->bi_blocks = bytes * GFS2_NBBY;
 808                 }
 809
 810                 bytes_left -= bytes;
 811         }
 812
 813         if (bytes_left) {
 814                 gfs2_consist_rgrpd(rgd);
 815                 return -EIO;
 816         }
 817         bi = rgd->rd_bits + (length - 1);
 818         if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
 819                 if (gfs2_consist_rgrpd(rgd)) {
 820                         gfs2_rindex_print(rgd);
 821                         fs_err(sdp, "start=%u len=%u offset=%u\n",
 822                                bi->bi_start, bi->bi_len, bi->bi_offset);
 823                 }
 824                 return -EIO;
 825         }
 826
 827         return 0;
 828 }
 829
 830 /**
 831  * gfs2_ri_total - Total up the file system space, according to the rindex.
 832  * @sdp: the filesystem
 833  *
 834  */
 835 u64 gfs2_ri_total(struct gfs2_sbd *sdp)
 836 {
 837         u64 total_data = 0;
 838         struct inode *inode = sdp->sd_rindex;
 839         struct gfs2_inode *ip = GFS2_I(inode);
 840         char buf[sizeof(struct gfs2_rindex)];
 841         int error, rgrps;
 842
 843         for (rgrps = 0;; rgrps++) {
 844                 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
 845
 846                 if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
 847                         break;
 848                 error = gfs2_internal_read(ip, buf, &pos,
 849                                            sizeof(struct gfs2_rindex));
 850                 if (error != sizeof(struct gfs2_rindex))
 851                         break;
 852                 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
 853         }
 854         return total_data;
 855 }
 856
 857 static int rgd_insert(struct gfs2_rgrpd *rgd)
 858 {
 859         struct gfs2_sbd *sdp = rgd->rd_sbd;
 860         struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
 861
 862         /* Figure out where to put new node */
 863         while (*newn) {
 864                 struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
 865                                                   rd_node);
 866
 867                 parent = *newn;
 868                 if (rgd->rd_addr < cur->rd_addr)
 869                         newn = &((*newn)->rb_left);
 870                 else if (rgd->rd_addr > cur->rd_addr)
 871                         newn = &((*newn)->rb_right);
 872                 else
 873                         return -EEXIST;
 874         }
 875
 876         rb_link_node(&rgd->rd_node, parent, newn);
 877         rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
 878         sdp->sd_rgrps++;
 879         return 0;
 880 }
 881
 882 /**
 883  * read_rindex_entry - Pull in a new resource index entry from the disk
 884  * @ip: Pointer to the rindex inode
 885  *
 886  * Returns: 0 on success, > 0 on EOF, error code otherwise
 887  */
 888
 889 static int read_rindex_entry(struct gfs2_inode *ip)
 890 {
 891         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 892         const unsigned bsize = sdp->sd_sb.sb_bsize;
 893         loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
 894         struct gfs2_rindex buf;
 895         int error;
 896         struct gfs2_rgrpd *rgd;
 897
 898         if (pos >= i_size_read(&ip->i_inode))
 899                 return 1;
 900
 901         error = gfs2_internal_read(ip, (char *)&buf, &pos,
 902                                    sizeof(struct gfs2_rindex));
 903
 904         if (error != sizeof(struct gfs2_rindex))
 905                 return (error == 0) ? 1 : error;
 906
 907         rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
 908         error = -ENOMEM;
 909         if (!rgd)
 910                 return error;
 911
 912         rgd->rd_sbd = sdp;
 913         rgd->rd_addr = be64_to_cpu(buf.ri_addr);
 914         rgd->rd_length = be32_to_cpu(buf.ri_length);
 915         rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
 916         rgd->rd_data = be32_to_cpu(buf.ri_data);
 917         rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
 918         spin_lock_init(&rgd->rd_rsspin);
 919
 920         error = gfs2_glock_get(sdp, rgd->rd_addr,
 921                                &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
 922         if (error)
 923                 goto fail;
 924
 925         error = compute_bitstructs(rgd);
 926         if (error)
 927                 goto fail_glock;
 928
 929         rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
 930         rgd->rd_flags &= ~(GFS2_RDF_UPTODATE | GFS2_RDF_PREFERRED);
 931         if (rgd->rd_data > sdp->sd_max_rg_data)
 932                 sdp->sd_max_rg_data = rgd->rd_data;
 933         spin_lock(&sdp->sd_rindex_spin);
 934         error = rgd_insert(rgd);
 935         spin_unlock(&sdp->sd_rindex_spin);
 936         if (!error) {
 937                 rgd->rd_gl->gl_object = rgd;
 938                 rgd->rd_gl->gl_vm.start = (rgd->rd_addr * bsize) & PAGE_MASK;
 939                 rgd->rd_gl->gl_vm.end = PAGE_ALIGN((rgd->rd_addr +
 940                                                     rgd->rd_length) * bsize) - 1;
 941                 return 0;
 942         }
 943
 944         error = 0; /* someone else read in the rgrp; free it and ignore it */
 945 fail_glock:
 946         gfs2_glock_put(rgd->rd_gl);
 947
 948 fail:
 949         kfree(rgd->rd_bits);
 950         rgd->rd_bits = NULL;
 951         kmem_cache_free(gfs2_rgrpd_cachep, rgd);
 952         return error;
 953 }
 954
 955 /**
 956  * set_rgrp_preferences - Run all the rgrps, selecting some we prefer to use
 957  * @sdp: the GFS2 superblock
 958  *
 959  * The purpose of this function is to select a subset of the resource groups
 960  * and mark them as PREFERRED. We do it in such a way that each node prefers
 961  * to use a unique set of rgrps to minimize glock contention.
 962  */
 963 static void set_rgrp_preferences(struct gfs2_sbd *sdp)
 964 {
 965         struct gfs2_rgrpd *rgd, *first;
 966         int i;
 967
 968         /* Skip an initial number of rgrps, based on this node's journal ID.
 969            That should start each node out on its own set. */
 970         rgd = gfs2_rgrpd_get_first(sdp);
 971         for (i = 0; i < sdp->sd_lockstruct.ls_jid; i++)
 972                 rgd = gfs2_rgrpd_get_next(rgd);
 973         first = rgd;
 974
 975         do {
 976                 rgd->rd_flags |= GFS2_RDF_PREFERRED;
 977                 for (i = 0; i < sdp->sd_journals; i++) {
 978                         rgd = gfs2_rgrpd_get_next(rgd);
 979                         if (!rgd || rgd == first)
 980                                 break;
 981                 }
 982         } while (rgd && rgd != first);
 983 }
 984
 985 /**
 986  * gfs2_ri_update - Pull in a new resource index from the disk
 987  * @ip: pointer to the rindex inode
 988  *
 989  * Returns: 0 on successful update, error code otherwise
 990  */
 991
 992 static int gfs2_ri_update(struct gfs2_inode *ip)
 993 {
 994         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 995         int error;
 996
 997         do {
 998                 error = read_rindex_entry(ip);
 999         } while (error == 0);
1000
1001         if (error < 0)
1002                 return error;
1003
1004         if (RB_EMPTY_ROOT(&sdp->sd_rindex_tree)) {
1005                 fs_err(sdp, "no resource groups found in the file system.\n");
1006                 return -ENOENT;
1007         }
1008         set_rgrp_preferences(sdp);
1009
1010         sdp->sd_rindex_uptodate = 1;
1011         return 0;
1012 }
1013
1014 /**
1015  * gfs2_rindex_update - Update the rindex if required
1016  * @sdp: The GFS2 superblock
1017  *
1018  * We grab a lock on the rindex inode to make sure that it doesn't
1019  * change whilst we are performing an operation. We keep this lock
1020  * for quite long periods of time compared to other locks. This
1021  * doesn't matter, since it is shared and it is very, very rarely
1022  * accessed in the exclusive mode (i.e. only when expanding the filesystem).
1023  *
1024  * This makes sure that we're using the latest copy of the resource index
1025  * special file, which might have been updated if someone expanded the
1026  * filesystem (via gfs2_grow utility), which adds new resource groups.
1027  *
1028  * Returns: 0 on succeess, error code otherwise
1029  */
1030
1031 int gfs2_rindex_update(struct gfs2_sbd *sdp)
1032 {
1033         struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
1034         struct gfs2_glock *gl = ip->i_gl;
1035         struct gfs2_holder ri_gh;
1036         int error = 0;
1037         int unlock_required = 0;
1038
1039         /* Read new copy from disk if we don't have the latest */
1040         if (!sdp->sd_rindex_uptodate) {
1041                 if (!gfs2_glock_is_locked_by_me(gl)) {
1042                         error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
1043                         if (error)
1044                                 return error;
1045                         unlock_required = 1;
1046                 }
1047                 if (!sdp->sd_rindex_uptodate)
1048                         error = gfs2_ri_update(ip);
1049                 if (unlock_required)
1050                         gfs2_glock_dq_uninit(&ri_gh);
1051         }
1052
1053         return error;
1054 }
1055
1056 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1057 {
1058         const struct gfs2_rgrp *str = buf;
1059         u32 rg_flags;
1060
1061         rg_flags = be32_to_cpu(str->rg_flags);
1062         rg_flags &= ~GFS2_RDF_MASK;
1063         rgd->rd_flags &= GFS2_RDF_MASK;
1064         rgd->rd_flags |= rg_flags;
1065         rgd->rd_free = be32_to_cpu(str->rg_free);
1066         rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1067         rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1068 }
1069
1070 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1071 {
1072         struct gfs2_rgrp *str = buf;
1073
1074         str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
1075         str->rg_free = cpu_to_be32(rgd->rd_free);
1076         str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
1077         str->__pad = cpu_to_be32(0);
1078         str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
1079         memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
1080 }
1081
1082 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1083 {
1084         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1085         struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
1086
1087         if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
1088             rgl->rl_dinodes != str->rg_dinodes ||
1089             rgl->rl_igeneration != str->rg_igeneration)
1090                 return 0;
1091         return 1;
1092 }
1093
1094 static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1095 {
1096         const struct gfs2_rgrp *str = buf;
1097
1098         rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1099         rgl->rl_flags = str->rg_flags;
1100         rgl->rl_free = str->rg_free;
1101         rgl->rl_dinodes = str->rg_dinodes;
1102         rgl->rl_igeneration = str->rg_igeneration;
1103         rgl->__pad = 0UL;
1104 }
1105
1106 static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
1107 {
1108         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1109         u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
1110         rgl->rl_unlinked = cpu_to_be32(unlinked);
1111 }
1112
1113 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1114 {
1115         struct gfs2_bitmap *bi;
1116         const u32 length = rgd->rd_length;
1117         const u8 *buffer = NULL;
1118         u32 i, goal, count = 0;
1119
1120         for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1121                 goal = 0;
1122                 buffer = bi->bi_bh->b_data + bi->bi_offset;
1123                 WARN_ON(!buffer_uptodate(bi->bi_bh));
1124                 while (goal < bi->bi_len * GFS2_NBBY) {
1125                         goal = gfs2_bitfit(buffer, bi->bi_len, goal,
1126                                            GFS2_BLKST_UNLINKED);
1127                         if (goal == BFITNOENT)
1128                                 break;
1129                         count++;
1130                         goal++;
1131                 }
1132         }
1133
1134         return count;
1135 }
1136
1137
1138 /**
1139  * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
1140  * @rgd: the struct gfs2_rgrpd describing the RG to read in
1141  *
1142  * Read in all of a Resource Group's header and bitmap blocks.
1143  * Caller must eventually call gfs2_rgrp_brelse() to free the bitmaps.
1144  *
1145  * Returns: errno
1146  */
1147
1148 static int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
1149 {
1150         struct gfs2_sbd *sdp = rgd->rd_sbd;
1151         struct gfs2_glock *gl = rgd->rd_gl;
1152         unsigned int length = rgd->rd_length;
1153         struct gfs2_bitmap *bi;
1154         unsigned int x, y;
1155         int error;
1156
1157         if (rgd->rd_bits[0].bi_bh != NULL)
1158                 return 0;
1159
1160         for (x = 0; x < length; x++) {
1161                 bi = rgd->rd_bits + x;
1162                 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
1163                 if (error)
1164                         goto fail;
1165         }
1166
1167         for (y = length; y--;) {
1168                 bi = rgd->rd_bits + y;
1169                 error = gfs2_meta_wait(sdp, bi->bi_bh);
1170                 if (error)
1171                         goto fail;
1172                 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
1173                                               GFS2_METATYPE_RG)) {
1174                         error = -EIO;
1175                         goto fail;
1176                 }
1177         }
1178
1179         if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1180                 for (x = 0; x < length; x++)
1181                         clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1182                 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1183                 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1184                 rgd->rd_free_clone = rgd->rd_free;
1185                 /* max out the rgrp allocation failure point */
1186                 rgd->rd_extfail_pt = rgd->rd_free;
1187         }
1188         if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1189                 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1190                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1191                                      rgd->rd_bits[0].bi_bh->b_data);
1192         }
1193         else if (sdp->sd_args.ar_rgrplvb) {
1194                 if (!gfs2_rgrp_lvb_valid(rgd)){
1195                         gfs2_consist_rgrpd(rgd);
1196                         error = -EIO;
1197                         goto fail;
1198                 }
1199                 if (rgd->rd_rgl->rl_unlinked == 0)
1200                         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1201         }
1202         return 0;
1203
1204 fail:
1205         while (x--) {
1206                 bi = rgd->rd_bits + x;
1207                 brelse(bi->bi_bh);
1208                 bi->bi_bh = NULL;
1209                 gfs2_assert_warn(sdp, !bi->bi_clone);
1210         }
1211
1212         return error;
1213 }
1214
1215 static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
1216 {
1217         u32 rl_flags;
1218
1219         if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1220                 return 0;
1221
1222         if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1223                 return gfs2_rgrp_bh_get(rgd);
1224
1225         rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1226         rl_flags &= ~GFS2_RDF_MASK;
1227         rgd->rd_flags &= GFS2_RDF_MASK;
1228         rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
1229         if (rgd->rd_rgl->rl_unlinked == 0)
1230                 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1231         rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1232         rgd->rd_free_clone = rgd->rd_free;
1233         rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1234         rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1235         return 0;
1236 }
1237
1238 int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
1239 {
1240         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1241         struct gfs2_sbd *sdp = rgd->rd_sbd;
1242
1243         if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
1244                 return 0;
1245         return gfs2_rgrp_bh_get(rgd);
1246 }
1247
1248 /**
1249  * gfs2_rgrp_brelse - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1250  * @rgd: The resource group
1251  *
1252  */
1253
1254 void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
1255 {
1256         int x, length = rgd->rd_length;
1257
1258         for (x = 0; x < length; x++) {
1259                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1260                 if (bi->bi_bh) {
1261                         brelse(bi->bi_bh);
1262                         bi->bi_bh = NULL;
1263                 }
1264         }
1265
1266 }
1267
1268 /**
1269  * gfs2_rgrp_go_unlock - Unlock a rgrp glock
1270  * @gh: The glock holder for the resource group
1271  *
1272  */
1273
1274 void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
1275 {
1276         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1277         int demote_requested = test_bit(GLF_DEMOTE, &gh->gh_gl->gl_flags) |
1278                 test_bit(GLF_PENDING_DEMOTE, &gh->gh_gl->gl_flags);
1279
1280         if (rgd && demote_requested)
1281                 gfs2_rgrp_brelse(rgd);
1282 }
1283
1284 int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1285                              struct buffer_head *bh,
1286                              const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1287 {
1288         struct super_block *sb = sdp->sd_vfs;
1289         u64 blk;
1290         sector_t start = 0;
1291         sector_t nr_blks = 0;
1292         int rv;
1293         unsigned int x;
1294         u32 trimmed = 0;
1295         u8 diff;
1296
1297         for (x = 0; x < bi->bi_len; x++) {
1298                 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1299                 clone += bi->bi_offset;
1300                 clone += x;
1301                 if (bh) {
1302                         const u8 *orig = bh->b_data + bi->bi_offset + x;
1303                         diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1304                 } else {
1305                         diff = ~(*clone | (*clone >> 1));
1306                 }
1307                 diff &= 0x55;
1308                 if (diff == 0)
1309                         continue;
1310                 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
1311                 while(diff) {
1312                         if (diff & 1) {
1313                                 if (nr_blks == 0)
1314                                         goto start_new_extent;
1315                                 if ((start + nr_blks) != blk) {
1316                                         if (nr_blks >= minlen) {
1317                                                 rv = sb_issue_discard(sb,
1318                                                         start, nr_blks,
1319                                                         GFP_NOFS, 0);
1320                                                 if (rv)
1321                                                         goto fail;
1322                                                 trimmed += nr_blks;
1323                                         }
1324                                         nr_blks = 0;
1325 start_new_extent:
1326                                         start = blk;
1327                                 }
1328                                 nr_blks++;
1329                         }
1330                         diff >>= 2;
1331                         blk++;
1332                 }
1333         }
1334         if (nr_blks >= minlen) {
1335                 rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
1336                 if (rv)
1337                         goto fail;
1338                 trimmed += nr_blks;
1339         }
1340         if (ptrimmed)
1341                 *ptrimmed = trimmed;
1342         return 0;
1343
1344 fail:
1345         if (sdp->sd_args.ar_discard)
1346                 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1347         sdp->sd_args.ar_discard = 0;
1348         return -EIO;
1349 }
1350
1351 /**
1352  * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1353  * @filp: Any file on the filesystem
1354  * @argp: Pointer to the arguments (also used to pass result)
1355  *
1356  * Returns: 0 on success, otherwise error code
1357  */
1358
1359 int gfs2_fitrim(struct file *filp, void __user *argp)
1360 {
1361         struct inode *inode = file_inode(filp);
1362         struct gfs2_sbd *sdp = GFS2_SB(inode);
1363         struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1364         struct buffer_head *bh;
1365         struct gfs2_rgrpd *rgd;
1366         struct gfs2_rgrpd *rgd_end;
1367         struct gfs2_holder gh;
1368         struct fstrim_range r;
1369         int ret = 0;
1370         u64 amt;
1371         u64 trimmed = 0;
1372         u64 start, end, minlen;
1373         unsigned int x;
1374         unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
1375
1376         if (!capable(CAP_SYS_ADMIN))
1377                 return -EPERM;
1378
1379         if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1380                 return -EROFS;
1381
1382         if (!blk_queue_discard(q))
1383                 return -EOPNOTSUPP;
1384
1385         if (copy_from_user(&r, argp, sizeof(r)))
1386                 return -EFAULT;
1387
1388         ret = gfs2_rindex_update(sdp);
1389         if (ret)
1390                 return ret;
1391
1392         start = r.start >> bs_shift;
1393         end = start + (r.len >> bs_shift);
1394         minlen = max_t(u64, r.minlen, sdp->sd_sb.sb_bsize);
1395         minlen = max_t(u64, minlen,
1396                        q->limits.discard_granularity) >> bs_shift;
1397
1398         if (end <= start || minlen > sdp->sd_max_rg_data)
1399                 return -EINVAL;
1400
1401         rgd = gfs2_blk2rgrpd(sdp, start, 0);
1402         rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
1403
1404         if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
1405             && (start > rgd_end->rd_data0 + rgd_end->rd_data))
1406                 return -EINVAL; /* start is beyond the end of the fs */
1407
1408         while (1) {
1409
1410                 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1411                 if (ret)
1412                         goto out;
1413
1414                 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1415                         /* Trim each bitmap in the rgrp */
1416                         for (x = 0; x < rgd->rd_length; x++) {
1417                                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1418                                 ret = gfs2_rgrp_send_discards(sdp,
1419                                                 rgd->rd_data0, NULL, bi, minlen,
1420                                                 &amt);
1421                                 if (ret) {
1422                                         gfs2_glock_dq_uninit(&gh);
1423                                         goto out;
1424                                 }
1425                                 trimmed += amt;
1426                         }
1427
1428                         /* Mark rgrp as having been trimmed */
1429                         ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1430                         if (ret == 0) {
1431                                 bh = rgd->rd_bits[0].bi_bh;
1432                                 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1433                                 gfs2_trans_add_meta(rgd->rd_gl, bh);
1434                                 gfs2_rgrp_out(rgd, bh->b_data);
1435                                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
1436                                 gfs2_trans_end(sdp);
1437                         }
1438                 }
1439                 gfs2_glock_dq_uninit(&gh);
1440
1441                 if (rgd == rgd_end)
1442                         break;
1443
1444                 rgd = gfs2_rgrpd_get_next(rgd);
1445         }
1446
1447 out:
1448         r.len = trimmed << bs_shift;
1449         if (copy_to_user(argp, &r, sizeof(r)))
1450                 return -EFAULT;
1451
1452         return ret;
1453 }
1454
1455 /**
1456  * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
1457  * @ip: the inode structure
1458  *
1459  */
1460 static void rs_insert(struct gfs2_inode *ip)
1461 {
1462         struct rb_node **newn, *parent = NULL;
1463         int rc;
1464         struct gfs2_blkreserv *rs = &ip->i_res;
1465         struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1466         u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
1467
1468         BUG_ON(gfs2_rs_active(rs));
1469
1470         spin_lock(&rgd->rd_rsspin);
1471         newn = &rgd->rd_rstree.rb_node;
1472         while (*newn) {
1473                 struct gfs2_blkreserv *cur =
1474                         rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1475
1476                 parent = *newn;
1477                 rc = rs_cmp(fsblock, rs->rs_free, cur);
1478                 if (rc > 0)
1479                         newn = &((*newn)->rb_right);
1480                 else if (rc < 0)
1481                         newn = &((*newn)->rb_left);
1482                 else {
1483                         spin_unlock(&rgd->rd_rsspin);
1484                         WARN_ON(1);
1485                         return;
1486                 }
1487         }
1488
1489         rb_link_node(&rs->rs_node, parent, newn);
1490         rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1491
1492         /* Do our rgrp accounting for the reservation */
1493         rgd->rd_reserved += rs->rs_free; /* blocks reserved */
1494         spin_unlock(&rgd->rd_rsspin);
1495         trace_gfs2_rs(rs, TRACE_RS_INSERT);
1496 }
1497
1498 /**
1499  * rg_mblk_search - find a group of multiple free blocks to form a reservation
1500  * @rgd: the resource group descriptor
1501  * @ip: pointer to the inode for which we're reserving blocks
1502  * @ap: the allocation parameters
1503  *
1504  */
1505
1506 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1507                            const struct gfs2_alloc_parms *ap)
1508 {
1509         struct gfs2_rbm rbm = { .rgd = rgd, };
1510         u64 goal;
1511         struct gfs2_blkreserv *rs = &ip->i_res;
1512         u32 extlen;
1513         u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
1514         int ret;
1515         struct inode *inode = &ip->i_inode;
1516
1517         if (S_ISDIR(inode->i_mode))
1518                 extlen = 1;
1519         else {
1520                 extlen = max_t(u32, atomic_read(&rs->rs_sizehint), ap->target);
1521                 extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
1522         }
1523         if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1524                 return;
1525
1526         /* Find bitmap block that contains bits for goal block */
1527         if (rgrp_contains_block(rgd, ip->i_goal))
1528                 goal = ip->i_goal;
1529         else
1530                 goal = rgd->rd_last_alloc + rgd->rd_data0;
1531
1532         if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1533                 return;
1534
1535         ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, ip, true);
1536         if (ret == 0) {
1537                 rs->rs_rbm = rbm;
1538                 rs->rs_free = extlen;
1539                 rs->rs_inum = ip->i_no_addr;
1540                 rs_insert(ip);
1541         } else {
1542                 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1543                         rgd->rd_last_alloc = 0;
1544         }
1545 }
1546
1547 /**
1548  * gfs2_next_unreserved_block - Return next block that is not reserved
1549  * @rgd: The resource group
1550  * @block: The starting block
1551  * @length: The required length
1552  * @ip: Ignore any reservations for this inode
1553  *
1554  * If the block does not appear in any reservation, then return the
1555  * block number unchanged. If it does appear in the reservation, then
1556  * keep looking through the tree of reservations in order to find the
1557  * first block number which is not reserved.
1558  */
1559
1560 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1561                                       u32 length,
1562                                       const struct gfs2_inode *ip)
1563 {
1564         struct gfs2_blkreserv *rs;
1565         struct rb_node *n;
1566         int rc;
1567
1568         spin_lock(&rgd->rd_rsspin);
1569         n = rgd->rd_rstree.rb_node;
1570         while (n) {
1571                 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1572                 rc = rs_cmp(block, length, rs);
1573                 if (rc < 0)
1574                         n = n->rb_left;
1575                 else if (rc > 0)
1576                         n = n->rb_right;
1577                 else
1578                         break;
1579         }
1580
1581         if (n) {
1582                 while ((rs_cmp(block, length, rs) == 0) && (&ip->i_res != rs)) {
1583                         block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1584                         n = n->rb_right;
1585                         if (n == NULL)
1586                                 break;
1587                         rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1588                 }
1589         }
1590
1591         spin_unlock(&rgd->rd_rsspin);
1592         return block;
1593 }
1594
1595 /**
1596  * gfs2_reservation_check_and_update - Check for reservations during block alloc
1597  * @rbm: The current position in the resource group
1598  * @ip: The inode for which we are searching for blocks
1599  * @minext: The minimum extent length
1600  * @maxext: A pointer to the maximum extent structure
1601  *
1602  * This checks the current position in the rgrp to see whether there is
1603  * a reservation covering this block. If not then this function is a
1604  * no-op. If there is, then the position is moved to the end of the
1605  * contiguous reservation(s) so that we are pointing at the first
1606  * non-reserved block.
1607  *
1608  * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1609  */
1610
1611 static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1612                                              const struct gfs2_inode *ip,
1613                                              u32 minext,
1614                                              struct gfs2_extent *maxext)
1615 {
1616         u64 block = gfs2_rbm_to_block(rbm);
1617         u32 extlen = 1;
1618         u64 nblock;
1619         int ret;
1620
1621         /*
1622          * If we have a minimum extent length, then skip over any extent
1623          * which is less than the min extent length in size.
1624          */
1625         if (minext) {
1626                 extlen = gfs2_free_extlen(rbm, minext);
1627                 if (extlen <= maxext->len)
1628                         goto fail;
1629         }
1630
1631         /*
1632          * Check the extent which has been found against the reservations
1633          * and skip if parts of it are already reserved
1634          */
1635         nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1636         if (nblock == block) {
1637                 if (!minext || extlen >= minext)
1638                         return 0;
1639
1640                 if (extlen > maxext->len) {
1641                         maxext->len = extlen;
1642                         maxext->rbm = *rbm;
1643                 }
1644 fail:
1645                 nblock = block + extlen;
1646         }
1647         ret = gfs2_rbm_from_block(rbm, nblock);
1648         if (ret < 0)
1649                 return ret;
1650         return 1;
1651 }
1652
1653 /**
1654  * gfs2_rbm_find - Look for blocks of a particular state
1655  * @rbm: Value/result starting position and final position
1656  * @state: The state which we want to find
1657  * @minext: Pointer to the requested extent length (NULL for a single block)
1658  *          This is updated to be the actual reservation size.
1659  * @ip: If set, check for reservations
1660  * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1661  *          around until we've reached the starting point.
1662  *
1663  * Side effects:
1664  * - If looking for free blocks, we set GBF_FULL on each bitmap which
1665  *   has no free blocks in it.
1666  * - If looking for free blocks, we set rd_extfail_pt on each rgrp which
1667  *   has come up short on a free block search.
1668  *
1669  * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1670  */
1671
1672 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
1673                          const struct gfs2_inode *ip, bool nowrap)
1674 {
1675         struct buffer_head *bh;
1676         int initial_bii;
1677         u32 initial_offset;
1678         int first_bii = rbm->bii;
1679         u32 first_offset = rbm->offset;
1680         u32 offset;
1681         u8 *buffer;
1682         int n = 0;
1683         int iters = rbm->rgd->rd_length;
1684         int ret;
1685         struct gfs2_bitmap *bi;
1686         struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
1687
1688         /* If we are not starting at the beginning of a bitmap, then we
1689          * need to add one to the bitmap count to ensure that we search
1690          * the starting bitmap twice.
1691          */
1692         if (rbm->offset != 0)
1693                 iters++;
1694
1695         while(1) {
1696                 bi = rbm_bi(rbm);
1697                 if ((ip == NULL || !gfs2_rs_active(&ip->i_res)) &&
1698                     test_bit(GBF_FULL, &bi->bi_flags) &&
1699                     (state == GFS2_BLKST_FREE))
1700                         goto next_bitmap;
1701
1702                 bh = bi->bi_bh;
1703                 buffer = bh->b_data + bi->bi_offset;
1704                 WARN_ON(!buffer_uptodate(bh));
1705                 if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1706                         buffer = bi->bi_clone + bi->bi_offset;
1707                 initial_offset = rbm->offset;
1708                 offset = gfs2_bitfit(buffer, bi->bi_len, rbm->offset, state);
1709                 if (offset == BFITNOENT)
1710                         goto bitmap_full;
1711                 rbm->offset = offset;
1712                 if (ip == NULL)
1713                         return 0;
1714
1715                 initial_bii = rbm->bii;
1716                 ret = gfs2_reservation_check_and_update(rbm, ip,
1717                                                         minext ? *minext : 0,
1718                                                         &maxext);
1719                 if (ret == 0)
1720                         return 0;
1721                 if (ret > 0) {
1722                         n += (rbm->bii - initial_bii);
1723                         goto next_iter;
1724                 }
1725                 if (ret == -E2BIG) {
1726                         rbm->bii = 0;
1727                         rbm->offset = 0;
1728                         n += (rbm->bii - initial_bii);
1729                         goto res_covered_end_of_rgrp;
1730                 }
1731                 return ret;
1732
1733 bitmap_full:    /* Mark bitmap as full and fall through */
1734                 if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
1735                         set_bit(GBF_FULL, &bi->bi_flags);
1736
1737 next_bitmap:    /* Find next bitmap in the rgrp */
1738                 rbm->offset = 0;
1739                 rbm->bii++;
1740                 if (rbm->bii == rbm->rgd->rd_length)
1741                         rbm->bii = 0;
1742 res_covered_end_of_rgrp:
1743                 if ((rbm->bii == 0) && nowrap)
1744                         break;
1745                 n++;
1746 next_iter:
1747                 if (n >= iters)
1748                         break;
1749         }
1750
1751         if (minext == NULL || state != GFS2_BLKST_FREE)
1752                 return -ENOSPC;
1753
1754         /* If the extent was too small, and it's smaller than the smallest
1755            to have failed before, remember for future reference that it's
1756            useless to search this rgrp again for this amount or more. */
1757         if ((first_offset == 0) && (first_bii == 0) &&
1758             (*minext < rbm->rgd->rd_extfail_pt))
1759                 rbm->rgd->rd_extfail_pt = *minext;
1760
1761         /* If the maximum extent we found is big enough to fulfill the
1762            minimum requirements, use it anyway. */
1763         if (maxext.len) {
1764                 *rbm = maxext.rbm;
1765                 *minext = maxext.len;
1766                 return 0;
1767         }
1768
1769         return -ENOSPC;
1770 }
1771
1772 /**
1773  * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1774  * @rgd: The rgrp
1775  * @last_unlinked: block address of the last dinode we unlinked
1776  * @skip: block address we should explicitly not unlink
1777  *
1778  * Returns: 0 if no error
1779  *          The inode, if one has been found, in inode.
1780  */
1781
1782 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1783 {
1784         u64 block;
1785         struct gfs2_sbd *sdp = rgd->rd_sbd;
1786         struct gfs2_glock *gl;
1787         struct gfs2_inode *ip;
1788         int error;
1789         int found = 0;
1790         struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
1791
1792         while (1) {
1793                 down_write(&sdp->sd_log_flush_lock);
1794                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
1795                                       true);
1796                 up_write(&sdp->sd_log_flush_lock);
1797                 if (error == -ENOSPC)
1798                         break;
1799                 if (WARN_ON_ONCE(error))
1800                         break;
1801
1802                 block = gfs2_rbm_to_block(&rbm);
1803                 if (gfs2_rbm_from_block(&rbm, block + 1))
1804                         break;
1805                 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1806                         continue;
1807                 if (block == skip)
1808                         continue;
1809                 *last_unlinked = block;
1810
1811                 error = gfs2_glock_get(sdp, block, &gfs2_iopen_glops, CREATE, &gl);
1812                 if (error)
1813                         continue;
1814
1815                 /* If the inode is already in cache, we can ignore it here
1816                  * because the existing inode disposal code will deal with
1817                  * it when all refs have gone away. Accessing gl_object like
1818                  * this is not safe in general. Here it is ok because we do
1819                  * not dereference the pointer, and we only need an approx
1820                  * answer to whether it is NULL or not.
1821                  */
1822                 ip = gl->gl_object;
1823
1824                 if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
1825                         gfs2_glock_put(gl);
1826                 else
1827                         found++;
1828
1829                 /* Limit reclaim to sensible number of tasks */
1830                 if (found > NR_CPUS)
1831                         return;
1832         }
1833
1834         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1835         return;
1836 }
1837
1838 /**
1839  * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1840  * @rgd: The rgrp in question
1841  * @loops: An indication of how picky we can be (0=very, 1=less so)
1842  *
1843  * This function uses the recently added glock statistics in order to
1844  * figure out whether a parciular resource group is suffering from
1845  * contention from multiple nodes. This is done purely on the basis
1846  * of timings, since this is the only data we have to work with and
1847  * our aim here is to reject a resource group which is highly contended
1848  * but (very important) not to do this too often in order to ensure that
1849  * we do not land up introducing fragmentation by changing resource
1850  * groups when not actually required.
1851  *
1852  * The calculation is fairly simple, we want to know whether the SRTTB
1853  * (i.e. smoothed round trip time for blocking operations) to acquire
1854  * the lock for this rgrp's glock is significantly greater than the
1855  * time taken for resource groups on average. We introduce a margin in
1856  * the form of the variable @var which is computed as the sum of the two
1857  * respective variences, and multiplied by a factor depending on @loops
1858  * and whether we have a lot of data to base the decision on. This is
1859  * then tested against the square difference of the means in order to
1860  * decide whether the result is statistically significant or not.
1861  *
1862  * Returns: A boolean verdict on the congestion status
1863  */
1864
1865 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1866 {
1867         const struct gfs2_glock *gl = rgd->rd_gl;
1868         const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
1869         struct gfs2_lkstats *st;
1870         u64 r_dcount, l_dcount;
1871         u64 l_srttb, a_srttb = 0;
1872         s64 srttb_diff;
1873         u64 sqr_diff;
1874         u64 var;
1875         int cpu, nonzero = 0;
1876
1877         preempt_disable();
1878         for_each_present_cpu(cpu) {
1879                 st = &per_cpu_ptr(sdp->sd_lkstats, cpu)->lkstats[LM_TYPE_RGRP];
1880                 if (st->stats[GFS2_LKS_SRTTB]) {
1881                         a_srttb += st->stats[GFS2_LKS_SRTTB];
1882                         nonzero++;
1883                 }
1884         }
1885         st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
1886         if (nonzero)
1887                 do_div(a_srttb, nonzero);
1888         r_dcount = st->stats[GFS2_LKS_DCOUNT];
1889         var = st->stats[GFS2_LKS_SRTTVARB] +
1890               gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1891         preempt_enable();
1892
1893         l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1894         l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1895
1896         if ((l_dcount < 1) || (r_dcount < 1) || (a_srttb == 0))
1897                 return false;
1898
1899         srttb_diff = a_srttb - l_srttb;
1900         sqr_diff = srttb_diff * srttb_diff;
1901
1902         var *= 2;
1903         if (l_dcount < 8 || r_dcount < 8)
1904                 var *= 2;
1905         if (loops == 1)
1906                 var *= 2;
1907
1908         return ((srttb_diff < 0) && (sqr_diff > var));
1909 }
1910
1911 /**
1912  * gfs2_rgrp_used_recently
1913  * @rs: The block reservation with the rgrp to test
1914  * @msecs: The time limit in milliseconds
1915  *
1916  * Returns: True if the rgrp glock has been used within the time limit
1917  */
1918 static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1919                                     u64 msecs)
1920 {
1921         u64 tdiff;
1922
1923         tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
1924                             rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1925
1926         return tdiff > (msecs * 1000 * 1000);
1927 }
1928
1929 static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1930 {
1931         const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1932         u32 skip;
1933
1934         get_random_bytes(&skip, sizeof(skip));
1935         return skip % sdp->sd_rgrps;
1936 }
1937
1938 static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1939 {
1940         struct gfs2_rgrpd *rgd = *pos;
1941         struct gfs2_sbd *sdp = rgd->rd_sbd;
1942
1943         rgd = gfs2_rgrpd_get_next(rgd);
1944         if (rgd == NULL)
1945                 rgd = gfs2_rgrpd_get_first(sdp);
1946         *pos = rgd;
1947         if (rgd != begin) /* If we didn't wrap */
1948                 return true;
1949         return false;
1950 }
1951
1952 /**
1953  * fast_to_acquire - determine if a resource group will be fast to acquire
1954  *
1955  * If this is one of our preferred rgrps, it should be quicker to acquire,
1956  * because we tried to set ourselves up as dlm lock master.
1957  */
1958 static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
1959 {
1960         struct gfs2_glock *gl = rgd->rd_gl;
1961
1962         if (gl->gl_state != LM_ST_UNLOCKED && list_empty(&gl->gl_holders) &&
1963             !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
1964             !test_bit(GLF_DEMOTE, &gl->gl_flags))
1965                 return 1;
1966         if (rgd->rd_flags & GFS2_RDF_PREFERRED)
1967                 return 1;
1968         return 0;
1969 }
1970
1971 /**
1972  * gfs2_inplace_reserve - Reserve space in the filesystem
1973  * @ip: the inode to reserve space for
1974  * @ap: the allocation parameters
1975  *
1976  * We try our best to find an rgrp that has at least ap->target blocks
1977  * available. After a couple of passes (loops == 2), the prospects of finding
1978  * such an rgrp diminish. At this stage, we return the first rgrp that has
1979  * atleast ap->min_target blocks available. Either way, we set ap->allowed to
1980  * the number of blocks available in the chosen rgrp.
1981  *
1982  * Returns: 0 on success,
1983  *          -ENOMEM if a suitable rgrp can't be found
1984  *          errno otherwise
1985  */
1986
1987 int gfs2_inplace_reserve(struct gfs2_inode *ip, struct gfs2_alloc_parms *ap)
1988 {
1989         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1990         struct gfs2_rgrpd *begin = NULL;
1991         struct gfs2_blkreserv *rs = &ip->i_res;
1992         int error = 0, rg_locked, flags = 0;
1993         u64 last_unlinked = NO_BLOCK;
1994         int loops = 0;
1995         u32 skip = 0;
1996
1997         if (sdp->sd_args.ar_rgrplvb)
1998                 flags |= GL_SKIP;
1999         if (gfs2_assert_warn(sdp, ap->target))
2000                 return -EINVAL;
2001         if (gfs2_rs_active(rs)) {
2002                 begin = rs->rs_rbm.rgd;
2003         } else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
2004                 rs->rs_rbm.rgd = begin = ip->i_rgd;
2005         } else {
2006                 check_and_update_goal(ip);
2007                 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
2008         }
2009         if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
2010                 skip = gfs2_orlov_skip(ip);
2011         if (rs->rs_rbm.rgd == NULL)
2012                 return -EBADSLT;
2013
2014         while (loops < 3) {
2015                 rg_locked = 1;
2016
2017                 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
2018                         rg_locked = 0;
2019                         if (skip && skip--)
2020                                 goto next_rgrp;
2021                         if (!gfs2_rs_active(rs)) {
2022                                 if (loops == 0 &&
2023                                     !fast_to_acquire(rs->rs_rbm.rgd))
2024                                         goto next_rgrp;
2025                                 if ((loops < 2) &&
2026                                     gfs2_rgrp_used_recently(rs, 1000) &&
2027                                     gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2028                                         goto next_rgrp;
2029                         }
2030                         error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
2031                                                    LM_ST_EXCLUSIVE, flags,
2032                                                    &rs->rs_rgd_gh);
2033                         if (unlikely(error))
2034                                 return error;
2035                         if (!gfs2_rs_active(rs) && (loops < 2) &&
2036                             gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2037                                 goto skip_rgrp;
2038                         if (sdp->sd_args.ar_rgrplvb) {
2039                                 error = update_rgrp_lvb(rs->rs_rbm.rgd);
2040                                 if (unlikely(error)) {
2041                                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2042                                         return error;
2043                                 }
2044                         }
2045                 }
2046
2047                 /* Skip unuseable resource groups */
2048                 if ((rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC |
2049                                                  GFS2_RDF_ERROR)) ||
2050                     (loops == 0 && ap->target > rs->rs_rbm.rgd->rd_extfail_pt))
2051                         goto skip_rgrp;
2052
2053                 if (sdp->sd_args.ar_rgrplvb)
2054                         gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
2055
2056                 /* Get a reservation if we don't already have one */
2057                 if (!gfs2_rs_active(rs))
2058                         rg_mblk_search(rs->rs_rbm.rgd, ip, ap);
2059
2060                 /* Skip rgrps when we can't get a reservation on first pass */
2061                 if (!gfs2_rs_active(rs) && (loops < 1))
2062                         goto check_rgrp;
2063
2064                 /* If rgrp has enough free space, use it */
2065                 if (rs->rs_rbm.rgd->rd_free_clone >= ap->target ||
2066                     (loops == 2 && ap->min_target &&
2067                      rs->rs_rbm.rgd->rd_free_clone >= ap->min_target)) {
2068                         ip->i_rgd = rs->rs_rbm.rgd;
2069                         ap->allowed = ip->i_rgd->rd_free_clone;
2070                         return 0;
2071                 }
2072 check_rgrp:
2073                 /* Check for unlinked inodes which can be reclaimed */
2074                 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
2075                         try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
2076                                         ip->i_no_addr);
2077 skip_rgrp:
2078                 /* Drop reservation, if we couldn't use reserved rgrp */
2079                 if (gfs2_rs_active(rs))
2080                         gfs2_rs_deltree(rs);
2081
2082                 /* Unlock rgrp if required */
2083                 if (!rg_locked)
2084                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2085 next_rgrp:
2086                 /* Find the next rgrp, and continue looking */
2087                 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
2088                         continue;
2089                 if (skip)
2090                         continue;
2091
2092                 /* If we've scanned all the rgrps, but found no free blocks
2093                  * then this checks for some less likely conditions before
2094                  * trying again.
2095                  */
2096                 loops++;
2097                 /* Check that fs hasn't grown if writing to rindex */
2098                 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
2099                         error = gfs2_ri_update(ip);
2100                         if (error)
2101                                 return error;
2102                 }
2103                 /* Flushing the log may release space */
2104                 if (loops == 2)
2105                         gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
2106         }
2107
2108         return -ENOSPC;
2109 }
2110
2111 /**
2112  * gfs2_inplace_release - release an inplace reservation
2113  * @ip: the inode the reservation was taken out on
2114  *
2115  * Release a reservation made by gfs2_inplace_reserve().
2116  */
2117
2118 void gfs2_inplace_release(struct gfs2_inode *ip)
2119 {
2120         struct gfs2_blkreserv *rs = &ip->i_res;
2121
2122         if (gfs2_holder_initialized(&rs->rs_rgd_gh))
2123                 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2124 }
2125
2126 /**
2127  * gfs2_get_block_type - Check a block in a RG is of given type
2128  * @rgd: the resource group holding the block
2129  * @block: the block number
2130  *
2131  * Returns: The block type (GFS2_BLKST_*)
2132  */
2133
2134 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
2135 {
2136         struct gfs2_rbm rbm = { .rgd = rgd, };
2137         int ret;
2138
2139         ret = gfs2_rbm_from_block(&rbm, block);
2140         WARN_ON_ONCE(ret != 0);
2141
2142         return gfs2_testbit(&rbm);
2143 }
2144
2145
2146 /**
2147  * gfs2_alloc_extent - allocate an extent from a given bitmap
2148  * @rbm: the resource group information
2149  * @dinode: TRUE if the first block we allocate is for a dinode
2150  * @n: The extent length (value/result)
2151  *
2152  * Add the bitmap buffer to the transaction.
2153  * Set the found bits to @new_state to change block's allocation state.
2154  */
2155 static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
2156                              unsigned int *n)
2157 {
2158         struct gfs2_rbm pos = { .rgd = rbm->rgd, };
2159         const unsigned int elen = *n;
2160         u64 block;
2161         int ret;
2162
2163         *n = 1;
2164         block = gfs2_rbm_to_block(rbm);
2165         gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
2166         gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2167         block++;
2168         while (*n < elen) {
2169                 ret = gfs2_rbm_from_block(&pos, block);
2170                 if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
2171                         break;
2172                 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
2173                 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
2174                 (*n)++;
2175                 block++;
2176         }
2177 }
2178
2179 /**
2180  * rgblk_free - Change alloc state of given block(s)
2181  * @sdp: the filesystem
2182  * @bstart: the start of a run of blocks to free
2183  * @blen: the length of the block run (all must lie within ONE RG!)
2184  * @new_state: GFS2_BLKST_XXX the after-allocation block state
2185  *
2186  * Returns:  Resource group containing the block(s)
2187  */
2188
2189 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
2190                                      u32 blen, unsigned char new_state)
2191 {
2192         struct gfs2_rbm rbm;
2193         struct gfs2_bitmap *bi, *bi_prev = NULL;
2194
2195         rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
2196         if (!rbm.rgd) {
2197                 if (gfs2_consist(sdp))
2198                         fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
2199                 return NULL;
2200         }
2201
2202         gfs2_rbm_from_block(&rbm, bstart);
2203         while (blen--) {
2204                 bi = rbm_bi(&rbm);
2205                 if (bi != bi_prev) {
2206                         if (!bi->bi_clone) {
2207                                 bi->bi_clone = kmalloc(bi->bi_bh->b_size,
2208                                                       GFP_NOFS | __GFP_NOFAIL);
2209                                 memcpy(bi->bi_clone + bi->bi_offset,
2210                                        bi->bi_bh->b_data + bi->bi_offset,
2211                                        bi->bi_len);
2212                         }
2213                         gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2214                         bi_prev = bi;
2215                 }
2216                 gfs2_setbit(&rbm, false, new_state);
2217                 gfs2_rbm_incr(&rbm);
2218         }
2219
2220         return rbm.rgd;
2221 }
2222
2223 /**
2224  * gfs2_rgrp_dump - print out an rgrp
2225  * @seq: The iterator
2226  * @gl: The glock in question
2227  *
2228  */
2229
2230 void gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
2231 {
2232         struct gfs2_rgrpd *rgd = gl->gl_object;
2233         struct gfs2_blkreserv *trs;
2234         const struct rb_node *n;
2235
2236         if (rgd == NULL)
2237                 return;
2238         gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u e:%u\n",
2239                        (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2240                        rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2241                        rgd->rd_reserved, rgd->rd_extfail_pt);
2242         spin_lock(&rgd->rd_rsspin);
2243         for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2244                 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
2245                 dump_rs(seq, trs);
2246         }
2247         spin_unlock(&rgd->rd_rsspin);
2248 }
2249
2250 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2251 {
2252         struct gfs2_sbd *sdp = rgd->rd_sbd;
2253         fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
2254                 (unsigned long long)rgd->rd_addr);
2255         fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2256         gfs2_rgrp_dump(NULL, rgd->rd_gl);
2257         rgd->rd_flags |= GFS2_RDF_ERROR;
2258 }
2259
2260 /**
2261  * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2262  * @ip: The inode we have just allocated blocks for
2263  * @rbm: The start of the allocated blocks
2264  * @len: The extent length
2265  *
2266  * Adjusts a reservation after an allocation has taken place. If the
2267  * reservation does not match the allocation, or if it is now empty
2268  * then it is removed.
2269  */
2270
2271 static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2272                                     const struct gfs2_rbm *rbm, unsigned len)
2273 {
2274         struct gfs2_blkreserv *rs = &ip->i_res;
2275         struct gfs2_rgrpd *rgd = rbm->rgd;
2276         unsigned rlen;
2277         u64 block;
2278         int ret;
2279
2280         spin_lock(&rgd->rd_rsspin);
2281         if (gfs2_rs_active(rs)) {
2282                 if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
2283                         block = gfs2_rbm_to_block(rbm);
2284                         ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
2285                         rlen = min(rs->rs_free, len);
2286                         rs->rs_free -= rlen;
2287                         rgd->rd_reserved -= rlen;
2288                         trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2289                         if (rs->rs_free && !ret)
2290                                 goto out;
2291                         /* We used up our block reservation, so we should
2292                            reserve more blocks next time. */
2293                         atomic_add(RGRP_RSRV_ADDBLKS, &rs->rs_sizehint);
2294                 }
2295                 __rs_deltree(rs);
2296         }
2297 out:
2298         spin_unlock(&rgd->rd_rsspin);
2299 }
2300
2301 /**
2302  * gfs2_set_alloc_start - Set starting point for block allocation
2303  * @rbm: The rbm which will be set to the required location
2304  * @ip: The gfs2 inode
2305  * @dinode: Flag to say if allocation includes a new inode
2306  *
2307  * This sets the starting point from the reservation if one is active
2308  * otherwise it falls back to guessing a start point based on the
2309  * inode's goal block or the last allocation point in the rgrp.
2310  */
2311
2312 static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
2313                                  const struct gfs2_inode *ip, bool dinode)
2314 {
2315         u64 goal;
2316
2317         if (gfs2_rs_active(&ip->i_res)) {
2318                 *rbm = ip->i_res.rs_rbm;
2319                 return;
2320         }
2321
2322         if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2323                 goal = ip->i_goal;
2324         else
2325                 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
2326
2327         gfs2_rbm_from_block(rbm, goal);
2328 }
2329
2330 /**
2331  * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
2332  * @ip: the inode to allocate the block for
2333  * @bn: Used to return the starting block number
2334  * @nblocks: requested number of blocks/extent length (value/result)
2335  * @dinode: 1 if we're allocating a dinode block, else 0
2336  * @generation: the generation number of the inode
2337  *
2338  * Returns: 0 or error
2339  */
2340
2341 int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2342                       bool dinode, u64 *generation)
2343 {
2344         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2345         struct buffer_head *dibh;
2346         struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2347         unsigned int ndata;
2348         u64 block; /* block, within the file system scope */
2349         int error;
2350
2351         gfs2_set_alloc_start(&rbm, ip, dinode);
2352         error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, ip, false);
2353
2354         if (error == -ENOSPC) {
2355                 gfs2_set_alloc_start(&rbm, ip, dinode);
2356                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, NULL, false);
2357         }
2358
2359         /* Since all blocks are reserved in advance, this shouldn't happen */
2360         if (error) {
2361                 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
2362                         (unsigned long long)ip->i_no_addr, error, *nblocks,
2363                         test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2364                         rbm.rgd->rd_extfail_pt);
2365                 goto rgrp_error;
2366         }
2367
2368         gfs2_alloc_extent(&rbm, dinode, nblocks);
2369         block = gfs2_rbm_to_block(&rbm);
2370         rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2371         if (gfs2_rs_active(&ip->i_res))
2372                 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2373         ndata = *nblocks;
2374         if (dinode)
2375                 ndata--;
2376
2377         if (!dinode) {
2378                 ip->i_goal = block + ndata - 1;
2379                 error = gfs2_meta_inode_buffer(ip, &dibh);
2380                 if (error == 0) {
2381                         struct gfs2_dinode *di =
2382                                 (struct gfs2_dinode *)dibh->b_data;
2383                         gfs2_trans_add_meta(ip->i_gl, dibh);
2384                         di->di_goal_meta = di->di_goal_data =
2385                                 cpu_to_be64(ip->i_goal);
2386                         brelse(dibh);
2387                 }
2388         }
2389         if (rbm.rgd->rd_free < *nblocks) {
2390                 pr_warn("nblocks=%u\n", *nblocks);
2391                 goto rgrp_error;
2392         }
2393
2394         rbm.rgd->rd_free -= *nblocks;
2395         if (dinode) {
2396                 rbm.rgd->rd_dinodes++;
2397                 *generation = rbm.rgd->rd_igeneration++;
2398                 if (*generation == 0)
2399                         *generation = rbm.rgd->rd_igeneration++;
2400         }
2401
2402         gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2403         gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2404         gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
2405
2406         gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2407         if (dinode)
2408                 gfs2_trans_add_unrevoke(sdp, block, *nblocks);
2409
2410         gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
2411
2412         rbm.rgd->rd_free_clone -= *nblocks;
2413         trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2414                                dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2415         *bn = block;
2416         return 0;
2417
2418 rgrp_error:
2419         gfs2_rgrp_error(rbm.rgd);
2420         return -EIO;
2421 }
2422
2423 /**
2424  * __gfs2_free_blocks - free a contiguous run of block(s)
2425  * @ip: the inode these blocks are being freed from
2426  * @bstart: first block of a run of contiguous blocks
2427  * @blen: the length of the block run
2428  * @meta: 1 if the blocks represent metadata
2429  *
2430  */
2431
2432 void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
2433 {
2434         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2435         struct gfs2_rgrpd *rgd;
2436
2437         rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
2438         if (!rgd)
2439                 return;
2440         trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2441         rgd->rd_free += blen;
2442         rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2443         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2444         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2445         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2446
2447         /* Directories keep their data in the metadata address space */
2448         if (meta || ip->i_depth)
2449                 gfs2_meta_wipe(ip, bstart, blen);
2450 }
2451
2452 /**
2453  * gfs2_free_meta - free a contiguous run of data block(s)
2454  * @ip: the inode these blocks are being freed from
2455  * @bstart: first block of a run of contiguous blocks
2456  * @blen: the length of the block run
2457  *
2458  */
2459
2460 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
2461 {
2462         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2463
2464         __gfs2_free_blocks(ip, bstart, blen, 1);
2465         gfs2_statfs_change(sdp, 0, +blen, 0);
2466         gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
2467 }
2468
2469 void gfs2_unlink_di(struct inode *inode)
2470 {
2471         struct gfs2_inode *ip = GFS2_I(inode);
2472         struct gfs2_sbd *sdp = GFS2_SB(inode);
2473         struct gfs2_rgrpd *rgd;
2474         u64 blkno = ip->i_no_addr;
2475
2476         rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
2477         if (!rgd)
2478                 return;
2479         trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2480         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2481         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2482         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2483         update_rgrp_lvb_unlinked(rgd, 1);
2484 }
2485
2486 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
2487 {
2488         struct gfs2_sbd *sdp = rgd->rd_sbd;
2489         struct gfs2_rgrpd *tmp_rgd;
2490
2491         tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
2492         if (!tmp_rgd)
2493                 return;
2494         gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
2495
2496         if (!rgd->rd_dinodes)
2497                 gfs2_consist_rgrpd(rgd);
2498         rgd->rd_dinodes--;
2499         rgd->rd_free++;
2500
2501         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2502         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2503         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2504         update_rgrp_lvb_unlinked(rgd, -1);
2505
2506         gfs2_statfs_change(sdp, 0, +1, -1);
2507 }
2508
2509
2510 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2511 {
2512         gfs2_free_uninit_di(rgd, ip->i_no_addr);
2513         trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2514         gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2515         gfs2_meta_wipe(ip, ip->i_no_addr, 1);
2516 }
2517
2518 /**
2519  * gfs2_check_blk_type - Check the type of a block
2520  * @sdp: The superblock
2521  * @no_addr: The block number to check
2522  * @type: The block type we are looking for
2523  *
2524  * Returns: 0 if the block type matches the expected type
2525  *          -ESTALE if it doesn't match
2526  *          or -ve errno if something went wrong while checking
2527  */
2528
2529 int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2530 {
2531         struct gfs2_rgrpd *rgd;
2532         struct gfs2_holder rgd_gh;
2533         int error = -EINVAL;
2534
2535         rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2536         if (!rgd)
2537                 goto fail;
2538
2539         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2540         if (error)
2541                 goto fail;
2542
2543         if (gfs2_get_block_type(rgd, no_addr) != type)
2544                 error = -ESTALE;
2545
2546         gfs2_glock_dq_uninit(&rgd_gh);
2547 fail:
2548         return error;
2549 }
2550
2551 /**
2552  * gfs2_rlist_add - add a RG to a list of RGs
2553  * @ip: the inode
2554  * @rlist: the list of resource groups
2555  * @block: the block
2556  *
2557  * Figure out what RG a block belongs to and add that RG to the list
2558  *
2559  * FIXME: Don't use NOFAIL
2560  *
2561  */
2562
2563 void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2564                     u64 block)
2565 {
2566         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2567         struct gfs2_rgrpd *rgd;
2568         struct gfs2_rgrpd **tmp;
2569         unsigned int new_space;
2570         unsigned int x;
2571
2572         if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2573                 return;
2574
2575         if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
2576                 rgd = ip->i_rgd;
2577         else
2578                 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2579         if (!rgd) {
2580                 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
2581                 return;
2582         }
2583         ip->i_rgd = rgd;
2584
2585         for (x = 0; x < rlist->rl_rgrps; x++)
2586                 if (rlist->rl_rgd[x] == rgd)
2587                         return;
2588
2589         if (rlist->rl_rgrps == rlist->rl_space) {
2590                 new_space = rlist->rl_space + 10;
2591
2592                 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
2593                               GFP_NOFS | __GFP_NOFAIL);
2594
2595                 if (rlist->rl_rgd) {
2596                         memcpy(tmp, rlist->rl_rgd,
2597                                rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2598                         kfree(rlist->rl_rgd);
2599                 }
2600
2601                 rlist->rl_space = new_space;
2602                 rlist->rl_rgd = tmp;
2603         }
2604
2605         rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2606 }
2607
2608 /**
2609  * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2610  *      and initialize an array of glock holders for them
2611  * @rlist: the list of resource groups
2612  * @state: the lock state to acquire the RG lock in
2613  *
2614  * FIXME: Don't use NOFAIL
2615  *
2616  */
2617
2618 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
2619 {
2620         unsigned int x;
2621
2622         rlist->rl_ghs = kmalloc(rlist->rl_rgrps * sizeof(struct gfs2_holder),
2623                                 GFP_NOFS | __GFP_NOFAIL);
2624         for (x = 0; x < rlist->rl_rgrps; x++)
2625                 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2626                                 state, 0,
2627                                 &rlist->rl_ghs[x]);
2628 }
2629
2630 /**
2631  * gfs2_rlist_free - free a resource group list
2632  * @rlist: the list of resource groups
2633  *
2634  */
2635
2636 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2637 {
2638         unsigned int x;
2639
2640         kfree(rlist->rl_rgd);
2641
2642         if (rlist->rl_ghs) {
2643                 for (x = 0; x < rlist->rl_rgrps; x++)
2644                         gfs2_holder_uninit(&rlist->rl_ghs[x]);
2645                 kfree(rlist->rl_ghs);
2646                 rlist->rl_ghs = NULL;
2647         }
2648 }
2649