797f1d3114ef22684fed08d076e9d329d01c8807
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
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.
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/prefetch.h>
17 #include <linux/blkdev.h>
18 #include <linux/rbtree.h>
19 #include <linux/random.h>
34 #include "trace_gfs2.h"
36 #define BFITNOENT ((u32)~0)
37 #define NO_BLOCK ((u64)~0)
39 #if BITS_PER_LONG == 32
40 #define LBITMASK (0x55555555UL)
41 #define LBITSKIP55 (0x55555555UL)
42 #define LBITSKIP00 (0x00000000UL)
44 #define LBITMASK (0x5555555555555555UL)
45 #define LBITSKIP55 (0x5555555555555555UL)
46 #define LBITSKIP00 (0x0000000000000000UL)
50 * These routines are used by the resource group routines (rgrp.c)
51 * to keep track of block allocation. Each block is represented by two
52 * bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.
55 * 1 = Used (not metadata)
56 * 2 = Unlinked (still in use) inode
65 static const char valid_change
[16] = {
73 static int gfs2_rbm_find(struct gfs2_rbm
*rbm
, u8 state
, u32
*minext
,
74 const struct gfs2_inode
*ip
, bool nowrap
,
75 const struct gfs2_alloc_parms
*ap
);
79 * gfs2_setbit - Set a bit in the bitmaps
80 * @rbm: The position of the bit to set
81 * @do_clone: Also set the clone bitmap, if it exists
82 * @new_state: the new state of the block
86 static inline void gfs2_setbit(const struct gfs2_rbm
*rbm
, bool do_clone
,
87 unsigned char new_state
)
89 unsigned char *byte1
, *byte2
, *end
, cur_state
;
90 struct gfs2_bitmap
*bi
= rbm_bi(rbm
);
91 unsigned int buflen
= bi
->bi_len
;
92 const unsigned int bit
= (rbm
->offset
% GFS2_NBBY
) * GFS2_BIT_SIZE
;
94 byte1
= bi
->bi_bh
->b_data
+ bi
->bi_offset
+ (rbm
->offset
/ GFS2_NBBY
);
95 end
= bi
->bi_bh
->b_data
+ bi
->bi_offset
+ buflen
;
99 cur_state
= (*byte1
>> bit
) & GFS2_BIT_MASK
;
101 if (unlikely(!valid_change
[new_state
* 4 + cur_state
])) {
102 printk(KERN_WARNING
"GFS2: buf_blk = 0x%x old_state=%d, "
103 "new_state=%d\n", rbm
->offset
, cur_state
, new_state
);
104 printk(KERN_WARNING
"GFS2: rgrp=0x%llx bi_start=0x%x\n",
105 (unsigned long long)rbm
->rgd
->rd_addr
, bi
->bi_start
);
106 printk(KERN_WARNING
"GFS2: bi_offset=0x%x bi_len=0x%x\n",
107 bi
->bi_offset
, bi
->bi_len
);
109 gfs2_consist_rgrpd(rbm
->rgd
);
112 *byte1
^= (cur_state
^ new_state
) << bit
;
114 if (do_clone
&& bi
->bi_clone
) {
115 byte2
= bi
->bi_clone
+ bi
->bi_offset
+ (rbm
->offset
/ GFS2_NBBY
);
116 cur_state
= (*byte2
>> bit
) & GFS2_BIT_MASK
;
117 *byte2
^= (cur_state
^ new_state
) << bit
;
122 * gfs2_testbit - test a bit in the bitmaps
123 * @rbm: The bit to test
125 * Returns: The two bit block state of the requested bit
128 static inline u8
gfs2_testbit(const struct gfs2_rbm
*rbm
)
130 struct gfs2_bitmap
*bi
= rbm_bi(rbm
);
131 const u8
*buffer
= bi
->bi_bh
->b_data
+ bi
->bi_offset
;
135 byte
= buffer
+ (rbm
->offset
/ GFS2_NBBY
);
136 bit
= (rbm
->offset
% GFS2_NBBY
) * GFS2_BIT_SIZE
;
138 return (*byte
>> bit
) & GFS2_BIT_MASK
;
143 * @ptr: Pointer to bitmap data
144 * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
145 * @state: The state we are searching for
147 * We xor the bitmap data with a patter which is the bitwise opposite
148 * of what we are looking for, this gives rise to a pattern of ones
149 * wherever there is a match. Since we have two bits per entry, we
150 * take this pattern, shift it down by one place and then and it with
151 * the original. All the even bit positions (0,2,4, etc) then represent
152 * successful matches, so we mask with 0x55555..... to remove the unwanted
155 * This allows searching of a whole u64 at once (32 blocks) with a
156 * single test (on 64 bit arches).
159 static inline u64
gfs2_bit_search(const __le64
*ptr
, u64 mask
, u8 state
)
162 static const u64 search
[] = {
163 [0] = 0xffffffffffffffffULL
,
164 [1] = 0xaaaaaaaaaaaaaaaaULL
,
165 [2] = 0x5555555555555555ULL
,
166 [3] = 0x0000000000000000ULL
,
168 tmp
= le64_to_cpu(*ptr
) ^ search
[state
];
175 * rs_cmp - multi-block reservation range compare
176 * @blk: absolute file system block number of the new reservation
177 * @len: number of blocks in the new reservation
178 * @rs: existing reservation to compare against
180 * returns: 1 if the block range is beyond the reach of the reservation
181 * -1 if the block range is before the start of the reservation
182 * 0 if the block range overlaps with the reservation
184 static inline int rs_cmp(u64 blk
, u32 len
, struct gfs2_blkreserv
*rs
)
186 u64 startblk
= gfs2_rbm_to_block(&rs
->rs_rbm
);
188 if (blk
>= startblk
+ rs
->rs_free
)
190 if (blk
+ len
- 1 < startblk
)
196 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
197 * a block in a given allocation state.
198 * @buf: the buffer that holds the bitmaps
199 * @len: the length (in bytes) of the buffer
200 * @goal: start search at this block's bit-pair (within @buffer)
201 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
203 * Scope of @goal and returned block number is only within this bitmap buffer,
204 * not entire rgrp or filesystem. @buffer will be offset from the actual
205 * beginning of a bitmap block buffer, skipping any header structures, but
206 * headers are always a multiple of 64 bits long so that the buffer is
207 * always aligned to a 64 bit boundary.
209 * The size of the buffer is in bytes, but is it assumed that it is
210 * always ok to read a complete multiple of 64 bits at the end
211 * of the block in case the end is no aligned to a natural boundary.
213 * Return: the block number (bitmap buffer scope) that was found
216 static u32
gfs2_bitfit(const u8
*buf
, const unsigned int len
,
219 u32 spoint
= (goal
<< 1) & ((8*sizeof(u64
)) - 1);
220 const __le64
*ptr
= ((__le64
*)buf
) + (goal
>> 5);
221 const __le64
*end
= (__le64
*)(buf
+ ALIGN(len
, sizeof(u64
)));
223 u64 mask
= 0x5555555555555555ULL
;
226 /* Mask off bits we don't care about at the start of the search */
228 tmp
= gfs2_bit_search(ptr
, mask
, state
);
230 while(tmp
== 0 && ptr
< end
) {
231 tmp
= gfs2_bit_search(ptr
, 0x5555555555555555ULL
, state
);
234 /* Mask off any bits which are more than len bytes from the start */
235 if (ptr
== end
&& (len
& (sizeof(u64
) - 1)))
236 tmp
&= (((u64
)~0) >> (64 - 8*(len
& (sizeof(u64
) - 1))));
237 /* Didn't find anything, so return */
242 bit
/= 2; /* two bits per entry in the bitmap */
243 return (((const unsigned char *)ptr
- buf
) * GFS2_NBBY
) + bit
;
247 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
248 * @rbm: The rbm with rgd already set correctly
249 * @block: The block number (filesystem relative)
251 * This sets the bi and offset members of an rbm based on a
252 * resource group and a filesystem relative block number. The
253 * resource group must be set in the rbm on entry, the bi and
254 * offset members will be set by this function.
256 * Returns: 0 on success, or an error code
259 static int gfs2_rbm_from_block(struct gfs2_rbm
*rbm
, u64 block
)
261 u64 rblock
= block
- rbm
->rgd
->rd_data0
;
263 if (WARN_ON_ONCE(rblock
> UINT_MAX
))
265 if (block
>= rbm
->rgd
->rd_data0
+ rbm
->rgd
->rd_data
)
269 rbm
->offset
= (u32
)(rblock
);
270 /* Check if the block is within the first block */
271 if (rbm
->offset
< rbm_bi(rbm
)->bi_blocks
)
274 /* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
275 rbm
->offset
+= (sizeof(struct gfs2_rgrp
) -
276 sizeof(struct gfs2_meta_header
)) * GFS2_NBBY
;
277 rbm
->bii
= rbm
->offset
/ rbm
->rgd
->rd_sbd
->sd_blocks_per_bitmap
;
278 rbm
->offset
-= rbm
->bii
* rbm
->rgd
->rd_sbd
->sd_blocks_per_bitmap
;
283 * gfs2_rbm_incr - increment an rbm structure
284 * @rbm: The rbm with rgd already set correctly
286 * This function takes an existing rbm structure and increments it to the next
287 * viable block offset.
289 * Returns: If incrementing the offset would cause the rbm to go past the
290 * end of the rgrp, true is returned, otherwise false.
294 static bool gfs2_rbm_incr(struct gfs2_rbm
*rbm
)
296 if (rbm
->offset
+ 1 < rbm_bi(rbm
)->bi_blocks
) { /* in the same bitmap */
300 if (rbm
->bii
== rbm
->rgd
->rd_length
- 1) /* at the last bitmap */
309 * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
310 * @rbm: Position to search (value/result)
311 * @n_unaligned: Number of unaligned blocks to check
312 * @len: Decremented for each block found (terminate on zero)
314 * Returns: true if a non-free block is encountered
317 static bool gfs2_unaligned_extlen(struct gfs2_rbm
*rbm
, u32 n_unaligned
, u32
*len
)
322 for (n
= 0; n
< n_unaligned
; n
++) {
323 res
= gfs2_testbit(rbm
);
324 if (res
!= GFS2_BLKST_FREE
)
329 if (gfs2_rbm_incr(rbm
))
337 * gfs2_free_extlen - Return extent length of free blocks
338 * @rbm: Starting position
339 * @len: Max length to check
341 * Starting at the block specified by the rbm, see how many free blocks
342 * there are, not reading more than len blocks ahead. This can be done
343 * using memchr_inv when the blocks are byte aligned, but has to be done
344 * on a block by block basis in case of unaligned blocks. Also this
345 * function can cope with bitmap boundaries (although it must stop on
346 * a resource group boundary)
348 * Returns: Number of free blocks in the extent
351 static u32
gfs2_free_extlen(const struct gfs2_rbm
*rrbm
, u32 len
)
353 struct gfs2_rbm rbm
= *rrbm
;
354 u32 n_unaligned
= rbm
.offset
& 3;
358 u8
*ptr
, *start
, *end
;
360 struct gfs2_bitmap
*bi
;
363 gfs2_unaligned_extlen(&rbm
, 4 - n_unaligned
, &len
))
366 n_unaligned
= len
& 3;
367 /* Start is now byte aligned */
370 start
= bi
->bi_bh
->b_data
;
372 start
= bi
->bi_clone
;
373 end
= start
+ bi
->bi_bh
->b_size
;
374 start
+= bi
->bi_offset
;
375 BUG_ON(rbm
.offset
& 3);
376 start
+= (rbm
.offset
/ GFS2_NBBY
);
377 bytes
= min_t(u32
, len
/ GFS2_NBBY
, (end
- start
));
378 ptr
= memchr_inv(start
, 0, bytes
);
379 chunk_size
= ((ptr
== NULL
) ? bytes
: (ptr
- start
));
380 chunk_size
*= GFS2_NBBY
;
381 BUG_ON(len
< chunk_size
);
383 block
= gfs2_rbm_to_block(&rbm
);
384 if (gfs2_rbm_from_block(&rbm
, block
+ chunk_size
)) {
392 n_unaligned
= len
& 3;
395 /* Deal with any bits left over at the end */
397 gfs2_unaligned_extlen(&rbm
, n_unaligned
, &len
);
403 * gfs2_bitcount - count the number of bits in a certain state
404 * @rgd: the resource group descriptor
405 * @buffer: the buffer that holds the bitmaps
406 * @buflen: the length (in bytes) of the buffer
407 * @state: the state of the block we're looking for
409 * Returns: The number of bits
412 static u32
gfs2_bitcount(struct gfs2_rgrpd
*rgd
, const u8
*buffer
,
413 unsigned int buflen
, u8 state
)
415 const u8
*byte
= buffer
;
416 const u8
*end
= buffer
+ buflen
;
417 const u8 state1
= state
<< 2;
418 const u8 state2
= state
<< 4;
419 const u8 state3
= state
<< 6;
422 for (; byte
< end
; byte
++) {
423 if (((*byte
) & 0x03) == state
)
425 if (((*byte
) & 0x0C) == state1
)
427 if (((*byte
) & 0x30) == state2
)
429 if (((*byte
) & 0xC0) == state3
)
437 * gfs2_rgrp_verify - Verify that a resource group is consistent
442 void gfs2_rgrp_verify(struct gfs2_rgrpd
*rgd
)
444 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
445 struct gfs2_bitmap
*bi
= NULL
;
446 u32 length
= rgd
->rd_length
;
450 memset(count
, 0, 4 * sizeof(u32
));
452 /* Count # blocks in each of 4 possible allocation states */
453 for (buf
= 0; buf
< length
; buf
++) {
454 bi
= rgd
->rd_bits
+ buf
;
455 for (x
= 0; x
< 4; x
++)
456 count
[x
] += gfs2_bitcount(rgd
,
462 if (count
[0] != rgd
->rd_free
) {
463 if (gfs2_consist_rgrpd(rgd
))
464 fs_err(sdp
, "free data mismatch: %u != %u\n",
465 count
[0], rgd
->rd_free
);
469 tmp
= rgd
->rd_data
- rgd
->rd_free
- rgd
->rd_dinodes
;
470 if (count
[1] != tmp
) {
471 if (gfs2_consist_rgrpd(rgd
))
472 fs_err(sdp
, "used data mismatch: %u != %u\n",
477 if (count
[2] + count
[3] != rgd
->rd_dinodes
) {
478 if (gfs2_consist_rgrpd(rgd
))
479 fs_err(sdp
, "used metadata mismatch: %u != %u\n",
480 count
[2] + count
[3], rgd
->rd_dinodes
);
485 static inline int rgrp_contains_block(struct gfs2_rgrpd
*rgd
, u64 block
)
487 u64 first
= rgd
->rd_data0
;
488 u64 last
= first
+ rgd
->rd_data
;
489 return first
<= block
&& block
< last
;
493 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
494 * @sdp: The GFS2 superblock
495 * @blk: The data block number
496 * @exact: True if this needs to be an exact match
498 * Returns: The resource group, or NULL if not found
501 struct gfs2_rgrpd
*gfs2_blk2rgrpd(struct gfs2_sbd
*sdp
, u64 blk
, bool exact
)
503 struct rb_node
*n
, *next
;
504 struct gfs2_rgrpd
*cur
;
506 spin_lock(&sdp
->sd_rindex_spin
);
507 n
= sdp
->sd_rindex_tree
.rb_node
;
509 cur
= rb_entry(n
, struct gfs2_rgrpd
, rd_node
);
511 if (blk
< cur
->rd_addr
)
513 else if (blk
>= cur
->rd_data0
+ cur
->rd_data
)
516 spin_unlock(&sdp
->sd_rindex_spin
);
518 if (blk
< cur
->rd_addr
)
520 if (blk
>= cur
->rd_data0
+ cur
->rd_data
)
527 spin_unlock(&sdp
->sd_rindex_spin
);
533 * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
534 * @sdp: The GFS2 superblock
536 * Returns: The first rgrp in the filesystem
539 struct gfs2_rgrpd
*gfs2_rgrpd_get_first(struct gfs2_sbd
*sdp
)
541 const struct rb_node
*n
;
542 struct gfs2_rgrpd
*rgd
;
544 spin_lock(&sdp
->sd_rindex_spin
);
545 n
= rb_first(&sdp
->sd_rindex_tree
);
546 rgd
= rb_entry(n
, struct gfs2_rgrpd
, rd_node
);
547 spin_unlock(&sdp
->sd_rindex_spin
);
553 * gfs2_rgrpd_get_next - get the next RG
554 * @rgd: the resource group descriptor
556 * Returns: The next rgrp
559 struct gfs2_rgrpd
*gfs2_rgrpd_get_next(struct gfs2_rgrpd
*rgd
)
561 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
562 const struct rb_node
*n
;
564 spin_lock(&sdp
->sd_rindex_spin
);
565 n
= rb_next(&rgd
->rd_node
);
567 n
= rb_first(&sdp
->sd_rindex_tree
);
569 if (unlikely(&rgd
->rd_node
== n
)) {
570 spin_unlock(&sdp
->sd_rindex_spin
);
573 rgd
= rb_entry(n
, struct gfs2_rgrpd
, rd_node
);
574 spin_unlock(&sdp
->sd_rindex_spin
);
578 void gfs2_free_clones(struct gfs2_rgrpd
*rgd
)
582 for (x
= 0; x
< rgd
->rd_length
; x
++) {
583 struct gfs2_bitmap
*bi
= rgd
->rd_bits
+ x
;
590 * gfs2_rs_alloc - make sure we have a reservation assigned to the inode
591 * @ip: the inode for this reservation
593 int gfs2_rs_alloc(struct gfs2_inode
*ip
)
597 down_write(&ip
->i_rw_mutex
);
601 ip
->i_res
= kmem_cache_zalloc(gfs2_rsrv_cachep
, GFP_NOFS
);
607 RB_CLEAR_NODE(&ip
->i_res
->rs_node
);
609 up_write(&ip
->i_rw_mutex
);
613 static void dump_rs(struct seq_file
*seq
, const struct gfs2_blkreserv
*rs
)
615 gfs2_print_dbg(seq
, " B: n:%llu s:%llu b:%u f:%u\n",
616 (unsigned long long)rs
->rs_inum
,
617 (unsigned long long)gfs2_rbm_to_block(&rs
->rs_rbm
),
618 rs
->rs_rbm
.offset
, rs
->rs_free
);
622 * __rs_deltree - remove a multi-block reservation from the rgd tree
623 * @rs: The reservation to remove
626 static void __rs_deltree(struct gfs2_blkreserv
*rs
)
628 struct gfs2_rgrpd
*rgd
;
630 if (!gfs2_rs_active(rs
))
633 rgd
= rs
->rs_rbm
.rgd
;
634 trace_gfs2_rs(rs
, TRACE_RS_TREEDEL
);
635 rb_erase(&rs
->rs_node
, &rgd
->rd_rstree
);
636 RB_CLEAR_NODE(&rs
->rs_node
);
639 struct gfs2_bitmap
*bi
= rbm_bi(&rs
->rs_rbm
);
641 /* return reserved blocks to the rgrp */
642 BUG_ON(rs
->rs_rbm
.rgd
->rd_reserved
< rs
->rs_free
);
643 rs
->rs_rbm
.rgd
->rd_reserved
-= rs
->rs_free
;
644 /* The rgrp extent failure point is likely not to increase;
645 it will only do so if the freed blocks are somehow
646 contiguous with a span of free blocks that follows. Still,
647 it will force the number to be recalculated later. */
648 rgd
->rd_extfail_pt
+= rs
->rs_free
;
650 clear_bit(GBF_FULL
, &bi
->bi_flags
);
655 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
656 * @rs: The reservation to remove
659 void gfs2_rs_deltree(struct gfs2_blkreserv
*rs
)
661 struct gfs2_rgrpd
*rgd
;
663 rgd
= rs
->rs_rbm
.rgd
;
665 spin_lock(&rgd
->rd_rsspin
);
667 spin_unlock(&rgd
->rd_rsspin
);
672 * gfs2_rs_delete - delete a multi-block reservation
673 * @ip: The inode for this reservation
674 * @wcount: The inode's write count, or NULL
677 void gfs2_rs_delete(struct gfs2_inode
*ip
, atomic_t
*wcount
)
679 down_write(&ip
->i_rw_mutex
);
680 if (ip
->i_res
&& ((wcount
== NULL
) || (atomic_read(wcount
) <= 1))) {
681 gfs2_rs_deltree(ip
->i_res
);
682 BUG_ON(ip
->i_res
->rs_free
);
683 kmem_cache_free(gfs2_rsrv_cachep
, ip
->i_res
);
686 up_write(&ip
->i_rw_mutex
);
690 * return_all_reservations - return all reserved blocks back to the rgrp.
691 * @rgd: the rgrp that needs its space back
693 * We previously reserved a bunch of blocks for allocation. Now we need to
694 * give them back. This leave the reservation structures in tact, but removes
695 * all of their corresponding "no-fly zones".
697 static void return_all_reservations(struct gfs2_rgrpd
*rgd
)
700 struct gfs2_blkreserv
*rs
;
702 spin_lock(&rgd
->rd_rsspin
);
703 while ((n
= rb_first(&rgd
->rd_rstree
))) {
704 rs
= rb_entry(n
, struct gfs2_blkreserv
, rs_node
);
707 spin_unlock(&rgd
->rd_rsspin
);
710 void gfs2_clear_rgrpd(struct gfs2_sbd
*sdp
)
713 struct gfs2_rgrpd
*rgd
;
714 struct gfs2_glock
*gl
;
716 while ((n
= rb_first(&sdp
->sd_rindex_tree
))) {
717 rgd
= rb_entry(n
, struct gfs2_rgrpd
, rd_node
);
720 rb_erase(n
, &sdp
->sd_rindex_tree
);
723 spin_lock(&gl
->gl_spin
);
724 gl
->gl_object
= NULL
;
725 spin_unlock(&gl
->gl_spin
);
726 gfs2_glock_add_to_lru(gl
);
730 gfs2_free_clones(rgd
);
732 return_all_reservations(rgd
);
733 kmem_cache_free(gfs2_rgrpd_cachep
, rgd
);
737 static void gfs2_rindex_print(const struct gfs2_rgrpd
*rgd
)
739 printk(KERN_INFO
" ri_addr = %llu\n", (unsigned long long)rgd
->rd_addr
);
740 printk(KERN_INFO
" ri_length = %u\n", rgd
->rd_length
);
741 printk(KERN_INFO
" ri_data0 = %llu\n", (unsigned long long)rgd
->rd_data0
);
742 printk(KERN_INFO
" ri_data = %u\n", rgd
->rd_data
);
743 printk(KERN_INFO
" ri_bitbytes = %u\n", rgd
->rd_bitbytes
);
747 * gfs2_compute_bitstructs - Compute the bitmap sizes
748 * @rgd: The resource group descriptor
750 * Calculates bitmap descriptors, one for each block that contains bitmap data
755 static int compute_bitstructs(struct gfs2_rgrpd
*rgd
)
757 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
758 struct gfs2_bitmap
*bi
;
759 u32 length
= rgd
->rd_length
; /* # blocks in hdr & bitmap */
760 u32 bytes_left
, bytes
;
766 rgd
->rd_bits
= kcalloc(length
, sizeof(struct gfs2_bitmap
), GFP_NOFS
);
770 bytes_left
= rgd
->rd_bitbytes
;
772 for (x
= 0; x
< length
; x
++) {
773 bi
= rgd
->rd_bits
+ x
;
776 /* small rgrp; bitmap stored completely in header block */
779 bi
->bi_offset
= sizeof(struct gfs2_rgrp
);
782 bi
->bi_blocks
= bytes
* GFS2_NBBY
;
785 bytes
= sdp
->sd_sb
.sb_bsize
- sizeof(struct gfs2_rgrp
);
786 bi
->bi_offset
= sizeof(struct gfs2_rgrp
);
789 bi
->bi_blocks
= bytes
* GFS2_NBBY
;
791 } else if (x
+ 1 == length
) {
793 bi
->bi_offset
= sizeof(struct gfs2_meta_header
);
794 bi
->bi_start
= rgd
->rd_bitbytes
- bytes_left
;
796 bi
->bi_blocks
= bytes
* GFS2_NBBY
;
799 bytes
= sdp
->sd_sb
.sb_bsize
-
800 sizeof(struct gfs2_meta_header
);
801 bi
->bi_offset
= sizeof(struct gfs2_meta_header
);
802 bi
->bi_start
= rgd
->rd_bitbytes
- bytes_left
;
804 bi
->bi_blocks
= bytes
* GFS2_NBBY
;
811 gfs2_consist_rgrpd(rgd
);
814 bi
= rgd
->rd_bits
+ (length
- 1);
815 if ((bi
->bi_start
+ bi
->bi_len
) * GFS2_NBBY
!= rgd
->rd_data
) {
816 if (gfs2_consist_rgrpd(rgd
)) {
817 gfs2_rindex_print(rgd
);
818 fs_err(sdp
, "start=%u len=%u offset=%u\n",
819 bi
->bi_start
, bi
->bi_len
, bi
->bi_offset
);
828 * gfs2_ri_total - Total up the file system space, according to the rindex.
829 * @sdp: the filesystem
832 u64
gfs2_ri_total(struct gfs2_sbd
*sdp
)
835 struct inode
*inode
= sdp
->sd_rindex
;
836 struct gfs2_inode
*ip
= GFS2_I(inode
);
837 char buf
[sizeof(struct gfs2_rindex
)];
840 for (rgrps
= 0;; rgrps
++) {
841 loff_t pos
= rgrps
* sizeof(struct gfs2_rindex
);
843 if (pos
+ sizeof(struct gfs2_rindex
) > i_size_read(inode
))
845 error
= gfs2_internal_read(ip
, buf
, &pos
,
846 sizeof(struct gfs2_rindex
));
847 if (error
!= sizeof(struct gfs2_rindex
))
849 total_data
+= be32_to_cpu(((struct gfs2_rindex
*)buf
)->ri_data
);
854 static int rgd_insert(struct gfs2_rgrpd
*rgd
)
856 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
857 struct rb_node
**newn
= &sdp
->sd_rindex_tree
.rb_node
, *parent
= NULL
;
859 /* Figure out where to put new node */
861 struct gfs2_rgrpd
*cur
= rb_entry(*newn
, struct gfs2_rgrpd
,
865 if (rgd
->rd_addr
< cur
->rd_addr
)
866 newn
= &((*newn
)->rb_left
);
867 else if (rgd
->rd_addr
> cur
->rd_addr
)
868 newn
= &((*newn
)->rb_right
);
873 rb_link_node(&rgd
->rd_node
, parent
, newn
);
874 rb_insert_color(&rgd
->rd_node
, &sdp
->sd_rindex_tree
);
880 * read_rindex_entry - Pull in a new resource index entry from the disk
881 * @ip: Pointer to the rindex inode
883 * Returns: 0 on success, > 0 on EOF, error code otherwise
886 static int read_rindex_entry(struct gfs2_inode
*ip
)
888 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
889 loff_t pos
= sdp
->sd_rgrps
* sizeof(struct gfs2_rindex
);
890 struct gfs2_rindex buf
;
892 struct gfs2_rgrpd
*rgd
;
894 if (pos
>= i_size_read(&ip
->i_inode
))
897 error
= gfs2_internal_read(ip
, (char *)&buf
, &pos
,
898 sizeof(struct gfs2_rindex
));
900 if (error
!= sizeof(struct gfs2_rindex
))
901 return (error
== 0) ? 1 : error
;
903 rgd
= kmem_cache_zalloc(gfs2_rgrpd_cachep
, GFP_NOFS
);
909 rgd
->rd_addr
= be64_to_cpu(buf
.ri_addr
);
910 rgd
->rd_length
= be32_to_cpu(buf
.ri_length
);
911 rgd
->rd_data0
= be64_to_cpu(buf
.ri_data0
);
912 rgd
->rd_data
= be32_to_cpu(buf
.ri_data
);
913 rgd
->rd_bitbytes
= be32_to_cpu(buf
.ri_bitbytes
);
914 spin_lock_init(&rgd
->rd_rsspin
);
916 error
= compute_bitstructs(rgd
);
920 error
= gfs2_glock_get(sdp
, rgd
->rd_addr
,
921 &gfs2_rgrp_glops
, CREATE
, &rgd
->rd_gl
);
925 rgd
->rd_gl
->gl_object
= rgd
;
926 rgd
->rd_rgl
= (struct gfs2_rgrp_lvb
*)rgd
->rd_gl
->gl_lksb
.sb_lvbptr
;
927 rgd
->rd_flags
&= ~GFS2_RDF_UPTODATE
;
928 if (rgd
->rd_data
> sdp
->sd_max_rg_data
)
929 sdp
->sd_max_rg_data
= rgd
->rd_data
;
930 spin_lock(&sdp
->sd_rindex_spin
);
931 error
= rgd_insert(rgd
);
932 spin_unlock(&sdp
->sd_rindex_spin
);
936 error
= 0; /* someone else read in the rgrp; free it and ignore it */
937 gfs2_glock_put(rgd
->rd_gl
);
941 kmem_cache_free(gfs2_rgrpd_cachep
, rgd
);
946 * gfs2_ri_update - Pull in a new resource index from the disk
947 * @ip: pointer to the rindex inode
949 * Returns: 0 on successful update, error code otherwise
952 static int gfs2_ri_update(struct gfs2_inode
*ip
)
954 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
958 error
= read_rindex_entry(ip
);
959 } while (error
== 0);
964 sdp
->sd_rindex_uptodate
= 1;
969 * gfs2_rindex_update - Update the rindex if required
970 * @sdp: The GFS2 superblock
972 * We grab a lock on the rindex inode to make sure that it doesn't
973 * change whilst we are performing an operation. We keep this lock
974 * for quite long periods of time compared to other locks. This
975 * doesn't matter, since it is shared and it is very, very rarely
976 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
978 * This makes sure that we're using the latest copy of the resource index
979 * special file, which might have been updated if someone expanded the
980 * filesystem (via gfs2_grow utility), which adds new resource groups.
982 * Returns: 0 on succeess, error code otherwise
985 int gfs2_rindex_update(struct gfs2_sbd
*sdp
)
987 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_rindex
);
988 struct gfs2_glock
*gl
= ip
->i_gl
;
989 struct gfs2_holder ri_gh
;
991 int unlock_required
= 0;
993 /* Read new copy from disk if we don't have the latest */
994 if (!sdp
->sd_rindex_uptodate
) {
995 if (!gfs2_glock_is_locked_by_me(gl
)) {
996 error
= gfs2_glock_nq_init(gl
, LM_ST_SHARED
, 0, &ri_gh
);
1001 if (!sdp
->sd_rindex_uptodate
)
1002 error
= gfs2_ri_update(ip
);
1003 if (unlock_required
)
1004 gfs2_glock_dq_uninit(&ri_gh
);
1010 static void gfs2_rgrp_in(struct gfs2_rgrpd
*rgd
, const void *buf
)
1012 const struct gfs2_rgrp
*str
= buf
;
1015 rg_flags
= be32_to_cpu(str
->rg_flags
);
1016 rg_flags
&= ~GFS2_RDF_MASK
;
1017 rgd
->rd_flags
&= GFS2_RDF_MASK
;
1018 rgd
->rd_flags
|= rg_flags
;
1019 rgd
->rd_free
= be32_to_cpu(str
->rg_free
);
1020 rgd
->rd_dinodes
= be32_to_cpu(str
->rg_dinodes
);
1021 rgd
->rd_igeneration
= be64_to_cpu(str
->rg_igeneration
);
1024 static void gfs2_rgrp_out(struct gfs2_rgrpd
*rgd
, void *buf
)
1026 struct gfs2_rgrp
*str
= buf
;
1028 str
->rg_flags
= cpu_to_be32(rgd
->rd_flags
& ~GFS2_RDF_MASK
);
1029 str
->rg_free
= cpu_to_be32(rgd
->rd_free
);
1030 str
->rg_dinodes
= cpu_to_be32(rgd
->rd_dinodes
);
1031 str
->__pad
= cpu_to_be32(0);
1032 str
->rg_igeneration
= cpu_to_be64(rgd
->rd_igeneration
);
1033 memset(&str
->rg_reserved
, 0, sizeof(str
->rg_reserved
));
1036 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd
*rgd
)
1038 struct gfs2_rgrp_lvb
*rgl
= rgd
->rd_rgl
;
1039 struct gfs2_rgrp
*str
= (struct gfs2_rgrp
*)rgd
->rd_bits
[0].bi_bh
->b_data
;
1041 if (rgl
->rl_flags
!= str
->rg_flags
|| rgl
->rl_free
!= str
->rg_free
||
1042 rgl
->rl_dinodes
!= str
->rg_dinodes
||
1043 rgl
->rl_igeneration
!= str
->rg_igeneration
)
1048 static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb
*rgl
, const void *buf
)
1050 const struct gfs2_rgrp
*str
= buf
;
1052 rgl
->rl_magic
= cpu_to_be32(GFS2_MAGIC
);
1053 rgl
->rl_flags
= str
->rg_flags
;
1054 rgl
->rl_free
= str
->rg_free
;
1055 rgl
->rl_dinodes
= str
->rg_dinodes
;
1056 rgl
->rl_igeneration
= str
->rg_igeneration
;
1060 static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd
*rgd
, u32 change
)
1062 struct gfs2_rgrp_lvb
*rgl
= rgd
->rd_rgl
;
1063 u32 unlinked
= be32_to_cpu(rgl
->rl_unlinked
) + change
;
1064 rgl
->rl_unlinked
= cpu_to_be32(unlinked
);
1067 static u32
count_unlinked(struct gfs2_rgrpd
*rgd
)
1069 struct gfs2_bitmap
*bi
;
1070 const u32 length
= rgd
->rd_length
;
1071 const u8
*buffer
= NULL
;
1072 u32 i
, goal
, count
= 0;
1074 for (i
= 0, bi
= rgd
->rd_bits
; i
< length
; i
++, bi
++) {
1076 buffer
= bi
->bi_bh
->b_data
+ bi
->bi_offset
;
1077 WARN_ON(!buffer_uptodate(bi
->bi_bh
));
1078 while (goal
< bi
->bi_len
* GFS2_NBBY
) {
1079 goal
= gfs2_bitfit(buffer
, bi
->bi_len
, goal
,
1080 GFS2_BLKST_UNLINKED
);
1081 if (goal
== BFITNOENT
)
1093 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
1094 * @rgd: the struct gfs2_rgrpd describing the RG to read in
1096 * Read in all of a Resource Group's header and bitmap blocks.
1097 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
1102 int gfs2_rgrp_bh_get(struct gfs2_rgrpd
*rgd
)
1104 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
1105 struct gfs2_glock
*gl
= rgd
->rd_gl
;
1106 unsigned int length
= rgd
->rd_length
;
1107 struct gfs2_bitmap
*bi
;
1111 if (rgd
->rd_bits
[0].bi_bh
!= NULL
)
1114 for (x
= 0; x
< length
; x
++) {
1115 bi
= rgd
->rd_bits
+ x
;
1116 error
= gfs2_meta_read(gl
, rgd
->rd_addr
+ x
, 0, &bi
->bi_bh
);
1121 for (y
= length
; y
--;) {
1122 bi
= rgd
->rd_bits
+ y
;
1123 error
= gfs2_meta_wait(sdp
, bi
->bi_bh
);
1126 if (gfs2_metatype_check(sdp
, bi
->bi_bh
, y
? GFS2_METATYPE_RB
:
1127 GFS2_METATYPE_RG
)) {
1133 if (!(rgd
->rd_flags
& GFS2_RDF_UPTODATE
)) {
1134 for (x
= 0; x
< length
; x
++)
1135 clear_bit(GBF_FULL
, &rgd
->rd_bits
[x
].bi_flags
);
1136 gfs2_rgrp_in(rgd
, (rgd
->rd_bits
[0].bi_bh
)->b_data
);
1137 rgd
->rd_flags
|= (GFS2_RDF_UPTODATE
| GFS2_RDF_CHECK
);
1138 rgd
->rd_free_clone
= rgd
->rd_free
;
1139 /* max out the rgrp allocation failure point */
1140 rgd
->rd_extfail_pt
= rgd
->rd_free
;
1142 if (cpu_to_be32(GFS2_MAGIC
) != rgd
->rd_rgl
->rl_magic
) {
1143 rgd
->rd_rgl
->rl_unlinked
= cpu_to_be32(count_unlinked(rgd
));
1144 gfs2_rgrp_ondisk2lvb(rgd
->rd_rgl
,
1145 rgd
->rd_bits
[0].bi_bh
->b_data
);
1147 else if (sdp
->sd_args
.ar_rgrplvb
) {
1148 if (!gfs2_rgrp_lvb_valid(rgd
)){
1149 gfs2_consist_rgrpd(rgd
);
1153 if (rgd
->rd_rgl
->rl_unlinked
== 0)
1154 rgd
->rd_flags
&= ~GFS2_RDF_CHECK
;
1160 bi
= rgd
->rd_bits
+ x
;
1163 gfs2_assert_warn(sdp
, !bi
->bi_clone
);
1169 int update_rgrp_lvb(struct gfs2_rgrpd
*rgd
)
1173 if (rgd
->rd_flags
& GFS2_RDF_UPTODATE
)
1176 if (cpu_to_be32(GFS2_MAGIC
) != rgd
->rd_rgl
->rl_magic
)
1177 return gfs2_rgrp_bh_get(rgd
);
1179 rl_flags
= be32_to_cpu(rgd
->rd_rgl
->rl_flags
);
1180 rl_flags
&= ~GFS2_RDF_MASK
;
1181 rgd
->rd_flags
&= GFS2_RDF_MASK
;
1182 rgd
->rd_flags
|= (rl_flags
| GFS2_RDF_UPTODATE
| GFS2_RDF_CHECK
);
1183 if (rgd
->rd_rgl
->rl_unlinked
== 0)
1184 rgd
->rd_flags
&= ~GFS2_RDF_CHECK
;
1185 rgd
->rd_free
= be32_to_cpu(rgd
->rd_rgl
->rl_free
);
1186 rgd
->rd_free_clone
= rgd
->rd_free
;
1187 rgd
->rd_dinodes
= be32_to_cpu(rgd
->rd_rgl
->rl_dinodes
);
1188 rgd
->rd_igeneration
= be64_to_cpu(rgd
->rd_rgl
->rl_igeneration
);
1192 int gfs2_rgrp_go_lock(struct gfs2_holder
*gh
)
1194 struct gfs2_rgrpd
*rgd
= gh
->gh_gl
->gl_object
;
1195 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
1197 if (gh
->gh_flags
& GL_SKIP
&& sdp
->sd_args
.ar_rgrplvb
)
1199 return gfs2_rgrp_bh_get((struct gfs2_rgrpd
*)gh
->gh_gl
->gl_object
);
1203 * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1204 * @gh: The glock holder for the resource group
1208 void gfs2_rgrp_go_unlock(struct gfs2_holder
*gh
)
1210 struct gfs2_rgrpd
*rgd
= gh
->gh_gl
->gl_object
;
1211 int x
, length
= rgd
->rd_length
;
1213 for (x
= 0; x
< length
; x
++) {
1214 struct gfs2_bitmap
*bi
= rgd
->rd_bits
+ x
;
1223 int gfs2_rgrp_send_discards(struct gfs2_sbd
*sdp
, u64 offset
,
1224 struct buffer_head
*bh
,
1225 const struct gfs2_bitmap
*bi
, unsigned minlen
, u64
*ptrimmed
)
1227 struct super_block
*sb
= sdp
->sd_vfs
;
1230 sector_t nr_blks
= 0;
1236 for (x
= 0; x
< bi
->bi_len
; x
++) {
1237 const u8
*clone
= bi
->bi_clone
? bi
->bi_clone
: bi
->bi_bh
->b_data
;
1238 clone
+= bi
->bi_offset
;
1241 const u8
*orig
= bh
->b_data
+ bi
->bi_offset
+ x
;
1242 diff
= ~(*orig
| (*orig
>> 1)) & (*clone
| (*clone
>> 1));
1244 diff
= ~(*clone
| (*clone
>> 1));
1249 blk
= offset
+ ((bi
->bi_start
+ x
) * GFS2_NBBY
);
1253 goto start_new_extent
;
1254 if ((start
+ nr_blks
) != blk
) {
1255 if (nr_blks
>= minlen
) {
1256 rv
= sb_issue_discard(sb
,
1273 if (nr_blks
>= minlen
) {
1274 rv
= sb_issue_discard(sb
, start
, nr_blks
, GFP_NOFS
, 0);
1280 *ptrimmed
= trimmed
;
1284 if (sdp
->sd_args
.ar_discard
)
1285 fs_warn(sdp
, "error %d on discard request, turning discards off for this filesystem", rv
);
1286 sdp
->sd_args
.ar_discard
= 0;
1291 * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1292 * @filp: Any file on the filesystem
1293 * @argp: Pointer to the arguments (also used to pass result)
1295 * Returns: 0 on success, otherwise error code
1298 int gfs2_fitrim(struct file
*filp
, void __user
*argp
)
1300 struct inode
*inode
= file_inode(filp
);
1301 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
1302 struct request_queue
*q
= bdev_get_queue(sdp
->sd_vfs
->s_bdev
);
1303 struct buffer_head
*bh
;
1304 struct gfs2_rgrpd
*rgd
;
1305 struct gfs2_rgrpd
*rgd_end
;
1306 struct gfs2_holder gh
;
1307 struct fstrim_range r
;
1311 u64 start
, end
, minlen
;
1313 unsigned bs_shift
= sdp
->sd_sb
.sb_bsize_shift
;
1315 if (!capable(CAP_SYS_ADMIN
))
1318 if (!blk_queue_discard(q
))
1321 if (copy_from_user(&r
, argp
, sizeof(r
)))
1324 ret
= gfs2_rindex_update(sdp
);
1328 start
= r
.start
>> bs_shift
;
1329 end
= start
+ (r
.len
>> bs_shift
);
1330 minlen
= max_t(u64
, r
.minlen
,
1331 q
->limits
.discard_granularity
) >> bs_shift
;
1333 if (end
<= start
|| minlen
> sdp
->sd_max_rg_data
)
1336 rgd
= gfs2_blk2rgrpd(sdp
, start
, 0);
1337 rgd_end
= gfs2_blk2rgrpd(sdp
, end
, 0);
1339 if ((gfs2_rgrpd_get_first(sdp
) == gfs2_rgrpd_get_next(rgd_end
))
1340 && (start
> rgd_end
->rd_data0
+ rgd_end
->rd_data
))
1341 return -EINVAL
; /* start is beyond the end of the fs */
1345 ret
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
1349 if (!(rgd
->rd_flags
& GFS2_RGF_TRIMMED
)) {
1350 /* Trim each bitmap in the rgrp */
1351 for (x
= 0; x
< rgd
->rd_length
; x
++) {
1352 struct gfs2_bitmap
*bi
= rgd
->rd_bits
+ x
;
1353 ret
= gfs2_rgrp_send_discards(sdp
,
1354 rgd
->rd_data0
, NULL
, bi
, minlen
,
1357 gfs2_glock_dq_uninit(&gh
);
1363 /* Mark rgrp as having been trimmed */
1364 ret
= gfs2_trans_begin(sdp
, RES_RG_HDR
, 0);
1366 bh
= rgd
->rd_bits
[0].bi_bh
;
1367 rgd
->rd_flags
|= GFS2_RGF_TRIMMED
;
1368 gfs2_trans_add_meta(rgd
->rd_gl
, bh
);
1369 gfs2_rgrp_out(rgd
, bh
->b_data
);
1370 gfs2_rgrp_ondisk2lvb(rgd
->rd_rgl
, bh
->b_data
);
1371 gfs2_trans_end(sdp
);
1374 gfs2_glock_dq_uninit(&gh
);
1379 rgd
= gfs2_rgrpd_get_next(rgd
);
1383 r
.len
= trimmed
<< bs_shift
;
1384 if (copy_to_user(argp
, &r
, sizeof(r
)))
1391 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
1392 * @ip: the inode structure
1395 static void rs_insert(struct gfs2_inode
*ip
)
1397 struct rb_node
**newn
, *parent
= NULL
;
1399 struct gfs2_blkreserv
*rs
= ip
->i_res
;
1400 struct gfs2_rgrpd
*rgd
= rs
->rs_rbm
.rgd
;
1401 u64 fsblock
= gfs2_rbm_to_block(&rs
->rs_rbm
);
1403 BUG_ON(gfs2_rs_active(rs
));
1405 spin_lock(&rgd
->rd_rsspin
);
1406 newn
= &rgd
->rd_rstree
.rb_node
;
1408 struct gfs2_blkreserv
*cur
=
1409 rb_entry(*newn
, struct gfs2_blkreserv
, rs_node
);
1412 rc
= rs_cmp(fsblock
, rs
->rs_free
, cur
);
1414 newn
= &((*newn
)->rb_right
);
1416 newn
= &((*newn
)->rb_left
);
1418 spin_unlock(&rgd
->rd_rsspin
);
1424 rb_link_node(&rs
->rs_node
, parent
, newn
);
1425 rb_insert_color(&rs
->rs_node
, &rgd
->rd_rstree
);
1427 /* Do our rgrp accounting for the reservation */
1428 rgd
->rd_reserved
+= rs
->rs_free
; /* blocks reserved */
1429 spin_unlock(&rgd
->rd_rsspin
);
1430 trace_gfs2_rs(rs
, TRACE_RS_INSERT
);
1434 * rg_mblk_search - find a group of multiple free blocks to form a reservation
1435 * @rgd: the resource group descriptor
1436 * @ip: pointer to the inode for which we're reserving blocks
1437 * @ap: the allocation parameters
1441 static void rg_mblk_search(struct gfs2_rgrpd
*rgd
, struct gfs2_inode
*ip
,
1442 const struct gfs2_alloc_parms
*ap
)
1444 struct gfs2_rbm rbm
= { .rgd
= rgd
, };
1446 struct gfs2_blkreserv
*rs
= ip
->i_res
;
1448 u32 free_blocks
= rgd
->rd_free_clone
- rgd
->rd_reserved
;
1450 struct inode
*inode
= &ip
->i_inode
;
1452 if (S_ISDIR(inode
->i_mode
))
1455 extlen
= max_t(u32
, atomic_read(&rs
->rs_sizehint
), ap
->target
);
1456 extlen
= clamp(extlen
, RGRP_RSRV_MINBLKS
, free_blocks
);
1458 if ((rgd
->rd_free_clone
< rgd
->rd_reserved
) || (free_blocks
< extlen
))
1461 /* Find bitmap block that contains bits for goal block */
1462 if (rgrp_contains_block(rgd
, ip
->i_goal
))
1465 goal
= rgd
->rd_last_alloc
+ rgd
->rd_data0
;
1467 if (WARN_ON(gfs2_rbm_from_block(&rbm
, goal
)))
1470 ret
= gfs2_rbm_find(&rbm
, GFS2_BLKST_FREE
, &extlen
, ip
, true, ap
);
1473 rs
->rs_free
= extlen
;
1474 rs
->rs_inum
= ip
->i_no_addr
;
1477 if (goal
== rgd
->rd_last_alloc
+ rgd
->rd_data0
)
1478 rgd
->rd_last_alloc
= 0;
1483 * gfs2_next_unreserved_block - Return next block that is not reserved
1484 * @rgd: The resource group
1485 * @block: The starting block
1486 * @length: The required length
1487 * @ip: Ignore any reservations for this inode
1489 * If the block does not appear in any reservation, then return the
1490 * block number unchanged. If it does appear in the reservation, then
1491 * keep looking through the tree of reservations in order to find the
1492 * first block number which is not reserved.
1495 static u64
gfs2_next_unreserved_block(struct gfs2_rgrpd
*rgd
, u64 block
,
1497 const struct gfs2_inode
*ip
)
1499 struct gfs2_blkreserv
*rs
;
1503 spin_lock(&rgd
->rd_rsspin
);
1504 n
= rgd
->rd_rstree
.rb_node
;
1506 rs
= rb_entry(n
, struct gfs2_blkreserv
, rs_node
);
1507 rc
= rs_cmp(block
, length
, rs
);
1517 while ((rs_cmp(block
, length
, rs
) == 0) && (ip
->i_res
!= rs
)) {
1518 block
= gfs2_rbm_to_block(&rs
->rs_rbm
) + rs
->rs_free
;
1522 rs
= rb_entry(n
, struct gfs2_blkreserv
, rs_node
);
1526 spin_unlock(&rgd
->rd_rsspin
);
1531 * gfs2_reservation_check_and_update - Check for reservations during block alloc
1532 * @rbm: The current position in the resource group
1533 * @ip: The inode for which we are searching for blocks
1534 * @minext: The minimum extent length
1535 * @maxext: A pointer to the maximum extent structure
1537 * This checks the current position in the rgrp to see whether there is
1538 * a reservation covering this block. If not then this function is a
1539 * no-op. If there is, then the position is moved to the end of the
1540 * contiguous reservation(s) so that we are pointing at the first
1541 * non-reserved block.
1543 * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1546 static int gfs2_reservation_check_and_update(struct gfs2_rbm
*rbm
,
1547 const struct gfs2_inode
*ip
,
1549 struct gfs2_extent
*maxext
)
1551 u64 block
= gfs2_rbm_to_block(rbm
);
1557 * If we have a minimum extent length, then skip over any extent
1558 * which is less than the min extent length in size.
1561 extlen
= gfs2_free_extlen(rbm
, minext
);
1562 if (extlen
<= maxext
->len
)
1567 * Check the extent which has been found against the reservations
1568 * and skip if parts of it are already reserved
1570 nblock
= gfs2_next_unreserved_block(rbm
->rgd
, block
, extlen
, ip
);
1571 if (nblock
== block
) {
1572 if (!minext
|| extlen
>= minext
)
1575 if (extlen
> maxext
->len
) {
1576 maxext
->len
= extlen
;
1580 nblock
= block
+ extlen
;
1582 ret
= gfs2_rbm_from_block(rbm
, nblock
);
1589 * gfs2_rbm_find - Look for blocks of a particular state
1590 * @rbm: Value/result starting position and final position
1591 * @state: The state which we want to find
1592 * @minext: Pointer to the requested extent length (NULL for a single block)
1593 * This is updated to be the actual reservation size.
1594 * @ip: If set, check for reservations
1595 * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1596 * around until we've reached the starting point.
1597 * @ap: the allocation parameters
1600 * - If looking for free blocks, we set GBF_FULL on each bitmap which
1601 * has no free blocks in it.
1602 * - If looking for free blocks, we set rd_extfail_pt on each rgrp which
1603 * has come up short on a free block search.
1605 * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1608 static int gfs2_rbm_find(struct gfs2_rbm
*rbm
, u8 state
, u32
*minext
,
1609 const struct gfs2_inode
*ip
, bool nowrap
,
1610 const struct gfs2_alloc_parms
*ap
)
1612 struct buffer_head
*bh
;
1615 int first_bii
= rbm
->bii
;
1616 u32 first_offset
= rbm
->offset
;
1620 int iters
= rbm
->rgd
->rd_length
;
1622 struct gfs2_bitmap
*bi
;
1623 struct gfs2_extent maxext
= { .rbm
.rgd
= rbm
->rgd
, };
1625 /* If we are not starting at the beginning of a bitmap, then we
1626 * need to add one to the bitmap count to ensure that we search
1627 * the starting bitmap twice.
1629 if (rbm
->offset
!= 0)
1634 if (test_bit(GBF_FULL
, &bi
->bi_flags
) &&
1635 (state
== GFS2_BLKST_FREE
))
1639 buffer
= bh
->b_data
+ bi
->bi_offset
;
1640 WARN_ON(!buffer_uptodate(bh
));
1641 if (state
!= GFS2_BLKST_UNLINKED
&& bi
->bi_clone
)
1642 buffer
= bi
->bi_clone
+ bi
->bi_offset
;
1643 initial_offset
= rbm
->offset
;
1644 offset
= gfs2_bitfit(buffer
, bi
->bi_len
, rbm
->offset
, state
);
1645 if (offset
== BFITNOENT
)
1647 rbm
->offset
= offset
;
1651 initial_bii
= rbm
->bii
;
1652 ret
= gfs2_reservation_check_and_update(rbm
, ip
,
1653 minext
? *minext
: 0,
1658 n
+= (rbm
->bii
- initial_bii
);
1661 if (ret
== -E2BIG
) {
1664 n
+= (rbm
->bii
- initial_bii
);
1665 goto res_covered_end_of_rgrp
;
1669 bitmap_full
: /* Mark bitmap as full and fall through */
1670 if ((state
== GFS2_BLKST_FREE
) && initial_offset
== 0) {
1671 struct gfs2_bitmap
*bi
= rbm_bi(rbm
);
1672 set_bit(GBF_FULL
, &bi
->bi_flags
);
1675 next_bitmap
: /* Find next bitmap in the rgrp */
1678 if (rbm
->bii
== rbm
->rgd
->rd_length
)
1680 res_covered_end_of_rgrp
:
1681 if ((rbm
->bii
== 0) && nowrap
)
1689 if (minext
== NULL
|| state
!= GFS2_BLKST_FREE
)
1692 /* If the extent was too small, and it's smaller than the smallest
1693 to have failed before, remember for future reference that it's
1694 useless to search this rgrp again for this amount or more. */
1695 if ((first_offset
== 0) && (first_bii
== 0) &&
1696 (*minext
< rbm
->rgd
->rd_extfail_pt
))
1697 rbm
->rgd
->rd_extfail_pt
= *minext
;
1699 /* If the maximum extent we found is big enough to fulfill the
1700 minimum requirements, use it anyway. */
1703 *minext
= maxext
.len
;
1711 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1713 * @last_unlinked: block address of the last dinode we unlinked
1714 * @skip: block address we should explicitly not unlink
1716 * Returns: 0 if no error
1717 * The inode, if one has been found, in inode.
1720 static void try_rgrp_unlink(struct gfs2_rgrpd
*rgd
, u64
*last_unlinked
, u64 skip
)
1723 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
1724 struct gfs2_glock
*gl
;
1725 struct gfs2_inode
*ip
;
1728 struct gfs2_rbm rbm
= { .rgd
= rgd
, .bii
= 0, .offset
= 0 };
1731 down_write(&sdp
->sd_log_flush_lock
);
1732 error
= gfs2_rbm_find(&rbm
, GFS2_BLKST_UNLINKED
, NULL
, NULL
,
1734 up_write(&sdp
->sd_log_flush_lock
);
1735 if (error
== -ENOSPC
)
1737 if (WARN_ON_ONCE(error
))
1740 block
= gfs2_rbm_to_block(&rbm
);
1741 if (gfs2_rbm_from_block(&rbm
, block
+ 1))
1743 if (*last_unlinked
!= NO_BLOCK
&& block
<= *last_unlinked
)
1747 *last_unlinked
= block
;
1749 error
= gfs2_glock_get(sdp
, block
, &gfs2_inode_glops
, CREATE
, &gl
);
1753 /* If the inode is already in cache, we can ignore it here
1754 * because the existing inode disposal code will deal with
1755 * it when all refs have gone away. Accessing gl_object like
1756 * this is not safe in general. Here it is ok because we do
1757 * not dereference the pointer, and we only need an approx
1758 * answer to whether it is NULL or not.
1762 if (ip
|| queue_work(gfs2_delete_workqueue
, &gl
->gl_delete
) == 0)
1767 /* Limit reclaim to sensible number of tasks */
1768 if (found
> NR_CPUS
)
1772 rgd
->rd_flags
&= ~GFS2_RDF_CHECK
;
1777 * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1778 * @rgd: The rgrp in question
1779 * @loops: An indication of how picky we can be (0=very, 1=less so)
1781 * This function uses the recently added glock statistics in order to
1782 * figure out whether a parciular resource group is suffering from
1783 * contention from multiple nodes. This is done purely on the basis
1784 * of timings, since this is the only data we have to work with and
1785 * our aim here is to reject a resource group which is highly contended
1786 * but (very important) not to do this too often in order to ensure that
1787 * we do not land up introducing fragmentation by changing resource
1788 * groups when not actually required.
1790 * The calculation is fairly simple, we want to know whether the SRTTB
1791 * (i.e. smoothed round trip time for blocking operations) to acquire
1792 * the lock for this rgrp's glock is significantly greater than the
1793 * time taken for resource groups on average. We introduce a margin in
1794 * the form of the variable @var which is computed as the sum of the two
1795 * respective variences, and multiplied by a factor depending on @loops
1796 * and whether we have a lot of data to base the decision on. This is
1797 * then tested against the square difference of the means in order to
1798 * decide whether the result is statistically significant or not.
1800 * Returns: A boolean verdict on the congestion status
1803 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd
*rgd
, int loops
)
1805 const struct gfs2_glock
*gl
= rgd
->rd_gl
;
1806 const struct gfs2_sbd
*sdp
= gl
->gl_sbd
;
1807 struct gfs2_lkstats
*st
;
1808 s64 r_dcount
, l_dcount
;
1809 s64 r_srttb
, l_srttb
;
1815 st
= &this_cpu_ptr(sdp
->sd_lkstats
)->lkstats
[LM_TYPE_RGRP
];
1816 r_srttb
= st
->stats
[GFS2_LKS_SRTTB
];
1817 r_dcount
= st
->stats
[GFS2_LKS_DCOUNT
];
1818 var
= st
->stats
[GFS2_LKS_SRTTVARB
] +
1819 gl
->gl_stats
.stats
[GFS2_LKS_SRTTVARB
];
1822 l_srttb
= gl
->gl_stats
.stats
[GFS2_LKS_SRTTB
];
1823 l_dcount
= gl
->gl_stats
.stats
[GFS2_LKS_DCOUNT
];
1825 if ((l_dcount
< 1) || (r_dcount
< 1) || (r_srttb
== 0))
1828 srttb_diff
= r_srttb
- l_srttb
;
1829 sqr_diff
= srttb_diff
* srttb_diff
;
1832 if (l_dcount
< 8 || r_dcount
< 8)
1837 return ((srttb_diff
< 0) && (sqr_diff
> var
));
1841 * gfs2_rgrp_used_recently
1842 * @rs: The block reservation with the rgrp to test
1843 * @msecs: The time limit in milliseconds
1845 * Returns: True if the rgrp glock has been used within the time limit
1847 static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv
*rs
,
1852 tdiff
= ktime_to_ns(ktime_sub(ktime_get_real(),
1853 rs
->rs_rbm
.rgd
->rd_gl
->gl_dstamp
));
1855 return tdiff
> (msecs
* 1000 * 1000);
1858 static u32
gfs2_orlov_skip(const struct gfs2_inode
*ip
)
1860 const struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1863 get_random_bytes(&skip
, sizeof(skip
));
1864 return skip
% sdp
->sd_rgrps
;
1867 static bool gfs2_select_rgrp(struct gfs2_rgrpd
**pos
, const struct gfs2_rgrpd
*begin
)
1869 struct gfs2_rgrpd
*rgd
= *pos
;
1870 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
1872 rgd
= gfs2_rgrpd_get_next(rgd
);
1874 rgd
= gfs2_rgrpd_get_first(sdp
);
1876 if (rgd
!= begin
) /* If we didn't wrap */
1882 * gfs2_inplace_reserve - Reserve space in the filesystem
1883 * @ip: the inode to reserve space for
1884 * @ap: the allocation parameters
1889 int gfs2_inplace_reserve(struct gfs2_inode
*ip
, const struct gfs2_alloc_parms
*ap
)
1891 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1892 struct gfs2_rgrpd
*begin
= NULL
;
1893 struct gfs2_blkreserv
*rs
= ip
->i_res
;
1894 int error
= 0, rg_locked
, flags
= 0;
1895 u64 last_unlinked
= NO_BLOCK
;
1899 if (sdp
->sd_args
.ar_rgrplvb
)
1901 if (gfs2_assert_warn(sdp
, ap
->target
))
1903 if (gfs2_rs_active(rs
)) {
1904 begin
= rs
->rs_rbm
.rgd
;
1905 } else if (ip
->i_rgd
&& rgrp_contains_block(ip
->i_rgd
, ip
->i_goal
)) {
1906 rs
->rs_rbm
.rgd
= begin
= ip
->i_rgd
;
1908 rs
->rs_rbm
.rgd
= begin
= gfs2_blk2rgrpd(sdp
, ip
->i_goal
, 1);
1910 if (S_ISDIR(ip
->i_inode
.i_mode
) && (ap
->aflags
& GFS2_AF_ORLOV
))
1911 skip
= gfs2_orlov_skip(ip
);
1912 if (rs
->rs_rbm
.rgd
== NULL
)
1918 if (!gfs2_glock_is_locked_by_me(rs
->rs_rbm
.rgd
->rd_gl
)) {
1922 if (!gfs2_rs_active(rs
) && (loops
< 2) &&
1923 gfs2_rgrp_used_recently(rs
, 1000) &&
1924 gfs2_rgrp_congested(rs
->rs_rbm
.rgd
, loops
))
1926 error
= gfs2_glock_nq_init(rs
->rs_rbm
.rgd
->rd_gl
,
1927 LM_ST_EXCLUSIVE
, flags
,
1929 if (unlikely(error
))
1931 if (!gfs2_rs_active(rs
) && (loops
< 2) &&
1932 gfs2_rgrp_congested(rs
->rs_rbm
.rgd
, loops
))
1934 if (sdp
->sd_args
.ar_rgrplvb
) {
1935 error
= update_rgrp_lvb(rs
->rs_rbm
.rgd
);
1936 if (unlikely(error
)) {
1937 gfs2_glock_dq_uninit(&rs
->rs_rgd_gh
);
1943 /* Skip unuseable resource groups */
1944 if ((rs
->rs_rbm
.rgd
->rd_flags
& (GFS2_RGF_NOALLOC
|
1946 (ap
&& (ap
->target
> rs
->rs_rbm
.rgd
->rd_extfail_pt
)))
1949 if (sdp
->sd_args
.ar_rgrplvb
)
1950 gfs2_rgrp_bh_get(rs
->rs_rbm
.rgd
);
1952 /* Get a reservation if we don't already have one */
1953 if (!gfs2_rs_active(rs
))
1954 rg_mblk_search(rs
->rs_rbm
.rgd
, ip
, ap
);
1956 /* Skip rgrps when we can't get a reservation on first pass */
1957 if (!gfs2_rs_active(rs
) && (loops
< 1))
1960 /* If rgrp has enough free space, use it */
1961 if (rs
->rs_rbm
.rgd
->rd_free_clone
>= ap
->target
) {
1962 ip
->i_rgd
= rs
->rs_rbm
.rgd
;
1967 /* Check for unlinked inodes which can be reclaimed */
1968 if (rs
->rs_rbm
.rgd
->rd_flags
& GFS2_RDF_CHECK
)
1969 try_rgrp_unlink(rs
->rs_rbm
.rgd
, &last_unlinked
,
1972 /* Drop reservation, if we couldn't use reserved rgrp */
1973 if (gfs2_rs_active(rs
))
1974 gfs2_rs_deltree(rs
);
1976 /* Unlock rgrp if required */
1978 gfs2_glock_dq_uninit(&rs
->rs_rgd_gh
);
1980 /* Find the next rgrp, and continue looking */
1981 if (gfs2_select_rgrp(&rs
->rs_rbm
.rgd
, begin
))
1986 /* If we've scanned all the rgrps, but found no free blocks
1987 * then this checks for some less likely conditions before
1991 /* Check that fs hasn't grown if writing to rindex */
1992 if (ip
== GFS2_I(sdp
->sd_rindex
) && !sdp
->sd_rindex_uptodate
) {
1993 error
= gfs2_ri_update(ip
);
1997 /* Flushing the log may release space */
1999 gfs2_log_flush(sdp
, NULL
);
2006 * gfs2_inplace_release - release an inplace reservation
2007 * @ip: the inode the reservation was taken out on
2009 * Release a reservation made by gfs2_inplace_reserve().
2012 void gfs2_inplace_release(struct gfs2_inode
*ip
)
2014 struct gfs2_blkreserv
*rs
= ip
->i_res
;
2016 if (rs
->rs_rgd_gh
.gh_gl
)
2017 gfs2_glock_dq_uninit(&rs
->rs_rgd_gh
);
2021 * gfs2_get_block_type - Check a block in a RG is of given type
2022 * @rgd: the resource group holding the block
2023 * @block: the block number
2025 * Returns: The block type (GFS2_BLKST_*)
2028 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd
*rgd
, u64 block
)
2030 struct gfs2_rbm rbm
= { .rgd
= rgd
, };
2033 ret
= gfs2_rbm_from_block(&rbm
, block
);
2034 WARN_ON_ONCE(ret
!= 0);
2036 return gfs2_testbit(&rbm
);
2041 * gfs2_alloc_extent - allocate an extent from a given bitmap
2042 * @rbm: the resource group information
2043 * @dinode: TRUE if the first block we allocate is for a dinode
2044 * @n: The extent length (value/result)
2046 * Add the bitmap buffer to the transaction.
2047 * Set the found bits to @new_state to change block's allocation state.
2049 static void gfs2_alloc_extent(const struct gfs2_rbm
*rbm
, bool dinode
,
2052 struct gfs2_rbm pos
= { .rgd
= rbm
->rgd
, };
2053 const unsigned int elen
= *n
;
2058 block
= gfs2_rbm_to_block(rbm
);
2059 gfs2_trans_add_meta(rbm
->rgd
->rd_gl
, rbm_bi(rbm
)->bi_bh
);
2060 gfs2_setbit(rbm
, true, dinode
? GFS2_BLKST_DINODE
: GFS2_BLKST_USED
);
2063 ret
= gfs2_rbm_from_block(&pos
, block
);
2064 if (ret
|| gfs2_testbit(&pos
) != GFS2_BLKST_FREE
)
2066 gfs2_trans_add_meta(pos
.rgd
->rd_gl
, rbm_bi(&pos
)->bi_bh
);
2067 gfs2_setbit(&pos
, true, GFS2_BLKST_USED
);
2074 * rgblk_free - Change alloc state of given block(s)
2075 * @sdp: the filesystem
2076 * @bstart: the start of a run of blocks to free
2077 * @blen: the length of the block run (all must lie within ONE RG!)
2078 * @new_state: GFS2_BLKST_XXX the after-allocation block state
2080 * Returns: Resource group containing the block(s)
2083 static struct gfs2_rgrpd
*rgblk_free(struct gfs2_sbd
*sdp
, u64 bstart
,
2084 u32 blen
, unsigned char new_state
)
2086 struct gfs2_rbm rbm
;
2087 struct gfs2_bitmap
*bi
;
2089 rbm
.rgd
= gfs2_blk2rgrpd(sdp
, bstart
, 1);
2091 if (gfs2_consist(sdp
))
2092 fs_err(sdp
, "block = %llu\n", (unsigned long long)bstart
);
2097 gfs2_rbm_from_block(&rbm
, bstart
);
2100 if (!bi
->bi_clone
) {
2101 bi
->bi_clone
= kmalloc(bi
->bi_bh
->b_size
,
2102 GFP_NOFS
| __GFP_NOFAIL
);
2103 memcpy(bi
->bi_clone
+ bi
->bi_offset
,
2104 bi
->bi_bh
->b_data
+ bi
->bi_offset
, bi
->bi_len
);
2106 gfs2_trans_add_meta(rbm
.rgd
->rd_gl
, bi
->bi_bh
);
2107 gfs2_setbit(&rbm
, false, new_state
);
2114 * gfs2_rgrp_dump - print out an rgrp
2115 * @seq: The iterator
2116 * @gl: The glock in question
2120 int gfs2_rgrp_dump(struct seq_file
*seq
, const struct gfs2_glock
*gl
)
2122 struct gfs2_rgrpd
*rgd
= gl
->gl_object
;
2123 struct gfs2_blkreserv
*trs
;
2124 const struct rb_node
*n
;
2128 gfs2_print_dbg(seq
, " R: n:%llu f:%02x b:%u/%u i:%u r:%u e:%u\n",
2129 (unsigned long long)rgd
->rd_addr
, rgd
->rd_flags
,
2130 rgd
->rd_free
, rgd
->rd_free_clone
, rgd
->rd_dinodes
,
2131 rgd
->rd_reserved
, rgd
->rd_extfail_pt
);
2132 spin_lock(&rgd
->rd_rsspin
);
2133 for (n
= rb_first(&rgd
->rd_rstree
); n
; n
= rb_next(&trs
->rs_node
)) {
2134 trs
= rb_entry(n
, struct gfs2_blkreserv
, rs_node
);
2137 spin_unlock(&rgd
->rd_rsspin
);
2141 static void gfs2_rgrp_error(struct gfs2_rgrpd
*rgd
)
2143 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
2144 fs_warn(sdp
, "rgrp %llu has an error, marking it readonly until umount\n",
2145 (unsigned long long)rgd
->rd_addr
);
2146 fs_warn(sdp
, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2147 gfs2_rgrp_dump(NULL
, rgd
->rd_gl
);
2148 rgd
->rd_flags
|= GFS2_RDF_ERROR
;
2152 * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2153 * @ip: The inode we have just allocated blocks for
2154 * @rbm: The start of the allocated blocks
2155 * @len: The extent length
2157 * Adjusts a reservation after an allocation has taken place. If the
2158 * reservation does not match the allocation, or if it is now empty
2159 * then it is removed.
2162 static void gfs2_adjust_reservation(struct gfs2_inode
*ip
,
2163 const struct gfs2_rbm
*rbm
, unsigned len
)
2165 struct gfs2_blkreserv
*rs
= ip
->i_res
;
2166 struct gfs2_rgrpd
*rgd
= rbm
->rgd
;
2171 spin_lock(&rgd
->rd_rsspin
);
2172 if (gfs2_rs_active(rs
)) {
2173 if (gfs2_rbm_eq(&rs
->rs_rbm
, rbm
)) {
2174 block
= gfs2_rbm_to_block(rbm
);
2175 ret
= gfs2_rbm_from_block(&rs
->rs_rbm
, block
+ len
);
2176 rlen
= min(rs
->rs_free
, len
);
2177 rs
->rs_free
-= rlen
;
2178 rgd
->rd_reserved
-= rlen
;
2179 trace_gfs2_rs(rs
, TRACE_RS_CLAIM
);
2180 if (rs
->rs_free
&& !ret
)
2186 spin_unlock(&rgd
->rd_rsspin
);
2190 * gfs2_set_alloc_start - Set starting point for block allocation
2191 * @rbm: The rbm which will be set to the required location
2192 * @ip: The gfs2 inode
2193 * @dinode: Flag to say if allocation includes a new inode
2195 * This sets the starting point from the reservation if one is active
2196 * otherwise it falls back to guessing a start point based on the
2197 * inode's goal block or the last allocation point in the rgrp.
2200 static void gfs2_set_alloc_start(struct gfs2_rbm
*rbm
,
2201 const struct gfs2_inode
*ip
, bool dinode
)
2205 if (gfs2_rs_active(ip
->i_res
)) {
2206 *rbm
= ip
->i_res
->rs_rbm
;
2210 if (!dinode
&& rgrp_contains_block(rbm
->rgd
, ip
->i_goal
))
2213 goal
= rbm
->rgd
->rd_last_alloc
+ rbm
->rgd
->rd_data0
;
2215 gfs2_rbm_from_block(rbm
, goal
);
2219 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
2220 * @ip: the inode to allocate the block for
2221 * @bn: Used to return the starting block number
2222 * @nblocks: requested number of blocks/extent length (value/result)
2223 * @dinode: 1 if we're allocating a dinode block, else 0
2224 * @generation: the generation number of the inode
2226 * Returns: 0 or error
2229 int gfs2_alloc_blocks(struct gfs2_inode
*ip
, u64
*bn
, unsigned int *nblocks
,
2230 bool dinode
, u64
*generation
)
2232 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
2233 struct buffer_head
*dibh
;
2234 struct gfs2_rbm rbm
= { .rgd
= ip
->i_rgd
, };
2236 u64 block
; /* block, within the file system scope */
2239 gfs2_set_alloc_start(&rbm
, ip
, dinode
);
2240 error
= gfs2_rbm_find(&rbm
, GFS2_BLKST_FREE
, NULL
, ip
, false, NULL
);
2242 if (error
== -ENOSPC
) {
2243 gfs2_set_alloc_start(&rbm
, ip
, dinode
);
2244 error
= gfs2_rbm_find(&rbm
, GFS2_BLKST_FREE
, NULL
, NULL
, false,
2248 /* Since all blocks are reserved in advance, this shouldn't happen */
2250 fs_warn(sdp
, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
2251 (unsigned long long)ip
->i_no_addr
, error
, *nblocks
,
2252 test_bit(GBF_FULL
, &rbm
.rgd
->rd_bits
->bi_flags
),
2253 rbm
.rgd
->rd_extfail_pt
);
2257 gfs2_alloc_extent(&rbm
, dinode
, nblocks
);
2258 block
= gfs2_rbm_to_block(&rbm
);
2259 rbm
.rgd
->rd_last_alloc
= block
- rbm
.rgd
->rd_data0
;
2260 if (gfs2_rs_active(ip
->i_res
))
2261 gfs2_adjust_reservation(ip
, &rbm
, *nblocks
);
2267 ip
->i_goal
= block
+ ndata
- 1;
2268 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
2270 struct gfs2_dinode
*di
=
2271 (struct gfs2_dinode
*)dibh
->b_data
;
2272 gfs2_trans_add_meta(ip
->i_gl
, dibh
);
2273 di
->di_goal_meta
= di
->di_goal_data
=
2274 cpu_to_be64(ip
->i_goal
);
2278 if (rbm
.rgd
->rd_free
< *nblocks
) {
2279 printk(KERN_WARNING
"nblocks=%u\n", *nblocks
);
2283 rbm
.rgd
->rd_free
-= *nblocks
;
2285 rbm
.rgd
->rd_dinodes
++;
2286 *generation
= rbm
.rgd
->rd_igeneration
++;
2287 if (*generation
== 0)
2288 *generation
= rbm
.rgd
->rd_igeneration
++;
2291 gfs2_trans_add_meta(rbm
.rgd
->rd_gl
, rbm
.rgd
->rd_bits
[0].bi_bh
);
2292 gfs2_rgrp_out(rbm
.rgd
, rbm
.rgd
->rd_bits
[0].bi_bh
->b_data
);
2293 gfs2_rgrp_ondisk2lvb(rbm
.rgd
->rd_rgl
, rbm
.rgd
->rd_bits
[0].bi_bh
->b_data
);
2295 gfs2_statfs_change(sdp
, 0, -(s64
)*nblocks
, dinode
? 1 : 0);
2297 gfs2_trans_add_unrevoke(sdp
, block
, 1);
2299 gfs2_quota_change(ip
, *nblocks
, ip
->i_inode
.i_uid
, ip
->i_inode
.i_gid
);
2301 rbm
.rgd
->rd_free_clone
-= *nblocks
;
2302 trace_gfs2_block_alloc(ip
, rbm
.rgd
, block
, *nblocks
,
2303 dinode
? GFS2_BLKST_DINODE
: GFS2_BLKST_USED
);
2308 gfs2_rgrp_error(rbm
.rgd
);
2313 * __gfs2_free_blocks - free a contiguous run of block(s)
2314 * @ip: the inode these blocks are being freed from
2315 * @bstart: first block of a run of contiguous blocks
2316 * @blen: the length of the block run
2317 * @meta: 1 if the blocks represent metadata
2321 void __gfs2_free_blocks(struct gfs2_inode
*ip
, u64 bstart
, u32 blen
, int meta
)
2323 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
2324 struct gfs2_rgrpd
*rgd
;
2326 rgd
= rgblk_free(sdp
, bstart
, blen
, GFS2_BLKST_FREE
);
2329 trace_gfs2_block_alloc(ip
, rgd
, bstart
, blen
, GFS2_BLKST_FREE
);
2330 rgd
->rd_free
+= blen
;
2331 rgd
->rd_flags
&= ~GFS2_RGF_TRIMMED
;
2332 gfs2_trans_add_meta(rgd
->rd_gl
, rgd
->rd_bits
[0].bi_bh
);
2333 gfs2_rgrp_out(rgd
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2334 gfs2_rgrp_ondisk2lvb(rgd
->rd_rgl
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2336 /* Directories keep their data in the metadata address space */
2337 if (meta
|| ip
->i_depth
)
2338 gfs2_meta_wipe(ip
, bstart
, blen
);
2342 * gfs2_free_meta - free a contiguous run of data block(s)
2343 * @ip: the inode these blocks are being freed from
2344 * @bstart: first block of a run of contiguous blocks
2345 * @blen: the length of the block run
2349 void gfs2_free_meta(struct gfs2_inode
*ip
, u64 bstart
, u32 blen
)
2351 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
2353 __gfs2_free_blocks(ip
, bstart
, blen
, 1);
2354 gfs2_statfs_change(sdp
, 0, +blen
, 0);
2355 gfs2_quota_change(ip
, -(s64
)blen
, ip
->i_inode
.i_uid
, ip
->i_inode
.i_gid
);
2358 void gfs2_unlink_di(struct inode
*inode
)
2360 struct gfs2_inode
*ip
= GFS2_I(inode
);
2361 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
2362 struct gfs2_rgrpd
*rgd
;
2363 u64 blkno
= ip
->i_no_addr
;
2365 rgd
= rgblk_free(sdp
, blkno
, 1, GFS2_BLKST_UNLINKED
);
2368 trace_gfs2_block_alloc(ip
, rgd
, blkno
, 1, GFS2_BLKST_UNLINKED
);
2369 gfs2_trans_add_meta(rgd
->rd_gl
, rgd
->rd_bits
[0].bi_bh
);
2370 gfs2_rgrp_out(rgd
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2371 gfs2_rgrp_ondisk2lvb(rgd
->rd_rgl
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2372 update_rgrp_lvb_unlinked(rgd
, 1);
2375 static void gfs2_free_uninit_di(struct gfs2_rgrpd
*rgd
, u64 blkno
)
2377 struct gfs2_sbd
*sdp
= rgd
->rd_sbd
;
2378 struct gfs2_rgrpd
*tmp_rgd
;
2380 tmp_rgd
= rgblk_free(sdp
, blkno
, 1, GFS2_BLKST_FREE
);
2383 gfs2_assert_withdraw(sdp
, rgd
== tmp_rgd
);
2385 if (!rgd
->rd_dinodes
)
2386 gfs2_consist_rgrpd(rgd
);
2390 gfs2_trans_add_meta(rgd
->rd_gl
, rgd
->rd_bits
[0].bi_bh
);
2391 gfs2_rgrp_out(rgd
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2392 gfs2_rgrp_ondisk2lvb(rgd
->rd_rgl
, rgd
->rd_bits
[0].bi_bh
->b_data
);
2393 update_rgrp_lvb_unlinked(rgd
, -1);
2395 gfs2_statfs_change(sdp
, 0, +1, -1);
2399 void gfs2_free_di(struct gfs2_rgrpd
*rgd
, struct gfs2_inode
*ip
)
2401 gfs2_free_uninit_di(rgd
, ip
->i_no_addr
);
2402 trace_gfs2_block_alloc(ip
, rgd
, ip
->i_no_addr
, 1, GFS2_BLKST_FREE
);
2403 gfs2_quota_change(ip
, -1, ip
->i_inode
.i_uid
, ip
->i_inode
.i_gid
);
2404 gfs2_meta_wipe(ip
, ip
->i_no_addr
, 1);
2408 * gfs2_check_blk_type - Check the type of a block
2409 * @sdp: The superblock
2410 * @no_addr: The block number to check
2411 * @type: The block type we are looking for
2413 * Returns: 0 if the block type matches the expected type
2414 * -ESTALE if it doesn't match
2415 * or -ve errno if something went wrong while checking
2418 int gfs2_check_blk_type(struct gfs2_sbd
*sdp
, u64 no_addr
, unsigned int type
)
2420 struct gfs2_rgrpd
*rgd
;
2421 struct gfs2_holder rgd_gh
;
2422 int error
= -EINVAL
;
2424 rgd
= gfs2_blk2rgrpd(sdp
, no_addr
, 1);
2428 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_SHARED
, 0, &rgd_gh
);
2432 if (gfs2_get_block_type(rgd
, no_addr
) != type
)
2435 gfs2_glock_dq_uninit(&rgd_gh
);
2441 * gfs2_rlist_add - add a RG to a list of RGs
2443 * @rlist: the list of resource groups
2446 * Figure out what RG a block belongs to and add that RG to the list
2448 * FIXME: Don't use NOFAIL
2452 void gfs2_rlist_add(struct gfs2_inode
*ip
, struct gfs2_rgrp_list
*rlist
,
2455 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
2456 struct gfs2_rgrpd
*rgd
;
2457 struct gfs2_rgrpd
**tmp
;
2458 unsigned int new_space
;
2461 if (gfs2_assert_warn(sdp
, !rlist
->rl_ghs
))
2464 if (ip
->i_rgd
&& rgrp_contains_block(ip
->i_rgd
, block
))
2467 rgd
= gfs2_blk2rgrpd(sdp
, block
, 1);
2469 fs_err(sdp
, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block
);
2474 for (x
= 0; x
< rlist
->rl_rgrps
; x
++)
2475 if (rlist
->rl_rgd
[x
] == rgd
)
2478 if (rlist
->rl_rgrps
== rlist
->rl_space
) {
2479 new_space
= rlist
->rl_space
+ 10;
2481 tmp
= kcalloc(new_space
, sizeof(struct gfs2_rgrpd
*),
2482 GFP_NOFS
| __GFP_NOFAIL
);
2484 if (rlist
->rl_rgd
) {
2485 memcpy(tmp
, rlist
->rl_rgd
,
2486 rlist
->rl_space
* sizeof(struct gfs2_rgrpd
*));
2487 kfree(rlist
->rl_rgd
);
2490 rlist
->rl_space
= new_space
;
2491 rlist
->rl_rgd
= tmp
;
2494 rlist
->rl_rgd
[rlist
->rl_rgrps
++] = rgd
;
2498 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2499 * and initialize an array of glock holders for them
2500 * @rlist: the list of resource groups
2501 * @state: the lock state to acquire the RG lock in
2503 * FIXME: Don't use NOFAIL
2507 void gfs2_rlist_alloc(struct gfs2_rgrp_list
*rlist
, unsigned int state
)
2511 rlist
->rl_ghs
= kcalloc(rlist
->rl_rgrps
, sizeof(struct gfs2_holder
),
2512 GFP_NOFS
| __GFP_NOFAIL
);
2513 for (x
= 0; x
< rlist
->rl_rgrps
; x
++)
2514 gfs2_holder_init(rlist
->rl_rgd
[x
]->rd_gl
,
2520 * gfs2_rlist_free - free a resource group list
2521 * @list: the list of resource groups
2525 void gfs2_rlist_free(struct gfs2_rgrp_list
*rlist
)
2529 kfree(rlist
->rl_rgd
);
2531 if (rlist
->rl_ghs
) {
2532 for (x
= 0; x
< rlist
->rl_rgrps
; x
++)
2533 gfs2_holder_uninit(&rlist
->rl_ghs
[x
]);
2534 kfree(rlist
->rl_ghs
);
2535 rlist
->rl_ghs
= NULL
;
This page took 0.082297 seconds and 4 git commands to generate.