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