~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/gfs2/rgrp.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp