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 if (end <= start || minlen > sdp->sd_max_rg_data)
1292 return -EINVAL;
1293
1294 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1295 rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
1296
1297 if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
1298 && (start > rgd_end->rd_data0 + rgd_end->rd_data))
1299 return -EINVAL;
1300
1301 while (1) {
1302
1303 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1304 if (ret)
1305 goto out;
1306
1307 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1308
1309 for (x = 0; x < rgd->rd_length; x++) {
1310 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1311 ret = gfs2_rgrp_send_discards(sdp,
1312 rgd->rd_data0, NULL, bi, minlen,
1313 &amt);
1314 if (ret) {
1315 gfs2_glock_dq_uninit(&gh);
1316 goto out;
1317 }
1318 trimmed += amt;
1319 }
1320
1321
1322 ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1323 if (ret == 0) {
1324 bh = rgd->rd_bits[0].bi_bh;
1325 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1326 gfs2_trans_add_meta(rgd->rd_gl, bh);
1327 gfs2_rgrp_out(rgd, bh->b_data);
1328 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
1329 gfs2_trans_end(sdp);
1330 }
1331 }
1332 gfs2_glock_dq_uninit(&gh);
1333
1334 if (rgd == rgd_end)
1335 break;
1336
1337 rgd = gfs2_rgrpd_get_next(rgd);
1338 }
1339
1340out:
1341 r.len = trimmed << bs_shift;
1342 if (copy_to_user(argp, &r, sizeof(r)))
1343 return -EFAULT;
1344
1345 return ret;
1346}
1347
1348
1349
1350
1351
1352
1353static void rs_insert(struct gfs2_inode *ip)
1354{
1355 struct rb_node **newn, *parent = NULL;
1356 int rc;
1357 struct gfs2_blkreserv *rs = ip->i_res;
1358 struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1359 u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
1360
1361 BUG_ON(gfs2_rs_active(rs));
1362
1363 spin_lock(&rgd->rd_rsspin);
1364 newn = &rgd->rd_rstree.rb_node;
1365 while (*newn) {
1366 struct gfs2_blkreserv *cur =
1367 rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1368
1369 parent = *newn;
1370 rc = rs_cmp(fsblock, rs->rs_free, cur);
1371 if (rc > 0)
1372 newn = &((*newn)->rb_right);
1373 else if (rc < 0)
1374 newn = &((*newn)->rb_left);
1375 else {
1376 spin_unlock(&rgd->rd_rsspin);
1377 WARN_ON(1);
1378 return;
1379 }
1380 }
1381
1382 rb_link_node(&rs->rs_node, parent, newn);
1383 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1384
1385
1386 rgd->rd_reserved += rs->rs_free;
1387 spin_unlock(&rgd->rd_rsspin);
1388 trace_gfs2_rs(rs, TRACE_RS_INSERT);
1389}
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1400 unsigned requested)
1401{
1402 struct gfs2_rbm rbm = { .rgd = rgd, };
1403 u64 goal;
1404 struct gfs2_blkreserv *rs = ip->i_res;
1405 u32 extlen;
1406 u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
1407 int ret;
1408 struct inode *inode = &ip->i_inode;
1409
1410 if (S_ISDIR(inode->i_mode))
1411 extlen = 1;
1412 else {
1413 extlen = max_t(u32, atomic_read(&rs->rs_sizehint), requested);
1414 extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
1415 }
1416 if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1417 return;
1418
1419
1420 if (rgrp_contains_block(rgd, ip->i_goal))
1421 goal = ip->i_goal;
1422 else
1423 goal = rgd->rd_last_alloc + rgd->rd_data0;
1424
1425 if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1426 return;
1427
1428 ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, extlen, ip, true);
1429 if (ret == 0) {
1430 rs->rs_rbm = rbm;
1431 rs->rs_free = extlen;
1432 rs->rs_inum = ip->i_no_addr;
1433 rs_insert(ip);
1434 } else {
1435 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1436 rgd->rd_last_alloc = 0;
1437 }
1438}
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1454 u32 length,
1455 const struct gfs2_inode *ip)
1456{
1457 struct gfs2_blkreserv *rs;
1458 struct rb_node *n;
1459 int rc;
1460
1461 spin_lock(&rgd->rd_rsspin);
1462 n = rgd->rd_rstree.rb_node;
1463 while (n) {
1464 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1465 rc = rs_cmp(block, length, rs);
1466 if (rc < 0)
1467 n = n->rb_left;
1468 else if (rc > 0)
1469 n = n->rb_right;
1470 else
1471 break;
1472 }
1473
1474 if (n) {
1475 while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) {
1476 block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1477 n = n->rb_right;
1478 if (n == NULL)
1479 break;
1480 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1481 }
1482 }
1483
1484 spin_unlock(&rgd->rd_rsspin);
1485 return block;
1486}
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1504 const struct gfs2_inode *ip,
1505 u32 minext)
1506{
1507 u64 block = gfs2_rbm_to_block(rbm);
1508 u32 extlen = 1;
1509 u64 nblock;
1510 int ret;
1511
1512
1513
1514
1515
1516 if (minext) {
1517 extlen = gfs2_free_extlen(rbm, minext);
1518 nblock = block + extlen;
1519 if (extlen < minext)
1520 goto fail;
1521 }
1522
1523
1524
1525
1526
1527 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1528 if (nblock == block)
1529 return 0;
1530fail:
1531 ret = gfs2_rbm_from_block(rbm, nblock);
1532 if (ret < 0)
1533 return ret;
1534 return 1;
1535}
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
1554 const struct gfs2_inode *ip, bool nowrap)
1555{
1556 struct buffer_head *bh;
1557 struct gfs2_bitmap *initial_bi;
1558 u32 initial_offset;
1559 u32 offset;
1560 u8 *buffer;
1561 int index;
1562 int n = 0;
1563 int iters = rbm->rgd->rd_length;
1564 int ret;
1565
1566
1567
1568
1569
1570 if (rbm->offset != 0)
1571 iters++;
1572
1573 while(1) {
1574 if (test_bit(GBF_FULL, &rbm->bi->bi_flags) &&
1575 (state == GFS2_BLKST_FREE))
1576 goto next_bitmap;
1577
1578 bh = rbm->bi->bi_bh;
1579 buffer = bh->b_data + rbm->bi->bi_offset;
1580 WARN_ON(!buffer_uptodate(bh));
1581 if (state != GFS2_BLKST_UNLINKED && rbm->bi->bi_clone)
1582 buffer = rbm->bi->bi_clone + rbm->bi->bi_offset;
1583 initial_offset = rbm->offset;
1584 offset = gfs2_bitfit(buffer, rbm->bi->bi_len, rbm->offset, state);
1585 if (offset == BFITNOENT)
1586 goto bitmap_full;
1587 rbm->offset = offset;
1588 if (ip == NULL)
1589 return 0;
1590
1591 initial_bi = rbm->bi;
1592 ret = gfs2_reservation_check_and_update(rbm, ip, minext);
1593 if (ret == 0)
1594 return 0;
1595 if (ret > 0) {
1596 n += (rbm->bi - initial_bi);
1597 goto next_iter;
1598 }
1599 if (ret == -E2BIG) {
1600 index = 0;
1601 rbm->offset = 0;
1602 n += (rbm->bi - initial_bi);
1603 goto res_covered_end_of_rgrp;
1604 }
1605 return ret;
1606
1607bitmap_full:
1608 if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
1609 set_bit(GBF_FULL, &rbm->bi->bi_flags);
1610
1611next_bitmap:
1612 rbm->offset = 0;
1613 index = rbm->bi - rbm->rgd->rd_bits;
1614 index++;
1615 if (index == rbm->rgd->rd_length)
1616 index = 0;
1617res_covered_end_of_rgrp:
1618 rbm->bi = &rbm->rgd->rd_bits[index];
1619 if ((index == 0) && nowrap)
1620 break;
1621 n++;
1622next_iter:
1623 if (n >= iters)
1624 break;
1625 }
1626
1627 return -ENOSPC;
1628}
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1641{
1642 u64 block;
1643 struct gfs2_sbd *sdp = rgd->rd_sbd;
1644 struct gfs2_glock *gl;
1645 struct gfs2_inode *ip;
1646 int error;
1647 int found = 0;
1648 struct gfs2_rbm rbm = { .rgd = rgd, .bi = rgd->rd_bits, .offset = 0 };
1649
1650 while (1) {
1651 down_write(&sdp->sd_log_flush_lock);
1652 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, 0, NULL, true);
1653 up_write(&sdp->sd_log_flush_lock);
1654 if (error == -ENOSPC)
1655 break;
1656 if (WARN_ON_ONCE(error))
1657 break;
1658
1659 block = gfs2_rbm_to_block(&rbm);
1660 if (gfs2_rbm_from_block(&rbm, block + 1))
1661 break;
1662 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1663 continue;
1664 if (block == skip)
1665 continue;
1666 *last_unlinked = block;
1667
1668 error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl);
1669 if (error)
1670 continue;
1671
1672
1673
1674
1675
1676
1677
1678
1679 ip = gl->gl_object;
1680
1681 if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
1682 gfs2_glock_put(gl);
1683 else
1684 found++;
1685
1686
1687 if (found > NR_CPUS)
1688 return;
1689 }
1690
1691 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1692 return;
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
1720
1721
1722static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1723{
1724 const struct gfs2_glock *gl = rgd->rd_gl;
1725 const struct gfs2_sbd *sdp = gl->gl_sbd;
1726 struct gfs2_lkstats *st;
1727 s64 r_dcount, l_dcount;
1728 s64 r_srttb, l_srttb;
1729 s64 srttb_diff;
1730 s64 sqr_diff;
1731 s64 var;
1732
1733 preempt_disable();
1734 st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
1735 r_srttb = st->stats[GFS2_LKS_SRTTB];
1736 r_dcount = st->stats[GFS2_LKS_DCOUNT];
1737 var = st->stats[GFS2_LKS_SRTTVARB] +
1738 gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1739 preempt_enable();
1740
1741 l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1742 l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1743
1744 if ((l_dcount < 1) || (r_dcount < 1) || (r_srttb == 0))
1745 return false;
1746
1747 srttb_diff = r_srttb - l_srttb;
1748 sqr_diff = srttb_diff * srttb_diff;
1749
1750 var *= 2;
1751 if (l_dcount < 8 || r_dcount < 8)
1752 var *= 2;
1753 if (loops == 1)
1754 var *= 2;
1755
1756 return ((srttb_diff < 0) && (sqr_diff > var));
1757}
1758
1759
1760
1761
1762
1763
1764
1765
1766static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1767 u64 msecs)
1768{
1769 u64 tdiff;
1770
1771 tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
1772 rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1773
1774 return tdiff > (msecs * 1000 * 1000);
1775}
1776
1777static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1778{
1779 const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1780 u32 skip;
1781
1782 get_random_bytes(&skip, sizeof(skip));
1783 return skip % sdp->sd_rgrps;
1784}
1785
1786static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1787{
1788 struct gfs2_rgrpd *rgd = *pos;
1789 struct gfs2_sbd *sdp = rgd->rd_sbd;
1790
1791 rgd = gfs2_rgrpd_get_next(rgd);
1792 if (rgd == NULL)
1793 rgd = gfs2_rgrpd_get_first(sdp);
1794 *pos = rgd;
1795 if (rgd != begin)
1796 return true;
1797 return false;
1798}
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested, u32 aflags)
1809{
1810 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1811 struct gfs2_rgrpd *begin = NULL;
1812 struct gfs2_blkreserv *rs = ip->i_res;
1813 int error = 0, rg_locked, flags = 0;
1814 u64 last_unlinked = NO_BLOCK;
1815 int loops = 0;
1816 u32 skip = 0;
1817
1818 if (sdp->sd_args.ar_rgrplvb)
1819 flags |= GL_SKIP;
1820 if (gfs2_assert_warn(sdp, requested))
1821 return -EINVAL;
1822 if (gfs2_rs_active(rs)) {
1823 begin = rs->rs_rbm.rgd;
1824 flags = 0;
1825 } else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
1826 rs->rs_rbm.rgd = begin = ip->i_rgd;
1827 } else {
1828 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
1829 }
1830 if (S_ISDIR(ip->i_inode.i_mode) && (aflags & GFS2_AF_ORLOV))
1831 skip = gfs2_orlov_skip(ip);
1832 if (rs->rs_rbm.rgd == NULL)
1833 return -EBADSLT;
1834
1835 while (loops < 3) {
1836 rg_locked = 1;
1837
1838 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
1839 rg_locked = 0;
1840 if (skip && skip--)
1841 goto next_rgrp;
1842 if (!gfs2_rs_active(rs) && (loops < 2) &&
1843 gfs2_rgrp_used_recently(rs, 1000) &&
1844 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1845 goto next_rgrp;
1846 error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
1847 LM_ST_EXCLUSIVE, flags,
1848 &rs->rs_rgd_gh);
1849 if (unlikely(error))
1850 return error;
1851 if (!gfs2_rs_active(rs) && (loops < 2) &&
1852 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1853 goto skip_rgrp;
1854 if (sdp->sd_args.ar_rgrplvb) {
1855 error = update_rgrp_lvb(rs->rs_rbm.rgd);
1856 if (unlikely(error)) {
1857 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1858 return error;
1859 }
1860 }
1861 }
1862
1863
1864 if (rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
1865 goto skip_rgrp;
1866
1867 if (sdp->sd_args.ar_rgrplvb)
1868 gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
1869
1870
1871 if (!gfs2_rs_active(rs))
1872 rg_mblk_search(rs->rs_rbm.rgd, ip, requested);
1873
1874
1875 if (!gfs2_rs_active(rs) && (loops < 1))
1876 goto check_rgrp;
1877
1878
1879 if (rs->rs_rbm.rgd->rd_free_clone >= requested) {
1880 ip->i_rgd = rs->rs_rbm.rgd;
1881 return 0;
1882 }
1883
1884
1885 if (gfs2_rs_active(rs))
1886 gfs2_rs_deltree(rs);
1887check_rgrp:
1888
1889 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
1890 try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
1891 ip->i_no_addr);
1892skip_rgrp:
1893
1894 if (!rg_locked)
1895 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1896next_rgrp:
1897
1898 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
1899 continue;
1900 if (skip)
1901 continue;
1902
1903
1904
1905
1906
1907 loops++;
1908
1909 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
1910 error = gfs2_ri_update(ip);
1911 if (error)
1912 return error;
1913 }
1914
1915 if (loops == 2)
1916 gfs2_log_flush(sdp, NULL);
1917 }
1918
1919 return -ENOSPC;
1920}
1921
1922
1923
1924
1925
1926
1927
1928
1929void gfs2_inplace_release(struct gfs2_inode *ip)
1930{
1931 struct gfs2_blkreserv *rs = ip->i_res;
1932
1933 if (rs->rs_rgd_gh.gh_gl)
1934 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1935}
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
1946{
1947 struct gfs2_rbm rbm = { .rgd = rgd, };
1948 int ret;
1949
1950 ret = gfs2_rbm_from_block(&rbm, block);
1951 WARN_ON_ONCE(ret != 0);
1952
1953 return gfs2_testbit(&rbm);
1954}
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
1967 unsigned int *n)
1968{
1969 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
1970 const unsigned int elen = *n;
1971 u64 block;
1972 int ret;
1973
1974 *n = 1;
1975 block = gfs2_rbm_to_block(rbm);
1976 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm->bi->bi_bh);
1977 gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1978 block++;
1979 while (*n < elen) {
1980 ret = gfs2_rbm_from_block(&pos, block);
1981 if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
1982 break;
1983 gfs2_trans_add_meta(pos.rgd->rd_gl, pos.bi->bi_bh);
1984 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
1985 (*n)++;
1986 block++;
1987 }
1988}
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
2001 u32 blen, unsigned char new_state)
2002{
2003 struct gfs2_rbm rbm;
2004
2005 rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
2006 if (!rbm.rgd) {
2007 if (gfs2_consist(sdp))
2008 fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
2009 return NULL;
2010 }
2011
2012 while (blen--) {
2013 gfs2_rbm_from_block(&rbm, bstart);
2014 bstart++;
2015 if (!rbm.bi->bi_clone) {
2016 rbm.bi->bi_clone = kmalloc(rbm.bi->bi_bh->b_size,
2017 GFP_NOFS | __GFP_NOFAIL);
2018 memcpy(rbm.bi->bi_clone + rbm.bi->bi_offset,
2019 rbm.bi->bi_bh->b_data + rbm.bi->bi_offset,
2020 rbm.bi->bi_len);
2021 }
2022 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.bi->bi_bh);
2023 gfs2_setbit(&rbm, false, new_state);
2024 }
2025
2026 return rbm.rgd;
2027}
2028
2029
2030
2031
2032
2033
2034
2035
2036int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
2037{
2038 struct gfs2_rgrpd *rgd = gl->gl_object;
2039 struct gfs2_blkreserv *trs;
2040 const struct rb_node *n;
2041
2042 if (rgd == NULL)
2043 return 0;
2044 gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
2045 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2046 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2047 rgd->rd_reserved);
2048 spin_lock(&rgd->rd_rsspin);
2049 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2050 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
2051 dump_rs(seq, trs);
2052 }
2053 spin_unlock(&rgd->rd_rsspin);
2054 return 0;
2055}
2056
2057static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2058{
2059 struct gfs2_sbd *sdp = rgd->rd_sbd;
2060 fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
2061 (unsigned long long)rgd->rd_addr);
2062 fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2063 gfs2_rgrp_dump(NULL, rgd->rd_gl);
2064 rgd->rd_flags |= GFS2_RDF_ERROR;
2065}
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2079 const struct gfs2_rbm *rbm, unsigned len)
2080{
2081 struct gfs2_blkreserv *rs = ip->i_res;
2082 struct gfs2_rgrpd *rgd = rbm->rgd;
2083 unsigned rlen;
2084 u64 block;
2085 int ret;
2086
2087 spin_lock(&rgd->rd_rsspin);
2088 if (gfs2_rs_active(rs)) {
2089 if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
2090 block = gfs2_rbm_to_block(rbm);
2091 ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
2092 rlen = min(rs->rs_free, len);
2093 rs->rs_free -= rlen;
2094 rgd->rd_reserved -= rlen;
2095 trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2096 if (rs->rs_free && !ret)
2097 goto out;
2098 }
2099 __rs_deltree(rs);
2100 }
2101out:
2102 spin_unlock(&rgd->rd_rsspin);
2103}
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2117 bool dinode, u64 *generation)
2118{
2119 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2120 struct buffer_head *dibh;
2121 struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2122 unsigned int ndata;
2123 u64 goal;
2124 u64 block;
2125 int error;
2126
2127 if (gfs2_rs_active(ip->i_res))
2128 goal = gfs2_rbm_to_block(&ip->i_res->rs_rbm);
2129 else if (!dinode && rgrp_contains_block(rbm.rgd, ip->i_goal))
2130 goal = ip->i_goal;
2131 else
2132 goal = rbm.rgd->rd_last_alloc + rbm.rgd->rd_data0;
2133
2134 gfs2_rbm_from_block(&rbm, goal);
2135 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, ip, false);
2136
2137 if (error == -ENOSPC) {
2138 gfs2_rbm_from_block(&rbm, goal);
2139 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, NULL, false);
2140 }
2141
2142
2143 if (error) {
2144 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d\n",
2145 (unsigned long long)ip->i_no_addr, error, *nblocks,
2146 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags));
2147 goto rgrp_error;
2148 }
2149
2150 gfs2_alloc_extent(&rbm, dinode, nblocks);
2151 block = gfs2_rbm_to_block(&rbm);
2152 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2153 if (gfs2_rs_active(ip->i_res))
2154 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2155 ndata = *nblocks;
2156 if (dinode)
2157 ndata--;
2158
2159 if (!dinode) {
2160 ip->i_goal = block + ndata - 1;
2161 error = gfs2_meta_inode_buffer(ip, &dibh);
2162 if (error == 0) {
2163 struct gfs2_dinode *di =
2164 (struct gfs2_dinode *)dibh->b_data;
2165 gfs2_trans_add_meta(ip->i_gl, dibh);
2166 di->di_goal_meta = di->di_goal_data =
2167 cpu_to_be64(ip->i_goal);
2168 brelse(dibh);
2169 }
2170 }
2171 if (rbm.rgd->rd_free < *nblocks) {
2172 printk(KERN_WARNING "nblocks=%u\n", *nblocks);
2173 goto rgrp_error;
2174 }
2175
2176 rbm.rgd->rd_free -= *nblocks;
2177 if (dinode) {
2178 rbm.rgd->rd_dinodes++;
2179 *generation = rbm.rgd->rd_igeneration++;
2180 if (*generation == 0)
2181 *generation = rbm.rgd->rd_igeneration++;
2182 }
2183
2184 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2185 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2186 gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
2187
2188 gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2189 if (dinode)
2190 gfs2_trans_add_unrevoke(sdp, block, 1);
2191
2192 gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
2193
2194 rbm.rgd->rd_free_clone -= *nblocks;
2195 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2196 dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2197 *bn = block;
2198 return 0;
2199
2200rgrp_error:
2201 gfs2_rgrp_error(rbm.rgd);
2202 return -EIO;
2203}
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
2215{
2216 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2217 struct gfs2_rgrpd *rgd;
2218
2219 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
2220 if (!rgd)
2221 return;
2222 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2223 rgd->rd_free += blen;
2224 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2225 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2226 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2227 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2228
2229
2230 if (meta || ip->i_depth)
2231 gfs2_meta_wipe(ip, bstart, blen);
2232}
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
2243{
2244 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2245
2246 __gfs2_free_blocks(ip, bstart, blen, 1);
2247 gfs2_statfs_change(sdp, 0, +blen, 0);
2248 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
2249}
2250
2251void gfs2_unlink_di(struct inode *inode)
2252{
2253 struct gfs2_inode *ip = GFS2_I(inode);
2254 struct gfs2_sbd *sdp = GFS2_SB(inode);
2255 struct gfs2_rgrpd *rgd;
2256 u64 blkno = ip->i_no_addr;
2257
2258 rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
2259 if (!rgd)
2260 return;
2261 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2262 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2263 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2264 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2265 update_rgrp_lvb_unlinked(rgd, 1);
2266}
2267
2268static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
2269{
2270 struct gfs2_sbd *sdp = rgd->rd_sbd;
2271 struct gfs2_rgrpd *tmp_rgd;
2272
2273 tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
2274 if (!tmp_rgd)
2275 return;
2276 gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
2277
2278 if (!rgd->rd_dinodes)
2279 gfs2_consist_rgrpd(rgd);
2280 rgd->rd_dinodes--;
2281 rgd->rd_free++;
2282
2283 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2284 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2285 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2286 update_rgrp_lvb_unlinked(rgd, -1);
2287
2288 gfs2_statfs_change(sdp, 0, +1, -1);
2289}
2290
2291
2292void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2293{
2294 gfs2_free_uninit_di(rgd, ip->i_no_addr);
2295 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2296 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2297 gfs2_meta_wipe(ip, ip->i_no_addr, 1);
2298}
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2312{
2313 struct gfs2_rgrpd *rgd;
2314 struct gfs2_holder rgd_gh;
2315 int error = -EINVAL;
2316
2317 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2318 if (!rgd)
2319 goto fail;
2320
2321 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2322 if (error)
2323 goto fail;
2324
2325 if (gfs2_get_block_type(rgd, no_addr) != type)
2326 error = -ESTALE;
2327
2328 gfs2_glock_dq_uninit(&rgd_gh);
2329fail:
2330 return error;
2331}
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2346 u64 block)
2347{
2348 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2349 struct gfs2_rgrpd *rgd;
2350 struct gfs2_rgrpd **tmp;
2351 unsigned int new_space;
2352 unsigned int x;
2353
2354 if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2355 return;
2356
2357 if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
2358 rgd = ip->i_rgd;
2359 else
2360 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2361 if (!rgd) {
2362 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
2363 return;
2364 }
2365 ip->i_rgd = rgd;
2366
2367 for (x = 0; x < rlist->rl_rgrps; x++)
2368 if (rlist->rl_rgd[x] == rgd)
2369 return;
2370
2371 if (rlist->rl_rgrps == rlist->rl_space) {
2372 new_space = rlist->rl_space + 10;
2373
2374 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
2375 GFP_NOFS | __GFP_NOFAIL);
2376
2377 if (rlist->rl_rgd) {
2378 memcpy(tmp, rlist->rl_rgd,
2379 rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2380 kfree(rlist->rl_rgd);
2381 }
2382
2383 rlist->rl_space = new_space;
2384 rlist->rl_rgd = tmp;
2385 }
2386
2387 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2388}
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
2401{
2402 unsigned int x;
2403
2404 rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
2405 GFP_NOFS | __GFP_NOFAIL);
2406 for (x = 0; x < rlist->rl_rgrps; x++)
2407 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2408 state, 0,
2409 &rlist->rl_ghs[x]);
2410}
2411
2412
2413
2414
2415
2416
2417
2418void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2419{
2420 unsigned int x;
2421
2422 kfree(rlist->rl_rgd);
2423
2424 if (rlist->rl_ghs) {
2425 for (x = 0; x < rlist->rl_rgrps; x++)
2426 gfs2_holder_uninit(&rlist->rl_ghs[x]);
2427 kfree(rlist->rl_ghs);
2428 rlist->rl_ghs = NULL;
2429 }
2430}
2431
2432