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 = compute_bitstructs(rgd);
 921         if (error)
 922                 goto fail;
 923
 924         error = gfs2_glock_get(sdp, rgd->rd_addr,
 925                                &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
 926         if (error)
 927                 goto fail;
 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         gfs2_glock_put(rgd->rd_gl);
 946
 947 fail:
 948         kfree(rgd->rd_bits);
 949         rgd->rd_bits = NULL;
 950         kmem_cache_free(gfs2_rgrpd_cachep, rgd);
 951         return error;
 952 }
 953
 954 /**
 955  * set_rgrp_preferences - Run all the rgrps, selecting some we prefer to use
 956  * @sdp: the GFS2 superblock
 957  *
 958  * The purpose of this function is to select a subset of the resource groups
 959  * and mark them as PREFERRED. We do it in such a way that each node prefers
 960  * to use a unique set of rgrps to minimize glock contention.
 961  */
 962 static void set_rgrp_preferences(struct gfs2_sbd *sdp)
 963 {
 964         struct gfs2_rgrpd *rgd, *first;
 965         int i;
 966
 967         /* Skip an initial number of rgrps, based on this node's journal ID.
 968            That should start each node out on its own set. */
 969         rgd = gfs2_rgrpd_get_first(sdp);
 970         for (i = 0; i < sdp->sd_lockstruct.ls_jid; i++)
 971                 rgd = gfs2_rgrpd_get_next(rgd);
 972         first = rgd;
 973
 974         do {
 975                 rgd->rd_flags |= GFS2_RDF_PREFERRED;
 976                 for (i = 0; i < sdp->sd_journals; i++) {
 977                         rgd = gfs2_rgrpd_get_next(rgd);
 978                         if (!rgd || rgd == first)
 979                                 break;
 980                 }
 981         } while (rgd && rgd != first);
 982 }
 983
 984 /**
 985  * gfs2_ri_update - Pull in a new resource index from the disk
 986  * @ip: pointer to the rindex inode
 987  *
 988  * Returns: 0 on successful update, error code otherwise
 989  */
 990
 991 static int gfs2_ri_update(struct gfs2_inode *ip)
 992 {
 993         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 994         int error;
 995
 996         do {
 997                 error = read_rindex_entry(ip);
 998         } while (error == 0);
 999
1000         if (error < 0)
1001                 return error;
1002
1003         if (RB_EMPTY_ROOT(&sdp->sd_rindex_tree)) {
1004                 fs_err(sdp, "no resource groups found in the file system.\n");
1005                 return -ENOENT;
1006         }
1007         set_rgrp_preferences(sdp);
1008
1009         sdp->sd_rindex_uptodate = 1;
1010         return 0;
1011 }
1012
1013 /**
1014  * gfs2_rindex_update - Update the rindex if required
1015  * @sdp: The GFS2 superblock
1016  *
1017  * We grab a lock on the rindex inode to make sure that it doesn't
1018  * change whilst we are performing an operation. We keep this lock
1019  * for quite long periods of time compared to other locks. This
1020  * doesn't matter, since it is shared and it is very, very rarely
1021  * accessed in the exclusive mode (i.e. only when expanding the filesystem).
1022  *
1023  * This makes sure that we're using the latest copy of the resource index
1024  * special file, which might have been updated if someone expanded the
1025  * filesystem (via gfs2_grow utility), which adds new resource groups.
1026  *
1027  * Returns: 0 on succeess, error code otherwise
1028  */
1029
1030 int gfs2_rindex_update(struct gfs2_sbd *sdp)
1031 {
1032         struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
1033         struct gfs2_glock *gl = ip->i_gl;
1034         struct gfs2_holder ri_gh;
1035         int error = 0;
1036         int unlock_required = 0;
1037
1038         /* Read new copy from disk if we don't have the latest */
1039         if (!sdp->sd_rindex_uptodate) {
1040                 if (!gfs2_glock_is_locked_by_me(gl)) {
1041                         error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
1042                         if (error)
1043                                 return error;
1044                         unlock_required = 1;
1045                 }
1046                 if (!sdp->sd_rindex_uptodate)
1047                         error = gfs2_ri_update(ip);
1048                 if (unlock_required)
1049                         gfs2_glock_dq_uninit(&ri_gh);
1050         }
1051
1052         return error;
1053 }
1054
1055 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1056 {
1057         const struct gfs2_rgrp *str = buf;
1058         u32 rg_flags;
1059
1060         rg_flags = be32_to_cpu(str->rg_flags);
1061         rg_flags &= ~GFS2_RDF_MASK;
1062         rgd->rd_flags &= GFS2_RDF_MASK;
1063         rgd->rd_flags |= rg_flags;
1064         rgd->rd_free = be32_to_cpu(str->rg_free);
1065         rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1066         rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1067 }
1068
1069 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1070 {
1071         struct gfs2_rgrp *str = buf;
1072
1073         str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
1074         str->rg_free = cpu_to_be32(rgd->rd_free);
1075         str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
1076         str->__pad = cpu_to_be32(0);
1077         str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
1078         memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
1079 }
1080
1081 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1082 {
1083         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1084         struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
1085
1086         if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
1087             rgl->rl_dinodes != str->rg_dinodes ||
1088             rgl->rl_igeneration != str->rg_igeneration)
1089                 return 0;
1090         return 1;
1091 }
1092
1093 static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1094 {
1095         const struct gfs2_rgrp *str = buf;
1096
1097         rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1098         rgl->rl_flags = str->rg_flags;
1099         rgl->rl_free = str->rg_free;
1100         rgl->rl_dinodes = str->rg_dinodes;
1101         rgl->rl_igeneration = str->rg_igeneration;
1102         rgl->__pad = 0UL;
1103 }
1104
1105 static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
1106 {
1107         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1108         u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
1109         rgl->rl_unlinked = cpu_to_be32(unlinked);
1110 }
1111
1112 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1113 {
1114         struct gfs2_bitmap *bi;
1115         const u32 length = rgd->rd_length;
1116         const u8 *buffer = NULL;
1117         u32 i, goal, count = 0;
1118
1119         for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1120                 goal = 0;
1121                 buffer = bi->bi_bh->b_data + bi->bi_offset;
1122                 WARN_ON(!buffer_uptodate(bi->bi_bh));
1123                 while (goal < bi->bi_len * GFS2_NBBY) {
1124                         goal = gfs2_bitfit(buffer, bi->bi_len, goal,
1125                                            GFS2_BLKST_UNLINKED);
1126                         if (goal == BFITNOENT)
1127                                 break;
1128                         count++;
1129                         goal++;
1130                 }
1131         }
1132
1133         return count;
1134 }
1135
1136
1137 /**
1138  * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
1139  * @rgd: the struct gfs2_rgrpd describing the RG to read in
1140  *
1141  * Read in all of a Resource Group's header and bitmap blocks.
1142  * Caller must eventually call gfs2_rgrp_brelse() to free the bitmaps.
1143  *
1144  * Returns: errno
1145  */
1146
1147 static int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
1148 {
1149         struct gfs2_sbd *sdp = rgd->rd_sbd;
1150         struct gfs2_glock *gl = rgd->rd_gl;
1151         unsigned int length = rgd->rd_length;
1152         struct gfs2_bitmap *bi;
1153         unsigned int x, y;
1154         int error;
1155
1156         if (rgd->rd_bits[0].bi_bh != NULL)
1157                 return 0;
1158
1159         for (x = 0; x < length; x++) {
1160                 bi = rgd->rd_bits + x;
1161                 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
1162                 if (error)
1163                         goto fail;
1164         }
1165
1166         for (y = length; y--;) {
1167                 bi = rgd->rd_bits + y;
1168                 error = gfs2_meta_wait(sdp, bi->bi_bh);
1169                 if (error)
1170                         goto fail;
1171                 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
1172                                               GFS2_METATYPE_RG)) {
1173                         error = -EIO;
1174                         goto fail;
1175                 }
1176         }
1177
1178         if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1179                 for (x = 0; x < length; x++)
1180                         clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1181                 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1182                 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1183                 rgd->rd_free_clone = rgd->rd_free;
1184                 /* max out the rgrp allocation failure point */
1185                 rgd->rd_extfail_pt = rgd->rd_free;
1186         }
1187         if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1188                 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1189                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1190                                      rgd->rd_bits[0].bi_bh->b_data);
1191         }
1192         else if (sdp->sd_args.ar_rgrplvb) {
1193                 if (!gfs2_rgrp_lvb_valid(rgd)){
1194                         gfs2_consist_rgrpd(rgd);
1195                         error = -EIO;
1196                         goto fail;
1197                 }
1198                 if (rgd->rd_rgl->rl_unlinked == 0)
1199                         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1200         }
1201         return 0;
1202
1203 fail:
1204         while (x--) {
1205                 bi = rgd->rd_bits + x;
1206                 brelse(bi->bi_bh);
1207                 bi->bi_bh = NULL;
1208                 gfs2_assert_warn(sdp, !bi->bi_clone);
1209         }
1210
1211         return error;
1212 }
1213
1214 static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
1215 {
1216         u32 rl_flags;
1217
1218         if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1219                 return 0;
1220
1221         if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1222                 return gfs2_rgrp_bh_get(rgd);
1223
1224         rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1225         rl_flags &= ~GFS2_RDF_MASK;
1226         rgd->rd_flags &= GFS2_RDF_MASK;
1227         rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
1228         if (rgd->rd_rgl->rl_unlinked == 0)
1229                 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1230         rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1231         rgd->rd_free_clone = rgd->rd_free;
1232         rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1233         rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1234         return 0;
1235 }
1236
1237 int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
1238 {
1239         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1240         struct gfs2_sbd *sdp = rgd->rd_sbd;
1241
1242         if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
1243                 return 0;
1244         return gfs2_rgrp_bh_get(rgd);
1245 }
1246
1247 /**
1248  * gfs2_rgrp_brelse - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1249  * @rgd: The resource group
1250  *
1251  */
1252
1253 void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
1254 {
1255         int x, length = rgd->rd_length;
1256
1257         for (x = 0; x < length; x++) {
1258                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1259                 if (bi->bi_bh) {
1260                         brelse(bi->bi_bh);
1261                         bi->bi_bh = NULL;
1262                 }
1263         }
1264
1265 }
1266
1267 /**
1268  * gfs2_rgrp_go_unlock - Unlock a rgrp glock
1269  * @gh: The glock holder for the resource group
1270  *
1271  */
1272
1273 void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
1274 {
1275         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1276         int demote_requested = test_bit(GLF_DEMOTE, &gh->gh_gl->gl_flags) |
1277                 test_bit(GLF_PENDING_DEMOTE, &gh->gh_gl->gl_flags);
1278
1279         if (rgd && demote_requested)
1280                 gfs2_rgrp_brelse(rgd);
1281 }
1282
1283 int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1284                              struct buffer_head *bh,
1285                              const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1286 {
1287         struct super_block *sb = sdp->sd_vfs;
1288         u64 blk;
1289         sector_t start = 0;
1290         sector_t nr_blks = 0;
1291         int rv;
1292         unsigned int x;
1293         u32 trimmed = 0;
1294         u8 diff;
1295
1296         for (x = 0; x < bi->bi_len; x++) {
1297                 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1298                 clone += bi->bi_offset;
1299                 clone += x;
1300                 if (bh) {
1301                         const u8 *orig = bh->b_data + bi->bi_offset + x;
1302                         diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1303                 } else {
1304                         diff = ~(*clone | (*clone >> 1));
1305                 }
1306                 diff &= 0x55;
1307                 if (diff == 0)
1308                         continue;
1309                 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
1310                 while(diff) {
1311                         if (diff & 1) {
1312                                 if (nr_blks == 0)
1313                                         goto start_new_extent;
1314                                 if ((start + nr_blks) != blk) {
1315                                         if (nr_blks >= minlen) {
1316                                                 rv = sb_issue_discard(sb,
1317                                                         start, nr_blks,
1318                                                         GFP_NOFS, 0);
1319                                                 if (rv)
1320                                                         goto fail;
1321                                                 trimmed += nr_blks;
1322                                         }
1323                                         nr_blks = 0;
1324 start_new_extent:
1325                                         start = blk;
1326                                 }
1327                                 nr_blks++;
1328                         }
1329                         diff >>= 2;
1330                         blk++;
1331                 }
1332         }
1333         if (nr_blks >= minlen) {
1334                 rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
1335                 if (rv)
1336                         goto fail;
1337                 trimmed += nr_blks;
1338         }
1339         if (ptrimmed)
1340                 *ptrimmed = trimmed;
1341         return 0;
1342
1343 fail:
1344         if (sdp->sd_args.ar_discard)
1345                 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1346         sdp->sd_args.ar_discard = 0;
1347         return -EIO;
1348 }
1349
1350 /**
1351  * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1352  * @filp: Any file on the filesystem
1353  * @argp: Pointer to the arguments (also used to pass result)
1354  *
1355  * Returns: 0 on success, otherwise error code
1356  */
1357
1358 int gfs2_fitrim(struct file *filp, void __user *argp)
1359 {
1360         struct inode *inode = file_inode(filp);
1361         struct gfs2_sbd *sdp = GFS2_SB(inode);
1362         struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1363         struct buffer_head *bh;
1364         struct gfs2_rgrpd *rgd;
1365         struct gfs2_rgrpd *rgd_end;
1366         struct gfs2_holder gh;
1367         struct fstrim_range r;
1368         int ret = 0;
1369         u64 amt;
1370         u64 trimmed = 0;
1371         u64 start, end, minlen;
1372         unsigned int x;
1373         unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
1374
1375         if (!capable(CAP_SYS_ADMIN))
1376                 return -EPERM;
1377
1378         if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1379                 return -EROFS;
1380
1381         if (!blk_queue_discard(q))
1382                 return -EOPNOTSUPP;
1383
1384         if (copy_from_user(&r, argp, sizeof(r)))
1385                 return -EFAULT;
1386
1387         ret = gfs2_rindex_update(sdp);
1388         if (ret)
1389                 return ret;
1390
1391         start = r.start >> bs_shift;
1392         end = start + (r.len >> bs_shift);
1393         minlen = max_t(u64, r.minlen,
1394                        q->limits.discard_granularity) >> bs_shift;
1395
1396         if (end <= start || minlen > sdp->sd_max_rg_data)
1397                 return -EINVAL;
1398
1399         rgd = gfs2_blk2rgrpd(sdp, start, 0);
1400         rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
1401
1402         if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
1403             && (start > rgd_end->rd_data0 + rgd_end->rd_data))
1404                 return -EINVAL; /* start is beyond the end of the fs */
1405
1406         while (1) {
1407
1408                 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1409                 if (ret)
1410                         goto out;
1411
1412                 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1413                         /* Trim each bitmap in the rgrp */
1414                         for (x = 0; x < rgd->rd_length; x++) {
1415                                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1416                                 ret = gfs2_rgrp_send_discards(sdp,
1417                                                 rgd->rd_data0, NULL, bi, minlen,
1418                                                 &amt);
1419                                 if (ret) {
1420                                         gfs2_glock_dq_uninit(&gh);
1421                                         goto out;
1422                                 }
1423                                 trimmed += amt;
1424                         }
1425
1426                         /* Mark rgrp as having been trimmed */
1427                         ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1428                         if (ret == 0) {
1429                                 bh = rgd->rd_bits[0].bi_bh;
1430                                 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1431                                 gfs2_trans_add_meta(rgd->rd_gl, bh);
1432                                 gfs2_rgrp_out(rgd, bh->b_data);
1433                                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
1434                                 gfs2_trans_end(sdp);
1435                         }
1436                 }
1437                 gfs2_glock_dq_uninit(&gh);
1438
1439                 if (rgd == rgd_end)
1440                         break;
1441
1442                 rgd = gfs2_rgrpd_get_next(rgd);
1443         }
1444
1445 out:
1446         r.len = trimmed << bs_shift;
1447         if (copy_to_user(argp, &r, sizeof(r)))
1448                 return -EFAULT;
1449
1450         return ret;
1451 }
1452
1453 /**
1454  * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
1455  * @ip: the inode structure
1456  *
1457  */
1458 static void rs_insert(struct gfs2_inode *ip)
1459 {
1460         struct rb_node **newn, *parent = NULL;
1461         int rc;
1462         struct gfs2_blkreserv *rs = &ip->i_res;
1463         struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1464         u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
1465
1466         BUG_ON(gfs2_rs_active(rs));
1467
1468         spin_lock(&rgd->rd_rsspin);
1469         newn = &rgd->rd_rstree.rb_node;
1470         while (*newn) {
1471                 struct gfs2_blkreserv *cur =
1472                         rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1473
1474                 parent = *newn;
1475                 rc = rs_cmp(fsblock, rs->rs_free, cur);
1476                 if (rc > 0)
1477                         newn = &((*newn)->rb_right);
1478                 else if (rc < 0)
1479                         newn = &((*newn)->rb_left);
1480                 else {
1481                         spin_unlock(&rgd->rd_rsspin);
1482                         WARN_ON(1);
1483                         return;
1484                 }
1485         }
1486
1487         rb_link_node(&rs->rs_node, parent, newn);
1488         rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1489
1490         /* Do our rgrp accounting for the reservation */
1491         rgd->rd_reserved += rs->rs_free; /* blocks reserved */
1492         spin_unlock(&rgd->rd_rsspin);
1493         trace_gfs2_rs(rs, TRACE_RS_INSERT);
1494 }
1495
1496 /**
1497  * rg_mblk_search - find a group of multiple free blocks to form a reservation
1498  * @rgd: the resource group descriptor
1499  * @ip: pointer to the inode for which we're reserving blocks
1500  * @ap: the allocation parameters
1501  *
1502  */
1503
1504 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1505                            const struct gfs2_alloc_parms *ap)
1506 {
1507         struct gfs2_rbm rbm = { .rgd = rgd, };
1508         u64 goal;
1509         struct gfs2_blkreserv *rs = &ip->i_res;
1510         u32 extlen;
1511         u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
1512         int ret;
1513         struct inode *inode = &ip->i_inode;
1514
1515         if (S_ISDIR(inode->i_mode))
1516                 extlen = 1;
1517         else {
1518                 extlen = max_t(u32, atomic_read(&rs->rs_sizehint), ap->target);
1519                 extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
1520         }
1521         if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1522                 return;
1523
1524         /* Find bitmap block that contains bits for goal block */
1525         if (rgrp_contains_block(rgd, ip->i_goal))
1526                 goal = ip->i_goal;
1527         else
1528                 goal = rgd->rd_last_alloc + rgd->rd_data0;
1529
1530         if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1531                 return;
1532
1533         ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, ip, true);
1534         if (ret == 0) {
1535                 rs->rs_rbm = rbm;
1536                 rs->rs_free = extlen;
1537                 rs->rs_inum = ip->i_no_addr;
1538                 rs_insert(ip);
1539         } else {
1540                 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1541                         rgd->rd_last_alloc = 0;
1542         }
1543 }
1544
1545 /**
1546  * gfs2_next_unreserved_block - Return next block that is not reserved
1547  * @rgd: The resource group
1548  * @block: The starting block
1549  * @length: The required length
1550  * @ip: Ignore any reservations for this inode
1551  *
1552  * If the block does not appear in any reservation, then return the
1553  * block number unchanged. If it does appear in the reservation, then
1554  * keep looking through the tree of reservations in order to find the
1555  * first block number which is not reserved.
1556  */
1557
1558 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1559                                       u32 length,
1560                                       const struct gfs2_inode *ip)
1561 {
1562         struct gfs2_blkreserv *rs;
1563         struct rb_node *n;
1564         int rc;
1565
1566         spin_lock(&rgd->rd_rsspin);
1567         n = rgd->rd_rstree.rb_node;
1568         while (n) {
1569                 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1570                 rc = rs_cmp(block, length, rs);
1571                 if (rc < 0)
1572                         n = n->rb_left;
1573                 else if (rc > 0)
1574                         n = n->rb_right;
1575                 else
1576                         break;
1577         }
1578
1579         if (n) {
1580                 while ((rs_cmp(block, length, rs) == 0) && (&ip->i_res != rs)) {
1581                         block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1582                         n = n->rb_right;
1583                         if (n == NULL)
1584                                 break;
1585                         rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1586                 }
1587         }
1588
1589         spin_unlock(&rgd->rd_rsspin);
1590         return block;
1591 }
1592
1593 /**
1594  * gfs2_reservation_check_and_update - Check for reservations during block alloc
1595  * @rbm: The current position in the resource group
1596  * @ip: The inode for which we are searching for blocks
1597  * @minext: The minimum extent length
1598  * @maxext: A pointer to the maximum extent structure
1599  *
1600  * This checks the current position in the rgrp to see whether there is
1601  * a reservation covering this block. If not then this function is a
1602  * no-op. If there is, then the position is moved to the end of the
1603  * contiguous reservation(s) so that we are pointing at the first
1604  * non-reserved block.
1605  *
1606  * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1607  */
1608
1609 static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1610                                              const struct gfs2_inode *ip,
1611                                              u32 minext,
1612                                              struct gfs2_extent *maxext)
1613 {
1614         u64 block = gfs2_rbm_to_block(rbm);
1615         u32 extlen = 1;
1616         u64 nblock;
1617         int ret;
1618
1619         /*
1620          * If we have a minimum extent length, then skip over any extent
1621          * which is less than the min extent length in size.
1622          */
1623         if (minext) {
1624                 extlen = gfs2_free_extlen(rbm, minext);
1625                 if (extlen <= maxext->len)
1626                         goto fail;
1627         }
1628
1629         /*
1630          * Check the extent which has been found against the reservations
1631          * and skip if parts of it are already reserved
1632          */
1633         nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1634         if (nblock == block) {
1635                 if (!minext || extlen >= minext)
1636                         return 0;
1637
1638                 if (extlen > maxext->len) {
1639                         maxext->len = extlen;
1640                         maxext->rbm = *rbm;
1641                 }
1642 fail:
1643                 nblock = block + extlen;
1644         }
1645         ret = gfs2_rbm_from_block(rbm, nblock);
1646         if (ret < 0)
1647                 return ret;
1648         return 1;
1649 }
1650
1651 /**
1652  * gfs2_rbm_find - Look for blocks of a particular state
1653  * @rbm: Value/result starting position and final position
1654  * @state: The state which we want to find
1655  * @minext: Pointer to the requested extent length (NULL for a single block)
1656  *          This is updated to be the actual reservation size.
1657  * @ip: If set, check for reservations
1658  * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1659  *          around until we've reached the starting point.
1660  *
1661  * Side effects:
1662  * - If looking for free blocks, we set GBF_FULL on each bitmap which
1663  *   has no free blocks in it.
1664  * - If looking for free blocks, we set rd_extfail_pt on each rgrp which
1665  *   has come up short on a free block search.
1666  *
1667  * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1668  */
1669
1670 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
1671                          const struct gfs2_inode *ip, bool nowrap)
1672 {
1673         struct buffer_head *bh;
1674         int initial_bii;
1675         u32 initial_offset;
1676         int first_bii = rbm->bii;
1677         u32 first_offset = rbm->offset;
1678         u32 offset;
1679         u8 *buffer;
1680         int n = 0;
1681         int iters = rbm->rgd->rd_length;
1682         int ret;
1683         struct gfs2_bitmap *bi;
1684         struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
1685
1686         /* If we are not starting at the beginning of a bitmap, then we
1687          * need to add one to the bitmap count to ensure that we search
1688          * the starting bitmap twice.
1689          */
1690         if (rbm->offset != 0)
1691                 iters++;
1692
1693         while(1) {
1694                 bi = rbm_bi(rbm);
1695                 if ((ip == NULL || !gfs2_rs_active(&ip->i_res)) &&
1696                     test_bit(GBF_FULL, &bi->bi_flags) &&
1697                     (state == GFS2_BLKST_FREE))
1698                         goto next_bitmap;
1699
1700                 bh = bi->bi_bh;
1701                 buffer = bh->b_data + bi->bi_offset;
1702                 WARN_ON(!buffer_uptodate(bh));
1703                 if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1704                         buffer = bi->bi_clone + bi->bi_offset;
1705                 initial_offset = rbm->offset;
1706                 offset = gfs2_bitfit(buffer, bi->bi_len, rbm->offset, state);
1707                 if (offset == BFITNOENT)
1708                         goto bitmap_full;
1709                 rbm->offset = offset;
1710                 if (ip == NULL)
1711                         return 0;
1712
1713                 initial_bii = rbm->bii;
1714                 ret = gfs2_reservation_check_and_update(rbm, ip,
1715                                                         minext ? *minext : 0,
1716                                                         &maxext);
1717                 if (ret == 0)
1718                         return 0;
1719                 if (ret > 0) {
1720                         n += (rbm->bii - initial_bii);
1721                         goto next_iter;
1722                 }
1723                 if (ret == -E2BIG) {
1724                         rbm->bii = 0;
1725                         rbm->offset = 0;
1726                         n += (rbm->bii - initial_bii);
1727                         goto res_covered_end_of_rgrp;
1728                 }
1729                 return ret;
1730
1731 bitmap_full:    /* Mark bitmap as full and fall through */
1732                 if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
1733                         set_bit(GBF_FULL, &bi->bi_flags);
1734
1735 next_bitmap:    /* Find next bitmap in the rgrp */
1736                 rbm->offset = 0;
1737                 rbm->bii++;
1738                 if (rbm->bii == rbm->rgd->rd_length)
1739                         rbm->bii = 0;
1740 res_covered_end_of_rgrp:
1741                 if ((rbm->bii == 0) && nowrap)
1742                         break;
1743                 n++;
1744 next_iter:
1745                 if (n >= iters)
1746                         break;
1747         }
1748
1749         if (minext == NULL || state != GFS2_BLKST_FREE)
1750                 return -ENOSPC;
1751
1752         /* If the extent was too small, and it's smaller than the smallest
1753            to have failed before, remember for future reference that it's
1754            useless to search this rgrp again for this amount or more. */
1755         if ((first_offset == 0) && (first_bii == 0) &&
1756             (*minext < rbm->rgd->rd_extfail_pt))
1757                 rbm->rgd->rd_extfail_pt = *minext;
1758
1759         /* If the maximum extent we found is big enough to fulfill the
1760            minimum requirements, use it anyway. */
1761         if (maxext.len) {
1762                 *rbm = maxext.rbm;
1763                 *minext = maxext.len;
1764                 return 0;
1765         }
1766
1767         return -ENOSPC;
1768 }
1769
1770 /**
1771  * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1772  * @rgd: The rgrp
1773  * @last_unlinked: block address of the last dinode we unlinked
1774  * @skip: block address we should explicitly not unlink
1775  *
1776  * Returns: 0 if no error
1777  *          The inode, if one has been found, in inode.
1778  */
1779
1780 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1781 {
1782         u64 block;
1783         struct gfs2_sbd *sdp = rgd->rd_sbd;
1784         struct gfs2_glock *gl;
1785         struct gfs2_inode *ip;
1786         int error;
1787         int found = 0;
1788         struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
1789
1790         while (1) {
1791                 down_write(&sdp->sd_log_flush_lock);
1792                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
1793                                       true);
1794                 up_write(&sdp->sd_log_flush_lock);
1795                 if (error == -ENOSPC)
1796                         break;
1797                 if (WARN_ON_ONCE(error))
1798                         break;
1799
1800                 block = gfs2_rbm_to_block(&rbm);
1801                 if (gfs2_rbm_from_block(&rbm, block + 1))
1802                         break;
1803                 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1804                         continue;
1805                 if (block == skip)
1806                         continue;
1807                 *last_unlinked = block;
1808
1809                 error = gfs2_glock_get(sdp, block, &gfs2_iopen_glops, CREATE, &gl);
1810                 if (error)
1811                         continue;
1812
1813                 /* If the inode is already in cache, we can ignore it here
1814                  * because the existing inode disposal code will deal with
1815                  * it when all refs have gone away. Accessing gl_object like
1816                  * this is not safe in general. Here it is ok because we do
1817                  * not dereference the pointer, and we only need an approx
1818                  * answer to whether it is NULL or not.
1819                  */
1820                 ip = gl->gl_object;
1821
1822                 if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
1823                         gfs2_glock_put(gl);
1824                 else
1825                         found++;
1826
1827                 /* Limit reclaim to sensible number of tasks */
1828                 if (found > NR_CPUS)
1829                         return;
1830         }
1831
1832         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1833         return;
1834 }
1835
1836 /**
1837  * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1838  * @rgd: The rgrp in question
1839  * @loops: An indication of how picky we can be (0=very, 1=less so)
1840  *
1841  * This function uses the recently added glock statistics in order to
1842  * figure out whether a parciular resource group is suffering from
1843  * contention from multiple nodes. This is done purely on the basis
1844  * of timings, since this is the only data we have to work with and
1845  * our aim here is to reject a resource group which is highly contended
1846  * but (very important) not to do this too often in order to ensure that
1847  * we do not land up introducing fragmentation by changing resource
1848  * groups when not actually required.
1849  *
1850  * The calculation is fairly simple, we want to know whether the SRTTB
1851  * (i.e. smoothed round trip time for blocking operations) to acquire
1852  * the lock for this rgrp's glock is significantly greater than the
1853  * time taken for resource groups on average. We introduce a margin in
1854  * the form of the variable @var which is computed as the sum of the two
1855  * respective variences, and multiplied by a factor depending on @loops
1856  * and whether we have a lot of data to base the decision on. This is
1857  * then tested against the square difference of the means in order to
1858  * decide whether the result is statistically significant or not.
1859  *
1860  * Returns: A boolean verdict on the congestion status
1861  */
1862
1863 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1864 {
1865         const struct gfs2_glock *gl = rgd->rd_gl;
1866         const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
1867         struct gfs2_lkstats *st;
1868         u64 r_dcount, l_dcount;
1869         u64 l_srttb, a_srttb = 0;
1870         s64 srttb_diff;
1871         u64 sqr_diff;
1872         u64 var;
1873         int cpu, nonzero = 0;
1874
1875         preempt_disable();
1876         for_each_present_cpu(cpu) {
1877                 st = &per_cpu_ptr(sdp->sd_lkstats, cpu)->lkstats[LM_TYPE_RGRP];
1878                 if (st->stats[GFS2_LKS_SRTTB]) {
1879                         a_srttb += st->stats[GFS2_LKS_SRTTB];
1880                         nonzero++;
1881                 }
1882         }
1883         st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
1884         if (nonzero)
1885                 do_div(a_srttb, nonzero);
1886         r_dcount = st->stats[GFS2_LKS_DCOUNT];
1887         var = st->stats[GFS2_LKS_SRTTVARB] +
1888               gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1889         preempt_enable();
1890
1891         l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1892         l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1893
1894         if ((l_dcount < 1) || (r_dcount < 1) || (a_srttb == 0))
1895                 return false;
1896
1897         srttb_diff = a_srttb - l_srttb;
1898         sqr_diff = srttb_diff * srttb_diff;
1899
1900         var *= 2;
1901         if (l_dcount < 8 || r_dcount < 8)
1902                 var *= 2;
1903         if (loops == 1)
1904                 var *= 2;
1905
1906         return ((srttb_diff < 0) && (sqr_diff > var));
1907 }
1908
1909 /**
1910  * gfs2_rgrp_used_recently
1911  * @rs: The block reservation with the rgrp to test
1912  * @msecs: The time limit in milliseconds
1913  *
1914  * Returns: True if the rgrp glock has been used within the time limit
1915  */
1916 static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1917                                     u64 msecs)
1918 {
1919         u64 tdiff;
1920
1921         tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
1922                             rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1923
1924         return tdiff > (msecs * 1000 * 1000);
1925 }
1926
1927 static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1928 {
1929         const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1930         u32 skip;
1931
1932         get_random_bytes(&skip, sizeof(skip));
1933         return skip % sdp->sd_rgrps;
1934 }
1935
1936 static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1937 {
1938         struct gfs2_rgrpd *rgd = *pos;
1939         struct gfs2_sbd *sdp = rgd->rd_sbd;
1940
1941         rgd = gfs2_rgrpd_get_next(rgd);
1942         if (rgd == NULL)
1943                 rgd = gfs2_rgrpd_get_first(sdp);
1944         *pos = rgd;
1945         if (rgd != begin) /* If we didn't wrap */
1946                 return true;
1947         return false;
1948 }
1949
1950 /**
1951  * fast_to_acquire - determine if a resource group will be fast to acquire
1952  *
1953  * If this is one of our preferred rgrps, it should be quicker to acquire,
1954  * because we tried to set ourselves up as dlm lock master.
1955  */
1956 static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
1957 {
1958         struct gfs2_glock *gl = rgd->rd_gl;
1959
1960         if (gl->gl_state != LM_ST_UNLOCKED && list_empty(&gl->gl_holders) &&
1961             !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
1962             !test_bit(GLF_DEMOTE, &gl->gl_flags))
1963                 return 1;
1964         if (rgd->rd_flags & GFS2_RDF_PREFERRED)
1965                 return 1;
1966         return 0;
1967 }
1968
1969 /**
1970  * gfs2_inplace_reserve - Reserve space in the filesystem
1971  * @ip: the inode to reserve space for
1972  * @ap: the allocation parameters
1973  *
1974  * We try our best to find an rgrp that has at least ap->target blocks
1975  * available. After a couple of passes (loops == 2), the prospects of finding
1976  * such an rgrp diminish. At this stage, we return the first rgrp that has
1977  * atleast ap->min_target blocks available. Either way, we set ap->allowed to
1978  * the number of blocks available in the chosen rgrp.
1979  *
1980  * Returns: 0 on success,
1981  *          -ENOMEM if a suitable rgrp can't be found
1982  *          errno otherwise
1983  */
1984
1985 int gfs2_inplace_reserve(struct gfs2_inode *ip, struct gfs2_alloc_parms *ap)
1986 {
1987         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1988         struct gfs2_rgrpd *begin = NULL;
1989         struct gfs2_blkreserv *rs = &ip->i_res;
1990         int error = 0, rg_locked, flags = 0;
1991         u64 last_unlinked = NO_BLOCK;
1992         int loops = 0;
1993         u32 skip = 0;
1994
1995         if (sdp->sd_args.ar_rgrplvb)
1996                 flags |= GL_SKIP;
1997         if (gfs2_assert_warn(sdp, ap->target))
1998                 return -EINVAL;
1999         if (gfs2_rs_active(rs)) {
2000                 begin = rs->rs_rbm.rgd;
2001         } else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
2002                 rs->rs_rbm.rgd = begin = ip->i_rgd;
2003         } else {
2004                 check_and_update_goal(ip);
2005                 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
2006         }
2007         if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
2008                 skip = gfs2_orlov_skip(ip);
2009         if (rs->rs_rbm.rgd == NULL)
2010                 return -EBADSLT;
2011
2012         while (loops < 3) {
2013                 rg_locked = 1;
2014
2015                 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
2016                         rg_locked = 0;
2017                         if (skip && skip--)
2018                                 goto next_rgrp;
2019                         if (!gfs2_rs_active(rs)) {
2020                                 if (loops == 0 &&
2021                                     !fast_to_acquire(rs->rs_rbm.rgd))
2022                                         goto next_rgrp;
2023                                 if ((loops < 2) &&
2024                                     gfs2_rgrp_used_recently(rs, 1000) &&
2025                                     gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2026                                         goto next_rgrp;
2027                         }
2028                         error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
2029                                                    LM_ST_EXCLUSIVE, flags,
2030                                                    &rs->rs_rgd_gh);
2031                         if (unlikely(error))
2032                                 return error;
2033                         if (!gfs2_rs_active(rs) && (loops < 2) &&
2034                             gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2035                                 goto skip_rgrp;
2036                         if (sdp->sd_args.ar_rgrplvb) {
2037                                 error = update_rgrp_lvb(rs->rs_rbm.rgd);
2038                                 if (unlikely(error)) {
2039                                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2040                                         return error;
2041                                 }
2042                         }
2043                 }
2044
2045                 /* Skip unuseable resource groups */
2046                 if ((rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC |
2047                                                  GFS2_RDF_ERROR)) ||
2048                     (loops == 0 && ap->target > rs->rs_rbm.rgd->rd_extfail_pt))
2049                         goto skip_rgrp;
2050
2051                 if (sdp->sd_args.ar_rgrplvb)
2052                         gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
2053
2054                 /* Get a reservation if we don't already have one */
2055                 if (!gfs2_rs_active(rs))
2056                         rg_mblk_search(rs->rs_rbm.rgd, ip, ap);
2057
2058                 /* Skip rgrps when we can't get a reservation on first pass */
2059                 if (!gfs2_rs_active(rs) && (loops < 1))
2060                         goto check_rgrp;
2061
2062                 /* If rgrp has enough free space, use it */
2063                 if (rs->rs_rbm.rgd->rd_free_clone >= ap->target ||
2064                     (loops == 2 && ap->min_target &&
2065                      rs->rs_rbm.rgd->rd_free_clone >= ap->min_target)) {
2066                         ip->i_rgd = rs->rs_rbm.rgd;
2067                         ap->allowed = ip->i_rgd->rd_free_clone;
2068                         return 0;
2069                 }
2070 check_rgrp:
2071                 /* Check for unlinked inodes which can be reclaimed */
2072                 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
2073                         try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
2074                                         ip->i_no_addr);
2075 skip_rgrp:
2076                 /* Drop reservation, if we couldn't use reserved rgrp */
2077                 if (gfs2_rs_active(rs))
2078                         gfs2_rs_deltree(rs);
2079
2080                 /* Unlock rgrp if required */
2081                 if (!rg_locked)
2082                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2083 next_rgrp:
2084                 /* Find the next rgrp, and continue looking */
2085                 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
2086                         continue;
2087                 if (skip)
2088                         continue;
2089
2090                 /* If we've scanned all the rgrps, but found no free blocks
2091                  * then this checks for some less likely conditions before
2092                  * trying again.
2093                  */
2094                 loops++;
2095                 /* Check that fs hasn't grown if writing to rindex */
2096                 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
2097                         error = gfs2_ri_update(ip);
2098                         if (error)
2099                                 return error;
2100                 }
2101                 /* Flushing the log may release space */
2102                 if (loops == 2)
2103                         gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
2104         }
2105
2106         return -ENOSPC;
2107 }
2108
2109 /**
2110  * gfs2_inplace_release - release an inplace reservation
2111  * @ip: the inode the reservation was taken out on
2112  *
2113  * Release a reservation made by gfs2_inplace_reserve().
2114  */
2115
2116 void gfs2_inplace_release(struct gfs2_inode *ip)
2117 {
2118         struct gfs2_blkreserv *rs = &ip->i_res;
2119
2120         if (gfs2_holder_initialized(&rs->rs_rgd_gh))
2121                 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
2122 }
2123
2124 /**
2125  * gfs2_get_block_type - Check a block in a RG is of given type
2126  * @rgd: the resource group holding the block
2127  * @block: the block number
2128  *
2129  * Returns: The block type (GFS2_BLKST_*)
2130  */
2131
2132 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
2133 {
2134         struct gfs2_rbm rbm = { .rgd = rgd, };
2135         int ret;
2136
2137         ret = gfs2_rbm_from_block(&rbm, block);
2138         WARN_ON_ONCE(ret != 0);
2139
2140         return gfs2_testbit(&rbm);
2141 }
2142
2143
2144 /**
2145  * gfs2_alloc_extent - allocate an extent from a given bitmap
2146  * @rbm: the resource group information
2147  * @dinode: TRUE if the first block we allocate is for a dinode
2148  * @n: The extent length (value/result)
2149  *
2150  * Add the bitmap buffer to the transaction.
2151  * Set the found bits to @new_state to change block's allocation state.
2152  */
2153 static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
2154                              unsigned int *n)
2155 {
2156         struct gfs2_rbm pos = { .rgd = rbm->rgd, };
2157         const unsigned int elen = *n;
2158         u64 block;
2159         int ret;
2160
2161         *n = 1;
2162         block = gfs2_rbm_to_block(rbm);
2163         gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
2164         gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2165         block++;
2166         while (*n < elen) {
2167                 ret = gfs2_rbm_from_block(&pos, block);
2168                 if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
2169                         break;
2170                 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
2171                 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
2172                 (*n)++;
2173                 block++;
2174         }
2175 }
2176
2177 /**
2178  * rgblk_free - Change alloc state of given block(s)
2179  * @sdp: the filesystem
2180  * @bstart: the start of a run of blocks to free
2181  * @blen: the length of the block run (all must lie within ONE RG!)
2182  * @new_state: GFS2_BLKST_XXX the after-allocation block state
2183  *
2184  * Returns:  Resource group containing the block(s)
2185  */
2186
2187 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
2188                                      u32 blen, unsigned char new_state)
2189 {
2190         struct gfs2_rbm rbm;
2191         struct gfs2_bitmap *bi, *bi_prev = NULL;
2192
2193         rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
2194         if (!rbm.rgd) {
2195                 if (gfs2_consist(sdp))
2196                         fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
2197                 return NULL;
2198         }
2199
2200         gfs2_rbm_from_block(&rbm, bstart);
2201         while (blen--) {
2202                 bi = rbm_bi(&rbm);
2203                 if (bi != bi_prev) {
2204                         if (!bi->bi_clone) {
2205                                 bi->bi_clone = kmalloc(bi->bi_bh->b_size,
2206                                                       GFP_NOFS | __GFP_NOFAIL);
2207                                 memcpy(bi->bi_clone + bi->bi_offset,
2208                                        bi->bi_bh->b_data + bi->bi_offset,
2209                                        bi->bi_len);
2210                         }
2211                         gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2212                         bi_prev = bi;
2213                 }
2214                 gfs2_setbit(&rbm, false, new_state);
2215                 gfs2_rbm_incr(&rbm);
2216         }
2217
2218         return rbm.rgd;
2219 }
2220
2221 /**
2222  * gfs2_rgrp_dump - print out an rgrp
2223  * @seq: The iterator
2224  * @gl: The glock in question
2225  *
2226  */
2227
2228 void gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
2229 {
2230         struct gfs2_rgrpd *rgd = gl->gl_object;
2231         struct gfs2_blkreserv *trs;
2232         const struct rb_node *n;
2233
2234         if (rgd == NULL)
2235                 return;
2236         gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u e:%u\n",
2237                        (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2238                        rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2239                        rgd->rd_reserved, rgd->rd_extfail_pt);
2240         spin_lock(&rgd->rd_rsspin);
2241         for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2242                 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
2243                 dump_rs(seq, trs);
2244         }
2245         spin_unlock(&rgd->rd_rsspin);
2246 }
2247
2248 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2249 {
2250         struct gfs2_sbd *sdp = rgd->rd_sbd;
2251         fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
2252                 (unsigned long long)rgd->rd_addr);
2253         fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2254         gfs2_rgrp_dump(NULL, rgd->rd_gl);
2255         rgd->rd_flags |= GFS2_RDF_ERROR;
2256 }
2257
2258 /**
2259  * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2260  * @ip: The inode we have just allocated blocks for
2261  * @rbm: The start of the allocated blocks
2262  * @len: The extent length
2263  *
2264  * Adjusts a reservation after an allocation has taken place. If the
2265  * reservation does not match the allocation, or if it is now empty
2266  * then it is removed.
2267  */
2268
2269 static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2270                                     const struct gfs2_rbm *rbm, unsigned len)
2271 {
2272         struct gfs2_blkreserv *rs = &ip->i_res;
2273         struct gfs2_rgrpd *rgd = rbm->rgd;
2274         unsigned rlen;
2275         u64 block;
2276         int ret;
2277
2278         spin_lock(&rgd->rd_rsspin);
2279         if (gfs2_rs_active(rs)) {
2280                 if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
2281                         block = gfs2_rbm_to_block(rbm);
2282                         ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
2283                         rlen = min(rs->rs_free, len);
2284                         rs->rs_free -= rlen;
2285                         rgd->rd_reserved -= rlen;
2286                         trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2287                         if (rs->rs_free && !ret)
2288                                 goto out;
2289                         /* We used up our block reservation, so we should
2290                            reserve more blocks next time. */
2291                         atomic_add(RGRP_RSRV_ADDBLKS, &rs->rs_sizehint);
2292                 }
2293                 __rs_deltree(rs);
2294         }
2295 out:
2296         spin_unlock(&rgd->rd_rsspin);
2297 }
2298
2299 /**
2300  * gfs2_set_alloc_start - Set starting point for block allocation
2301  * @rbm: The rbm which will be set to the required location
2302  * @ip: The gfs2 inode
2303  * @dinode: Flag to say if allocation includes a new inode
2304  *
2305  * This sets the starting point from the reservation if one is active
2306  * otherwise it falls back to guessing a start point based on the
2307  * inode's goal block or the last allocation point in the rgrp.
2308  */
2309
2310 static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
2311                                  const struct gfs2_inode *ip, bool dinode)
2312 {
2313         u64 goal;
2314
2315         if (gfs2_rs_active(&ip->i_res)) {
2316                 *rbm = ip->i_res.rs_rbm;
2317                 return;
2318         }
2319
2320         if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2321                 goal = ip->i_goal;
2322         else
2323                 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
2324
2325         gfs2_rbm_from_block(rbm, goal);
2326 }
2327
2328 /**
2329  * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
2330  * @ip: the inode to allocate the block for
2331  * @bn: Used to return the starting block number
2332  * @nblocks: requested number of blocks/extent length (value/result)
2333  * @dinode: 1 if we're allocating a dinode block, else 0
2334  * @generation: the generation number of the inode
2335  *
2336  * Returns: 0 or error
2337  */
2338
2339 int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2340                       bool dinode, u64 *generation)
2341 {
2342         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2343         struct buffer_head *dibh;
2344         struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2345         unsigned int ndata;
2346         u64 block; /* block, within the file system scope */
2347         int error;
2348
2349         gfs2_set_alloc_start(&rbm, ip, dinode);
2350         error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, ip, false);
2351
2352         if (error == -ENOSPC) {
2353                 gfs2_set_alloc_start(&rbm, ip, dinode);
2354                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, NULL, false);
2355         }
2356
2357         /* Since all blocks are reserved in advance, this shouldn't happen */
2358         if (error) {
2359                 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
2360                         (unsigned long long)ip->i_no_addr, error, *nblocks,
2361                         test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2362                         rbm.rgd->rd_extfail_pt);
2363                 goto rgrp_error;
2364         }
2365
2366         gfs2_alloc_extent(&rbm, dinode, nblocks);
2367         block = gfs2_rbm_to_block(&rbm);
2368         rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2369         if (gfs2_rs_active(&ip->i_res))
2370                 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2371         ndata = *nblocks;
2372         if (dinode)
2373                 ndata--;
2374
2375         if (!dinode) {
2376                 ip->i_goal = block + ndata - 1;
2377                 error = gfs2_meta_inode_buffer(ip, &dibh);
2378                 if (error == 0) {
2379                         struct gfs2_dinode *di =
2380                                 (struct gfs2_dinode *)dibh->b_data;
2381                         gfs2_trans_add_meta(ip->i_gl, dibh);
2382                         di->di_goal_meta = di->di_goal_data =
2383                                 cpu_to_be64(ip->i_goal);
2384                         brelse(dibh);
2385                 }
2386         }
2387         if (rbm.rgd->rd_free < *nblocks) {
2388                 pr_warn("nblocks=%u\n", *nblocks);
2389                 goto rgrp_error;
2390         }
2391
2392         rbm.rgd->rd_free -= *nblocks;
2393         if (dinode) {
2394                 rbm.rgd->rd_dinodes++;
2395                 *generation = rbm.rgd->rd_igeneration++;
2396                 if (*generation == 0)
2397                         *generation = rbm.rgd->rd_igeneration++;
2398         }
2399
2400         gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2401         gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2402         gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
2403
2404         gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2405         if (dinode)
2406                 gfs2_trans_add_unrevoke(sdp, block, *nblocks);
2407
2408         gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
2409
2410         rbm.rgd->rd_free_clone -= *nblocks;
2411         trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2412                                dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2413         *bn = block;
2414         return 0;
2415
2416 rgrp_error:
2417         gfs2_rgrp_error(rbm.rgd);
2418         return -EIO;
2419 }
2420
2421 /**
2422  * __gfs2_free_blocks - free a contiguous run of block(s)
2423  * @ip: the inode these blocks are being freed from
2424  * @bstart: first block of a run of contiguous blocks
2425  * @blen: the length of the block run
2426  * @meta: 1 if the blocks represent metadata
2427  *
2428  */
2429
2430 void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
2431 {
2432         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2433         struct gfs2_rgrpd *rgd;
2434
2435         rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
2436         if (!rgd)
2437                 return;
2438         trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2439         rgd->rd_free += blen;
2440         rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2441         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2442         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2443         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2444
2445         /* Directories keep their data in the metadata address space */
2446         if (meta || ip->i_depth)
2447                 gfs2_meta_wipe(ip, bstart, blen);
2448 }
2449
2450 /**
2451  * gfs2_free_meta - free a contiguous run of data block(s)
2452  * @ip: the inode these blocks are being freed from
2453  * @bstart: first block of a run of contiguous blocks
2454  * @blen: the length of the block run
2455  *
2456  */
2457
2458 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
2459 {
2460         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2461
2462         __gfs2_free_blocks(ip, bstart, blen, 1);
2463         gfs2_statfs_change(sdp, 0, +blen, 0);
2464         gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
2465 }
2466
2467 void gfs2_unlink_di(struct inode *inode)
2468 {
2469         struct gfs2_inode *ip = GFS2_I(inode);
2470         struct gfs2_sbd *sdp = GFS2_SB(inode);
2471         struct gfs2_rgrpd *rgd;
2472         u64 blkno = ip->i_no_addr;
2473
2474         rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
2475         if (!rgd)
2476                 return;
2477         trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2478         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2479         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2480         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2481         update_rgrp_lvb_unlinked(rgd, 1);
2482 }
2483
2484 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
2485 {
2486         struct gfs2_sbd *sdp = rgd->rd_sbd;
2487         struct gfs2_rgrpd *tmp_rgd;
2488
2489         tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
2490         if (!tmp_rgd)
2491                 return;
2492         gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
2493
2494         if (!rgd->rd_dinodes)
2495                 gfs2_consist_rgrpd(rgd);
2496         rgd->rd_dinodes--;
2497         rgd->rd_free++;
2498
2499         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2500         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2501         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2502         update_rgrp_lvb_unlinked(rgd, -1);
2503
2504         gfs2_statfs_change(sdp, 0, +1, -1);
2505 }
2506
2507
2508 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2509 {
2510         gfs2_free_uninit_di(rgd, ip->i_no_addr);
2511         trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2512         gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2513         gfs2_meta_wipe(ip, ip->i_no_addr, 1);
2514 }
2515
2516 /**
2517  * gfs2_check_blk_type - Check the type of a block
2518  * @sdp: The superblock
2519  * @no_addr: The block number to check
2520  * @type: The block type we are looking for
2521  *
2522  * Returns: 0 if the block type matches the expected type
2523  *          -ESTALE if it doesn't match
2524  *          or -ve errno if something went wrong while checking
2525  */
2526
2527 int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2528 {
2529         struct gfs2_rgrpd *rgd;
2530         struct gfs2_holder rgd_gh;
2531         int error = -EINVAL;
2532
2533         rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2534         if (!rgd)
2535                 goto fail;
2536
2537         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2538         if (error)
2539                 goto fail;
2540
2541         if (gfs2_get_block_type(rgd, no_addr) != type)
2542                 error = -ESTALE;
2543
2544         gfs2_glock_dq_uninit(&rgd_gh);
2545 fail:
2546         return error;
2547 }
2548
2549 /**
2550  * gfs2_rlist_add - add a RG to a list of RGs
2551  * @ip: the inode
2552  * @rlist: the list of resource groups
2553  * @block: the block
2554  *
2555  * Figure out what RG a block belongs to and add that RG to the list
2556  *
2557  * FIXME: Don't use NOFAIL
2558  *
2559  */
2560
2561 void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2562                     u64 block)
2563 {
2564         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2565         struct gfs2_rgrpd *rgd;
2566         struct gfs2_rgrpd **tmp;
2567         unsigned int new_space;
2568         unsigned int x;
2569
2570         if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2571                 return;
2572
2573         if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
2574                 rgd = ip->i_rgd;
2575         else
2576                 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2577         if (!rgd) {
2578                 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
2579                 return;
2580         }
2581         ip->i_rgd = rgd;
2582
2583         for (x = 0; x < rlist->rl_rgrps; x++)
2584                 if (rlist->rl_rgd[x] == rgd)
2585                         return;
2586
2587         if (rlist->rl_rgrps == rlist->rl_space) {
2588                 new_space = rlist->rl_space + 10;
2589
2590                 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
2591                               GFP_NOFS | __GFP_NOFAIL);
2592
2593                 if (rlist->rl_rgd) {
2594                         memcpy(tmp, rlist->rl_rgd,
2595                                rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2596                         kfree(rlist->rl_rgd);
2597                 }
2598
2599                 rlist->rl_space = new_space;
2600                 rlist->rl_rgd = tmp;
2601         }
2602
2603         rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2604 }
2605
2606 /**
2607  * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2608  *      and initialize an array of glock holders for them
2609  * @rlist: the list of resource groups
2610  * @state: the lock state to acquire the RG lock in
2611  *
2612  * FIXME: Don't use NOFAIL
2613  *
2614  */
2615
2616 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
2617 {
2618         unsigned int x;
2619
2620         rlist->rl_ghs = kmalloc(rlist->rl_rgrps * sizeof(struct gfs2_holder),
2621                                 GFP_NOFS | __GFP_NOFAIL);
2622         for (x = 0; x < rlist->rl_rgrps; x++)
2623                 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2624                                 state, 0,
2625                                 &rlist->rl_ghs[x]);
2626 }
2627
2628 /**
2629  * gfs2_rlist_free - free a resource group list
2630  * @rlist: the list of resource groups
2631  *
2632  */
2633
2634 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2635 {
2636         unsigned int x;
2637
2638         kfree(rlist->rl_rgd);
2639
2640         if (rlist->rl_ghs) {
2641                 for (x = 0; x < rlist->rl_rgrps; x++)
2642                         gfs2_holder_uninit(&rlist->rl_ghs[x]);
2643                 kfree(rlist->rl_ghs);
2644                 rlist->rl_ghs = NULL;
2645         }
2646 }
2647