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