1
2
3
4
5
6
7
8
9
10#include <linux/spinlock.h>
11#include <linux/completion.h>
12#include <linux/buffer_head.h>
13#include <linux/gfs2_ondisk.h>
14#include <linux/crc32.h>
15
16#include "gfs2.h"
17#include "incore.h"
18#include "bmap.h"
19#include "glock.h"
20#include "inode.h"
21#include "meta_io.h"
22#include "quota.h"
23#include "rgrp.h"
24#include "trans.h"
25#include "dir.h"
26#include "util.h"
27#include "trace_gfs2.h"
28
29
30
31
32
33struct metapath {
34 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
35 __u16 mp_list[GFS2_MAX_META_HEIGHT];
36};
37
38typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh,
39 struct buffer_head *bh, __be64 *top,
40 __be64 *bottom, unsigned int height,
41 void *data);
42
43struct strip_mine {
44 int sm_first;
45 unsigned int sm_height;
46};
47
48
49
50
51
52
53
54
55
56
57
58static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
59 u64 block, struct page *page)
60{
61 struct inode *inode = &ip->i_inode;
62 struct buffer_head *bh;
63 int release = 0;
64
65 if (!page || page->index) {
66 page = grab_cache_page(inode->i_mapping, 0);
67 if (!page)
68 return -ENOMEM;
69 release = 1;
70 }
71
72 if (!PageUptodate(page)) {
73 void *kaddr = kmap(page);
74 u64 dsize = i_size_read(inode);
75
76 if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
77 dsize = dibh->b_size - sizeof(struct gfs2_dinode);
78
79 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
80 memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
81 kunmap(page);
82
83 SetPageUptodate(page);
84 }
85
86 if (!page_has_buffers(page))
87 create_empty_buffers(page, 1 << inode->i_blkbits,
88 (1 << BH_Uptodate));
89
90 bh = page_buffers(page);
91
92 if (!buffer_mapped(bh))
93 map_bh(bh, inode->i_sb, block);
94
95 set_buffer_uptodate(bh);
96 if (!gfs2_is_jdata(ip))
97 mark_buffer_dirty(bh);
98 if (!gfs2_is_writeback(ip))
99 gfs2_trans_add_bh(ip->i_gl, bh, 0);
100
101 if (release) {
102 unlock_page(page);
103 page_cache_release(page);
104 }
105
106 return 0;
107}
108
109
110
111
112
113
114
115
116
117
118
119
120int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
121{
122 struct buffer_head *bh, *dibh;
123 struct gfs2_dinode *di;
124 u64 block = 0;
125 int isdir = gfs2_is_dir(ip);
126 int error;
127
128 down_write(&ip->i_rw_mutex);
129
130 error = gfs2_meta_inode_buffer(ip, &dibh);
131 if (error)
132 goto out;
133
134 if (i_size_read(&ip->i_inode)) {
135
136
137
138 unsigned int n = 1;
139 error = gfs2_alloc_block(ip, &block, &n);
140 if (error)
141 goto out_brelse;
142 if (isdir) {
143 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
144 error = gfs2_dir_get_new_buffer(ip, block, &bh);
145 if (error)
146 goto out_brelse;
147 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
148 dibh, sizeof(struct gfs2_dinode));
149 brelse(bh);
150 } else {
151 error = gfs2_unstuffer_page(ip, dibh, block, page);
152 if (error)
153 goto out_brelse;
154 }
155 }
156
157
158
159 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
160 di = (struct gfs2_dinode *)dibh->b_data;
161 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
162
163 if (i_size_read(&ip->i_inode)) {
164 *(__be64 *)(di + 1) = cpu_to_be64(block);
165 gfs2_add_inode_blocks(&ip->i_inode, 1);
166 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
167 }
168
169 ip->i_height = 1;
170 di->di_height = cpu_to_be16(1);
171
172out_brelse:
173 brelse(dibh);
174out:
175 up_write(&ip->i_rw_mutex);
176 return error;
177}
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
241 struct metapath *mp, unsigned int height)
242{
243 unsigned int i;
244
245 for (i = height; i--;)
246 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
247
248}
249
250static inline unsigned int metapath_branch_start(const struct metapath *mp)
251{
252 if (mp->mp_list[0] == 0)
253 return 2;
254 return 1;
255}
256
257
258
259
260
261
262
263
264
265
266
267static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
268{
269 struct buffer_head *bh = mp->mp_bh[height];
270 unsigned int head_size = (height > 0) ?
271 sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
272 return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];
273}
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
293{
294 unsigned int end_of_metadata = ip->i_height - 1;
295 unsigned int x;
296 __be64 *ptr;
297 u64 dblock;
298 int ret;
299
300 for (x = 0; x < end_of_metadata; x++) {
301 ptr = metapointer(x, mp);
302 dblock = be64_to_cpu(*ptr);
303 if (!dblock)
304 return x + 1;
305
306 ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, 0, &mp->mp_bh[x+1]);
307 if (ret)
308 return ret;
309 }
310
311 return ip->i_height;
312}
313
314static inline void release_metapath(struct metapath *mp)
315{
316 int i;
317
318 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
319 if (mp->mp_bh[i] == NULL)
320 break;
321 brelse(mp->mp_bh[i]);
322 }
323}
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, unsigned limit, int *eob)
341{
342 const __be64 *end = (start + len);
343 const __be64 *first = ptr;
344 u64 d = be64_to_cpu(*ptr);
345
346 *eob = 0;
347 do {
348 ptr++;
349 if (ptr >= end)
350 break;
351 if (limit && --limit == 0)
352 break;
353 if (d)
354 d++;
355 } while(be64_to_cpu(*ptr) == d);
356 if (ptr >= end)
357 *eob = 1;
358 return (ptr - first);
359}
360
361static inline void bmap_lock(struct gfs2_inode *ip, int create)
362{
363 if (create)
364 down_write(&ip->i_rw_mutex);
365 else
366 down_read(&ip->i_rw_mutex);
367}
368
369static inline void bmap_unlock(struct gfs2_inode *ip, int create)
370{
371 if (create)
372 up_write(&ip->i_rw_mutex);
373 else
374 up_read(&ip->i_rw_mutex);
375}
376
377static inline __be64 *gfs2_indirect_init(struct metapath *mp,
378 struct gfs2_glock *gl, unsigned int i,
379 unsigned offset, u64 bn)
380{
381 __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
382 ((i > 1) ? sizeof(struct gfs2_meta_header) :
383 sizeof(struct gfs2_dinode)));
384 BUG_ON(i < 1);
385 BUG_ON(mp->mp_bh[i] != NULL);
386 mp->mp_bh[i] = gfs2_meta_new(gl, bn);
387 gfs2_trans_add_bh(gl, mp->mp_bh[i], 1);
388 gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
389 gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
390 ptr += offset;
391 *ptr = cpu_to_be64(bn);
392 return ptr;
393}
394
395enum alloc_state {
396 ALLOC_DATA = 0,
397 ALLOC_GROW_DEPTH = 1,
398 ALLOC_GROW_HEIGHT = 2,
399
400};
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
427 struct buffer_head *bh_map, struct metapath *mp,
428 const unsigned int sheight,
429 const unsigned int height,
430 const unsigned int maxlen)
431{
432 struct gfs2_inode *ip = GFS2_I(inode);
433 struct gfs2_sbd *sdp = GFS2_SB(inode);
434 struct buffer_head *dibh = mp->mp_bh[0];
435 u64 bn, dblock = 0;
436 unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
437 unsigned dblks = 0;
438 unsigned ptrs_per_blk;
439 const unsigned end_of_metadata = height - 1;
440 int eob = 0;
441 enum alloc_state state;
442 __be64 *ptr;
443 __be64 zero_bn = 0;
444
445 BUG_ON(sheight < 1);
446 BUG_ON(dibh == NULL);
447
448 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
449
450 if (height == sheight) {
451 struct buffer_head *bh;
452
453 ptr = metapointer(end_of_metadata, mp);
454 bh = mp->mp_bh[end_of_metadata];
455 dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,
456 &eob);
457 BUG_ON(dblks < 1);
458 state = ALLOC_DATA;
459 } else {
460
461 ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;
462 dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]);
463 if (height == ip->i_height) {
464
465 iblks = height - sheight;
466 state = ALLOC_GROW_DEPTH;
467 } else {
468
469 state = ALLOC_GROW_HEIGHT;
470 iblks = height - ip->i_height;
471 branch_start = metapath_branch_start(mp);
472 iblks += (height - branch_start);
473 }
474 }
475
476
477
478 blks = dblks + iblks;
479 i = sheight;
480 do {
481 int error;
482 n = blks - alloced;
483 error = gfs2_alloc_block(ip, &bn, &n);
484 if (error)
485 return error;
486 alloced += n;
487 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
488 gfs2_trans_add_unrevoke(sdp, bn, n);
489 switch (state) {
490
491 case ALLOC_GROW_HEIGHT:
492 if (i == 1) {
493 ptr = (__be64 *)(dibh->b_data +
494 sizeof(struct gfs2_dinode));
495 zero_bn = *ptr;
496 }
497 for (; i - 1 < height - ip->i_height && n > 0; i++, n--)
498 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
499 if (i - 1 == height - ip->i_height) {
500 i--;
501 gfs2_buffer_copy_tail(mp->mp_bh[i],
502 sizeof(struct gfs2_meta_header),
503 dibh, sizeof(struct gfs2_dinode));
504 gfs2_buffer_clear_tail(dibh,
505 sizeof(struct gfs2_dinode) +
506 sizeof(__be64));
507 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
508 sizeof(struct gfs2_meta_header));
509 *ptr = zero_bn;
510 state = ALLOC_GROW_DEPTH;
511 for(i = branch_start; i < height; i++) {
512 if (mp->mp_bh[i] == NULL)
513 break;
514 brelse(mp->mp_bh[i]);
515 mp->mp_bh[i] = NULL;
516 }
517 i = branch_start;
518 }
519 if (n == 0)
520 break;
521
522 case ALLOC_GROW_DEPTH:
523 if (i > 1 && i < height)
524 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);
525 for (; i < height && n > 0; i++, n--)
526 gfs2_indirect_init(mp, ip->i_gl, i,
527 mp->mp_list[i-1], bn++);
528 if (i == height)
529 state = ALLOC_DATA;
530 if (n == 0)
531 break;
532
533 case ALLOC_DATA:
534 BUG_ON(n > dblks);
535 BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
536 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1);
537 dblks = n;
538 ptr = metapointer(end_of_metadata, mp);
539 dblock = bn;
540 while (n-- > 0)
541 *ptr++ = cpu_to_be64(bn++);
542 break;
543 }
544 } while ((state != ALLOC_DATA) || !dblock);
545
546 ip->i_height = height;
547 gfs2_add_inode_blocks(&ip->i_inode, alloced);
548 gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
549 map_bh(bh_map, inode->i_sb, dblock);
550 bh_map->b_size = dblks << inode->i_blkbits;
551 set_buffer_new(bh_map);
552 return 0;
553}
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569int gfs2_block_map(struct inode *inode, sector_t lblock,
570 struct buffer_head *bh_map, int create)
571{
572 struct gfs2_inode *ip = GFS2_I(inode);
573 struct gfs2_sbd *sdp = GFS2_SB(inode);
574 unsigned int bsize = sdp->sd_sb.sb_bsize;
575 const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;
576 const u64 *arr = sdp->sd_heightsize;
577 __be64 *ptr;
578 u64 size;
579 struct metapath mp;
580 int ret;
581 int eob;
582 unsigned int len;
583 struct buffer_head *bh;
584 u8 height;
585
586 BUG_ON(maxlen == 0);
587
588 memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
589 bmap_lock(ip, create);
590 clear_buffer_mapped(bh_map);
591 clear_buffer_new(bh_map);
592 clear_buffer_boundary(bh_map);
593 trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
594 if (gfs2_is_dir(ip)) {
595 bsize = sdp->sd_jbsize;
596 arr = sdp->sd_jheightsize;
597 }
598
599 ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
600 if (ret)
601 goto out;
602
603 height = ip->i_height;
604 size = (lblock + 1) * bsize;
605 while (size > arr[height])
606 height++;
607 find_metapath(sdp, lblock, &mp, height);
608 ret = 1;
609 if (height > ip->i_height || gfs2_is_stuffed(ip))
610 goto do_alloc;
611 ret = lookup_metapath(ip, &mp);
612 if (ret < 0)
613 goto out;
614 if (ret != ip->i_height)
615 goto do_alloc;
616 ptr = metapointer(ip->i_height - 1, &mp);
617 if (*ptr == 0)
618 goto do_alloc;
619 map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));
620 bh = mp.mp_bh[ip->i_height - 1];
621 len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);
622 bh_map->b_size = (len << inode->i_blkbits);
623 if (eob)
624 set_buffer_boundary(bh_map);
625 ret = 0;
626out:
627 release_metapath(&mp);
628 trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
629 bmap_unlock(ip, create);
630 return ret;
631
632do_alloc:
633
634 if (!create) {
635 BUG_ON(gfs2_is_stuffed(ip));
636 ret = 0;
637 goto out;
638 }
639
640
641 ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);
642 goto out;
643}
644
645
646
647
648int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
649{
650 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
651 int ret;
652 int create = *new;
653
654 BUG_ON(!extlen);
655 BUG_ON(!dblock);
656 BUG_ON(!new);
657
658 bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5));
659 ret = gfs2_block_map(inode, lblock, &bh, create);
660 *extlen = bh.b_size >> inode->i_blkbits;
661 *dblock = bh.b_blocknr;
662 if (buffer_new(&bh))
663 *new = 1;
664 else
665 *new = 0;
666 return ret;
667}
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,
687 struct metapath *mp, unsigned int height,
688 u64 block, int first, block_call_t bc,
689 void *data)
690{
691 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
692 struct buffer_head *bh = NULL;
693 __be64 *top, *bottom;
694 u64 bn;
695 int error;
696 int mh_size = sizeof(struct gfs2_meta_header);
697
698 if (!height) {
699 error = gfs2_meta_inode_buffer(ip, &bh);
700 if (error)
701 return error;
702 dibh = bh;
703
704 top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
705 bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
706 } else {
707 error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh);
708 if (error)
709 return error;
710
711 top = (__be64 *)(bh->b_data + mh_size) +
712 (first ? mp->mp_list[height] : 0);
713
714 bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;
715 }
716
717 error = bc(ip, dibh, bh, top, bottom, height, data);
718 if (error)
719 goto out;
720
721 if (height < ip->i_height - 1)
722 for (; top < bottom; top++, first = 0) {
723 if (!*top)
724 continue;
725
726 bn = be64_to_cpu(*top);
727
728 error = recursive_scan(ip, dibh, mp, height + 1, bn,
729 first, bc, data);
730 if (error)
731 break;
732 }
733
734out:
735 brelse(bh);
736 return error;
737}
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
753 struct buffer_head *bh, __be64 *top, __be64 *bottom,
754 unsigned int height, void *data)
755{
756 struct strip_mine *sm = data;
757 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
758 struct gfs2_rgrp_list rlist;
759 u64 bn, bstart;
760 u32 blen;
761 __be64 *p;
762 unsigned int rg_blocks = 0;
763 int metadata;
764 unsigned int revokes = 0;
765 int x;
766 int error = 0;
767
768 if (!*top)
769 sm->sm_first = 0;
770
771 if (height != sm->sm_height)
772 return 0;
773
774 if (sm->sm_first) {
775 top++;
776 sm->sm_first = 0;
777 }
778
779 metadata = (height != ip->i_height - 1);
780 if (metadata)
781 revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;
782
783 if (ip != GFS2_I(sdp->sd_rindex))
784 error = gfs2_rindex_hold(sdp, &ip->i_alloc->al_ri_gh);
785 else if (!sdp->sd_rgrps)
786 error = gfs2_ri_update(ip);
787
788 if (error)
789 return error;
790
791 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
792 bstart = 0;
793 blen = 0;
794
795 for (p = top; p < bottom; p++) {
796 if (!*p)
797 continue;
798
799 bn = be64_to_cpu(*p);
800
801 if (bstart + blen == bn)
802 blen++;
803 else {
804 if (bstart)
805 gfs2_rlist_add(sdp, &rlist, bstart);
806
807 bstart = bn;
808 blen = 1;
809 }
810 }
811
812 if (bstart)
813 gfs2_rlist_add(sdp, &rlist, bstart);
814 else
815 goto out;
816
817 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
818
819 for (x = 0; x < rlist.rl_rgrps; x++) {
820 struct gfs2_rgrpd *rgd;
821 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
822 rg_blocks += rgd->rd_length;
823 }
824
825 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
826 if (error)
827 goto out_rlist;
828
829 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
830 RES_INDIRECT + RES_STATFS + RES_QUOTA,
831 revokes);
832 if (error)
833 goto out_rg_gunlock;
834
835 down_write(&ip->i_rw_mutex);
836
837 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
838 gfs2_trans_add_bh(ip->i_gl, bh, 1);
839
840 bstart = 0;
841 blen = 0;
842
843 for (p = top; p < bottom; p++) {
844 if (!*p)
845 continue;
846
847 bn = be64_to_cpu(*p);
848
849 if (bstart + blen == bn)
850 blen++;
851 else {
852 if (bstart) {
853 if (metadata)
854 gfs2_free_meta(ip, bstart, blen);
855 else
856 gfs2_free_data(ip, bstart, blen);
857 }
858
859 bstart = bn;
860 blen = 1;
861 }
862
863 *p = 0;
864 gfs2_add_inode_blocks(&ip->i_inode, -1);
865 }
866 if (bstart) {
867 if (metadata)
868 gfs2_free_meta(ip, bstart, blen);
869 else
870 gfs2_free_data(ip, bstart, blen);
871 }
872
873 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
874
875 gfs2_dinode_out(ip, dibh->b_data);
876
877 up_write(&ip->i_rw_mutex);
878
879 gfs2_trans_end(sdp);
880
881out_rg_gunlock:
882 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
883out_rlist:
884 gfs2_rlist_free(&rlist);
885out:
886 if (ip != GFS2_I(sdp->sd_rindex))
887 gfs2_glock_dq_uninit(&ip->i_alloc->al_ri_gh);
888 return error;
889}
890
891
892
893
894
895
896static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)
897{
898 struct inode *inode = mapping->host;
899 struct gfs2_inode *ip = GFS2_I(inode);
900 unsigned long index = from >> PAGE_CACHE_SHIFT;
901 unsigned offset = from & (PAGE_CACHE_SIZE-1);
902 unsigned blocksize, iblock, length, pos;
903 struct buffer_head *bh;
904 struct page *page;
905 int err;
906
907 page = grab_cache_page(mapping, index);
908 if (!page)
909 return 0;
910
911 blocksize = inode->i_sb->s_blocksize;
912 length = blocksize - (offset & (blocksize - 1));
913 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
914
915 if (!page_has_buffers(page))
916 create_empty_buffers(page, blocksize, 0);
917
918
919 bh = page_buffers(page);
920 pos = blocksize;
921 while (offset >= pos) {
922 bh = bh->b_this_page;
923 iblock++;
924 pos += blocksize;
925 }
926
927 err = 0;
928
929 if (!buffer_mapped(bh)) {
930 gfs2_block_map(inode, iblock, bh, 0);
931
932 if (!buffer_mapped(bh))
933 goto unlock;
934 }
935
936
937 if (PageUptodate(page))
938 set_buffer_uptodate(bh);
939
940 if (!buffer_uptodate(bh)) {
941 err = -EIO;
942 ll_rw_block(READ, 1, &bh);
943 wait_on_buffer(bh);
944
945 if (!buffer_uptodate(bh))
946 goto unlock;
947 err = 0;
948 }
949
950 if (!gfs2_is_writeback(ip))
951 gfs2_trans_add_bh(ip->i_gl, bh, 0);
952
953 zero_user(page, offset, length);
954 mark_buffer_dirty(bh);
955unlock:
956 unlock_page(page);
957 page_cache_release(page);
958 return err;
959}
960
961static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
962{
963 struct gfs2_inode *ip = GFS2_I(inode);
964 struct gfs2_sbd *sdp = GFS2_SB(inode);
965 struct address_space *mapping = inode->i_mapping;
966 struct buffer_head *dibh;
967 int journaled = gfs2_is_jdata(ip);
968 int error;
969
970 error = gfs2_trans_begin(sdp,
971 RES_DINODE + (journaled ? RES_JDATA : 0), 0);
972 if (error)
973 return error;
974
975 error = gfs2_meta_inode_buffer(ip, &dibh);
976 if (error)
977 goto out;
978
979 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
980
981 if (gfs2_is_stuffed(ip)) {
982 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
983 } else {
984 if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {
985 error = gfs2_block_truncate_page(mapping, newsize);
986 if (error)
987 goto out_brelse;
988 }
989 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
990 }
991
992 i_size_write(inode, newsize);
993 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
994 gfs2_dinode_out(ip, dibh->b_data);
995
996 truncate_pagecache(inode, oldsize, newsize);
997out_brelse:
998 brelse(dibh);
999out:
1000 gfs2_trans_end(sdp);
1001 return error;
1002}
1003
1004static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
1005{
1006 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1007 unsigned int height = ip->i_height;
1008 u64 lblock;
1009 struct metapath mp;
1010 int error;
1011
1012 if (!size)
1013 lblock = 0;
1014 else
1015 lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;
1016
1017 find_metapath(sdp, lblock, &mp, ip->i_height);
1018 if (!gfs2_alloc_get(ip))
1019 return -ENOMEM;
1020
1021 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1022 if (error)
1023 goto out;
1024
1025 while (height--) {
1026 struct strip_mine sm;
1027 sm.sm_first = !!size;
1028 sm.sm_height = height;
1029
1030 error = recursive_scan(ip, NULL, &mp, 0, 0, 1, do_strip, &sm);
1031 if (error)
1032 break;
1033 }
1034
1035 gfs2_quota_unhold(ip);
1036
1037out:
1038 gfs2_alloc_put(ip);
1039 return error;
1040}
1041
1042static int trunc_end(struct gfs2_inode *ip)
1043{
1044 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1045 struct buffer_head *dibh;
1046 int error;
1047
1048 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1049 if (error)
1050 return error;
1051
1052 down_write(&ip->i_rw_mutex);
1053
1054 error = gfs2_meta_inode_buffer(ip, &dibh);
1055 if (error)
1056 goto out;
1057
1058 if (!i_size_read(&ip->i_inode)) {
1059 ip->i_height = 0;
1060 ip->i_goal = ip->i_no_addr;
1061 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1062 }
1063 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1064 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1065
1066 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1067 gfs2_dinode_out(ip, dibh->b_data);
1068 brelse(dibh);
1069
1070out:
1071 up_write(&ip->i_rw_mutex);
1072 gfs2_trans_end(sdp);
1073 return error;
1074}
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)
1089{
1090 struct gfs2_inode *ip = GFS2_I(inode);
1091 int error;
1092
1093 error = trunc_start(inode, oldsize, newsize);
1094 if (error < 0)
1095 return error;
1096 if (gfs2_is_stuffed(ip))
1097 return 0;
1098
1099 error = trunc_dealloc(ip, newsize);
1100 if (error == 0)
1101 error = trunc_end(ip);
1102
1103 return error;
1104}
1105
1106void gfs2_trim_blocks(struct inode *inode)
1107{
1108 u64 size = inode->i_size;
1109 int ret;
1110
1111 ret = do_shrink(inode, size, size);
1112 WARN_ON(ret != 0);
1113}
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135static int do_grow(struct inode *inode, u64 size)
1136{
1137 struct gfs2_inode *ip = GFS2_I(inode);
1138 struct gfs2_sbd *sdp = GFS2_SB(inode);
1139 struct buffer_head *dibh;
1140 struct gfs2_alloc *al = NULL;
1141 int error;
1142
1143 if (gfs2_is_stuffed(ip) &&
1144 (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
1145 al = gfs2_alloc_get(ip);
1146 if (al == NULL)
1147 return -ENOMEM;
1148
1149 error = gfs2_quota_lock_check(ip);
1150 if (error)
1151 goto do_grow_alloc_put;
1152
1153 al->al_requested = 1;
1154 error = gfs2_inplace_reserve(ip);
1155 if (error)
1156 goto do_grow_qunlock;
1157 }
1158
1159 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);
1160 if (error)
1161 goto do_grow_release;
1162
1163 if (al) {
1164 error = gfs2_unstuff_dinode(ip, NULL);
1165 if (error)
1166 goto do_end_trans;
1167 }
1168
1169 error = gfs2_meta_inode_buffer(ip, &dibh);
1170 if (error)
1171 goto do_end_trans;
1172
1173 i_size_write(inode, size);
1174 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1175 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1176 gfs2_dinode_out(ip, dibh->b_data);
1177 brelse(dibh);
1178
1179do_end_trans:
1180 gfs2_trans_end(sdp);
1181do_grow_release:
1182 if (al) {
1183 gfs2_inplace_release(ip);
1184do_grow_qunlock:
1185 gfs2_quota_unlock(ip);
1186do_grow_alloc_put:
1187 gfs2_alloc_put(ip);
1188 }
1189 return error;
1190}
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204int gfs2_setattr_size(struct inode *inode, u64 newsize)
1205{
1206 int ret;
1207 u64 oldsize;
1208
1209 BUG_ON(!S_ISREG(inode->i_mode));
1210
1211 ret = inode_newsize_ok(inode, newsize);
1212 if (ret)
1213 return ret;
1214
1215 oldsize = inode->i_size;
1216 if (newsize >= oldsize)
1217 return do_grow(inode, newsize);
1218
1219 return do_shrink(inode, oldsize, newsize);
1220}
1221
1222int gfs2_truncatei_resume(struct gfs2_inode *ip)
1223{
1224 int error;
1225 error = trunc_dealloc(ip, i_size_read(&ip->i_inode));
1226 if (!error)
1227 error = trunc_end(ip);
1228 return error;
1229}
1230
1231int gfs2_file_dealloc(struct gfs2_inode *ip)
1232{
1233 return trunc_dealloc(ip, 0);
1234}
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1246 unsigned int len)
1247{
1248 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1249 struct buffer_head bh;
1250 unsigned int shift;
1251 u64 lblock, lblock_stop, size;
1252 u64 end_of_file;
1253
1254 if (!len)
1255 return 0;
1256
1257 if (gfs2_is_stuffed(ip)) {
1258 if (offset + len >
1259 sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1260 return 1;
1261 return 0;
1262 }
1263
1264 shift = sdp->sd_sb.sb_bsize_shift;
1265 BUG_ON(gfs2_is_dir(ip));
1266 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
1267 lblock = offset >> shift;
1268 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1269 if (lblock_stop > end_of_file)
1270 return 1;
1271
1272 size = (lblock_stop - lblock) << shift;
1273 do {
1274 bh.b_state = 0;
1275 bh.b_size = size;
1276 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1277 if (!buffer_mapped(&bh))
1278 return 1;
1279 size -= bh.b_size;
1280 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1281 } while(size > 0);
1282
1283 return 0;
1284}
1285
1286