2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
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>
27 #include "trace_gfs2.h"
29 /* This doesn't need to be that large as max 64 bit pointers in a 4k
30 * block is 512, so __u16 is fine for that. It saves stack space to
34 struct buffer_head
*mp_bh
[GFS2_MAX_META_HEIGHT
];
35 __u16 mp_list
[GFS2_MAX_META_HEIGHT
];
38 typedef 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
,
45 unsigned int sm_height
;
49 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
51 * @dibh: the dinode buffer
52 * @block: the block number that was allocated
53 * @private: any locked page held by the caller process
58 static int gfs2_unstuffer_page(struct gfs2_inode
*ip
, struct buffer_head
*dibh
,
59 u64 block
, struct page
*page
)
61 struct inode
*inode
= &ip
->i_inode
;
62 struct buffer_head
*bh
;
65 if (!page
|| page
->index
) {
66 page
= grab_cache_page(inode
->i_mapping
, 0);
72 if (!PageUptodate(page
)) {
73 void *kaddr
= kmap(page
);
75 memcpy(kaddr
, dibh
->b_data
+ sizeof(struct gfs2_dinode
),
77 memset(kaddr
+ ip
->i_disksize
, 0,
78 PAGE_CACHE_SIZE
- ip
->i_disksize
);
81 SetPageUptodate(page
);
84 if (!page_has_buffers(page
))
85 create_empty_buffers(page
, 1 << inode
->i_blkbits
,
88 bh
= page_buffers(page
);
90 if (!buffer_mapped(bh
))
91 map_bh(bh
, inode
->i_sb
, block
);
93 set_buffer_uptodate(bh
);
94 if (!gfs2_is_jdata(ip
))
95 mark_buffer_dirty(bh
);
96 if (!gfs2_is_writeback(ip
))
97 gfs2_trans_add_bh(ip
->i_gl
, bh
, 0);
101 page_cache_release(page
);
108 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
109 * @ip: The GFS2 inode to unstuff
110 * @unstuffer: the routine that handles unstuffing a non-zero length file
111 * @private: private data for the unstuffer
113 * This routine unstuffs a dinode and returns it to a "normal" state such
114 * that the height can be grown in the traditional way.
119 int gfs2_unstuff_dinode(struct gfs2_inode
*ip
, struct page
*page
)
121 struct buffer_head
*bh
, *dibh
;
122 struct gfs2_dinode
*di
;
124 int isdir
= gfs2_is_dir(ip
);
127 down_write(&ip
->i_rw_mutex
);
129 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
133 if (ip
->i_disksize
) {
134 /* Get a free block, fill it with the stuffed data,
135 and write it out to disk */
138 error
= gfs2_alloc_block(ip
, &block
, &n
);
142 gfs2_trans_add_unrevoke(GFS2_SB(&ip
->i_inode
), block
, 1);
143 error
= gfs2_dir_get_new_buffer(ip
, block
, &bh
);
146 gfs2_buffer_copy_tail(bh
, sizeof(struct gfs2_meta_header
),
147 dibh
, sizeof(struct gfs2_dinode
));
150 error
= gfs2_unstuffer_page(ip
, dibh
, block
, page
);
156 /* Set up the pointer to the new block */
158 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
159 di
= (struct gfs2_dinode
*)dibh
->b_data
;
160 gfs2_buffer_clear_tail(dibh
, sizeof(struct gfs2_dinode
));
162 if (ip
->i_disksize
) {
163 *(__be64
*)(di
+ 1) = cpu_to_be64(block
);
164 gfs2_add_inode_blocks(&ip
->i_inode
, 1);
165 di
->di_blocks
= cpu_to_be64(gfs2_get_inode_blocks(&ip
->i_inode
));
169 di
->di_height
= cpu_to_be16(1);
174 up_write(&ip
->i_rw_mutex
);
180 * find_metapath - Find path through the metadata tree
181 * @sdp: The superblock
182 * @mp: The metapath to return the result in
183 * @block: The disk block to look up
184 * @height: The pre-calculated height of the metadata tree
186 * This routine returns a struct metapath structure that defines a path
187 * through the metadata of inode "ip" to get to block "block".
190 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
191 * filesystem with a blocksize of 4096.
193 * find_metapath() would return a struct metapath structure set to:
194 * mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
195 * and mp_list[2] = 165.
197 * That means that in order to get to the block containing the byte at
198 * offset 101342453, we would load the indirect block pointed to by pointer
199 * 0 in the dinode. We would then load the indirect block pointed to by
200 * pointer 48 in that indirect block. We would then load the data block
201 * pointed to by pointer 165 in that indirect block.
203 * ----------------------------------------
208 * ----------------------------------------
212 * ----------------------------------------
216 * |0 5 6 7 8 9 0 1 2|
217 * ----------------------------------------
221 * ----------------------------------------
226 * ----------------------------------------
230 * ----------------------------------------
231 * | Data block containing offset |
235 * ----------------------------------------
239 static void find_metapath(const struct gfs2_sbd
*sdp
, u64 block
,
240 struct metapath
*mp
, unsigned int height
)
244 for (i
= height
; i
--;)
245 mp
->mp_list
[i
] = do_div(block
, sdp
->sd_inptrs
);
249 static inline unsigned int metapath_branch_start(const struct metapath
*mp
)
251 if (mp
->mp_list
[0] == 0)
257 * metapointer - Return pointer to start of metadata in a buffer
258 * @height: The metadata height (0 = dinode)
261 * Return a pointer to the block number of the next height of the metadata
262 * tree given a buffer containing the pointer to the current height of the
266 static inline __be64
*metapointer(unsigned int height
, const struct metapath
*mp
)
268 struct buffer_head
*bh
= mp
->mp_bh
[height
];
269 unsigned int head_size
= (height
> 0) ?
270 sizeof(struct gfs2_meta_header
) : sizeof(struct gfs2_dinode
);
271 return ((__be64
*)(bh
->b_data
+ head_size
)) + mp
->mp_list
[height
];
275 * lookup_metapath - Walk the metadata tree to a specific point
279 * Assumes that the inode's buffer has already been looked up and
280 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
281 * by find_metapath().
283 * If this function encounters part of the tree which has not been
284 * allocated, it returns the current height of the tree at the point
285 * at which it found the unallocated block. Blocks which are found are
286 * added to the mp->mp_bh[] list.
288 * Returns: error or height of metadata tree
291 static int lookup_metapath(struct gfs2_inode
*ip
, struct metapath
*mp
)
293 unsigned int end_of_metadata
= ip
->i_height
- 1;
299 for (x
= 0; x
< end_of_metadata
; x
++) {
300 ptr
= metapointer(x
, mp
);
301 dblock
= be64_to_cpu(*ptr
);
305 ret
= gfs2_meta_indirect_buffer(ip
, x
+1, dblock
, 0, &mp
->mp_bh
[x
+1]);
313 static inline void release_metapath(struct metapath
*mp
)
317 for (i
= 0; i
< GFS2_MAX_META_HEIGHT
; i
++) {
318 if (mp
->mp_bh
[i
] == NULL
)
320 brelse(mp
->mp_bh
[i
]);
325 * gfs2_extent_length - Returns length of an extent of blocks
326 * @start: Start of the buffer
327 * @len: Length of the buffer in bytes
328 * @ptr: Current position in the buffer
329 * @limit: Max extent length to return (0 = unlimited)
330 * @eob: Set to 1 if we hit "end of block"
332 * If the first block is zero (unallocated) it will return the number of
333 * unallocated blocks in the extent, otherwise it will return the number
334 * of contiguous blocks in the extent.
336 * Returns: The length of the extent (minimum of one block)
339 static inline unsigned int gfs2_extent_length(void *start
, unsigned int len
, __be64
*ptr
, unsigned limit
, int *eob
)
341 const __be64
*end
= (start
+ len
);
342 const __be64
*first
= ptr
;
343 u64 d
= be64_to_cpu(*ptr
);
350 if (limit
&& --limit
== 0)
354 } while(be64_to_cpu(*ptr
) == d
);
357 return (ptr
- first
);
360 static inline void bmap_lock(struct gfs2_inode
*ip
, int create
)
363 down_write(&ip
->i_rw_mutex
);
365 down_read(&ip
->i_rw_mutex
);
368 static inline void bmap_unlock(struct gfs2_inode
*ip
, int create
)
371 up_write(&ip
->i_rw_mutex
);
373 up_read(&ip
->i_rw_mutex
);
376 static inline __be64
*gfs2_indirect_init(struct metapath
*mp
,
377 struct gfs2_glock
*gl
, unsigned int i
,
378 unsigned offset
, u64 bn
)
380 __be64
*ptr
= (__be64
*)(mp
->mp_bh
[i
- 1]->b_data
+
381 ((i
> 1) ? sizeof(struct gfs2_meta_header
) :
382 sizeof(struct gfs2_dinode
)));
384 BUG_ON(mp
->mp_bh
[i
] != NULL
);
385 mp
->mp_bh
[i
] = gfs2_meta_new(gl
, bn
);
386 gfs2_trans_add_bh(gl
, mp
->mp_bh
[i
], 1);
387 gfs2_metatype_set(mp
->mp_bh
[i
], GFS2_METATYPE_IN
, GFS2_FORMAT_IN
);
388 gfs2_buffer_clear_tail(mp
->mp_bh
[i
], sizeof(struct gfs2_meta_header
));
390 *ptr
= cpu_to_be64(bn
);
396 ALLOC_GROW_DEPTH
= 1,
397 ALLOC_GROW_HEIGHT
= 2,
398 /* ALLOC_UNSTUFF = 3, TBD and rather complicated */
402 * gfs2_bmap_alloc - Build a metadata tree of the requested height
403 * @inode: The GFS2 inode
404 * @lblock: The logical starting block of the extent
405 * @bh_map: This is used to return the mapping details
407 * @sheight: The starting height (i.e. whats already mapped)
408 * @height: The height to build to
409 * @maxlen: The max number of data blocks to alloc
411 * In this routine we may have to alloc:
412 * i) Indirect blocks to grow the metadata tree height
413 * ii) Indirect blocks to fill in lower part of the metadata tree
416 * The function is in two parts. The first part works out the total
417 * number of blocks which we need. The second part does the actual
418 * allocation asking for an extent at a time (if enough contiguous free
419 * blocks are available, there will only be one request per bmap call)
420 * and uses the state machine to initialise the blocks in order.
422 * Returns: errno on error
425 static int gfs2_bmap_alloc(struct inode
*inode
, const sector_t lblock
,
426 struct buffer_head
*bh_map
, struct metapath
*mp
,
427 const unsigned int sheight
,
428 const unsigned int height
,
429 const unsigned int maxlen
)
431 struct gfs2_inode
*ip
= GFS2_I(inode
);
432 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
433 struct buffer_head
*dibh
= mp
->mp_bh
[0];
435 unsigned n
, i
, blks
, alloced
= 0, iblks
= 0, branch_start
= 0;
437 unsigned ptrs_per_blk
;
438 const unsigned end_of_metadata
= height
- 1;
440 enum alloc_state state
;
445 BUG_ON(dibh
== NULL
);
447 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
449 if (height
== sheight
) {
450 struct buffer_head
*bh
;
451 /* Bottom indirect block exists, find unalloced extent size */
452 ptr
= metapointer(end_of_metadata
, mp
);
453 bh
= mp
->mp_bh
[end_of_metadata
];
454 dblks
= gfs2_extent_length(bh
->b_data
, bh
->b_size
, ptr
, maxlen
,
459 /* Need to allocate indirect blocks */
460 ptrs_per_blk
= height
> 1 ? sdp
->sd_inptrs
: sdp
->sd_diptrs
;
461 dblks
= min(maxlen
, ptrs_per_blk
- mp
->mp_list
[end_of_metadata
]);
462 if (height
== ip
->i_height
) {
463 /* Writing into existing tree, extend tree down */
464 iblks
= height
- sheight
;
465 state
= ALLOC_GROW_DEPTH
;
467 /* Building up tree height */
468 state
= ALLOC_GROW_HEIGHT
;
469 iblks
= height
- ip
->i_height
;
470 branch_start
= metapath_branch_start(mp
);
471 iblks
+= (height
- branch_start
);
475 /* start of the second part of the function (state machine) */
477 blks
= dblks
+ iblks
;
482 error
= gfs2_alloc_block(ip
, &bn
, &n
);
486 if (state
!= ALLOC_DATA
|| gfs2_is_jdata(ip
))
487 gfs2_trans_add_unrevoke(sdp
, bn
, n
);
489 /* Growing height of tree */
490 case ALLOC_GROW_HEIGHT
:
492 ptr
= (__be64
*)(dibh
->b_data
+
493 sizeof(struct gfs2_dinode
));
496 for (; i
- 1 < height
- ip
->i_height
&& n
> 0; i
++, n
--)
497 gfs2_indirect_init(mp
, ip
->i_gl
, i
, 0, bn
++);
498 if (i
- 1 == height
- ip
->i_height
) {
500 gfs2_buffer_copy_tail(mp
->mp_bh
[i
],
501 sizeof(struct gfs2_meta_header
),
502 dibh
, sizeof(struct gfs2_dinode
));
503 gfs2_buffer_clear_tail(dibh
,
504 sizeof(struct gfs2_dinode
) +
506 ptr
= (__be64
*)(mp
->mp_bh
[i
]->b_data
+
507 sizeof(struct gfs2_meta_header
));
509 state
= ALLOC_GROW_DEPTH
;
510 for(i
= branch_start
; i
< height
; i
++) {
511 if (mp
->mp_bh
[i
] == NULL
)
513 brelse(mp
->mp_bh
[i
]);
520 /* Branching from existing tree */
521 case ALLOC_GROW_DEPTH
:
522 if (i
> 1 && i
< height
)
523 gfs2_trans_add_bh(ip
->i_gl
, mp
->mp_bh
[i
-1], 1);
524 for (; i
< height
&& n
> 0; i
++, n
--)
525 gfs2_indirect_init(mp
, ip
->i_gl
, i
,
526 mp
->mp_list
[i
-1], bn
++);
531 /* Tree complete, adding data blocks */
534 BUG_ON(mp
->mp_bh
[end_of_metadata
] == NULL
);
535 gfs2_trans_add_bh(ip
->i_gl
, mp
->mp_bh
[end_of_metadata
], 1);
537 ptr
= metapointer(end_of_metadata
, mp
);
540 *ptr
++ = cpu_to_be64(bn
++);
543 } while ((state
!= ALLOC_DATA
) || !dblock
);
545 ip
->i_height
= height
;
546 gfs2_add_inode_blocks(&ip
->i_inode
, alloced
);
547 gfs2_dinode_out(ip
, mp
->mp_bh
[0]->b_data
);
548 map_bh(bh_map
, inode
->i_sb
, dblock
);
549 bh_map
->b_size
= dblks
<< inode
->i_blkbits
;
550 set_buffer_new(bh_map
);
555 * gfs2_block_map - Map a block from an inode to a disk block
557 * @lblock: The logical block number
558 * @bh_map: The bh to be mapped
559 * @create: True if its ok to alloc blocks to satify the request
561 * Sets buffer_mapped() if successful, sets buffer_boundary() if a
562 * read of metadata will be required before the next block can be
563 * mapped. Sets buffer_new() if new blocks were allocated.
568 int gfs2_block_map(struct inode
*inode
, sector_t lblock
,
569 struct buffer_head
*bh_map
, int create
)
571 struct gfs2_inode
*ip
= GFS2_I(inode
);
572 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
573 unsigned int bsize
= sdp
->sd_sb
.sb_bsize
;
574 const unsigned int maxlen
= bh_map
->b_size
>> inode
->i_blkbits
;
575 const u64
*arr
= sdp
->sd_heightsize
;
582 struct buffer_head
*bh
;
587 memset(mp
.mp_bh
, 0, sizeof(mp
.mp_bh
));
588 bmap_lock(ip
, create
);
589 clear_buffer_mapped(bh_map
);
590 clear_buffer_new(bh_map
);
591 clear_buffer_boundary(bh_map
);
592 trace_gfs2_bmap(ip
, bh_map
, lblock
, create
, 1);
593 if (gfs2_is_dir(ip
)) {
594 bsize
= sdp
->sd_jbsize
;
595 arr
= sdp
->sd_jheightsize
;
598 ret
= gfs2_meta_inode_buffer(ip
, &mp
.mp_bh
[0]);
602 height
= ip
->i_height
;
603 size
= (lblock
+ 1) * bsize
;
604 while (size
> arr
[height
])
606 find_metapath(sdp
, lblock
, &mp
, height
);
608 if (height
> ip
->i_height
|| gfs2_is_stuffed(ip
))
610 ret
= lookup_metapath(ip
, &mp
);
613 if (ret
!= ip
->i_height
)
615 ptr
= metapointer(ip
->i_height
- 1, &mp
);
618 map_bh(bh_map
, inode
->i_sb
, be64_to_cpu(*ptr
));
619 bh
= mp
.mp_bh
[ip
->i_height
- 1];
620 len
= gfs2_extent_length(bh
->b_data
, bh
->b_size
, ptr
, maxlen
, &eob
);
621 bh_map
->b_size
= (len
<< inode
->i_blkbits
);
623 set_buffer_boundary(bh_map
);
626 release_metapath(&mp
);
627 trace_gfs2_bmap(ip
, bh_map
, lblock
, create
, ret
);
628 bmap_unlock(ip
, create
);
632 /* All allocations are done here, firstly check create flag */
634 BUG_ON(gfs2_is_stuffed(ip
));
639 /* At this point ret is the tree depth of already allocated blocks */
640 ret
= gfs2_bmap_alloc(inode
, lblock
, bh_map
, &mp
, ret
, height
, maxlen
);
645 * Deprecated: do not use in new code
647 int gfs2_extent_map(struct inode
*inode
, u64 lblock
, int *new, u64
*dblock
, unsigned *extlen
)
649 struct buffer_head bh
= { .b_state
= 0, .b_blocknr
= 0 };
657 bh
.b_size
= 1 << (inode
->i_blkbits
+ (create
? 0 : 5));
658 ret
= gfs2_block_map(inode
, lblock
, &bh
, create
);
659 *extlen
= bh
.b_size
>> inode
->i_blkbits
;
660 *dblock
= bh
.b_blocknr
;
669 * recursive_scan - recursively scan through the end of a file
671 * @dibh: the dinode buffer
672 * @mp: the path through the metadata to the point to start
673 * @height: the height the recursion is at
674 * @block: the indirect block to look at
675 * @first: 1 if this is the first block
676 * @bc: the call to make for each piece of metadata
677 * @data: data opaque to this function to pass to @bc
679 * When this is first called @height and @block should be zero and
680 * @first should be 1.
685 static int recursive_scan(struct gfs2_inode
*ip
, struct buffer_head
*dibh
,
686 struct metapath
*mp
, unsigned int height
,
687 u64 block
, int first
, block_call_t bc
,
690 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
691 struct buffer_head
*bh
= NULL
;
692 __be64
*top
, *bottom
;
695 int mh_size
= sizeof(struct gfs2_meta_header
);
698 error
= gfs2_meta_inode_buffer(ip
, &bh
);
703 top
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_dinode
)) + mp
->mp_list
[0];
704 bottom
= (__be64
*)(bh
->b_data
+ sizeof(struct gfs2_dinode
)) + sdp
->sd_diptrs
;
706 error
= gfs2_meta_indirect_buffer(ip
, height
, block
, 0, &bh
);
710 top
= (__be64
*)(bh
->b_data
+ mh_size
) +
711 (first
? mp
->mp_list
[height
] : 0);
713 bottom
= (__be64
*)(bh
->b_data
+ mh_size
) + sdp
->sd_inptrs
;
716 error
= bc(ip
, dibh
, bh
, top
, bottom
, height
, data
);
720 if (height
< ip
->i_height
- 1)
721 for (; top
< bottom
; top
++, first
= 0) {
725 bn
= be64_to_cpu(*top
);
727 error
= recursive_scan(ip
, dibh
, mp
, height
+ 1, bn
,
739 * do_strip - Look for a layer a particular layer of the file and strip it off
741 * @dibh: the dinode buffer
742 * @bh: A buffer of pointers
743 * @top: The first pointer in the buffer
744 * @bottom: One more than the last pointer
745 * @height: the height this buffer is at
746 * @data: a pointer to a struct strip_mine
751 static int do_strip(struct gfs2_inode
*ip
, struct buffer_head
*dibh
,
752 struct buffer_head
*bh
, __be64
*top
, __be64
*bottom
,
753 unsigned int height
, void *data
)
755 struct strip_mine
*sm
= data
;
756 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
757 struct gfs2_rgrp_list rlist
;
761 unsigned int rg_blocks
= 0;
763 unsigned int revokes
= 0;
770 if (height
!= sm
->sm_height
)
778 metadata
= (height
!= ip
->i_height
- 1);
780 revokes
= (height
) ? sdp
->sd_inptrs
: sdp
->sd_diptrs
;
782 error
= gfs2_rindex_hold(sdp
, &ip
->i_alloc
->al_ri_gh
);
786 memset(&rlist
, 0, sizeof(struct gfs2_rgrp_list
));
790 for (p
= top
; p
< bottom
; p
++) {
794 bn
= be64_to_cpu(*p
);
796 if (bstart
+ blen
== bn
)
800 gfs2_rlist_add(sdp
, &rlist
, bstart
);
808 gfs2_rlist_add(sdp
, &rlist
, bstart
);
810 goto out
; /* Nothing to do */
812 gfs2_rlist_alloc(&rlist
, LM_ST_EXCLUSIVE
);
814 for (x
= 0; x
< rlist
.rl_rgrps
; x
++) {
815 struct gfs2_rgrpd
*rgd
;
816 rgd
= rlist
.rl_ghs
[x
].gh_gl
->gl_object
;
817 rg_blocks
+= rgd
->rd_length
;
820 error
= gfs2_glock_nq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
824 error
= gfs2_trans_begin(sdp
, rg_blocks
+ RES_DINODE
+
825 RES_INDIRECT
+ RES_STATFS
+ RES_QUOTA
,
830 down_write(&ip
->i_rw_mutex
);
832 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
833 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
838 for (p
= top
; p
< bottom
; p
++) {
842 bn
= be64_to_cpu(*p
);
844 if (bstart
+ blen
== bn
)
849 gfs2_free_meta(ip
, bstart
, blen
);
851 gfs2_free_data(ip
, bstart
, blen
);
859 gfs2_add_inode_blocks(&ip
->i_inode
, -1);
863 gfs2_free_meta(ip
, bstart
, blen
);
865 gfs2_free_data(ip
, bstart
, blen
);
868 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
870 gfs2_dinode_out(ip
, dibh
->b_data
);
872 up_write(&ip
->i_rw_mutex
);
877 gfs2_glock_dq_m(rlist
.rl_rgrps
, rlist
.rl_ghs
);
879 gfs2_rlist_free(&rlist
);
881 gfs2_glock_dq_uninit(&ip
->i_alloc
->al_ri_gh
);
886 * do_grow - Make a file look bigger than it is
888 * @size: the size to set the file to
890 * Called with an exclusive lock on @ip.
895 static int do_grow(struct gfs2_inode
*ip
, u64 size
)
897 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
898 struct gfs2_alloc
*al
;
899 struct buffer_head
*dibh
;
902 al
= gfs2_alloc_get(ip
);
906 error
= gfs2_quota_lock_check(ip
);
910 al
->al_requested
= sdp
->sd_max_height
+ RES_DATA
;
912 error
= gfs2_inplace_reserve(ip
);
916 error
= gfs2_trans_begin(sdp
,
917 sdp
->sd_max_height
+ al
->al_rgd
->rd_length
+
918 RES_JDATA
+ RES_DINODE
+ RES_STATFS
+ RES_QUOTA
, 0);
922 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
926 if (size
> sdp
->sd_sb
.sb_bsize
- sizeof(struct gfs2_dinode
)) {
927 if (gfs2_is_stuffed(ip
)) {
928 error
= gfs2_unstuff_dinode(ip
, NULL
);
934 ip
->i_disksize
= size
;
935 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
936 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
937 gfs2_dinode_out(ip
, dibh
->b_data
);
944 gfs2_inplace_release(ip
);
946 gfs2_quota_unlock(ip
);
954 * gfs2_block_truncate_page - Deal with zeroing out data for truncate
956 * This is partly borrowed from ext3.
958 static int gfs2_block_truncate_page(struct address_space
*mapping
)
960 struct inode
*inode
= mapping
->host
;
961 struct gfs2_inode
*ip
= GFS2_I(inode
);
962 loff_t from
= inode
->i_size
;
963 unsigned long index
= from
>> PAGE_CACHE_SHIFT
;
964 unsigned offset
= from
& (PAGE_CACHE_SIZE
-1);
965 unsigned blocksize
, iblock
, length
, pos
;
966 struct buffer_head
*bh
;
970 page
= grab_cache_page(mapping
, index
);
974 blocksize
= inode
->i_sb
->s_blocksize
;
975 length
= blocksize
- (offset
& (blocksize
- 1));
976 iblock
= index
<< (PAGE_CACHE_SHIFT
- inode
->i_sb
->s_blocksize_bits
);
978 if (!page_has_buffers(page
))
979 create_empty_buffers(page
, blocksize
, 0);
981 /* Find the buffer that contains "offset" */
982 bh
= page_buffers(page
);
984 while (offset
>= pos
) {
985 bh
= bh
->b_this_page
;
992 if (!buffer_mapped(bh
)) {
993 gfs2_block_map(inode
, iblock
, bh
, 0);
994 /* unmapped? It's a hole - nothing to do */
995 if (!buffer_mapped(bh
))
999 /* Ok, it's mapped. Make sure it's up-to-date */
1000 if (PageUptodate(page
))
1001 set_buffer_uptodate(bh
);
1003 if (!buffer_uptodate(bh
)) {
1005 ll_rw_block(READ
, 1, &bh
);
1007 /* Uhhuh. Read error. Complain and punt. */
1008 if (!buffer_uptodate(bh
))
1013 if (!gfs2_is_writeback(ip
))
1014 gfs2_trans_add_bh(ip
->i_gl
, bh
, 0);
1016 zero_user(page
, offset
, length
);
1017 mark_buffer_dirty(bh
);
1020 page_cache_release(page
);
1024 static int trunc_start(struct gfs2_inode
*ip
, u64 size
)
1026 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1027 struct buffer_head
*dibh
;
1028 int journaled
= gfs2_is_jdata(ip
);
1031 error
= gfs2_trans_begin(sdp
,
1032 RES_DINODE
+ (journaled
? RES_JDATA
: 0), 0);
1036 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1040 if (gfs2_is_stuffed(ip
)) {
1041 ip
->i_disksize
= size
;
1042 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1043 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1044 gfs2_dinode_out(ip
, dibh
->b_data
);
1045 gfs2_buffer_clear_tail(dibh
, sizeof(struct gfs2_dinode
) + size
);
1049 if (size
& (u64
)(sdp
->sd_sb
.sb_bsize
- 1))
1050 error
= gfs2_block_truncate_page(ip
->i_inode
.i_mapping
);
1053 ip
->i_disksize
= size
;
1054 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1055 ip
->i_diskflags
|= GFS2_DIF_TRUNC_IN_PROG
;
1056 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1057 gfs2_dinode_out(ip
, dibh
->b_data
);
1064 gfs2_trans_end(sdp
);
1068 static int trunc_dealloc(struct gfs2_inode
*ip
, u64 size
)
1070 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1071 unsigned int height
= ip
->i_height
;
1079 lblock
= (size
- 1) >> sdp
->sd_sb
.sb_bsize_shift
;
1081 find_metapath(sdp
, lblock
, &mp
, ip
->i_height
);
1082 if (!gfs2_alloc_get(ip
))
1085 error
= gfs2_quota_hold(ip
, NO_QUOTA_CHANGE
, NO_QUOTA_CHANGE
);
1090 struct strip_mine sm
;
1091 sm
.sm_first
= !!size
;
1092 sm
.sm_height
= height
;
1094 error
= recursive_scan(ip
, NULL
, &mp
, 0, 0, 1, do_strip
, &sm
);
1099 gfs2_quota_unhold(ip
);
1106 static int trunc_end(struct gfs2_inode
*ip
)
1108 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1109 struct buffer_head
*dibh
;
1112 error
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
1116 down_write(&ip
->i_rw_mutex
);
1118 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1122 if (!ip
->i_disksize
) {
1124 ip
->i_goal
= ip
->i_no_addr
;
1125 gfs2_buffer_clear_tail(dibh
, sizeof(struct gfs2_dinode
));
1127 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1128 ip
->i_diskflags
&= ~GFS2_DIF_TRUNC_IN_PROG
;
1130 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1131 gfs2_dinode_out(ip
, dibh
->b_data
);
1135 up_write(&ip
->i_rw_mutex
);
1136 gfs2_trans_end(sdp
);
1141 * do_shrink - make a file smaller
1143 * @size: the size to make the file
1144 * @truncator: function to truncate the last partial block
1146 * Called with an exclusive lock on @ip.
1151 static int do_shrink(struct gfs2_inode
*ip
, u64 size
)
1155 error
= trunc_start(ip
, size
);
1161 error
= trunc_dealloc(ip
, size
);
1163 error
= trunc_end(ip
);
1168 static int do_touch(struct gfs2_inode
*ip
, u64 size
)
1170 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1171 struct buffer_head
*dibh
;
1174 error
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
1178 down_write(&ip
->i_rw_mutex
);
1180 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
1184 ip
->i_inode
.i_mtime
= ip
->i_inode
.i_ctime
= CURRENT_TIME
;
1185 gfs2_trans_add_bh(ip
->i_gl
, dibh
, 1);
1186 gfs2_dinode_out(ip
, dibh
->b_data
);
1190 up_write(&ip
->i_rw_mutex
);
1191 gfs2_trans_end(sdp
);
1196 * gfs2_truncatei - make a file a given size
1198 * @size: the size to make the file
1199 * @truncator: function to truncate the last partial block
1201 * The file size can grow, shrink, or stay the same size.
1206 int gfs2_truncatei(struct gfs2_inode
*ip
, u64 size
)
1210 if (gfs2_assert_warn(GFS2_SB(&ip
->i_inode
), S_ISREG(ip
->i_inode
.i_mode
)))
1213 if (size
> ip
->i_disksize
)
1214 error
= do_grow(ip
, size
);
1215 else if (size
< ip
->i_disksize
)
1216 error
= do_shrink(ip
, size
);
1218 /* update time stamps */
1219 error
= do_touch(ip
, size
);
1224 int gfs2_truncatei_resume(struct gfs2_inode
*ip
)
1227 error
= trunc_dealloc(ip
, ip
->i_disksize
);
1229 error
= trunc_end(ip
);
1233 int gfs2_file_dealloc(struct gfs2_inode
*ip
)
1235 return trunc_dealloc(ip
, 0);
1239 * gfs2_write_alloc_required - figure out if a write will require an allocation
1240 * @ip: the file being written to
1241 * @offset: the offset to write to
1242 * @len: the number of bytes being written
1243 * @alloc_required: set to 1 if an alloc is required, 0 otherwise
1248 int gfs2_write_alloc_required(struct gfs2_inode
*ip
, u64 offset
,
1249 unsigned int len
, int *alloc_required
)
1251 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
1252 struct buffer_head bh
;
1254 u64 lblock
, lblock_stop
, size
;
1257 *alloc_required
= 0;
1262 if (gfs2_is_stuffed(ip
)) {
1264 sdp
->sd_sb
.sb_bsize
- sizeof(struct gfs2_dinode
))
1265 *alloc_required
= 1;
1269 *alloc_required
= 1;
1270 shift
= sdp
->sd_sb
.sb_bsize_shift
;
1271 BUG_ON(gfs2_is_dir(ip
));
1272 end_of_file
= (ip
->i_disksize
+ sdp
->sd_sb
.sb_bsize
- 1) >> shift
;
1273 lblock
= offset
>> shift
;
1274 lblock_stop
= (offset
+ len
+ sdp
->sd_sb
.sb_bsize
- 1) >> shift
;
1275 if (lblock_stop
> end_of_file
)
1278 size
= (lblock_stop
- lblock
) << shift
;
1282 gfs2_block_map(&ip
->i_inode
, lblock
, &bh
, 0);
1283 if (!buffer_mapped(&bh
))
1286 lblock
+= (bh
.b_size
>> ip
->i_inode
.i_blkbits
);
1289 *alloc_required
= 0;