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

~ [ 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