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/blkdev.h>
14 #include <linux/gfs2_ondisk.h>
15 #include <linux/crc32.h>
16 #include <linux/iomap.h>
32 #include "trace_gfs2.h"
34 /* This doesn't need to be that large as max 64 bit pointers in a 4k
35 * block is 512, so __u16 is fine for that. It saves stack space to
39 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
40 __u16 mp_list[GFS2_MAX_META_HEIGHT];
41 int mp_fheight; /* find_metapath height */
42 int mp_aheight; /* actual height (lookup height) */
45 static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length);
48 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
50 * @dibh: the dinode buffer
51 * @block: the block number that was allocated
52 * @page: The (optional) page. This is looked up if @page is NULL
57 static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
58 u64 block, struct page *page)
60 struct inode *inode = &ip->i_inode;
61 struct buffer_head *bh;
64 if (!page || page->index) {
65 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
71 if (!PageUptodate(page)) {
72 void *kaddr = kmap(page);
73 u64 dsize = i_size_read(inode);
75 if (dsize > gfs2_max_stuffed_size(ip))
76 dsize = gfs2_max_stuffed_size(ip);
78 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
79 memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
82 SetPageUptodate(page);
85 if (!page_has_buffers(page))
86 create_empty_buffers(page, BIT(inode->i_blkbits),
89 bh = page_buffers(page);
91 if (!buffer_mapped(bh))
92 map_bh(bh, inode->i_sb, block);
94 set_buffer_uptodate(bh);
95 if (gfs2_is_jdata(ip))
96 gfs2_trans_add_data(ip->i_gl, bh);
98 mark_buffer_dirty(bh);
99 gfs2_ordered_add_inode(ip);
111 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
112 * @ip: The GFS2 inode to unstuff
113 * @page: The (optional) page. This is looked up if the @page is NULL
115 * This routine unstuffs a dinode and returns it to a "normal" state such
116 * that the height can be grown in the traditional way.
121 int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
123 struct buffer_head *bh, *dibh;
124 struct gfs2_dinode *di;
126 int isdir = gfs2_is_dir(ip);
129 down_write(&ip->i_rw_mutex);
131 error = gfs2_meta_inode_buffer(ip, &dibh);
135 if (i_size_read(&ip->i_inode)) {
136 /* Get a free block, fill it with the stuffed data,
137 and write it out to disk */
140 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
144 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
145 error = gfs2_dir_get_new_buffer(ip, block, &bh);
148 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
149 dibh, sizeof(struct gfs2_dinode));
152 error = gfs2_unstuffer_page(ip, dibh, block, page);
158 /* Set up the pointer to the new block */
160 gfs2_trans_add_meta(ip->i_gl, dibh);
161 di = (struct gfs2_dinode *)dibh->b_data;
162 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
164 if (i_size_read(&ip->i_inode)) {
165 *(__be64 *)(di + 1) = cpu_to_be64(block);
166 gfs2_add_inode_blocks(&ip->i_inode, 1);
167 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
171 di->di_height = cpu_to_be16(1);
176 up_write(&ip->i_rw_mutex);
182 * find_metapath - Find path through the metadata tree
183 * @sdp: The superblock
184 * @block: The disk block to look up
185 * @mp: The metapath to return the result in
186 * @height: The pre-calculated height of the metadata tree
188 * This routine returns a struct metapath structure that defines a path
189 * through the metadata of inode "ip" to get to block "block".
192 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
193 * filesystem with a blocksize of 4096.
195 * find_metapath() would return a struct metapath structure set to:
196 * mp_fheight = 3, mp_list[0] = 0, mp_list[1] = 48, and mp_list[2] = 165.
198 * That means that in order to get to the block containing the byte at
199 * offset 101342453, we would load the indirect block pointed to by pointer
200 * 0 in the dinode. We would then load the indirect block pointed to by
201 * pointer 48 in that indirect block. We would then load the data block
202 * pointed to by pointer 165 in that indirect block.
204 * ----------------------------------------
209 * ----------------------------------------
213 * ----------------------------------------
217 * |0 5 6 7 8 9 0 1 2|
218 * ----------------------------------------
222 * ----------------------------------------
227 * ----------------------------------------
231 * ----------------------------------------
232 * | Data block containing offset |
236 * ----------------------------------------
240 static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
241 struct metapath *mp, unsigned int height)
245 mp->mp_fheight = height;
246 for (i = height; i--;)
247 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
250 static inline unsigned int metapath_branch_start(const struct metapath *mp)
252 if (mp->mp_list[0] == 0)
258 * metaptr1 - Return the first possible metadata pointer in a metapath buffer
259 * @height: The metadata height (0 = dinode)
262 static inline __be64 *metaptr1(unsigned int height, const struct metapath *mp)
264 struct buffer_head *bh = mp->mp_bh[height];
266 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)));
267 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)));
271 * metapointer - Return pointer to start of metadata in a buffer
272 * @height: The metadata height (0 = dinode)
275 * Return a pointer to the block number of the next height of the metadata
276 * tree given a buffer containing the pointer to the current height of the
280 static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
282 __be64 *p = metaptr1(height, mp);
283 return p + mp->mp_list[height];
286 static inline const __be64 *metaend(unsigned int height, const struct metapath *mp)
288 const struct buffer_head *bh = mp->mp_bh[height];
289 return (const __be64 *)(bh->b_data + bh->b_size);
292 static void clone_metapath(struct metapath *clone, struct metapath *mp)
297 for (hgt = 0; hgt < mp->mp_aheight; hgt++)
298 get_bh(clone->mp_bh[hgt]);
301 static void gfs2_metapath_ra(struct gfs2_glock *gl, __be64 *start, __be64 *end)
305 for (t = start; t < end; t++) {
306 struct buffer_head *rabh;
311 rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
312 if (trylock_buffer(rabh)) {
313 if (!buffer_uptodate(rabh)) {
314 rabh->b_end_io = end_buffer_read_sync;
315 submit_bh(REQ_OP_READ,
316 REQ_RAHEAD | REQ_META | REQ_PRIO,
326 static int __fillup_metapath(struct gfs2_inode *ip, struct metapath *mp,
327 unsigned int x, unsigned int h)
330 __be64 *ptr = metapointer(x, mp);
331 u64 dblock = be64_to_cpu(*ptr);
336 ret = gfs2_meta_indirect_buffer(ip, x + 1, dblock, &mp->mp_bh[x + 1]);
340 mp->mp_aheight = x + 1;
345 * lookup_metapath - Walk the metadata tree to a specific point
349 * Assumes that the inode's buffer has already been looked up and
350 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
351 * by find_metapath().
353 * If this function encounters part of the tree which has not been
354 * allocated, it returns the current height of the tree at the point
355 * at which it found the unallocated block. Blocks which are found are
356 * added to the mp->mp_bh[] list.
361 static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
363 return __fillup_metapath(ip, mp, 0, ip->i_height - 1);
367 * fillup_metapath - fill up buffers for the metadata path to a specific height
370 * @h: The height to which it should be mapped
372 * Similar to lookup_metapath, but does lookups for a range of heights
374 * Returns: error or the number of buffers filled
377 static int fillup_metapath(struct gfs2_inode *ip, struct metapath *mp, int h)
383 /* find the first buffer we need to look up. */
384 for (x = h - 1; x > 0; x--) {
389 ret = __fillup_metapath(ip, mp, x, h);
392 return mp->mp_aheight - x - 1;
395 static void release_metapath(struct metapath *mp)
399 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
400 if (mp->mp_bh[i] == NULL)
402 brelse(mp->mp_bh[i]);
408 * gfs2_extent_length - Returns length of an extent of blocks
409 * @bh: The metadata block
410 * @ptr: Current position in @bh
411 * @limit: Max extent length to return
412 * @eob: Set to 1 if we hit "end of block"
414 * Returns: The length of the extent (minimum of one block)
417 static inline unsigned int gfs2_extent_length(struct buffer_head *bh, __be64 *ptr, size_t limit, int *eob)
419 const __be64 *end = (__be64 *)(bh->b_data + bh->b_size);
420 const __be64 *first = ptr;
421 u64 d = be64_to_cpu(*ptr);
429 } while(be64_to_cpu(*ptr) == d);
435 typedef const __be64 *(*gfs2_metadata_walker)(
437 const __be64 *start, const __be64 *end,
438 u64 factor, void *data);
440 #define WALK_STOP ((__be64 *)0)
441 #define WALK_NEXT ((__be64 *)1)
443 static int gfs2_walk_metadata(struct inode *inode, sector_t lblock,
444 u64 len, struct metapath *mp, gfs2_metadata_walker walker,
447 struct metapath clone;
448 struct gfs2_inode *ip = GFS2_I(inode);
449 struct gfs2_sbd *sdp = GFS2_SB(inode);
450 const __be64 *start, *end, *ptr;
455 for (hgt = ip->i_height - 1; hgt >= mp->mp_aheight; hgt--)
456 factor *= sdp->sd_inptrs;
461 /* Walk indirect block. */
462 start = metapointer(hgt, mp);
463 end = metaend(hgt, mp);
465 step = (end - start) * factor;
467 end = start + DIV_ROUND_UP_ULL(len, factor);
469 ptr = walker(mp, start, end, factor, data);
470 if (ptr == WALK_STOP)
475 if (ptr != WALK_NEXT) {
477 mp->mp_list[hgt] += ptr - start;
478 goto fill_up_metapath;
482 /* Decrease height of metapath. */
484 clone_metapath(&clone, mp);
487 brelse(mp->mp_bh[hgt]);
488 mp->mp_bh[hgt] = NULL;
492 factor *= sdp->sd_inptrs;
494 /* Advance in metadata tree. */
495 (mp->mp_list[hgt])++;
496 start = metapointer(hgt, mp);
497 end = metaend(hgt, mp);
499 mp->mp_list[hgt] = 0;
506 /* Increase height of metapath. */
508 clone_metapath(&clone, mp);
511 ret = fillup_metapath(ip, mp, ip->i_height - 1);
516 do_div(factor, sdp->sd_inptrs);
517 mp->mp_aheight = hgt + 1;
520 release_metapath(mp);
524 struct gfs2_hole_walker_args {
528 static const __be64 *gfs2_hole_walker(struct metapath *mp,
529 const __be64 *start, const __be64 *end,
530 u64 factor, void *data)
532 struct gfs2_hole_walker_args *args = data;
535 for (ptr = start; ptr < end; ptr++) {
537 args->blocks += (ptr - start) * factor;
538 if (mp->mp_aheight == mp->mp_fheight)
540 return ptr; /* increase height */
543 args->blocks += (end - start) * factor;
548 * gfs2_hole_size - figure out the size of a hole
550 * @lblock: The logical starting block number
551 * @len: How far to look (in blocks)
552 * @mp: The metapath at lblock
553 * @iomap: The iomap to store the hole size in
555 * This function modifies @mp.
557 * Returns: errno on error
559 static int gfs2_hole_size(struct inode *inode, sector_t lblock, u64 len,
560 struct metapath *mp, struct iomap *iomap)
562 struct gfs2_hole_walker_args args = { };
565 ret = gfs2_walk_metadata(inode, lblock, len, mp, gfs2_hole_walker, &args);
567 iomap->length = args.blocks << inode->i_blkbits;
571 static inline __be64 *gfs2_indirect_init(struct metapath *mp,
572 struct gfs2_glock *gl, unsigned int i,
573 unsigned offset, u64 bn)
575 __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
576 ((i > 1) ? sizeof(struct gfs2_meta_header) :
577 sizeof(struct gfs2_dinode)));
579 BUG_ON(mp->mp_bh[i] != NULL);
580 mp->mp_bh[i] = gfs2_meta_new(gl, bn);
581 gfs2_trans_add_meta(gl, mp->mp_bh[i]);
582 gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
583 gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
585 *ptr = cpu_to_be64(bn);
591 ALLOC_GROW_DEPTH = 1,
592 ALLOC_GROW_HEIGHT = 2,
593 /* ALLOC_UNSTUFF = 3, TBD and rather complicated */
597 * gfs2_iomap_alloc - Build a metadata tree of the requested height
598 * @inode: The GFS2 inode
599 * @iomap: The iomap structure
600 * @flags: iomap flags
601 * @mp: The metapath, with proper height information calculated
603 * In this routine we may have to alloc:
604 * i) Indirect blocks to grow the metadata tree height
605 * ii) Indirect blocks to fill in lower part of the metadata tree
608 * This function is called after gfs2_iomap_get, which works out the
609 * total number of blocks which we need via gfs2_alloc_size.
611 * We then do the actual allocation asking for an extent at a time (if
612 * enough contiguous free blocks are available, there will only be one
613 * allocation request per call) and uses the state machine to initialise
614 * the blocks in order.
616 * Right now, this function will allocate at most one indirect block
617 * worth of data -- with a default block size of 4K, that's slightly
618 * less than 2M. If this limitation is ever removed to allow huge
619 * allocations, we would probably still want to limit the iomap size we
620 * return to avoid stalling other tasks during huge writes; the next
621 * iomap iteration would then find the blocks already allocated.
623 * Returns: errno on error
626 static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,
627 unsigned flags, struct metapath *mp)
629 struct gfs2_inode *ip = GFS2_I(inode);
630 struct gfs2_sbd *sdp = GFS2_SB(inode);
631 struct buffer_head *dibh = mp->mp_bh[0];
633 unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
634 size_t dblks = iomap->length >> inode->i_blkbits;
635 const unsigned end_of_metadata = mp->mp_fheight - 1;
637 enum alloc_state state;
641 BUG_ON(mp->mp_aheight < 1);
642 BUG_ON(dibh == NULL);
645 gfs2_trans_add_meta(ip->i_gl, dibh);
647 down_write(&ip->i_rw_mutex);
649 if (mp->mp_fheight == mp->mp_aheight) {
650 /* Bottom indirect block exists */
653 /* Need to allocate indirect blocks */
654 if (mp->mp_fheight == ip->i_height) {
655 /* Writing into existing tree, extend tree down */
656 iblks = mp->mp_fheight - mp->mp_aheight;
657 state = ALLOC_GROW_DEPTH;
659 /* Building up tree height */
660 state = ALLOC_GROW_HEIGHT;
661 iblks = mp->mp_fheight - ip->i_height;
662 branch_start = metapath_branch_start(mp);
663 iblks += (mp->mp_fheight - branch_start);
667 /* start of the second part of the function (state machine) */
669 blks = dblks + iblks;
673 ret = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
677 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
678 gfs2_trans_add_unrevoke(sdp, bn, n);
680 /* Growing height of tree */
681 case ALLOC_GROW_HEIGHT:
683 ptr = (__be64 *)(dibh->b_data +
684 sizeof(struct gfs2_dinode));
687 for (; i - 1 < mp->mp_fheight - ip->i_height && n > 0;
689 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
690 if (i - 1 == mp->mp_fheight - ip->i_height) {
692 gfs2_buffer_copy_tail(mp->mp_bh[i],
693 sizeof(struct gfs2_meta_header),
694 dibh, sizeof(struct gfs2_dinode));
695 gfs2_buffer_clear_tail(dibh,
696 sizeof(struct gfs2_dinode) +
698 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
699 sizeof(struct gfs2_meta_header));
701 state = ALLOC_GROW_DEPTH;
702 for(i = branch_start; i < mp->mp_fheight; i++) {
703 if (mp->mp_bh[i] == NULL)
705 brelse(mp->mp_bh[i]);
712 /* Branching from existing tree */
713 case ALLOC_GROW_DEPTH:
714 if (i > 1 && i < mp->mp_fheight)
715 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
716 for (; i < mp->mp_fheight && n > 0; i++, n--)
717 gfs2_indirect_init(mp, ip->i_gl, i,
718 mp->mp_list[i-1], bn++);
719 if (i == mp->mp_fheight)
723 /* Tree complete, adding data blocks */
726 BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
727 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
729 ptr = metapointer(end_of_metadata, mp);
730 iomap->addr = bn << inode->i_blkbits;
731 iomap->flags |= IOMAP_F_MERGED | IOMAP_F_NEW;
733 *ptr++ = cpu_to_be64(bn++);
736 } while (iomap->addr == IOMAP_NULL_ADDR);
738 iomap->type = IOMAP_MAPPED;
739 iomap->length = (u64)dblks << inode->i_blkbits;
740 ip->i_height = mp->mp_fheight;
741 gfs2_add_inode_blocks(&ip->i_inode, alloced);
742 gfs2_dinode_out(ip, dibh->b_data);
744 up_write(&ip->i_rw_mutex);
748 #define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE
751 * gfs2_alloc_size - Compute the maximum allocation size
754 * @size: Requested size in blocks
756 * Compute the maximum size of the next allocation at @mp.
758 * Returns: size in blocks
760 static u64 gfs2_alloc_size(struct inode *inode, struct metapath *mp, u64 size)
762 struct gfs2_inode *ip = GFS2_I(inode);
763 struct gfs2_sbd *sdp = GFS2_SB(inode);
764 const __be64 *first, *ptr, *end;
767 * For writes to stuffed files, this function is called twice via
768 * gfs2_iomap_get, before and after unstuffing. The size we return the
769 * first time needs to be large enough to get the reservation and
770 * allocation sizes right. The size we return the second time must
771 * be exact or else gfs2_iomap_alloc won't do the right thing.
774 if (gfs2_is_stuffed(ip) || mp->mp_fheight != mp->mp_aheight) {
775 unsigned int maxsize = mp->mp_fheight > 1 ?
776 sdp->sd_inptrs : sdp->sd_diptrs;
777 maxsize -= mp->mp_list[mp->mp_fheight - 1];
783 first = metapointer(ip->i_height - 1, mp);
784 end = metaend(ip->i_height - 1, mp);
785 if (end - first > size)
787 for (ptr = first; ptr < end; ptr++) {
795 * gfs2_iomap_get - Map blocks from an inode to disk blocks
797 * @pos: Starting position in bytes
798 * @length: Length to map, in bytes
799 * @flags: iomap flags
800 * @iomap: The iomap structure
805 static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length,
806 unsigned flags, struct iomap *iomap,
809 struct gfs2_inode *ip = GFS2_I(inode);
810 struct gfs2_sbd *sdp = GFS2_SB(inode);
811 loff_t size = i_size_read(inode);
814 sector_t lblock_stop;
818 struct buffer_head *dibh = NULL, *bh;
824 down_read(&ip->i_rw_mutex);
826 ret = gfs2_meta_inode_buffer(ip, &dibh);
829 iomap->private = dibh;
831 if (gfs2_is_stuffed(ip)) {
832 if (flags & IOMAP_WRITE) {
833 loff_t max_size = gfs2_max_stuffed_size(ip);
835 if (pos + length > max_size)
837 iomap->length = max_size;
840 if (flags & IOMAP_REPORT) {
846 iomap->length = length;
850 iomap->length = size;
852 iomap->addr = (ip->i_no_addr << inode->i_blkbits) +
853 sizeof(struct gfs2_dinode);
854 iomap->type = IOMAP_INLINE;
855 iomap->inline_data = dibh->b_data + sizeof(struct gfs2_dinode);
860 lblock = pos >> inode->i_blkbits;
861 iomap->offset = lblock << inode->i_blkbits;
862 lblock_stop = (pos + length - 1) >> inode->i_blkbits;
863 len = lblock_stop - lblock + 1;
864 iomap->length = len << inode->i_blkbits;
869 height = ip->i_height;
870 while ((lblock + 1) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])
872 find_metapath(sdp, lblock, mp, height);
873 if (height > ip->i_height || gfs2_is_stuffed(ip))
876 ret = lookup_metapath(ip, mp);
880 if (mp->mp_aheight != ip->i_height)
883 ptr = metapointer(ip->i_height - 1, mp);
887 bh = mp->mp_bh[ip->i_height - 1];
888 len = gfs2_extent_length(bh, ptr, len, &eob);
890 iomap->addr = be64_to_cpu(*ptr) << inode->i_blkbits;
891 iomap->length = len << inode->i_blkbits;
892 iomap->type = IOMAP_MAPPED;
893 iomap->flags |= IOMAP_F_MERGED;
895 iomap->flags |= IOMAP_F_GFS2_BOUNDARY;
898 iomap->bdev = inode->i_sb->s_bdev;
900 up_read(&ip->i_rw_mutex);
906 iomap->addr = IOMAP_NULL_ADDR;
907 iomap->type = IOMAP_HOLE;
908 if (flags & IOMAP_REPORT) {
911 else if (height == ip->i_height)
912 ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
914 iomap->length = size - pos;
915 } else if (flags & IOMAP_WRITE) {
918 if (flags & IOMAP_DIRECT)
919 goto out; /* (see gfs2_file_direct_write) */
921 len = gfs2_alloc_size(inode, mp, len);
922 alloc_size = len << inode->i_blkbits;
923 if (alloc_size < iomap->length)
924 iomap->length = alloc_size;
926 if (pos < size && height == ip->i_height)
927 ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
932 static int gfs2_write_lock(struct inode *inode)
934 struct gfs2_inode *ip = GFS2_I(inode);
935 struct gfs2_sbd *sdp = GFS2_SB(inode);
938 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
939 error = gfs2_glock_nq(&ip->i_gh);
942 if (&ip->i_inode == sdp->sd_rindex) {
943 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
945 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
946 GL_NOCACHE, &m_ip->i_gh);
953 gfs2_glock_dq(&ip->i_gh);
955 gfs2_holder_uninit(&ip->i_gh);
959 static void gfs2_write_unlock(struct inode *inode)
961 struct gfs2_inode *ip = GFS2_I(inode);
962 struct gfs2_sbd *sdp = GFS2_SB(inode);
964 if (&ip->i_inode == sdp->sd_rindex) {
965 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
967 gfs2_glock_dq_uninit(&m_ip->i_gh);
969 gfs2_glock_dq_uninit(&ip->i_gh);
972 static void gfs2_iomap_journaled_page_done(struct inode *inode, loff_t pos,
973 unsigned copied, struct page *page,
976 struct gfs2_inode *ip = GFS2_I(inode);
978 if (!page_has_buffers(page)) {
979 create_empty_buffers(page, inode->i_sb->s_blocksize,
980 (1 << BH_Dirty)|(1 << BH_Uptodate));
982 gfs2_page_add_databufs(ip, page, offset_in_page(pos), copied);
985 static int gfs2_iomap_begin_write(struct inode *inode, loff_t pos,
986 loff_t length, unsigned flags,
989 struct metapath mp = { .mp_aheight = 1, };
990 struct gfs2_inode *ip = GFS2_I(inode);
991 struct gfs2_sbd *sdp = GFS2_SB(inode);
992 unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
993 bool unstuff, alloc_required;
996 ret = gfs2_write_lock(inode);
1000 unstuff = gfs2_is_stuffed(ip) &&
1001 pos + length > gfs2_max_stuffed_size(ip);
1003 ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
1007 alloc_required = unstuff || iomap->type == IOMAP_HOLE;
1009 if (alloc_required || gfs2_is_jdata(ip))
1010 gfs2_write_calc_reserv(ip, iomap->length, &data_blocks,
1013 if (alloc_required) {
1014 struct gfs2_alloc_parms ap = {
1015 .target = data_blocks + ind_blocks
1018 ret = gfs2_quota_lock_check(ip, &ap);
1022 ret = gfs2_inplace_reserve(ip, &ap);
1027 rblocks = RES_DINODE + ind_blocks;
1028 if (gfs2_is_jdata(ip))
1029 rblocks += data_blocks;
1030 if (ind_blocks || data_blocks)
1031 rblocks += RES_STATFS + RES_QUOTA;
1032 if (inode == sdp->sd_rindex)
1033 rblocks += 2 * RES_STATFS;
1035 rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
1037 ret = gfs2_trans_begin(sdp, rblocks, iomap->length >> inode->i_blkbits);
1039 goto out_trans_fail;
1042 ret = gfs2_unstuff_dinode(ip, NULL);
1045 release_metapath(&mp);
1046 brelse(iomap->private);
1047 iomap->private = NULL;
1048 ret = gfs2_iomap_get(inode, iomap->offset, iomap->length,
1054 if (iomap->type == IOMAP_HOLE) {
1055 ret = gfs2_iomap_alloc(inode, iomap, flags, &mp);
1057 gfs2_trans_end(sdp);
1058 gfs2_inplace_release(ip);
1059 punch_hole(ip, iomap->offset, iomap->length);
1063 release_metapath(&mp);
1064 if (gfs2_is_jdata(ip))
1065 iomap->page_done = gfs2_iomap_journaled_page_done;
1069 gfs2_trans_end(sdp);
1072 gfs2_inplace_release(ip);
1075 gfs2_quota_unlock(ip);
1078 brelse(iomap->private);
1079 release_metapath(&mp);
1080 gfs2_write_unlock(inode);
1084 static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
1085 unsigned flags, struct iomap *iomap)
1087 struct gfs2_inode *ip = GFS2_I(inode);
1088 struct metapath mp = { .mp_aheight = 1, };
1091 iomap->flags |= IOMAP_F_BUFFER_HEAD;
1093 trace_gfs2_iomap_start(ip, pos, length, flags);
1094 if ((flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT)) {
1095 ret = gfs2_iomap_begin_write(inode, pos, length, flags, iomap);
1097 ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
1098 release_metapath(&mp);
1100 * Silently fall back to buffered I/O for stuffed files or if
1101 * we've hot a hole (see gfs2_file_direct_write).
1103 if ((flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT) &&
1104 iomap->type != IOMAP_MAPPED)
1107 trace_gfs2_iomap_end(ip, iomap, ret);
1111 static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length,
1112 ssize_t written, unsigned flags, struct iomap *iomap)
1114 struct gfs2_inode *ip = GFS2_I(inode);
1115 struct gfs2_sbd *sdp = GFS2_SB(inode);
1116 struct gfs2_trans *tr = current->journal_info;
1117 struct buffer_head *dibh = iomap->private;
1119 if ((flags & (IOMAP_WRITE | IOMAP_DIRECT)) != IOMAP_WRITE)
1122 if (iomap->type != IOMAP_INLINE) {
1123 gfs2_ordered_add_inode(ip);
1125 if (tr->tr_num_buf_new)
1126 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1128 gfs2_trans_add_meta(ip->i_gl, dibh);
1131 if (inode == sdp->sd_rindex) {
1132 adjust_fs_space(inode);
1133 sdp->sd_rindex_uptodate = 0;
1136 gfs2_trans_end(sdp);
1137 gfs2_inplace_release(ip);
1139 if (length != written && (iomap->flags & IOMAP_F_NEW)) {
1140 /* Deallocate blocks that were just allocated. */
1141 loff_t blockmask = i_blocksize(inode) - 1;
1142 loff_t end = (pos + length) & ~blockmask;
1144 pos = (pos + written + blockmask) & ~blockmask;
1146 truncate_pagecache_range(inode, pos, end - 1);
1147 punch_hole(ip, pos, end - pos);
1151 if (ip->i_qadata && ip->i_qadata->qa_qd_num)
1152 gfs2_quota_unlock(ip);
1153 gfs2_write_unlock(inode);
1161 const struct iomap_ops gfs2_iomap_ops = {
1162 .iomap_begin = gfs2_iomap_begin,
1163 .iomap_end = gfs2_iomap_end,
1167 * gfs2_block_map - Map one or more blocks of an inode to a disk block
1169 * @lblock: The logical block number
1170 * @bh_map: The bh to be mapped
1171 * @create: True if its ok to alloc blocks to satify the request
1173 * The size of the requested mapping is defined in bh_map->b_size.
1175 * Clears buffer_mapped(bh_map) and leaves bh_map->b_size unchanged
1176 * when @lblock is not mapped. Sets buffer_mapped(bh_map) and
1177 * bh_map->b_size to indicate the size of the mapping when @lblock and
1178 * successive blocks are mapped, up to the requested size.
1180 * Sets buffer_boundary() if a read of metadata will be required
1181 * before the next block can be mapped. Sets buffer_new() if new
1182 * blocks were allocated.
1187 int gfs2_block_map(struct inode *inode, sector_t lblock,
1188 struct buffer_head *bh_map, int create)
1190 struct gfs2_inode *ip = GFS2_I(inode);
1191 loff_t pos = (loff_t)lblock << inode->i_blkbits;
1192 loff_t length = bh_map->b_size;
1193 struct metapath mp = { .mp_aheight = 1, };
1194 struct iomap iomap = { };
1197 clear_buffer_mapped(bh_map);
1198 clear_buffer_new(bh_map);
1199 clear_buffer_boundary(bh_map);
1200 trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
1203 ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, &iomap, &mp);
1204 if (!ret && iomap.type == IOMAP_HOLE)
1205 ret = gfs2_iomap_alloc(inode, &iomap, IOMAP_WRITE, &mp);
1206 release_metapath(&mp);
1208 ret = gfs2_iomap_get(inode, pos, length, 0, &iomap, &mp);
1209 release_metapath(&mp);
1214 if (iomap.length > bh_map->b_size) {
1215 iomap.length = bh_map->b_size;
1216 iomap.flags &= ~IOMAP_F_GFS2_BOUNDARY;
1218 if (iomap.addr != IOMAP_NULL_ADDR)
1219 map_bh(bh_map, inode->i_sb, iomap.addr >> inode->i_blkbits);
1220 bh_map->b_size = iomap.length;
1221 if (iomap.flags & IOMAP_F_GFS2_BOUNDARY)
1222 set_buffer_boundary(bh_map);
1223 if (iomap.flags & IOMAP_F_NEW)
1224 set_buffer_new(bh_map);
1227 trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
1232 * Deprecated: do not use in new code
1234 int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
1236 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
1244 bh.b_size = BIT(inode->i_blkbits + (create ? 0 : 5));
1245 ret = gfs2_block_map(inode, lblock, &bh, create);
1246 *extlen = bh.b_size >> inode->i_blkbits;
1247 *dblock = bh.b_blocknr;
1248 if (buffer_new(&bh))
1256 * gfs2_block_zero_range - Deal with zeroing out data
1258 * This is partly borrowed from ext3.
1260 static int gfs2_block_zero_range(struct inode *inode, loff_t from,
1261 unsigned int length)
1263 struct address_space *mapping = inode->i_mapping;
1264 struct gfs2_inode *ip = GFS2_I(inode);
1265 unsigned long index = from >> PAGE_SHIFT;
1266 unsigned offset = from & (PAGE_SIZE-1);
1267 unsigned blocksize, iblock, pos;
1268 struct buffer_head *bh;
1272 page = find_or_create_page(mapping, index, GFP_NOFS);
1276 blocksize = inode->i_sb->s_blocksize;
1277 iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
1279 if (!page_has_buffers(page))
1280 create_empty_buffers(page, blocksize, 0);
1282 /* Find the buffer that contains "offset" */
1283 bh = page_buffers(page);
1285 while (offset >= pos) {
1286 bh = bh->b_this_page;
1293 if (!buffer_mapped(bh)) {
1294 gfs2_block_map(inode, iblock, bh, 0);
1295 /* unmapped? It's a hole - nothing to do */
1296 if (!buffer_mapped(bh))
1300 /* Ok, it's mapped. Make sure it's up-to-date */
1301 if (PageUptodate(page))
1302 set_buffer_uptodate(bh);
1304 if (!buffer_uptodate(bh)) {
1306 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1308 /* Uhhuh. Read error. Complain and punt. */
1309 if (!buffer_uptodate(bh))
1314 if (gfs2_is_jdata(ip))
1315 gfs2_trans_add_data(ip->i_gl, bh);
1317 gfs2_ordered_add_inode(ip);
1319 zero_user(page, offset, length);
1320 mark_buffer_dirty(bh);
1327 #define GFS2_JTRUNC_REVOKES 8192
1330 * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
1331 * @inode: The inode being truncated
1332 * @oldsize: The original (larger) size
1333 * @newsize: The new smaller size
1335 * With jdata files, we have to journal a revoke for each block which is
1336 * truncated. As a result, we need to split this into separate transactions
1337 * if the number of pages being truncated gets too large.
1340 static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
1342 struct gfs2_sbd *sdp = GFS2_SB(inode);
1343 u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1347 while (oldsize != newsize) {
1348 struct gfs2_trans *tr;
1351 chunk = oldsize - newsize;
1352 if (chunk > max_chunk)
1355 offs = oldsize & ~PAGE_MASK;
1356 if (offs && chunk > PAGE_SIZE)
1357 chunk = offs + ((chunk - offs) & PAGE_MASK);
1359 truncate_pagecache(inode, oldsize - chunk);
1362 tr = current->journal_info;
1363 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
1366 gfs2_trans_end(sdp);
1367 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1375 static int trunc_start(struct inode *inode, u64 newsize)
1377 struct gfs2_inode *ip = GFS2_I(inode);
1378 struct gfs2_sbd *sdp = GFS2_SB(inode);
1379 struct buffer_head *dibh = NULL;
1380 int journaled = gfs2_is_jdata(ip);
1381 u64 oldsize = inode->i_size;
1385 error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1387 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1391 error = gfs2_meta_inode_buffer(ip, &dibh);
1395 gfs2_trans_add_meta(ip->i_gl, dibh);
1397 if (gfs2_is_stuffed(ip)) {
1398 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1400 unsigned int blocksize = i_blocksize(inode);
1401 unsigned int offs = newsize & (blocksize - 1);
1403 error = gfs2_block_zero_range(inode, newsize,
1408 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
1411 i_size_write(inode, newsize);
1412 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1413 gfs2_dinode_out(ip, dibh->b_data);
1416 error = gfs2_journaled_truncate(inode, oldsize, newsize);
1418 truncate_pagecache(inode, newsize);
1422 if (current->journal_info)
1423 gfs2_trans_end(sdp);
1427 int gfs2_iomap_get_alloc(struct inode *inode, loff_t pos, loff_t length,
1428 struct iomap *iomap)
1430 struct metapath mp = { .mp_aheight = 1, };
1433 ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, iomap, &mp);
1434 if (!ret && iomap->type == IOMAP_HOLE)
1435 ret = gfs2_iomap_alloc(inode, iomap, IOMAP_WRITE, &mp);
1436 release_metapath(&mp);
1441 * sweep_bh_for_rgrps - find an rgrp in a meta buffer and free blocks therein
1443 * @rg_gh: holder of resource group glock
1444 * @bh: buffer head to sweep
1445 * @start: starting point in bh
1446 * @end: end point in bh
1447 * @meta: true if bh points to metadata (rather than data)
1448 * @btotal: place to keep count of total blocks freed
1450 * We sweep a metadata buffer (provided by the metapath) for blocks we need to
1451 * free, and free them all. However, we do it one rgrp at a time. If this
1452 * block has references to multiple rgrps, we break it into individual
1453 * transactions. This allows other processes to use the rgrps while we're
1454 * focused on a single one, for better concurrency / performance.
1455 * At every transaction boundary, we rewrite the inode into the journal.
1456 * That way the bitmaps are kept consistent with the inode and we can recover
1457 * if we're interrupted by power-outages.
1459 * Returns: 0, or return code if an error occurred.
1460 * *btotal has the total number of blocks freed
1462 static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh,
1463 struct buffer_head *bh, __be64 *start, __be64 *end,
1464 bool meta, u32 *btotal)
1466 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1467 struct gfs2_rgrpd *rgd;
1468 struct gfs2_trans *tr;
1470 int blks_outside_rgrp;
1471 u64 bn, bstart, isize_blks;
1472 s64 blen; /* needs to be s64 or gfs2_add_inode_blocks breaks */
1474 bool buf_in_tr = false; /* buffer was added to transaction */
1478 if (gfs2_holder_initialized(rd_gh)) {
1479 rgd = gfs2_glock2rgrp(rd_gh->gh_gl);
1480 gfs2_assert_withdraw(sdp,
1481 gfs2_glock_is_locked_by_me(rd_gh->gh_gl));
1483 blks_outside_rgrp = 0;
1487 for (p = start; p < end; p++) {
1490 bn = be64_to_cpu(*p);
1493 if (!rgrp_contains_block(rgd, bn)) {
1494 blks_outside_rgrp++;
1498 rgd = gfs2_blk2rgrpd(sdp, bn, true);
1499 if (unlikely(!rgd)) {
1503 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1508 /* Must be done with the rgrp glock held: */
1509 if (gfs2_rs_active(&ip->i_res) &&
1510 rgd == ip->i_res.rs_rbm.rgd)
1511 gfs2_rs_deltree(&ip->i_res);
1514 /* The size of our transactions will be unknown until we
1515 actually process all the metadata blocks that relate to
1516 the rgrp. So we estimate. We know it can't be more than
1517 the dinode's i_blocks and we don't want to exceed the
1518 journal flush threshold, sd_log_thresh2. */
1519 if (current->journal_info == NULL) {
1520 unsigned int jblocks_rqsted, revokes;
1522 jblocks_rqsted = rgd->rd_length + RES_DINODE +
1524 isize_blks = gfs2_get_inode_blocks(&ip->i_inode);
1525 if (isize_blks > atomic_read(&sdp->sd_log_thresh2))
1527 atomic_read(&sdp->sd_log_thresh2);
1529 jblocks_rqsted += isize_blks;
1530 revokes = jblocks_rqsted;
1532 revokes += end - start;
1533 else if (ip->i_depth)
1534 revokes += sdp->sd_inptrs;
1535 ret = gfs2_trans_begin(sdp, jblocks_rqsted, revokes);
1538 down_write(&ip->i_rw_mutex);
1540 /* check if we will exceed the transaction blocks requested */
1541 tr = current->journal_info;
1542 if (tr->tr_num_buf_new + RES_STATFS +
1543 RES_QUOTA >= atomic_read(&sdp->sd_log_thresh2)) {
1544 /* We set blks_outside_rgrp to ensure the loop will
1545 be repeated for the same rgrp, but with a new
1547 blks_outside_rgrp++;
1548 /* This next part is tricky. If the buffer was added
1549 to the transaction, we've already set some block
1550 pointers to 0, so we better follow through and free
1551 them, or we will introduce corruption (so break).
1552 This may be impossible, or at least rare, but I
1553 decided to cover the case regardless.
1555 If the buffer was not added to the transaction
1556 (this call), doing so would exceed our transaction
1557 size, so we need to end the transaction and start a
1558 new one (so goto). */
1565 gfs2_trans_add_meta(ip->i_gl, bh);
1568 if (bstart + blen == bn) {
1573 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1575 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1581 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1583 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1586 if (!ret && blks_outside_rgrp) { /* If buffer still has non-zero blocks
1587 outside the rgrp we just processed,
1588 do it all over again. */
1589 if (current->journal_info) {
1590 struct buffer_head *dibh;
1592 ret = gfs2_meta_inode_buffer(ip, &dibh);
1596 /* Every transaction boundary, we rewrite the dinode
1597 to keep its di_blocks current in case of failure. */
1598 ip->i_inode.i_mtime = ip->i_inode.i_ctime =
1599 current_time(&ip->i_inode);
1600 gfs2_trans_add_meta(ip->i_gl, dibh);
1601 gfs2_dinode_out(ip, dibh->b_data);
1603 up_write(&ip->i_rw_mutex);
1604 gfs2_trans_end(sdp);
1606 gfs2_glock_dq_uninit(rd_gh);
1614 static bool mp_eq_to_hgt(struct metapath *mp, __u16 *list, unsigned int h)
1616 if (memcmp(mp->mp_list, list, h * sizeof(mp->mp_list[0])))
1622 * find_nonnull_ptr - find a non-null pointer given a metapath and height
1623 * @mp: starting metapath
1624 * @h: desired height to search
1626 * Assumes the metapath is valid (with buffers) out to height h.
1627 * Returns: true if a non-null pointer was found in the metapath buffer
1628 * false if all remaining pointers are NULL in the buffer
1630 static bool find_nonnull_ptr(struct gfs2_sbd *sdp, struct metapath *mp,
1632 __u16 *end_list, unsigned int end_aligned)
1634 struct buffer_head *bh = mp->mp_bh[h];
1635 __be64 *first, *ptr, *end;
1637 first = metaptr1(h, mp);
1638 ptr = first + mp->mp_list[h];
1639 end = (__be64 *)(bh->b_data + bh->b_size);
1640 if (end_list && mp_eq_to_hgt(mp, end_list, h)) {
1641 bool keep_end = h < end_aligned;
1642 end = first + end_list[h] + keep_end;
1646 if (*ptr) { /* if we have a non-null pointer */
1647 mp->mp_list[h] = ptr - first;
1649 if (h < GFS2_MAX_META_HEIGHT)
1658 enum dealloc_states {
1659 DEALLOC_MP_FULL = 0, /* Strip a metapath with all buffers read in */
1660 DEALLOC_MP_LOWER = 1, /* lower the metapath strip height */
1661 DEALLOC_FILL_MP = 2, /* Fill in the metapath to the given height. */
1662 DEALLOC_DONE = 3, /* process complete */
1666 metapointer_range(struct metapath *mp, int height,
1667 __u16 *start_list, unsigned int start_aligned,
1668 __u16 *end_list, unsigned int end_aligned,
1669 __be64 **start, __be64 **end)
1671 struct buffer_head *bh = mp->mp_bh[height];
1674 first = metaptr1(height, mp);
1676 if (mp_eq_to_hgt(mp, start_list, height)) {
1677 bool keep_start = height < start_aligned;
1678 *start = first + start_list[height] + keep_start;
1680 *end = (__be64 *)(bh->b_data + bh->b_size);
1681 if (end_list && mp_eq_to_hgt(mp, end_list, height)) {
1682 bool keep_end = height < end_aligned;
1683 *end = first + end_list[height] + keep_end;
1687 static inline bool walk_done(struct gfs2_sbd *sdp,
1688 struct metapath *mp, int height,
1689 __u16 *end_list, unsigned int end_aligned)
1694 bool keep_end = height < end_aligned;
1695 if (!mp_eq_to_hgt(mp, end_list, height))
1697 end = end_list[height] + keep_end;
1699 end = (height > 0) ? sdp->sd_inptrs : sdp->sd_diptrs;
1700 return mp->mp_list[height] >= end;
1704 * punch_hole - deallocate blocks in a file
1705 * @ip: inode to truncate
1706 * @offset: the start of the hole
1707 * @length: the size of the hole (or 0 for truncate)
1709 * Punch a hole into a file or truncate a file at a given position. This
1710 * function operates in whole blocks (@offset and @length are rounded
1711 * accordingly); partially filled blocks must be cleared otherwise.
1713 * This function works from the bottom up, and from the right to the left. In
1714 * other words, it strips off the highest layer (data) before stripping any of
1715 * the metadata. Doing it this way is best in case the operation is interrupted
1716 * by power failure, etc. The dinode is rewritten in every transaction to
1717 * guarantee integrity.
1719 static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length)
1721 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1722 u64 maxsize = sdp->sd_heightsize[ip->i_height];
1723 struct metapath mp = {};
1724 struct buffer_head *dibh, *bh;
1725 struct gfs2_holder rd_gh;
1726 unsigned int bsize_shift = sdp->sd_sb.sb_bsize_shift;
1727 u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
1728 __u16 start_list[GFS2_MAX_META_HEIGHT];
1729 __u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
1730 unsigned int start_aligned, uninitialized_var(end_aligned);
1731 unsigned int strip_h = ip->i_height - 1;
1734 int mp_h; /* metapath buffers are read in to this height */
1736 __be64 *start, *end;
1738 if (offset >= maxsize) {
1740 * The starting point lies beyond the allocated meta-data;
1741 * there are no blocks do deallocate.
1747 * The start position of the hole is defined by lblock, start_list, and
1748 * start_aligned. The end position of the hole is defined by lend,
1749 * end_list, and end_aligned.
1751 * start_aligned and end_aligned define down to which height the start
1752 * and end positions are aligned to the metadata tree (i.e., the
1753 * position is a multiple of the metadata granularity at the height
1754 * above). This determines at which heights additional meta pointers
1755 * needs to be preserved for the remaining data.
1759 u64 end_offset = offset + length;
1763 * Clip the end at the maximum file size for the given height:
1764 * that's how far the metadata goes; files bigger than that
1765 * will have additional layers of indirection.
1767 if (end_offset > maxsize)
1768 end_offset = maxsize;
1769 lend = end_offset >> bsize_shift;
1774 find_metapath(sdp, lend, &mp, ip->i_height);
1775 end_list = __end_list;
1776 memcpy(end_list, mp.mp_list, sizeof(mp.mp_list));
1778 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1785 find_metapath(sdp, lblock, &mp, ip->i_height);
1786 memcpy(start_list, mp.mp_list, sizeof(start_list));
1788 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1789 if (start_list[mp_h])
1792 start_aligned = mp_h;
1794 ret = gfs2_meta_inode_buffer(ip, &dibh);
1799 ret = lookup_metapath(ip, &mp);
1803 /* issue read-ahead on metadata */
1804 for (mp_h = 0; mp_h < mp.mp_aheight - 1; mp_h++) {
1805 metapointer_range(&mp, mp_h, start_list, start_aligned,
1806 end_list, end_aligned, &start, &end);
1807 gfs2_metapath_ra(ip->i_gl, start, end);
1810 if (mp.mp_aheight == ip->i_height)
1811 state = DEALLOC_MP_FULL; /* We have a complete metapath */
1813 state = DEALLOC_FILL_MP; /* deal with partial metapath */
1815 ret = gfs2_rindex_update(sdp);
1819 ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1822 gfs2_holder_mark_uninitialized(&rd_gh);
1826 while (state != DEALLOC_DONE) {
1828 /* Truncate a full metapath at the given strip height.
1829 * Note that strip_h == mp_h in order to be in this state. */
1830 case DEALLOC_MP_FULL:
1831 bh = mp.mp_bh[mp_h];
1832 gfs2_assert_withdraw(sdp, bh);
1833 if (gfs2_assert_withdraw(sdp,
1834 prev_bnr != bh->b_blocknr)) {
1835 printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1836 "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1838 (unsigned long long)ip->i_no_addr,
1839 prev_bnr, ip->i_height, strip_h, mp_h);
1841 prev_bnr = bh->b_blocknr;
1843 if (gfs2_metatype_check(sdp, bh,
1844 (mp_h ? GFS2_METATYPE_IN :
1845 GFS2_METATYPE_DI))) {
1851 * Below, passing end_aligned as 0 gives us the
1852 * metapointer range excluding the end point: the end
1853 * point is the first metapath we must not deallocate!
1856 metapointer_range(&mp, mp_h, start_list, start_aligned,
1857 end_list, 0 /* end_aligned */,
1859 ret = sweep_bh_for_rgrps(ip, &rd_gh, mp.mp_bh[mp_h],
1861 mp_h != ip->i_height - 1,
1864 /* If we hit an error or just swept dinode buffer,
1867 state = DEALLOC_DONE;
1870 state = DEALLOC_MP_LOWER;
1873 /* lower the metapath strip height */
1874 case DEALLOC_MP_LOWER:
1875 /* We're done with the current buffer, so release it,
1876 unless it's the dinode buffer. Then back up to the
1877 previous pointer. */
1879 brelse(mp.mp_bh[mp_h]);
1880 mp.mp_bh[mp_h] = NULL;
1882 /* If we can't get any lower in height, we've stripped
1883 off all we can. Next step is to back up and start
1884 stripping the previous level of metadata. */
1887 memcpy(mp.mp_list, start_list, sizeof(start_list));
1889 state = DEALLOC_FILL_MP;
1892 mp.mp_list[mp_h] = 0;
1893 mp_h--; /* search one metadata height down */
1895 if (walk_done(sdp, &mp, mp_h, end_list, end_aligned))
1897 /* Here we've found a part of the metapath that is not
1898 * allocated. We need to search at that height for the
1899 * next non-null pointer. */
1900 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) {
1901 state = DEALLOC_FILL_MP;
1904 /* No more non-null pointers at this height. Back up
1905 to the previous height and try again. */
1906 break; /* loop around in the same state */
1908 /* Fill the metapath with buffers to the given height. */
1909 case DEALLOC_FILL_MP:
1910 /* Fill the buffers out to the current height. */
1911 ret = fillup_metapath(ip, &mp, mp_h);
1915 /* issue read-ahead on metadata */
1916 if (mp.mp_aheight > 1) {
1917 for (; ret > 1; ret--) {
1918 metapointer_range(&mp, mp.mp_aheight - ret,
1919 start_list, start_aligned,
1920 end_list, end_aligned,
1922 gfs2_metapath_ra(ip->i_gl, start, end);
1926 /* If buffers found for the entire strip height */
1927 if (mp.mp_aheight - 1 == strip_h) {
1928 state = DEALLOC_MP_FULL;
1931 if (mp.mp_aheight < ip->i_height) /* We have a partial height */
1932 mp_h = mp.mp_aheight - 1;
1934 /* If we find a non-null block pointer, crawl a bit
1935 higher up in the metapath and try again, otherwise
1936 we need to look lower for a new starting point. */
1937 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned))
1940 state = DEALLOC_MP_LOWER;
1946 if (current->journal_info == NULL) {
1947 ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS +
1951 down_write(&ip->i_rw_mutex);
1953 gfs2_statfs_change(sdp, 0, +btotal, 0);
1954 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
1956 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1957 gfs2_trans_add_meta(ip->i_gl, dibh);
1958 gfs2_dinode_out(ip, dibh->b_data);
1959 up_write(&ip->i_rw_mutex);
1960 gfs2_trans_end(sdp);
1964 if (gfs2_holder_initialized(&rd_gh))
1965 gfs2_glock_dq_uninit(&rd_gh);
1966 if (current->journal_info) {
1967 up_write(&ip->i_rw_mutex);
1968 gfs2_trans_end(sdp);
1971 gfs2_quota_unhold(ip);
1973 release_metapath(&mp);
1977 static int trunc_end(struct gfs2_inode *ip)
1979 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1980 struct buffer_head *dibh;
1983 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1987 down_write(&ip->i_rw_mutex);
1989 error = gfs2_meta_inode_buffer(ip, &dibh);
1993 if (!i_size_read(&ip->i_inode)) {
1995 ip->i_goal = ip->i_no_addr;
1996 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1997 gfs2_ordered_del_inode(ip);
1999 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
2000 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
2002 gfs2_trans_add_meta(ip->i_gl, dibh);
2003 gfs2_dinode_out(ip, dibh->b_data);
2007 up_write(&ip->i_rw_mutex);
2008 gfs2_trans_end(sdp);
2013 * do_shrink - make a file smaller
2015 * @newsize: the size to make the file
2017 * Called with an exclusive lock on @inode. The @size must
2018 * be equal to or smaller than the current inode size.
2023 static int do_shrink(struct inode *inode, u64 newsize)
2025 struct gfs2_inode *ip = GFS2_I(inode);
2028 error = trunc_start(inode, newsize);
2031 if (gfs2_is_stuffed(ip))
2034 error = punch_hole(ip, newsize, 0);
2036 error = trunc_end(ip);
2041 void gfs2_trim_blocks(struct inode *inode)
2045 ret = do_shrink(inode, inode->i_size);
2050 * do_grow - Touch and update inode size
2052 * @size: The new size
2054 * This function updates the timestamps on the inode and
2055 * may also increase the size of the inode. This function
2056 * must not be called with @size any smaller than the current
2059 * Although it is not strictly required to unstuff files here,
2060 * earlier versions of GFS2 have a bug in the stuffed file reading
2061 * code which will result in a buffer overrun if the size is larger
2062 * than the max stuffed file size. In order to prevent this from
2063 * occurring, such files are unstuffed, but in other cases we can
2064 * just update the inode size directly.
2066 * Returns: 0 on success, or -ve on error
2069 static int do_grow(struct inode *inode, u64 size)
2071 struct gfs2_inode *ip = GFS2_I(inode);
2072 struct gfs2_sbd *sdp = GFS2_SB(inode);
2073 struct gfs2_alloc_parms ap = { .target = 1, };
2074 struct buffer_head *dibh;
2078 if (gfs2_is_stuffed(ip) && size > gfs2_max_stuffed_size(ip)) {
2079 error = gfs2_quota_lock_check(ip, &ap);
2083 error = gfs2_inplace_reserve(ip, &ap);
2085 goto do_grow_qunlock;
2089 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
2090 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
2093 goto do_grow_release;
2096 error = gfs2_unstuff_dinode(ip, NULL);
2101 error = gfs2_meta_inode_buffer(ip, &dibh);
2105 i_size_write(inode, size);
2106 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
2107 gfs2_trans_add_meta(ip->i_gl, dibh);
2108 gfs2_dinode_out(ip, dibh->b_data);
2112 gfs2_trans_end(sdp);
2115 gfs2_inplace_release(ip);
2117 gfs2_quota_unlock(ip);
2123 * gfs2_setattr_size - make a file a given size
2125 * @newsize: the size to make the file
2127 * The file size can grow, shrink, or stay the same size. This
2128 * is called holding i_rwsem and an exclusive glock on the inode
2134 int gfs2_setattr_size(struct inode *inode, u64 newsize)
2136 struct gfs2_inode *ip = GFS2_I(inode);
2139 BUG_ON(!S_ISREG(inode->i_mode));
2141 ret = inode_newsize_ok(inode, newsize);
2145 inode_dio_wait(inode);
2147 ret = gfs2_rsqa_alloc(ip);
2151 if (newsize >= inode->i_size) {
2152 ret = do_grow(inode, newsize);
2156 ret = do_shrink(inode, newsize);
2158 gfs2_rsqa_delete(ip, NULL);
2162 int gfs2_truncatei_resume(struct gfs2_inode *ip)
2165 error = punch_hole(ip, i_size_read(&ip->i_inode), 0);
2167 error = trunc_end(ip);
2171 int gfs2_file_dealloc(struct gfs2_inode *ip)
2173 return punch_hole(ip, 0, 0);
2177 * gfs2_free_journal_extents - Free cached journal bmap info
2182 void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
2184 struct gfs2_journal_extent *jext;
2186 while(!list_empty(&jd->extent_list)) {
2187 jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
2188 list_del(&jext->list);
2194 * gfs2_add_jextent - Add or merge a new extent to extent cache
2195 * @jd: The journal descriptor
2196 * @lblock: The logical block at start of new extent
2197 * @dblock: The physical block at start of new extent
2198 * @blocks: Size of extent in fs blocks
2200 * Returns: 0 on success or -ENOMEM
2203 static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
2205 struct gfs2_journal_extent *jext;
2207 if (!list_empty(&jd->extent_list)) {
2208 jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
2209 if ((jext->dblock + jext->blocks) == dblock) {
2210 jext->blocks += blocks;
2215 jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
2218 jext->dblock = dblock;
2219 jext->lblock = lblock;
2220 jext->blocks = blocks;
2221 list_add_tail(&jext->list, &jd->extent_list);
2227 * gfs2_map_journal_extents - Cache journal bmap info
2228 * @sdp: The super block
2229 * @jd: The journal to map
2231 * Create a reusable "extent" mapping from all logical
2232 * blocks to all physical blocks for the given journal. This will save
2233 * us time when writing journal blocks. Most journals will have only one
2234 * extent that maps all their logical blocks. That's because gfs2.mkfs
2235 * arranges the journal blocks sequentially to maximize performance.
2236 * So the extent would map the first block for the entire file length.
2237 * However, gfs2_jadd can happen while file activity is happening, so
2238 * those journals may not be sequential. Less likely is the case where
2239 * the users created their own journals by mounting the metafs and
2240 * laying it out. But it's still possible. These journals might have
2243 * Returns: 0 on success, or error on failure
2246 int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
2250 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
2251 struct buffer_head bh;
2252 unsigned int shift = sdp->sd_sb.sb_bsize_shift;
2256 lblock_stop = i_size_read(jd->jd_inode) >> shift;
2257 size = (lblock_stop - lblock) << shift;
2259 WARN_ON(!list_empty(&jd->extent_list));
2265 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
2266 if (rc || !buffer_mapped(&bh))
2268 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
2272 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2275 fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
2280 fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
2282 (unsigned long long)(i_size_read(jd->jd_inode) - size),
2284 fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
2285 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
2286 bh.b_state, (unsigned long long)bh.b_size);
2287 gfs2_free_journal_extents(jd);
2292 * gfs2_write_alloc_required - figure out if a write will require an allocation
2293 * @ip: the file being written to
2294 * @offset: the offset to write to
2295 * @len: the number of bytes being written
2297 * Returns: 1 if an alloc is required, 0 otherwise
2300 int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
2303 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2304 struct buffer_head bh;
2306 u64 lblock, lblock_stop, size;
2312 if (gfs2_is_stuffed(ip)) {
2313 if (offset + len > gfs2_max_stuffed_size(ip))
2318 shift = sdp->sd_sb.sb_bsize_shift;
2319 BUG_ON(gfs2_is_dir(ip));
2320 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
2321 lblock = offset >> shift;
2322 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
2323 if (lblock_stop > end_of_file && ip != GFS2_I(sdp->sd_rindex))
2326 size = (lblock_stop - lblock) << shift;
2330 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
2331 if (!buffer_mapped(&bh))
2334 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2340 static int stuffed_zero_range(struct inode *inode, loff_t offset, loff_t length)
2342 struct gfs2_inode *ip = GFS2_I(inode);
2343 struct buffer_head *dibh;
2346 if (offset >= inode->i_size)
2348 if (offset + length > inode->i_size)
2349 length = inode->i_size - offset;
2351 error = gfs2_meta_inode_buffer(ip, &dibh);
2354 gfs2_trans_add_meta(ip->i_gl, dibh);
2355 memset(dibh->b_data + sizeof(struct gfs2_dinode) + offset, 0,
2361 static int gfs2_journaled_truncate_range(struct inode *inode, loff_t offset,
2364 struct gfs2_sbd *sdp = GFS2_SB(inode);
2365 loff_t max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
2369 struct gfs2_trans *tr;
2374 if (chunk > max_chunk)
2377 offs = offset & ~PAGE_MASK;
2378 if (offs && chunk > PAGE_SIZE)
2379 chunk = offs + ((chunk - offs) & PAGE_MASK);
2381 truncate_pagecache_range(inode, offset, chunk);
2385 tr = current->journal_info;
2386 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
2389 gfs2_trans_end(sdp);
2390 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
2397 int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length)
2399 struct inode *inode = file_inode(file);
2400 struct gfs2_inode *ip = GFS2_I(inode);
2401 struct gfs2_sbd *sdp = GFS2_SB(inode);
2404 if (gfs2_is_jdata(ip))
2405 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
2406 GFS2_JTRUNC_REVOKES);
2408 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
2412 if (gfs2_is_stuffed(ip)) {
2413 error = stuffed_zero_range(inode, offset, length);
2417 unsigned int start_off, end_len, blocksize;
2419 blocksize = i_blocksize(inode);
2420 start_off = offset & (blocksize - 1);
2421 end_len = (offset + length) & (blocksize - 1);
2423 unsigned int len = length;
2424 if (length > blocksize - start_off)
2425 len = blocksize - start_off;
2426 error = gfs2_block_zero_range(inode, offset, len);
2429 if (start_off + length < blocksize)
2433 error = gfs2_block_zero_range(inode,
2434 offset + length - end_len, end_len);
2440 if (gfs2_is_jdata(ip)) {
2441 BUG_ON(!current->journal_info);
2442 gfs2_journaled_truncate_range(inode, offset, length);
2444 truncate_pagecache_range(inode, offset, offset + length - 1);
2446 file_update_time(file);
2447 mark_inode_dirty(inode);
2449 if (current->journal_info)
2450 gfs2_trans_end(sdp);
2452 if (!gfs2_is_stuffed(ip))
2453 error = punch_hole(ip, offset, length);
2456 if (current->journal_info)
2457 gfs2_trans_end(sdp);