1
2
3
4
5
6
7
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#include <linux/rbtree.h>
19#include <linux/random.h>
20
21#include "gfs2.h"
22#include "incore.h"
23#include "glock.h"
24#include "glops.h"
25#include "lops.h"
26#include "meta_io.h"
27#include "quota.h"
28#include "rgrp.h"
29#include "super.h"
30#include "trans.h"
31#include "util.h"
32#include "log.h"
33#include "inode.h"
34#include "trace_gfs2.h"
35
36#define BFITNOENT ((u32)~0)
37#define NO_BLOCK ((u64)~0)
38
39#if BITS_PER_LONG == 32
40#define LBITMASK (0x55555555UL)
41#define LBITSKIP55 (0x55555555UL)
42#define LBITSKIP00 (0x00000000UL)
43#else
44#define LBITMASK (0x5555555555555555UL)
45#define LBITSKIP55 (0x5555555555555555UL)
46#define LBITSKIP00 (0x0000000000000000UL)
47#endif
48
49
50
51
52
53
54
55
56
57
58
59
60static const char valid_change[16] = {
61
62 0, 1, 1, 1,
63 1, 0, 0, 0,
64 0, 0, 0, 1,
65 1, 0, 0, 0
66};
67
68static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
69 const struct gfs2_inode *ip, bool nowrap);
70
71
72
73
74
75
76
77
78
79
80static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
81 unsigned char new_state)
82{
83 unsigned char *byte1, *byte2, *end, cur_state;
84 unsigned int buflen = rbm->bi->bi_len;
85 const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
86
87 byte1 = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
88 end = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + buflen;
89
90 BUG_ON(byte1 >= end);
91
92 cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
93
94 if (unlikely(!valid_change[new_state * 4 + cur_state])) {
95 printk(KERN_WARNING "GFS2: buf_blk = 0x%x old_state=%d, "
96 "new_state=%d\n", rbm->offset, cur_state, new_state);
97 printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%x\n",
98 (unsigned long long)rbm->rgd->rd_addr,
99 rbm->bi->bi_start);
100 printk(KERN_WARNING "GFS2: bi_offset=0x%x bi_len=0x%x\n",
101 rbm->bi->bi_offset, rbm->bi->bi_len);
102 dump_stack();
103 gfs2_consist_rgrpd(rbm->rgd);
104 return;
105 }
106 *byte1 ^= (cur_state ^ new_state) << bit;
107
108 if (do_clone && rbm->bi->bi_clone) {
109 byte2 = rbm->bi->bi_clone + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
110 cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
111 *byte2 ^= (cur_state ^ new_state) << bit;
112 }
113}
114
115
116
117
118
119
120
121
122static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm)
123{
124 const u8 *buffer = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset;
125 const u8 *byte;
126 unsigned int bit;
127
128 byte = buffer + (rbm->offset / GFS2_NBBY);
129 bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
130
131 return (*byte >> bit) & GFS2_BIT_MASK;
132}
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
153{
154 u64 tmp;
155 static const u64 search[] = {
156 [0] = 0xffffffffffffffffULL,
157 [1] = 0xaaaaaaaaaaaaaaaaULL,
158 [2] = 0x5555555555555555ULL,
159 [3] = 0x0000000000000000ULL,
160 };
161 tmp = le64_to_cpu(*ptr) ^ search[state];
162 tmp &= (tmp >> 1);
163 tmp &= mask;
164 return tmp;
165}
166
167
168
169
170
171
172
173
174
175
176
177static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
178{
179 u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
180
181 if (blk >= startblk + rs->rs_free)
182 return 1;
183 if (blk + len - 1 < startblk)
184 return -1;
185 return 0;
186}
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
210 u32 goal, u8 state)
211{
212 u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
213 const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
214 const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
215 u64 tmp;
216 u64 mask = 0x5555555555555555ULL;
217 u32 bit;
218
219
220 mask <<= spoint;
221 tmp = gfs2_bit_search(ptr, mask, state);
222 ptr++;
223 while(tmp == 0 && ptr < end) {
224 tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
225 ptr++;
226 }
227
228 if (ptr == end && (len & (sizeof(u64) - 1)))
229 tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
230
231 if (tmp == 0)
232 return BFITNOENT;
233 ptr--;
234 bit = __ffs64(tmp);
235 bit /= 2;
236 return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
237}
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
253{
254 u64 rblock = block - rbm->rgd->rd_data0;
255 u32 x;
256
257 if (WARN_ON_ONCE(rblock > UINT_MAX))
258 return -EINVAL;
259 if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data)
260 return -E2BIG;
261
262 rbm->bi = rbm->rgd->rd_bits;
263 rbm->offset = (u32)(rblock);
264
265 if (rbm->offset < (rbm->bi->bi_start + rbm->bi->bi_len) * GFS2_NBBY)
266 return 0;
267
268
269 rbm->offset += (sizeof(struct gfs2_rgrp) -
270 sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
271 x = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
272 rbm->offset -= x * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
273 rbm->bi += x;
274 return 0;
275}
276
277
278
279
280
281
282
283
284
285
286static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
287{
288 u64 block;
289 u32 n;
290 u8 res;
291
292 for (n = 0; n < n_unaligned; n++) {
293 res = gfs2_testbit(rbm);
294 if (res != GFS2_BLKST_FREE)
295 return true;
296 (*len)--;
297 if (*len == 0)
298 return true;
299 block = gfs2_rbm_to_block(rbm);
300 if (gfs2_rbm_from_block(rbm, block + 1))
301 return true;
302 }
303
304 return false;
305}
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
323{
324 struct gfs2_rbm rbm = *rrbm;
325 u32 n_unaligned = rbm.offset & 3;
326 u32 size = len;
327 u32 bytes;
328 u32 chunk_size;
329 u8 *ptr, *start, *end;
330 u64 block;
331
332 if (n_unaligned &&
333 gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
334 goto out;
335
336 n_unaligned = len & 3;
337
338 while (len > 3) {
339 start = rbm.bi->bi_bh->b_data;
340 if (rbm.bi->bi_clone)
341 start = rbm.bi->bi_clone;
342 end = start + rbm.bi->bi_bh->b_size;
343 start += rbm.bi->bi_offset;
344 BUG_ON(rbm.offset & 3);
345 start += (rbm.offset / GFS2_NBBY);
346 bytes = min_t(u32, len / GFS2_NBBY, (end - start));
347 ptr = memchr_inv(start, 0, bytes);
348 chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
349 chunk_size *= GFS2_NBBY;
350 BUG_ON(len < chunk_size);
351 len -= chunk_size;
352 block = gfs2_rbm_to_block(&rbm);
353 if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
354 n_unaligned = 0;
355 break;
356 }
357 if (ptr) {
358 n_unaligned = 3;
359 break;
360 }
361 n_unaligned = len & 3;
362 }
363
364
365 if (n_unaligned)
366 gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
367out:
368 return size - len;
369}
370
371
372
373
374
375
376
377
378
379
380
381static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
382 unsigned int buflen, u8 state)
383{
384 const u8 *byte = buffer;
385 const u8 *end = buffer + buflen;
386 const u8 state1 = state << 2;
387 const u8 state2 = state << 4;
388 const u8 state3 = state << 6;
389 u32 count = 0;
390
391 for (; byte < end; byte++) {
392 if (((*byte) & 0x03) == state)
393 count++;
394 if (((*byte) & 0x0C) == state1)
395 count++;
396 if (((*byte) & 0x30) == state2)
397 count++;
398 if (((*byte) & 0xC0) == state3)
399 count++;
400 }
401
402 return count;
403}
404
405
406
407
408
409
410
411void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
412{
413 struct gfs2_sbd *sdp = rgd->rd_sbd;
414 struct gfs2_bitmap *bi = NULL;
415 u32 length = rgd->rd_length;
416 u32 count[4], tmp;
417 int buf, x;
418
419 memset(count, 0, 4 * sizeof(u32));
420
421
422 for (buf = 0; buf < length; buf++) {
423 bi = rgd->rd_bits + buf;
424 for (x = 0; x < 4; x++)
425 count[x] += gfs2_bitcount(rgd,
426 bi->bi_bh->b_data +
427 bi->bi_offset,
428 bi->bi_len, x);
429 }
430
431 if (count[0] != rgd->rd_free) {
432 if (gfs2_consist_rgrpd(rgd))
433 fs_err(sdp, "free data mismatch: %u != %u\n",
434 count[0], rgd->rd_free);
435 return;
436 }
437
438 tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
439 if (count[1] != tmp) {
440 if (gfs2_consist_rgrpd(rgd))
441 fs_err(sdp, "used data mismatch: %u != %u\n",
442 count[1], tmp);
443 return;
444 }
445
446 if (count[2] + count[3] != rgd->rd_dinodes) {
447 if (gfs2_consist_rgrpd(rgd))
448 fs_err(sdp, "used metadata mismatch: %u != %u\n",
449 count[2] + count[3], rgd->rd_dinodes);
450 return;
451 }
452}
453
454static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
455{
456 u64 first = rgd->rd_data0;
457 u64 last = first + rgd->rd_data;
458 return first <= block && block < last;
459}
460
461
462
463
464
465
466
467
468
469
470struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
471{
472 struct rb_node *n, *next;
473 struct gfs2_rgrpd *cur;
474
475 spin_lock(&sdp->sd_rindex_spin);
476 n = sdp->sd_rindex_tree.rb_node;
477 while (n) {
478 cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
479 next = NULL;
480 if (blk < cur->rd_addr)
481 next = n->rb_left;
482 else if (blk >= cur->rd_data0 + cur->rd_data)
483 next = n->rb_right;
484 if (next == NULL) {
485 spin_unlock(&sdp->sd_rindex_spin);
486 if (exact) {
487 if (blk < cur->rd_addr)
488 return NULL;
489 if (blk >= cur->rd_data0 + cur->rd_data)
490 return NULL;
491 }
492 return cur;
493 }
494 n = next;
495 }
496 spin_unlock(&sdp->sd_rindex_spin);
497
498 return NULL;
499}
500
501
502
503
504
505
506
507
508struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
509{
510 const struct rb_node *n;
511 struct gfs2_rgrpd *rgd;
512
513 spin_lock(&sdp->sd_rindex_spin);
514 n = rb_first(&sdp->sd_rindex_tree);
515 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
516 spin_unlock(&sdp->sd_rindex_spin);
517
518 return rgd;
519}
520
521
522
523
524
525
526
527
528struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
529{
530 struct gfs2_sbd *sdp = rgd->rd_sbd;
531 const struct rb_node *n;
532
533 spin_lock(&sdp->sd_rindex_spin);
534 n = rb_next(&rgd->rd_node);
535 if (n == NULL)
536 n = rb_first(&sdp->sd_rindex_tree);
537
538 if (unlikely(&rgd->rd_node == n)) {
539 spin_unlock(&sdp->sd_rindex_spin);
540 return NULL;
541 }
542 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
543 spin_unlock(&sdp->sd_rindex_spin);
544 return rgd;
545}
546
547void gfs2_free_clones(struct gfs2_rgrpd *rgd)
548{
549 int x;
550
551 for (x = 0; x < rgd->rd_length; x++) {
552 struct gfs2_bitmap *bi = rgd->rd_bits + x;
553 kfree(bi->bi_clone);
554 bi->bi_clone = NULL;
555 }
556}
557
558
559
560
561
562int gfs2_rs_alloc(struct gfs2_inode *ip)
563{
564 int error = 0;
565
566 down_write(&ip->i_rw_mutex);
567 if (ip->i_res)
568 goto out;
569
570 ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
571 if (!ip->i_res) {
572 error = -ENOMEM;
573 goto out;
574 }
575
576 RB_CLEAR_NODE(&ip->i_res->rs_node);
577out:
578 up_write(&ip->i_rw_mutex);
579 return error;
580}
581
582static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs)
583{
584 gfs2_print_dbg(seq, " B: n:%llu s:%llu b:%u f:%u\n",
585 (unsigned long long)rs->rs_inum,
586 (unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
587 rs->rs_rbm.offset, rs->rs_free);
588}
589
590
591
592
593
594
595static void __rs_deltree(struct gfs2_blkreserv *rs)
596{
597 struct gfs2_rgrpd *rgd;
598
599 if (!gfs2_rs_active(rs))
600 return;
601
602 rgd = rs->rs_rbm.rgd;
603 trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
604 rb_erase(&rs->rs_node, &rgd->rd_rstree);
605 RB_CLEAR_NODE(&rs->rs_node);
606
607 if (rs->rs_free) {
608
609 BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
610 rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
611 rs->rs_free = 0;
612 clear_bit(GBF_FULL, &rs->rs_rbm.bi->bi_flags);
613 smp_mb__after_clear_bit();
614 }
615}
616
617
618
619
620
621
622void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
623{
624 struct gfs2_rgrpd *rgd;
625
626 rgd = rs->rs_rbm.rgd;
627 if (rgd) {
628 spin_lock(&rgd->rd_rsspin);
629 __rs_deltree(rs);
630 spin_unlock(&rgd->rd_rsspin);
631 }
632}
633
634
635
636
637
638
639void gfs2_rs_delete(struct gfs2_inode *ip)
640{
641 struct inode *inode = &ip->i_inode;
642
643 down_write(&ip->i_rw_mutex);
644 if (ip->i_res && atomic_read(&inode->i_writecount) <= 1) {
645 gfs2_rs_deltree(ip->i_res);
646 BUG_ON(ip->i_res->rs_free);
647 kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
648 ip->i_res = NULL;
649 }
650 up_write(&ip->i_rw_mutex);
651}
652
653
654
655
656
657
658
659
660
661static void return_all_reservations(struct gfs2_rgrpd *rgd)
662{
663 struct rb_node *n;
664 struct gfs2_blkreserv *rs;
665
666 spin_lock(&rgd->rd_rsspin);
667 while ((n = rb_first(&rgd->rd_rstree))) {
668 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
669 __rs_deltree(rs);
670 }
671 spin_unlock(&rgd->rd_rsspin);
672}
673
674void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
675{
676 struct rb_node *n;
677 struct gfs2_rgrpd *rgd;
678 struct gfs2_glock *gl;
679
680 while ((n = rb_first(&sdp->sd_rindex_tree))) {
681 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
682 gl = rgd->rd_gl;
683
684 rb_erase(n, &sdp->sd_rindex_tree);
685
686 if (gl) {
687 spin_lock(&gl->gl_spin);
688 gl->gl_object = NULL;
689 spin_unlock(&gl->gl_spin);
690 gfs2_glock_add_to_lru(gl);
691 gfs2_glock_put(gl);
692 }
693
694 gfs2_free_clones(rgd);
695 kfree(rgd->rd_bits);
696 return_all_reservations(rgd);
697 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
698 }
699}
700
701static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
702{
703 printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
704 printk(KERN_INFO " ri_length = %u\n", rgd->rd_length);
705 printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
706 printk(KERN_INFO " ri_data = %u\n", rgd->rd_data);
707 printk(KERN_INFO " ri_bitbytes = %u\n", rgd->rd_bitbytes);
708}
709
710
711
712
713
714
715
716
717
718
719static int compute_bitstructs(struct gfs2_rgrpd *rgd)
720{
721 struct gfs2_sbd *sdp = rgd->rd_sbd;
722 struct gfs2_bitmap *bi;
723 u32 length = rgd->rd_length;
724 u32 bytes_left, bytes;
725 int x;
726
727 if (!length)
728 return -EINVAL;
729
730 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
731 if (!rgd->rd_bits)
732 return -ENOMEM;
733
734 bytes_left = rgd->rd_bitbytes;
735
736 for (x = 0; x < length; x++) {
737 bi = rgd->rd_bits + x;
738
739 bi->bi_flags = 0;
740
741 if (length == 1) {
742 bytes = bytes_left;
743 bi->bi_offset = sizeof(struct gfs2_rgrp);
744 bi->bi_start = 0;
745 bi->bi_len = bytes;
746
747 } else if (x == 0) {
748 bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
749 bi->bi_offset = sizeof(struct gfs2_rgrp);
750 bi->bi_start = 0;
751 bi->bi_len = bytes;
752
753 } else if (x + 1 == length) {
754 bytes = bytes_left;
755 bi->bi_offset = sizeof(struct gfs2_meta_header);
756 bi->bi_start = rgd->rd_bitbytes - bytes_left;
757 bi->bi_len = bytes;
758
759 } else {
760 bytes = sdp->sd_sb.sb_bsize -
761 sizeof(struct gfs2_meta_header);
762 bi->bi_offset = sizeof(struct gfs2_meta_header);
763 bi->bi_start = rgd->rd_bitbytes - bytes_left;
764 bi->bi_len = bytes;
765 }
766
767 bytes_left -= bytes;
768 }
769
770 if (bytes_left) {
771 gfs2_consist_rgrpd(rgd);
772 return -EIO;
773 }
774 bi = rgd->rd_bits + (length - 1);
775 if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
776 if (gfs2_consist_rgrpd(rgd)) {
777 gfs2_rindex_print(rgd);
778 fs_err(sdp, "start=%u len=%u offset=%u\n",
779 bi->bi_start, bi->bi_len, bi->bi_offset);
780 }
781 return -EIO;
782 }
783
784 return 0;
785}
786
787
788
789
790
791
792u64 gfs2_ri_total(struct gfs2_sbd *sdp)
793{
794 u64 total_data = 0;
795 struct inode *inode = sdp->sd_rindex;
796 struct gfs2_inode *ip = GFS2_I(inode);
797 char buf[sizeof(struct gfs2_rindex)];
798 int error, rgrps;
799
800 for (rgrps = 0;; rgrps++) {
801 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
802
803 if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
804 break;
805 error = gfs2_internal_read(ip, buf, &pos,
806 sizeof(struct gfs2_rindex));
807 if (error != sizeof(struct gfs2_rindex))
808 break;
809 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
810 }
811 return total_data;
812}
813
814static int rgd_insert(struct gfs2_rgrpd *rgd)
815{
816 struct gfs2_sbd *sdp = rgd->rd_sbd;
817 struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
818
819
820 while (*newn) {
821 struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
822 rd_node);
823
824 parent = *newn;
825 if (rgd->rd_addr < cur->rd_addr)
826 newn = &((*newn)->rb_left);
827 else if (rgd->rd_addr > cur->rd_addr)
828 newn = &((*newn)->rb_right);
829 else
830 return -EEXIST;
831 }
832
833 rb_link_node(&rgd->rd_node, parent, newn);
834 rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
835 sdp->sd_rgrps++;
836 return 0;
837}
838
839
840
841
842
843
844
845
846static int read_rindex_entry(struct gfs2_inode *ip)
847{
848 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
849 loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
850 struct gfs2_rindex buf;
851 int error;
852 struct gfs2_rgrpd *rgd;
853
854 if (pos >= i_size_read(&ip->i_inode))
855 return 1;
856
857 error = gfs2_internal_read(ip, (char *)&buf, &pos,
858 sizeof(struct gfs2_rindex));
859
860 if (error != sizeof(struct gfs2_rindex))
861 return (error == 0) ? 1 : error;
862
863 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
864 error = -ENOMEM;
865 if (!rgd)
866 return error;
867
868 rgd->rd_sbd = sdp;
869 rgd->rd_addr = be64_to_cpu(buf.ri_addr);
870 rgd->rd_length = be32_to_cpu(buf.ri_length);
871 rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
872 rgd->rd_data = be32_to_cpu(buf.ri_data);
873 rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
874 spin_lock_init(&rgd->rd_rsspin);
875
876 error = compute_bitstructs(rgd);
877 if (error)
878 goto fail;
879
880 error = gfs2_glock_get(sdp, rgd->rd_addr,
881 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
882 if (error)
883 goto fail;
884
885 rgd->rd_gl->gl_object = rgd;
886 rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
887 rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
888 if (rgd->rd_data > sdp->sd_max_rg_data)
889 sdp->sd_max_rg_data = rgd->rd_data;
890 spin_lock(&sdp->sd_rindex_spin);
891 error = rgd_insert(rgd);
892 spin_unlock(&sdp->sd_rindex_spin);
893 if (!error)
894 return 0;
895
896 error = 0;
897 gfs2_glock_put(rgd->rd_gl);
898
899fail:
900 kfree(rgd->rd_bits);
901 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
902 return error;
903}
904
905
906
907
908
909
910
911
912static int gfs2_ri_update(struct gfs2_inode *ip)
913{
914 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
915 int error;
916
917 do {
918 error = read_rindex_entry(ip);
919 } while (error == 0);
920
921 if (error < 0)
922 return error;
923
924 sdp->sd_rindex_uptodate = 1;
925 return 0;
926}
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945int gfs2_rindex_update(struct gfs2_sbd *sdp)
946{
947 struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
948 struct gfs2_glock *gl = ip->i_gl;
949 struct gfs2_holder ri_gh;
950 int error = 0;
951 int unlock_required = 0;
952
953
954 if (!sdp->sd_rindex_uptodate) {
955 if (!gfs2_glock_is_locked_by_me(gl)) {
956 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
957 if (error)
958 return error;
959 unlock_required = 1;
960 }
961 if (!sdp->sd_rindex_uptodate)
962 error = gfs2_ri_update(ip);
963 if (unlock_required)
964 gfs2_glock_dq_uninit(&ri_gh);
965 }
966
967 return error;
968}
969
970static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
971{
972 const struct gfs2_rgrp *str = buf;
973 u32 rg_flags;
974
975 rg_flags = be32_to_cpu(str->rg_flags);
976 rg_flags &= ~GFS2_RDF_MASK;
977 rgd->rd_flags &= GFS2_RDF_MASK;
978 rgd->rd_flags |= rg_flags;
979 rgd->rd_free = be32_to_cpu(str->rg_free);
980 rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
981 rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
982}
983
984static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
985{
986 struct gfs2_rgrp *str = buf;
987
988 str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
989 str->rg_free = cpu_to_be32(rgd->rd_free);
990 str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
991 str->__pad = cpu_to_be32(0);
992 str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
993 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
994}
995
996static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
997{
998 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
999 struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
1000
1001 if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
1002 rgl->rl_dinodes != str->rg_dinodes ||
1003 rgl->rl_igeneration != str->rg_igeneration)
1004 return 0;
1005 return 1;
1006}
1007
1008static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1009{
1010 const struct gfs2_rgrp *str = buf;
1011
1012 rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1013 rgl->rl_flags = str->rg_flags;
1014 rgl->rl_free = str->rg_free;
1015 rgl->rl_dinodes = str->rg_dinodes;
1016 rgl->rl_igeneration = str->rg_igeneration;
1017 rgl->__pad = 0UL;
1018}
1019
1020static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
1021{
1022 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1023 u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
1024 rgl->rl_unlinked = cpu_to_be32(unlinked);
1025}
1026
1027static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1028{
1029 struct gfs2_bitmap *bi;
1030 const u32 length = rgd->rd_length;
1031 const u8 *buffer = NULL;
1032 u32 i, goal, count = 0;
1033
1034 for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1035 goal = 0;
1036 buffer = bi->bi_bh->b_data + bi->bi_offset;
1037 WARN_ON(!buffer_uptodate(bi->bi_bh));
1038 while (goal < bi->bi_len * GFS2_NBBY) {
1039 goal = gfs2_bitfit(buffer, bi->bi_len, goal,
1040 GFS2_BLKST_UNLINKED);
1041 if (goal == BFITNOENT)
1042 break;
1043 count++;
1044 goal++;
1045 }
1046 }
1047
1048 return count;
1049}
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
1063{
1064 struct gfs2_sbd *sdp = rgd->rd_sbd;
1065 struct gfs2_glock *gl = rgd->rd_gl;
1066 unsigned int length = rgd->rd_length;
1067 struct gfs2_bitmap *bi;
1068 unsigned int x, y;
1069 int error;
1070
1071 if (rgd->rd_bits[0].bi_bh != NULL)
1072 return 0;
1073
1074 for (x = 0; x < length; x++) {
1075 bi = rgd->rd_bits + x;
1076 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
1077 if (error)
1078 goto fail;
1079 }
1080
1081 for (y = length; y--;) {
1082 bi = rgd->rd_bits + y;
1083 error = gfs2_meta_wait(sdp, bi->bi_bh);
1084 if (error)
1085 goto fail;
1086 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
1087 GFS2_METATYPE_RG)) {
1088 error = -EIO;
1089 goto fail;
1090 }
1091 }
1092
1093 if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1094 for (x = 0; x < length; x++)
1095 clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1096 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1097 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1098 rgd->rd_free_clone = rgd->rd_free;
1099 }
1100 if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1101 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1102 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1103 rgd->rd_bits[0].bi_bh->b_data);
1104 }
1105 else if (sdp->sd_args.ar_rgrplvb) {
1106 if (!gfs2_rgrp_lvb_valid(rgd)){
1107 gfs2_consist_rgrpd(rgd);
1108 error = -EIO;
1109 goto fail;
1110 }
1111 if (rgd->rd_rgl->rl_unlinked == 0)
1112 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1113 }
1114 return 0;
1115
1116fail:
1117 while (x--) {
1118 bi = rgd->rd_bits + x;
1119 brelse(bi->bi_bh);
1120 bi->bi_bh = NULL;
1121 gfs2_assert_warn(sdp, !bi->bi_clone);
1122 }
1123
1124 return error;
1125}
1126
1127int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
1128{
1129 u32 rl_flags;
1130
1131 if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1132 return 0;
1133
1134 if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1135 return gfs2_rgrp_bh_get(rgd);
1136
1137 rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1138 rl_flags &= ~GFS2_RDF_MASK;
1139 rgd->rd_flags &= GFS2_RDF_MASK;
1140 rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1141 if (rgd->rd_rgl->rl_unlinked == 0)
1142 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1143 rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1144 rgd->rd_free_clone = rgd->rd_free;
1145 rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1146 rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1147 return 0;
1148}
1149
1150int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
1151{
1152 struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1153 struct gfs2_sbd *sdp = rgd->rd_sbd;
1154
1155 if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
1156 return 0;
1157 return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
1158}
1159
1160
1161
1162
1163
1164
1165
1166void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
1167{
1168 struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1169 int x, length = rgd->rd_length;
1170
1171 for (x = 0; x < length; x++) {
1172 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1173 if (bi->bi_bh) {
1174 brelse(bi->bi_bh);
1175 bi->bi_bh = NULL;
1176 }
1177 }
1178
1179}
1180
1181int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1182 struct buffer_head *bh,
1183 const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1184{
1185 struct super_block *sb = sdp->sd_vfs;
1186 u64 blk;
1187 sector_t start = 0;
1188 sector_t nr_blks = 0;
1189 int rv;
1190 unsigned int x;
1191 u32 trimmed = 0;
1192 u8 diff;
1193
1194 for (x = 0; x < bi->bi_len; x++) {
1195 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1196 clone += bi->bi_offset;
1197 clone += x;
1198 if (bh) {
1199 const u8 *orig = bh->b_data + bi->bi_offset + x;
1200 diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1201 } else {
1202 diff = ~(*clone | (*clone >> 1));
1203 }
1204 diff &= 0x55;
1205 if (diff == 0)
1206 continue;
1207 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
1208 while(diff) {
1209 if (diff & 1) {
1210 if (nr_blks == 0)
1211 goto start_new_extent;
1212 if ((start + nr_blks) != blk) {
1213 if (nr_blks >= minlen) {
1214 rv = sb_issue_discard(sb,
1215 start, nr_blks,
1216 GFP_NOFS, 0);
1217 if (rv)
1218 goto fail;
1219 trimmed += nr_blks;
1220 }
1221 nr_blks = 0;
1222start_new_extent:
1223 start = blk;
1224 }
1225 nr_blks++;
1226 }
1227 diff >>= 2;
1228 blk++;
1229 }
1230 }
1231 if (nr_blks >= minlen) {
1232 rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
1233 if (rv)
1234 goto fail;
1235 trimmed += nr_blks;
1236 }
1237 if (ptrimmed)
1238 *ptrimmed = trimmed;
1239 return 0;
1240
1241fail:
1242 if (sdp->sd_args.ar_discard)
1243 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1244 sdp->sd_args.ar_discard = 0;
1245 return -EIO;
1246}
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256int gfs2_fitrim(struct file *filp, void __user *argp)
1257{
1258 struct inode *inode = file_inode(filp);
1259 struct gfs2_sbd *sdp = GFS2_SB(inode);
1260 struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1261 struct buffer_head *bh;
1262 struct gfs2_rgrpd *rgd;
1263 struct gfs2_rgrpd *rgd_end;
1264 struct gfs2_holder gh;
1265 struct fstrim_range r;
1266 int ret = 0;
1267 u64 amt;
1268 u64 trimmed = 0;
1269 u64 start, end, minlen;
1270 unsigned int x;
1271 unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
1272
1273 if (!capable(CAP_SYS_ADMIN))
1274 return -EPERM;
1275
1276 if (!blk_queue_discard(q))
1277 return -EOPNOTSUPP;
1278
1279 if (copy_from_user(&r, argp, sizeof(r)))
1280 return -EFAULT;
1281
1282 ret = gfs2_rindex_update(sdp);
1283 if (ret)
1284 return ret;
1285
1286 start = r.start >> bs_shift;
1287 end = start + (r.len >> bs_shift);
1288 minlen = max_t(u64, r.minlen,
1289 q->limits.discard_granularity) >> bs_shift;
1290
1291 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1292 rgd_end = gfs2_blk2rgrpd(sdp, end - 1, 0);
1293
1294 if (end <= start ||
1295 minlen > sdp->sd_max_rg_data ||
1296 start > rgd_end->rd_data0 + rgd_end->rd_data)
1297 return -EINVAL;
1298
1299 while (1) {
1300
1301 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1302 if (ret)
1303 goto out;
1304
1305 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1306
1307 for (x = 0; x < rgd->rd_length; x++) {
1308 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1309 ret = gfs2_rgrp_send_discards(sdp,
1310 rgd->rd_data0, NULL, bi, minlen,
1311 &amt);
1312 if (ret) {
1313 gfs2_glock_dq_uninit(&gh);
1314 goto out;
1315 }
1316 trimmed += amt;
1317 }
1318
1319
1320 ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1321 if (ret == 0) {
1322 bh = rgd->rd_bits[0].bi_bh;
1323 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1324 gfs2_trans_add_meta(rgd->rd_gl, bh);
1325 gfs2_rgrp_out(rgd, bh->b_data);
1326 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
1327 gfs2_trans_end(sdp);
1328 }
1329 }
1330 gfs2_glock_dq_uninit(&gh);
1331
1332 if (rgd == rgd_end)
1333 break;
1334
1335 rgd = gfs2_rgrpd_get_next(rgd);
1336 }
1337
1338out:
1339 r.len = trimmed << 9;
1340 if (copy_to_user(argp, &r, sizeof(r)))
1341 return -EFAULT;
1342
1343 return ret;
1344}
1345
1346
1347
1348
1349
1350
1351static void rs_insert(struct gfs2_inode *ip)
1352{
1353 struct rb_node **newn, *parent = NULL;
1354 int rc;
1355 struct gfs2_blkreserv *rs = ip->i_res;
1356 struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1357 u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
1358
1359 BUG_ON(gfs2_rs_active(rs));
1360
1361 spin_lock(&rgd->rd_rsspin);
1362 newn = &rgd->rd_rstree.rb_node;
1363 while (*newn) {
1364 struct gfs2_blkreserv *cur =
1365 rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1366
1367 parent = *newn;
1368 rc = rs_cmp(fsblock, rs->rs_free, cur);
1369 if (rc > 0)
1370 newn = &((*newn)->rb_right);
1371 else if (rc < 0)
1372 newn = &((*newn)->rb_left);
1373 else {
1374 spin_unlock(&rgd->rd_rsspin);
1375 WARN_ON(1);
1376 return;
1377 }
1378 }
1379
1380 rb_link_node(&rs->rs_node, parent, newn);
1381 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1382
1383
1384 rgd->rd_reserved += rs->rs_free;
1385 spin_unlock(&rgd->rd_rsspin);
1386 trace_gfs2_rs(rs, TRACE_RS_INSERT);
1387}
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1398 unsigned requested)
1399{
1400 struct gfs2_rbm rbm = { .rgd = rgd, };
1401 u64 goal;
1402 struct gfs2_blkreserv *rs = ip->i_res;
1403 u32 extlen;
1404 u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
1405 int ret;
1406 struct inode *inode = &ip->i_inode;
1407
1408 if (S_ISDIR(inode->i_mode))
1409 extlen = 1;
1410 else {
1411 extlen = max_t(u32, atomic_read(&rs->rs_sizehint), requested);
1412 extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
1413 }
1414 if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1415 return;
1416
1417
1418 if (rgrp_contains_block(rgd, ip->i_goal))
1419 goal = ip->i_goal;
1420 else
1421 goal = rgd->rd_last_alloc + rgd->rd_data0;
1422
1423 if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1424 return;
1425
1426 ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, extlen, ip, true);
1427 if (ret == 0) {
1428 rs->rs_rbm = rbm;
1429 rs->rs_free = extlen;
1430 rs->rs_inum = ip->i_no_addr;
1431 rs_insert(ip);
1432 } else {
1433 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1434 rgd->rd_last_alloc = 0;
1435 }
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1452 u32 length,
1453 const struct gfs2_inode *ip)
1454{
1455 struct gfs2_blkreserv *rs;
1456 struct rb_node *n;
1457 int rc;
1458
1459 spin_lock(&rgd->rd_rsspin);
1460 n = rgd->rd_rstree.rb_node;
1461 while (n) {
1462 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1463 rc = rs_cmp(block, length, rs);
1464 if (rc < 0)
1465 n = n->rb_left;
1466 else if (rc > 0)
1467 n = n->rb_right;
1468 else
1469 break;
1470 }
1471
1472 if (n) {
1473 while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) {
1474 block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1475 n = n->rb_right;
1476 if (n == NULL)
1477 break;
1478 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1479 }
1480 }
1481
1482 spin_unlock(&rgd->rd_rsspin);
1483 return block;
1484}
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1502 const struct gfs2_inode *ip,
1503 u32 minext)
1504{
1505 u64 block = gfs2_rbm_to_block(rbm);
1506 u32 extlen = 1;
1507 u64 nblock;
1508 int ret;
1509
1510
1511
1512
1513
1514 if (minext) {
1515 extlen = gfs2_free_extlen(rbm, minext);
1516 nblock = block + extlen;
1517 if (extlen < minext)
1518 goto fail;
1519 }
1520
1521
1522
1523
1524
1525 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1526 if (nblock == block)
1527 return 0;
1528fail:
1529 ret = gfs2_rbm_from_block(rbm, nblock);
1530 if (ret < 0)
1531 return ret;
1532 return 1;
1533}
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
1552 const struct gfs2_inode *ip, bool nowrap)
1553{
1554 struct buffer_head *bh;
1555 struct gfs2_bitmap *initial_bi;
1556 u32 initial_offset;
1557 u32 offset;
1558 u8 *buffer;
1559 int index;
1560 int n = 0;
1561 int iters = rbm->rgd->rd_length;
1562 int ret;
1563
1564
1565
1566
1567
1568 if (rbm->offset != 0)
1569 iters++;
1570
1571 while(1) {
1572 if (test_bit(GBF_FULL, &rbm->bi->bi_flags) &&
1573 (state == GFS2_BLKST_FREE))
1574 goto next_bitmap;
1575
1576 bh = rbm->bi->bi_bh;
1577 buffer = bh->b_data + rbm->bi->bi_offset;
1578 WARN_ON(!buffer_uptodate(bh));
1579 if (state != GFS2_BLKST_UNLINKED && rbm->bi->bi_clone)
1580 buffer = rbm->bi->bi_clone + rbm->bi->bi_offset;
1581 initial_offset = rbm->offset;
1582 offset = gfs2_bitfit(buffer, rbm->bi->bi_len, rbm->offset, state);
1583 if (offset == BFITNOENT)
1584 goto bitmap_full;
1585 rbm->offset = offset;
1586 if (ip == NULL)
1587 return 0;
1588
1589 initial_bi = rbm->bi;
1590 ret = gfs2_reservation_check_and_update(rbm, ip, minext);
1591 if (ret == 0)
1592 return 0;
1593 if (ret > 0) {
1594 n += (rbm->bi - initial_bi);
1595 goto next_iter;
1596 }
1597 if (ret == -E2BIG) {
1598 index = 0;
1599 rbm->offset = 0;
1600 n += (rbm->bi - initial_bi);
1601 goto res_covered_end_of_rgrp;
1602 }
1603 return ret;
1604
1605bitmap_full:
1606 if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
1607 set_bit(GBF_FULL, &rbm->bi->bi_flags);
1608
1609next_bitmap:
1610 rbm->offset = 0;
1611 index = rbm->bi - rbm->rgd->rd_bits;
1612 index++;
1613 if (index == rbm->rgd->rd_length)
1614 index = 0;
1615res_covered_end_of_rgrp:
1616 rbm->bi = &rbm->rgd->rd_bits[index];
1617 if ((index == 0) && nowrap)
1618 break;
1619 n++;
1620next_iter:
1621 if (n >= iters)
1622 break;
1623 }
1624
1625 return -ENOSPC;
1626}
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1639{
1640 u64 block;
1641 struct gfs2_sbd *sdp = rgd->rd_sbd;
1642 struct gfs2_glock *gl;
1643 struct gfs2_inode *ip;
1644 int error;
1645 int found = 0;
1646 struct gfs2_rbm rbm = { .rgd = rgd, .bi = rgd->rd_bits, .offset = 0 };
1647
1648 while (1) {
1649 down_write(&sdp->sd_log_flush_lock);
1650 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, 0, NULL, true);
1651 up_write(&sdp->sd_log_flush_lock);
1652 if (error == -ENOSPC)
1653 break;
1654 if (WARN_ON_ONCE(error))
1655 break;
1656
1657 block = gfs2_rbm_to_block(&rbm);
1658 if (gfs2_rbm_from_block(&rbm, block + 1))
1659 break;
1660 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1661 continue;
1662 if (block == skip)
1663 continue;
1664 *last_unlinked = block;
1665
1666 error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl);
1667 if (error)
1668 continue;
1669
1670
1671
1672
1673
1674
1675
1676
1677 ip = gl->gl_object;
1678
1679 if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
1680 gfs2_glock_put(gl);
1681 else
1682 found++;
1683
1684
1685 if (found > NR_CPUS)
1686 return;
1687 }
1688
1689 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1690 return;
1691}
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1721{
1722 const struct gfs2_glock *gl = rgd->rd_gl;
1723 const struct gfs2_sbd *sdp = gl->gl_sbd;
1724 struct gfs2_lkstats *st;
1725 s64 r_dcount, l_dcount;
1726 s64 r_srttb, l_srttb;
1727 s64 srttb_diff;
1728 s64 sqr_diff;
1729 s64 var;
1730
1731 preempt_disable();
1732 st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
1733 r_srttb = st->stats[GFS2_LKS_SRTTB];
1734 r_dcount = st->stats[GFS2_LKS_DCOUNT];
1735 var = st->stats[GFS2_LKS_SRTTVARB] +
1736 gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1737 preempt_enable();
1738
1739 l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1740 l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1741
1742 if ((l_dcount < 1) || (r_dcount < 1) || (r_srttb == 0))
1743 return false;
1744
1745 srttb_diff = r_srttb - l_srttb;
1746 sqr_diff = srttb_diff * srttb_diff;
1747
1748 var *= 2;
1749 if (l_dcount < 8 || r_dcount < 8)
1750 var *= 2;
1751 if (loops == 1)
1752 var *= 2;
1753
1754 return ((srttb_diff < 0) && (sqr_diff > var));
1755}
1756
1757
1758
1759
1760
1761
1762
1763
1764static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1765 u64 msecs)
1766{
1767 u64 tdiff;
1768
1769 tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
1770 rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1771
1772 return tdiff > (msecs * 1000 * 1000);
1773}
1774
1775static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1776{
1777 const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1778 u32 skip;
1779
1780 get_random_bytes(&skip, sizeof(skip));
1781 return skip % sdp->sd_rgrps;
1782}
1783
1784static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1785{
1786 struct gfs2_rgrpd *rgd = *pos;
1787 struct gfs2_sbd *sdp = rgd->rd_sbd;
1788
1789 rgd = gfs2_rgrpd_get_next(rgd);
1790 if (rgd == NULL)
1791 rgd = gfs2_rgrpd_get_first(sdp);
1792 *pos = rgd;
1793 if (rgd != begin)
1794 return true;
1795 return false;
1796}
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested, u32 aflags)
1807{
1808 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1809 struct gfs2_rgrpd *begin = NULL;
1810 struct gfs2_blkreserv *rs = ip->i_res;
1811 int error = 0, rg_locked, flags = 0;
1812 u64 last_unlinked = NO_BLOCK;
1813 int loops = 0;
1814 u32 skip = 0;
1815
1816 if (sdp->sd_args.ar_rgrplvb)
1817 flags |= GL_SKIP;
1818 if (gfs2_assert_warn(sdp, requested))
1819 return -EINVAL;
1820 if (gfs2_rs_active(rs)) {
1821 begin = rs->rs_rbm.rgd;
1822 flags = 0;
1823 } else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
1824 rs->rs_rbm.rgd = begin = ip->i_rgd;
1825 } else {
1826 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
1827 }
1828 if (S_ISDIR(ip->i_inode.i_mode) && (aflags & GFS2_AF_ORLOV))
1829 skip = gfs2_orlov_skip(ip);
1830 if (rs->rs_rbm.rgd == NULL)
1831 return -EBADSLT;
1832
1833 while (loops < 3) {
1834 rg_locked = 1;
1835
1836 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
1837 rg_locked = 0;
1838 if (skip && skip--)
1839 goto next_rgrp;
1840 if (!gfs2_rs_active(rs) && (loops < 2) &&
1841 gfs2_rgrp_used_recently(rs, 1000) &&
1842 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1843 goto next_rgrp;
1844 error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
1845 LM_ST_EXCLUSIVE, flags,
1846 &rs->rs_rgd_gh);
1847 if (unlikely(error))
1848 return error;
1849 if (!gfs2_rs_active(rs) && (loops < 2) &&
1850 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1851 goto skip_rgrp;
1852 if (sdp->sd_args.ar_rgrplvb) {
1853 error = update_rgrp_lvb(rs->rs_rbm.rgd);
1854 if (unlikely(error)) {
1855 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1856 return error;
1857 }
1858 }
1859 }
1860
1861
1862 if (rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
1863 goto skip_rgrp;
1864
1865 if (sdp->sd_args.ar_rgrplvb)
1866 gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
1867
1868
1869 if (!gfs2_rs_active(rs))
1870 rg_mblk_search(rs->rs_rbm.rgd, ip, requested);
1871
1872
1873 if (!gfs2_rs_active(rs) && (loops < 1))
1874 goto check_rgrp;
1875
1876
1877 if (rs->rs_rbm.rgd->rd_free_clone >= requested) {
1878 ip->i_rgd = rs->rs_rbm.rgd;
1879 return 0;
1880 }
1881
1882
1883 if (gfs2_rs_active(rs))
1884 gfs2_rs_deltree(rs);
1885check_rgrp:
1886
1887 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
1888 try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
1889 ip->i_no_addr);
1890skip_rgrp:
1891
1892 if (!rg_locked)
1893 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1894next_rgrp:
1895
1896 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
1897 continue;
1898 if (skip)
1899 continue;
1900
1901
1902
1903
1904
1905 loops++;
1906
1907 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
1908 error = gfs2_ri_update(ip);
1909 if (error)
1910 return error;
1911 }
1912
1913 if (loops == 2)
1914 gfs2_log_flush(sdp, NULL);
1915 }
1916
1917 return -ENOSPC;
1918}
1919
1920
1921
1922
1923
1924
1925
1926
1927void gfs2_inplace_release(struct gfs2_inode *ip)
1928{
1929 struct gfs2_blkreserv *rs = ip->i_res;
1930
1931 if (rs->rs_rgd_gh.gh_gl)
1932 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1933}
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
1944{
1945 struct gfs2_rbm rbm = { .rgd = rgd, };
1946 int ret;
1947
1948 ret = gfs2_rbm_from_block(&rbm, block);
1949 WARN_ON_ONCE(ret != 0);
1950
1951 return gfs2_testbit(&rbm);
1952}
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
1965 unsigned int *n)
1966{
1967 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
1968 const unsigned int elen = *n;
1969 u64 block;
1970 int ret;
1971
1972 *n = 1;
1973 block = gfs2_rbm_to_block(rbm);
1974 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm->bi->bi_bh);
1975 gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1976 block++;
1977 while (*n < elen) {
1978 ret = gfs2_rbm_from_block(&pos, block);
1979 if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
1980 break;
1981 gfs2_trans_add_meta(pos.rgd->rd_gl, pos.bi->bi_bh);
1982 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
1983 (*n)++;
1984 block++;
1985 }
1986}
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
1999 u32 blen, unsigned char new_state)
2000{
2001 struct gfs2_rbm rbm;
2002
2003 rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
2004 if (!rbm.rgd) {
2005 if (gfs2_consist(sdp))
2006 fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
2007 return NULL;
2008 }
2009
2010 while (blen--) {
2011 gfs2_rbm_from_block(&rbm, bstart);
2012 bstart++;
2013 if (!rbm.bi->bi_clone) {
2014 rbm.bi->bi_clone = kmalloc(rbm.bi->bi_bh->b_size,
2015 GFP_NOFS | __GFP_NOFAIL);
2016 memcpy(rbm.bi->bi_clone + rbm.bi->bi_offset,
2017 rbm.bi->bi_bh->b_data + rbm.bi->bi_offset,
2018 rbm.bi->bi_len);
2019 }
2020 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.bi->bi_bh);
2021 gfs2_setbit(&rbm, false, new_state);
2022 }
2023
2024 return rbm.rgd;
2025}
2026
2027
2028
2029
2030
2031
2032
2033
2034int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
2035{
2036 struct gfs2_rgrpd *rgd = gl->gl_object;
2037 struct gfs2_blkreserv *trs;
2038 const struct rb_node *n;
2039
2040 if (rgd == NULL)
2041 return 0;
2042 gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
2043 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2044 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2045 rgd->rd_reserved);
2046 spin_lock(&rgd->rd_rsspin);
2047 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2048 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
2049 dump_rs(seq, trs);
2050 }
2051 spin_unlock(&rgd->rd_rsspin);
2052 return 0;
2053}
2054
2055static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2056{
2057 struct gfs2_sbd *sdp = rgd->rd_sbd;
2058 fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
2059 (unsigned long long)rgd->rd_addr);
2060 fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2061 gfs2_rgrp_dump(NULL, rgd->rd_gl);
2062 rgd->rd_flags |= GFS2_RDF_ERROR;
2063}
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2077 const struct gfs2_rbm *rbm, unsigned len)
2078{
2079 struct gfs2_blkreserv *rs = ip->i_res;
2080 struct gfs2_rgrpd *rgd = rbm->rgd;
2081 unsigned rlen;
2082 u64 block;
2083 int ret;
2084
2085 spin_lock(&rgd->rd_rsspin);
2086 if (gfs2_rs_active(rs)) {
2087 if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
2088 block = gfs2_rbm_to_block(rbm);
2089 ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
2090 rlen = min(rs->rs_free, len);
2091 rs->rs_free -= rlen;
2092 rgd->rd_reserved -= rlen;
2093 trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2094 if (rs->rs_free && !ret)
2095 goto out;
2096 }
2097 __rs_deltree(rs);
2098 }
2099out:
2100 spin_unlock(&rgd->rd_rsspin);
2101}
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2115 bool dinode, u64 *generation)
2116{
2117 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2118 struct buffer_head *dibh;
2119 struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2120 unsigned int ndata;
2121 u64 goal;
2122 u64 block;
2123 int error;
2124
2125 if (gfs2_rs_active(ip->i_res))
2126 goal = gfs2_rbm_to_block(&ip->i_res->rs_rbm);
2127 else if (!dinode && rgrp_contains_block(rbm.rgd, ip->i_goal))
2128 goal = ip->i_goal;
2129 else
2130 goal = rbm.rgd->rd_last_alloc + rbm.rgd->rd_data0;
2131
2132 gfs2_rbm_from_block(&rbm, goal);
2133 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, ip, false);
2134
2135 if (error == -ENOSPC) {
2136 gfs2_rbm_from_block(&rbm, goal);
2137 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, NULL, false);
2138 }
2139
2140
2141 if (error) {
2142 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d\n",
2143 (unsigned long long)ip->i_no_addr, error, *nblocks,
2144 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags));
2145 goto rgrp_error;
2146 }
2147
2148 gfs2_alloc_extent(&rbm, dinode, nblocks);
2149 block = gfs2_rbm_to_block(&rbm);
2150 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2151 if (gfs2_rs_active(ip->i_res))
2152 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2153 ndata = *nblocks;
2154 if (dinode)
2155 ndata--;
2156
2157 if (!dinode) {
2158 ip->i_goal = block + ndata - 1;
2159 error = gfs2_meta_inode_buffer(ip, &dibh);
2160 if (error == 0) {
2161 struct gfs2_dinode *di =
2162 (struct gfs2_dinode *)dibh->b_data;
2163 gfs2_trans_add_meta(ip->i_gl, dibh);
2164 di->di_goal_meta = di->di_goal_data =
2165 cpu_to_be64(ip->i_goal);
2166 brelse(dibh);
2167 }
2168 }
2169 if (rbm.rgd->rd_free < *nblocks) {
2170 printk(KERN_WARNING "nblocks=%u\n", *nblocks);
2171 goto rgrp_error;
2172 }
2173
2174 rbm.rgd->rd_free -= *nblocks;
2175 if (dinode) {
2176 rbm.rgd->rd_dinodes++;
2177 *generation = rbm.rgd->rd_igeneration++;
2178 if (*generation == 0)
2179 *generation = rbm.rgd->rd_igeneration++;
2180 }
2181
2182 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2183 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2184 gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
2185
2186 gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2187 if (dinode)
2188 gfs2_trans_add_unrevoke(sdp, block, 1);
2189
2190 gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
2191
2192 rbm.rgd->rd_free_clone -= *nblocks;
2193 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2194 dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2195 *bn = block;
2196 return 0;
2197
2198rgrp_error:
2199 gfs2_rgrp_error(rbm.rgd);
2200 return -EIO;
2201}
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
2213{
2214 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2215 struct gfs2_rgrpd *rgd;
2216
2217 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
2218 if (!rgd)
2219 return;
2220 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2221 rgd->rd_free += blen;
2222 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2223 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2224 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2225 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2226
2227
2228 if (meta || ip->i_depth)
2229 gfs2_meta_wipe(ip, bstart, blen);
2230}
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
2241{
2242 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2243
2244 __gfs2_free_blocks(ip, bstart, blen, 1);
2245 gfs2_statfs_change(sdp, 0, +blen, 0);
2246 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
2247}
2248
2249void gfs2_unlink_di(struct inode *inode)
2250{
2251 struct gfs2_inode *ip = GFS2_I(inode);
2252 struct gfs2_sbd *sdp = GFS2_SB(inode);
2253 struct gfs2_rgrpd *rgd;
2254 u64 blkno = ip->i_no_addr;
2255
2256 rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
2257 if (!rgd)
2258 return;
2259 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2260 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2261 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2262 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2263 update_rgrp_lvb_unlinked(rgd, 1);
2264}
2265
2266static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
2267{
2268 struct gfs2_sbd *sdp = rgd->rd_sbd;
2269 struct gfs2_rgrpd *tmp_rgd;
2270
2271 tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
2272 if (!tmp_rgd)
2273 return;
2274 gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
2275
2276 if (!rgd->rd_dinodes)
2277 gfs2_consist_rgrpd(rgd);
2278 rgd->rd_dinodes--;
2279 rgd->rd_free++;
2280
2281 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2282 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2283 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2284 update_rgrp_lvb_unlinked(rgd, -1);
2285
2286 gfs2_statfs_change(sdp, 0, +1, -1);
2287}
2288
2289
2290void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2291{
2292 gfs2_free_uninit_di(rgd, ip->i_no_addr);
2293 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2294 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2295 gfs2_meta_wipe(ip, ip->i_no_addr, 1);
2296}
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2310{
2311 struct gfs2_rgrpd *rgd;
2312 struct gfs2_holder rgd_gh;
2313 int error = -EINVAL;
2314
2315 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2316 if (!rgd)
2317 goto fail;
2318
2319 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2320 if (error)
2321 goto fail;
2322
2323 if (gfs2_get_block_type(rgd, no_addr) != type)
2324 error = -ESTALE;
2325
2326 gfs2_glock_dq_uninit(&rgd_gh);
2327fail:
2328 return error;
2329}
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2344 u64 block)
2345{
2346 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2347 struct gfs2_rgrpd *rgd;
2348 struct gfs2_rgrpd **tmp;
2349 unsigned int new_space;
2350 unsigned int x;
2351
2352 if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2353 return;
2354
2355 if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
2356 rgd = ip->i_rgd;
2357 else
2358 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2359 if (!rgd) {
2360 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
2361 return;
2362 }
2363 ip->i_rgd = rgd;
2364
2365 for (x = 0; x < rlist->rl_rgrps; x++)
2366 if (rlist->rl_rgd[x] == rgd)
2367 return;
2368
2369 if (rlist->rl_rgrps == rlist->rl_space) {
2370 new_space = rlist->rl_space + 10;
2371
2372 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
2373 GFP_NOFS | __GFP_NOFAIL);
2374
2375 if (rlist->rl_rgd) {
2376 memcpy(tmp, rlist->rl_rgd,
2377 rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2378 kfree(rlist->rl_rgd);
2379 }
2380
2381 rlist->rl_space = new_space;
2382 rlist->rl_rgd = tmp;
2383 }
2384
2385 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2386}
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
2399{
2400 unsigned int x;
2401
2402 rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
2403 GFP_NOFS | __GFP_NOFAIL);
2404 for (x = 0; x < rlist->rl_rgrps; x++)
2405 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2406 state, 0,
2407 &rlist->rl_ghs[x]);
2408}
2409
2410
2411
2412
2413
2414
2415
2416void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2417{
2418 unsigned int x;
2419
2420 kfree(rlist->rl_rgd);
2421
2422 if (rlist->rl_ghs) {
2423 for (x = 0; x < rlist->rl_rgrps; x++)
2424 gfs2_holder_uninit(&rlist->rl_ghs[x]);
2425 kfree(rlist->rl_ghs);
2426 rlist->rl_ghs = NULL;
2427 }
2428}
2429
2430