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/gfs2_ondisk.h>
15#include <linux/crc32.h>
16
17#include "gfs2.h"
18#include "incore.h"
19#include "bmap.h"
20#include "glock.h"
21#include "inode.h"
22#include "meta_io.h"
23#include "quota.h"
24#include "rgrp.h"
25#include "trans.h"
26#include "dir.h"
27#include "util.h"
28#include "trace_gfs2.h"
29
30
31
32
33
34struct metapath {
35 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
36 __u16 mp_list[GFS2_MAX_META_HEIGHT];
37};
38
39typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh,
40 struct buffer_head *bh, __be64 *top,
41 __be64 *bottom, unsigned int height,
42 void *data);
43
44struct strip_mine {
45 int sm_first;
46 unsigned int sm_height;
47};
48
49
50
51
52
53
54
55
56
57
58
59static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
60 u64 block, struct page *page)
61{
62 struct inode *inode = &ip->i_inode;
63 struct buffer_head *bh;
64 int release = 0;
65
66 if (!page || page->index) {
67 page = grab_cache_page(inode->i_mapping, 0);
68 if (!page)
69 return -ENOMEM;
70 release = 1;
71 }
72
73 if (!PageUptodate(page)) {
74 void *kaddr = kmap(page);
75
76 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
77 ip->i_disksize);
78 memset(kaddr + ip->i_disksize, 0,
79 PAGE_CACHE_SIZE - ip->i_disksize);
80 kunmap(page);
81
82 SetPageUptodate(page);
83 }
84
85 if (!page_has_buffers(page))
86 create_empty_buffers(page, 1 << inode->i_blkbits,
87 (1 << BH_Uptodate));
88
89 bh = page_buffers(page);
90
91 if (!buffer_mapped(bh))
92 map_bh(bh, inode->i_sb, block);
93
94 set_buffer_uptodate(bh);
95 if (!gfs2_is_jdata(ip))
96 mark_buffer_dirty(bh);
97 if (!gfs2_is_writeback(ip))
98 gfs2_trans_add_bh(ip->i_gl, bh, 0);
99
100 if (release) {
101 unlock_page(page);
102 page_cache_release(page);
103 }
104
105 return 0;
106}
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 (ip->i_disksize) {
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 (ip->i_disksize) {
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);
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;
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 error = gfs2_rindex_hold(sdp, &ip->i_alloc->al_ri_gh);
784 if (error)
785 return error;
786
787 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
788 bstart = 0;
789 blen = 0;
790
791 for (p = top; p < bottom; p++) {
792 if (!*p)
793 continue;
794
795 bn = be64_to_cpu(*p);
796
797 if (bstart + blen == bn)
798 blen++;
799 else {
800 if (bstart)
801 gfs2_rlist_add(sdp, &rlist, bstart);
802
803 bstart = bn;
804 blen = 1;
805 }
806 }
807
808 if (bstart)
809 gfs2_rlist_add(sdp, &rlist, bstart);
810 else
811 goto out;
812
813 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
814
815 for (x = 0; x < rlist.rl_rgrps; x++) {
816 struct gfs2_rgrpd *rgd;
817 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
818 rg_blocks += rgd->rd_length;
819 }
820
821 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
822 if (error)
823 goto out_rlist;
824
825 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
826 RES_INDIRECT + RES_STATFS + RES_QUOTA,
827 revokes);
828 if (error)
829 goto out_rg_gunlock;
830
831 down_write(&ip->i_rw_mutex);
832
833 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
834 gfs2_trans_add_bh(ip->i_gl, bh, 1);
835
836 bstart = 0;
837 blen = 0;
838
839 for (p = top; p < bottom; p++) {
840 if (!*p)
841 continue;
842
843 bn = be64_to_cpu(*p);
844
845 if (bstart + blen == bn)
846 blen++;
847 else {
848 if (bstart) {
849 if (metadata)
850 gfs2_free_meta(ip, bstart, blen);
851 else
852 gfs2_free_data(ip, bstart, blen);
853 }
854
855 bstart = bn;
856 blen = 1;
857 }
858
859 *p = 0;
860 gfs2_add_inode_blocks(&ip->i_inode, -1);
861 }
862 if (bstart) {
863 if (metadata)
864 gfs2_free_meta(ip, bstart, blen);
865 else
866 gfs2_free_data(ip, bstart, blen);
867 }
868
869 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
870
871 gfs2_dinode_out(ip, dibh->b_data);
872
873 up_write(&ip->i_rw_mutex);
874
875 gfs2_trans_end(sdp);
876
877out_rg_gunlock:
878 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
879out_rlist:
880 gfs2_rlist_free(&rlist);
881out:
882 gfs2_glock_dq_uninit(&ip->i_alloc->al_ri_gh);
883 return error;
884}
885
886
887
888
889
890
891
892
893
894
895
896static int do_grow(struct gfs2_inode *ip, u64 size)
897{
898 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
899 struct gfs2_alloc *al;
900 struct buffer_head *dibh;
901 int error;
902
903 al = gfs2_alloc_get(ip);
904 if (!al)
905 return -ENOMEM;
906
907 error = gfs2_quota_lock_check(ip);
908 if (error)
909 goto out;
910
911 al->al_requested = sdp->sd_max_height + RES_DATA;
912
913 error = gfs2_inplace_reserve(ip);
914 if (error)
915 goto out_gunlock_q;
916
917 error = gfs2_trans_begin(sdp,
918 sdp->sd_max_height + al->al_rgd->rd_length +
919 RES_JDATA + RES_DINODE + RES_STATFS + RES_QUOTA, 0);
920 if (error)
921 goto out_ipres;
922
923 error = gfs2_meta_inode_buffer(ip, &dibh);
924 if (error)
925 goto out_end_trans;
926
927 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
928 if (gfs2_is_stuffed(ip)) {
929 error = gfs2_unstuff_dinode(ip, NULL);
930 if (error)
931 goto out_brelse;
932 }
933 }
934
935 ip->i_disksize = size;
936 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
937 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
938 gfs2_dinode_out(ip, dibh->b_data);
939
940out_brelse:
941 brelse(dibh);
942out_end_trans:
943 gfs2_trans_end(sdp);
944out_ipres:
945 gfs2_inplace_release(ip);
946out_gunlock_q:
947 gfs2_quota_unlock(ip);
948out:
949 gfs2_alloc_put(ip);
950 return error;
951}
952
953
954
955
956
957
958
959static int gfs2_block_truncate_page(struct address_space *mapping)
960{
961 struct inode *inode = mapping->host;
962 struct gfs2_inode *ip = GFS2_I(inode);
963 loff_t from = inode->i_size;
964 unsigned long index = from >> PAGE_CACHE_SHIFT;
965 unsigned offset = from & (PAGE_CACHE_SIZE-1);
966 unsigned blocksize, iblock, length, pos;
967 struct buffer_head *bh;
968 struct page *page;
969 int err;
970
971 page = grab_cache_page(mapping, index);
972 if (!page)
973 return 0;
974
975 blocksize = inode->i_sb->s_blocksize;
976 length = blocksize - (offset & (blocksize - 1));
977 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
978
979 if (!page_has_buffers(page))
980 create_empty_buffers(page, blocksize, 0);
981
982
983 bh = page_buffers(page);
984 pos = blocksize;
985 while (offset >= pos) {
986 bh = bh->b_this_page;
987 iblock++;
988 pos += blocksize;
989 }
990
991 err = 0;
992
993 if (!buffer_mapped(bh)) {
994 gfs2_block_map(inode, iblock, bh, 0);
995
996 if (!buffer_mapped(bh))
997 goto unlock;
998 }
999
1000
1001 if (PageUptodate(page))
1002 set_buffer_uptodate(bh);
1003
1004 if (!buffer_uptodate(bh)) {
1005 err = -EIO;
1006 ll_rw_block(READ, 1, &bh);
1007 wait_on_buffer(bh);
1008
1009 if (!buffer_uptodate(bh))
1010 goto unlock;
1011 err = 0;
1012 }
1013
1014 if (!gfs2_is_writeback(ip))
1015 gfs2_trans_add_bh(ip->i_gl, bh, 0);
1016
1017 zero_user(page, offset, length);
1018 mark_buffer_dirty(bh);
1019unlock:
1020 unlock_page(page);
1021 page_cache_release(page);
1022 return err;
1023}
1024
1025static int trunc_start(struct gfs2_inode *ip, u64 size)
1026{
1027 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1028 struct buffer_head *dibh;
1029 int journaled = gfs2_is_jdata(ip);
1030 int error;
1031
1032 error = gfs2_trans_begin(sdp,
1033 RES_DINODE + (journaled ? RES_JDATA : 0), 0);
1034 if (error)
1035 return error;
1036
1037 error = gfs2_meta_inode_buffer(ip, &dibh);
1038 if (error)
1039 goto out;
1040
1041 if (gfs2_is_stuffed(ip)) {
1042 ip->i_disksize = size;
1043 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1044 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1045 gfs2_dinode_out(ip, dibh->b_data);
1046 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + size);
1047 error = 1;
1048
1049 } else {
1050 if (size & (u64)(sdp->sd_sb.sb_bsize - 1))
1051 error = gfs2_block_truncate_page(ip->i_inode.i_mapping);
1052
1053 if (!error) {
1054 ip->i_disksize = size;
1055 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1056 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
1057 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1058 gfs2_dinode_out(ip, dibh->b_data);
1059 }
1060 }
1061
1062 brelse(dibh);
1063
1064out:
1065 gfs2_trans_end(sdp);
1066 return error;
1067}
1068
1069static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
1070{
1071 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1072 unsigned int height = ip->i_height;
1073 u64 lblock;
1074 struct metapath mp;
1075 int error;
1076
1077 if (!size)
1078 lblock = 0;
1079 else
1080 lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;
1081
1082 find_metapath(sdp, lblock, &mp, ip->i_height);
1083 if (!gfs2_alloc_get(ip))
1084 return -ENOMEM;
1085
1086 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1087 if (error)
1088 goto out;
1089
1090 while (height--) {
1091 struct strip_mine sm;
1092 sm.sm_first = !!size;
1093 sm.sm_height = height;
1094
1095 error = recursive_scan(ip, NULL, &mp, 0, 0, 1, do_strip, &sm);
1096 if (error)
1097 break;
1098 }
1099
1100 gfs2_quota_unhold(ip);
1101
1102out:
1103 gfs2_alloc_put(ip);
1104 return error;
1105}
1106
1107static int trunc_end(struct gfs2_inode *ip)
1108{
1109 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1110 struct buffer_head *dibh;
1111 int error;
1112
1113 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1114 if (error)
1115 return error;
1116
1117 down_write(&ip->i_rw_mutex);
1118
1119 error = gfs2_meta_inode_buffer(ip, &dibh);
1120 if (error)
1121 goto out;
1122
1123 if (!ip->i_disksize) {
1124 ip->i_height = 0;
1125 ip->i_goal = ip->i_no_addr;
1126 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1127 }
1128 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1129 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1130
1131 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1132 gfs2_dinode_out(ip, dibh->b_data);
1133 brelse(dibh);
1134
1135out:
1136 up_write(&ip->i_rw_mutex);
1137 gfs2_trans_end(sdp);
1138 return error;
1139}
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152static int do_shrink(struct gfs2_inode *ip, u64 size)
1153{
1154 int error;
1155
1156 error = trunc_start(ip, size);
1157 if (error < 0)
1158 return error;
1159 if (error > 0)
1160 return 0;
1161
1162 error = trunc_dealloc(ip, size);
1163 if (!error)
1164 error = trunc_end(ip);
1165
1166 return error;
1167}
1168
1169static int do_touch(struct gfs2_inode *ip, u64 size)
1170{
1171 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1172 struct buffer_head *dibh;
1173 int error;
1174
1175 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1176 if (error)
1177 return error;
1178
1179 down_write(&ip->i_rw_mutex);
1180
1181 error = gfs2_meta_inode_buffer(ip, &dibh);
1182 if (error)
1183 goto do_touch_out;
1184
1185 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1186 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1187 gfs2_dinode_out(ip, dibh->b_data);
1188 brelse(dibh);
1189
1190do_touch_out:
1191 up_write(&ip->i_rw_mutex);
1192 gfs2_trans_end(sdp);
1193 return error;
1194}
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207int gfs2_truncatei(struct gfs2_inode *ip, u64 size)
1208{
1209 int error;
1210
1211 if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), S_ISREG(ip->i_inode.i_mode)))
1212 return -EINVAL;
1213
1214 if (size > ip->i_disksize)
1215 error = do_grow(ip, size);
1216 else if (size < ip->i_disksize)
1217 error = do_shrink(ip, size);
1218 else
1219
1220 error = do_touch(ip, size);
1221
1222 return error;
1223}
1224
1225int gfs2_truncatei_resume(struct gfs2_inode *ip)
1226{
1227 int error;
1228 error = trunc_dealloc(ip, ip->i_disksize);
1229 if (!error)
1230 error = trunc_end(ip);
1231 return error;
1232}
1233
1234int gfs2_file_dealloc(struct gfs2_inode *ip)
1235{
1236 return trunc_dealloc(ip, 0);
1237}
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1250 unsigned int len, int *alloc_required)
1251{
1252 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1253 struct buffer_head bh;
1254 unsigned int shift;
1255 u64 lblock, lblock_stop, size;
1256 u64 end_of_file;
1257
1258 *alloc_required = 0;
1259
1260 if (!len)
1261 return 0;
1262
1263 if (gfs2_is_stuffed(ip)) {
1264 if (offset + len >
1265 sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1266 *alloc_required = 1;
1267 return 0;
1268 }
1269
1270 *alloc_required = 1;
1271 shift = sdp->sd_sb.sb_bsize_shift;
1272 BUG_ON(gfs2_is_dir(ip));
1273 end_of_file = (ip->i_disksize + sdp->sd_sb.sb_bsize - 1) >> shift;
1274 lblock = offset >> shift;
1275 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1276 if (lblock_stop > end_of_file)
1277 return 0;
1278
1279 size = (lblock_stop - lblock) << shift;
1280 do {
1281 bh.b_state = 0;
1282 bh.b_size = size;
1283 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1284 if (!buffer_mapped(&bh))
1285 return 0;
1286 size -= bh.b_size;
1287 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1288 } while(size > 0);
1289
1290 *alloc_required = 0;
1291 return 0;
1292}
1293
1294