Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[sfrench/cifs-2.6.git] / fs / gfs2 / bmap.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
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.
8  */
9
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>
17
18 #include "gfs2.h"
19 #include "incore.h"
20 #include "bmap.h"
21 #include "glock.h"
22 #include "inode.h"
23 #include "meta_io.h"
24 #include "quota.h"
25 #include "rgrp.h"
26 #include "log.h"
27 #include "super.h"
28 #include "trans.h"
29 #include "dir.h"
30 #include "util.h"
31 #include "aops.h"
32 #include "trace_gfs2.h"
33
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
36  * keep it small.
37  */
38 struct metapath {
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) */
43 };
44
45 static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length);
46
47 /**
48  * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
49  * @ip: the inode
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
53  *
54  * Returns: errno
55  */
56
57 static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
58                                u64 block, struct page *page)
59 {
60         struct inode *inode = &ip->i_inode;
61         struct buffer_head *bh;
62         int release = 0;
63
64         if (!page || page->index) {
65                 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
66                 if (!page)
67                         return -ENOMEM;
68                 release = 1;
69         }
70
71         if (!PageUptodate(page)) {
72                 void *kaddr = kmap(page);
73                 u64 dsize = i_size_read(inode);
74  
75                 if (dsize > gfs2_max_stuffed_size(ip))
76                         dsize = gfs2_max_stuffed_size(ip);
77
78                 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
79                 memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
80                 kunmap(page);
81
82                 SetPageUptodate(page);
83         }
84
85         if (!page_has_buffers(page))
86                 create_empty_buffers(page, BIT(inode->i_blkbits),
87                                      BIT(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                 gfs2_trans_add_data(ip->i_gl, bh);
97         else {
98                 mark_buffer_dirty(bh);
99                 gfs2_ordered_add_inode(ip);
100         }
101
102         if (release) {
103                 unlock_page(page);
104                 put_page(page);
105         }
106
107         return 0;
108 }
109
110 /**
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
114  *
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.
117  *
118  * Returns: errno
119  */
120
121 int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
122 {
123         struct buffer_head *bh, *dibh;
124         struct gfs2_dinode *di;
125         u64 block = 0;
126         int isdir = gfs2_is_dir(ip);
127         int error;
128
129         down_write(&ip->i_rw_mutex);
130
131         error = gfs2_meta_inode_buffer(ip, &dibh);
132         if (error)
133                 goto out;
134
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 */
138
139                 unsigned int n = 1;
140                 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
141                 if (error)
142                         goto out_brelse;
143                 if (isdir) {
144                         gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
145                         error = gfs2_dir_get_new_buffer(ip, block, &bh);
146                         if (error)
147                                 goto out_brelse;
148                         gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
149                                               dibh, sizeof(struct gfs2_dinode));
150                         brelse(bh);
151                 } else {
152                         error = gfs2_unstuffer_page(ip, dibh, block, page);
153                         if (error)
154                                 goto out_brelse;
155                 }
156         }
157
158         /*  Set up the pointer to the new block  */
159
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));
163
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));
168         }
169
170         ip->i_height = 1;
171         di->di_height = cpu_to_be16(1);
172
173 out_brelse:
174         brelse(dibh);
175 out:
176         up_write(&ip->i_rw_mutex);
177         return error;
178 }
179
180
181 /**
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
187  *
188  *   This routine returns a struct metapath structure that defines a path
189  *   through the metadata of inode "ip" to get to block "block".
190  *
191  *   Example:
192  *   Given:  "ip" is a height 3 file, "offset" is 101342453, and this is a
193  *   filesystem with a blocksize of 4096.
194  *
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.
197  *
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.
203  *
204  *             ----------------------------------------
205  *             | Dinode |                             |
206  *             |        |                            4|
207  *             |        |0 1 2 3 4 5                 9|
208  *             |        |                            6|
209  *             ----------------------------------------
210  *                       |
211  *                       |
212  *                       V
213  *             ----------------------------------------
214  *             | Indirect Block                       |
215  *             |                                     5|
216  *             |            4 4 4 4 4 5 5            1|
217  *             |0           5 6 7 8 9 0 1            2|
218  *             ----------------------------------------
219  *                                |
220  *                                |
221  *                                V
222  *             ----------------------------------------
223  *             | Indirect Block                       |
224  *             |                         1 1 1 1 1   5|
225  *             |                         6 6 6 6 6   1|
226  *             |0                        3 4 5 6 7   2|
227  *             ----------------------------------------
228  *                                           |
229  *                                           |
230  *                                           V
231  *             ----------------------------------------
232  *             | Data block containing offset         |
233  *             |            101342453                 |
234  *             |                                      |
235  *             |                                      |
236  *             ----------------------------------------
237  *
238  */
239
240 static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
241                           struct metapath *mp, unsigned int height)
242 {
243         unsigned int i;
244
245         mp->mp_fheight = height;
246         for (i = height; i--;)
247                 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
248 }
249
250 static 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  * metaptr1 - Return the first possible metadata pointer in a metapath buffer
259  * @height: The metadata height (0 = dinode)
260  * @mp: The metapath
261  */
262 static inline __be64 *metaptr1(unsigned int height, const struct metapath *mp)
263 {
264         struct buffer_head *bh = mp->mp_bh[height];
265         if (height == 0)
266                 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)));
267         return ((__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)));
268 }
269
270 /**
271  * metapointer - Return pointer to start of metadata in a buffer
272  * @height: The metadata height (0 = dinode)
273  * @mp: The metapath
274  *
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
277  * metadata tree.
278  */
279
280 static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
281 {
282         __be64 *p = metaptr1(height, mp);
283         return p + mp->mp_list[height];
284 }
285
286 static inline const __be64 *metaend(unsigned int height, const struct metapath *mp)
287 {
288         const struct buffer_head *bh = mp->mp_bh[height];
289         return (const __be64 *)(bh->b_data + bh->b_size);
290 }
291
292 static void clone_metapath(struct metapath *clone, struct metapath *mp)
293 {
294         unsigned int hgt;
295
296         *clone = *mp;
297         for (hgt = 0; hgt < mp->mp_aheight; hgt++)
298                 get_bh(clone->mp_bh[hgt]);
299 }
300
301 static void gfs2_metapath_ra(struct gfs2_glock *gl, __be64 *start, __be64 *end)
302 {
303         const __be64 *t;
304
305         for (t = start; t < end; t++) {
306                 struct buffer_head *rabh;
307
308                 if (!*t)
309                         continue;
310
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,
317                                           rabh);
318                                 continue;
319                         }
320                         unlock_buffer(rabh);
321                 }
322                 brelse(rabh);
323         }
324 }
325
326 static int __fillup_metapath(struct gfs2_inode *ip, struct metapath *mp,
327                              unsigned int x, unsigned int h)
328 {
329         for (; x < h; x++) {
330                 __be64 *ptr = metapointer(x, mp);
331                 u64 dblock = be64_to_cpu(*ptr);
332                 int ret;
333
334                 if (!dblock)
335                         break;
336                 ret = gfs2_meta_indirect_buffer(ip, x + 1, dblock, &mp->mp_bh[x + 1]);
337                 if (ret)
338                         return ret;
339         }
340         mp->mp_aheight = x + 1;
341         return 0;
342 }
343
344 /**
345  * lookup_metapath - Walk the metadata tree to a specific point
346  * @ip: The inode
347  * @mp: The metapath
348  *
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().
352  *
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.
357  *
358  * Returns: error
359  */
360
361 static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
362 {
363         return __fillup_metapath(ip, mp, 0, ip->i_height - 1);
364 }
365
366 /**
367  * fillup_metapath - fill up buffers for the metadata path to a specific height
368  * @ip: The inode
369  * @mp: The metapath
370  * @h: The height to which it should be mapped
371  *
372  * Similar to lookup_metapath, but does lookups for a range of heights
373  *
374  * Returns: error or the number of buffers filled
375  */
376
377 static int fillup_metapath(struct gfs2_inode *ip, struct metapath *mp, int h)
378 {
379         unsigned int x = 0;
380         int ret;
381
382         if (h) {
383                 /* find the first buffer we need to look up. */
384                 for (x = h - 1; x > 0; x--) {
385                         if (mp->mp_bh[x])
386                                 break;
387                 }
388         }
389         ret = __fillup_metapath(ip, mp, x, h);
390         if (ret)
391                 return ret;
392         return mp->mp_aheight - x - 1;
393 }
394
395 static void release_metapath(struct metapath *mp)
396 {
397         int i;
398
399         for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
400                 if (mp->mp_bh[i] == NULL)
401                         break;
402                 brelse(mp->mp_bh[i]);
403                 mp->mp_bh[i] = NULL;
404         }
405 }
406
407 /**
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"
413  *
414  * Returns: The length of the extent (minimum of one block)
415  */
416
417 static inline unsigned int gfs2_extent_length(struct buffer_head *bh, __be64 *ptr, size_t limit, int *eob)
418 {
419         const __be64 *end = (__be64 *)(bh->b_data + bh->b_size);
420         const __be64 *first = ptr;
421         u64 d = be64_to_cpu(*ptr);
422
423         *eob = 0;
424         do {
425                 ptr++;
426                 if (ptr >= end)
427                         break;
428                 d++;
429         } while(be64_to_cpu(*ptr) == d);
430         if (ptr >= end)
431                 *eob = 1;
432         return ptr - first;
433 }
434
435 typedef const __be64 *(*gfs2_metadata_walker)(
436                 struct metapath *mp,
437                 const __be64 *start, const __be64 *end,
438                 u64 factor, void *data);
439
440 #define WALK_STOP ((__be64 *)0)
441 #define WALK_NEXT ((__be64 *)1)
442
443 static int gfs2_walk_metadata(struct inode *inode, sector_t lblock,
444                 u64 len, struct metapath *mp, gfs2_metadata_walker walker,
445                 void *data)
446 {
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;
451         u64 factor = 1;
452         unsigned int hgt;
453         int ret = 0;
454
455         for (hgt = ip->i_height - 1; hgt >= mp->mp_aheight; hgt--)
456                 factor *= sdp->sd_inptrs;
457
458         for (;;) {
459                 u64 step;
460
461                 /* Walk indirect block. */
462                 start = metapointer(hgt, mp);
463                 end = metaend(hgt, mp);
464
465                 step = (end - start) * factor;
466                 if (step > len)
467                         end = start + DIV_ROUND_UP_ULL(len, factor);
468
469                 ptr = walker(mp, start, end, factor, data);
470                 if (ptr == WALK_STOP)
471                         break;
472                 if (step >= len)
473                         break;
474                 len -= step;
475                 if (ptr != WALK_NEXT) {
476                         BUG_ON(!*ptr);
477                         mp->mp_list[hgt] += ptr - start;
478                         goto fill_up_metapath;
479                 }
480
481 lower_metapath:
482                 /* Decrease height of metapath. */
483                 if (mp != &clone) {
484                         clone_metapath(&clone, mp);
485                         mp = &clone;
486                 }
487                 brelse(mp->mp_bh[hgt]);
488                 mp->mp_bh[hgt] = NULL;
489                 if (!hgt)
490                         break;
491                 hgt--;
492                 factor *= sdp->sd_inptrs;
493
494                 /* Advance in metadata tree. */
495                 (mp->mp_list[hgt])++;
496                 start = metapointer(hgt, mp);
497                 end = metaend(hgt, mp);
498                 if (start >= end) {
499                         mp->mp_list[hgt] = 0;
500                         if (!hgt)
501                                 break;
502                         goto lower_metapath;
503                 }
504
505 fill_up_metapath:
506                 /* Increase height of metapath. */
507                 if (mp != &clone) {
508                         clone_metapath(&clone, mp);
509                         mp = &clone;
510                 }
511                 ret = fillup_metapath(ip, mp, ip->i_height - 1);
512                 if (ret < 0)
513                         break;
514                 hgt += ret;
515                 for (; ret; ret--)
516                         do_div(factor, sdp->sd_inptrs);
517                 mp->mp_aheight = hgt + 1;
518         }
519         if (mp == &clone)
520                 release_metapath(mp);
521         return ret;
522 }
523
524 struct gfs2_hole_walker_args {
525         u64 blocks;
526 };
527
528 static const __be64 *gfs2_hole_walker(struct metapath *mp,
529                 const __be64 *start, const __be64 *end,
530                 u64 factor, void *data)
531 {
532         struct gfs2_hole_walker_args *args = data;
533         const __be64 *ptr;
534
535         for (ptr = start; ptr < end; ptr++) {
536                 if (*ptr) {
537                         args->blocks += (ptr - start) * factor;
538                         if (mp->mp_aheight == mp->mp_fheight)
539                                 return WALK_STOP;
540                         return ptr;  /* increase height */
541                 }
542         }
543         args->blocks += (end - start) * factor;
544         return WALK_NEXT;
545 }
546
547 /**
548  * gfs2_hole_size - figure out the size of a hole
549  * @inode: The inode
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
554  *
555  * This function modifies @mp.
556  *
557  * Returns: errno on error
558  */
559 static int gfs2_hole_size(struct inode *inode, sector_t lblock, u64 len,
560                           struct metapath *mp, struct iomap *iomap)
561 {
562         struct gfs2_hole_walker_args args = { };
563         int ret = 0;
564
565         ret = gfs2_walk_metadata(inode, lblock, len, mp, gfs2_hole_walker, &args);
566         if (!ret)
567                 iomap->length = args.blocks << inode->i_blkbits;
568         return ret;
569 }
570
571 static inline __be64 *gfs2_indirect_init(struct metapath *mp,
572                                          struct gfs2_glock *gl, unsigned int i,
573                                          unsigned offset, u64 bn)
574 {
575         __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
576                        ((i > 1) ? sizeof(struct gfs2_meta_header) :
577                                  sizeof(struct gfs2_dinode)));
578         BUG_ON(i < 1);
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));
584         ptr += offset;
585         *ptr = cpu_to_be64(bn);
586         return ptr;
587 }
588
589 enum alloc_state {
590         ALLOC_DATA = 0,
591         ALLOC_GROW_DEPTH = 1,
592         ALLOC_GROW_HEIGHT = 2,
593         /* ALLOC_UNSTUFF = 3,   TBD and rather complicated */
594 };
595
596 /**
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
602  *
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
606  * iii) Data blocks
607  *
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.
610  *
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.
615  *
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.
622  *
623  * Returns: errno on error
624  */
625
626 static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,
627                             unsigned flags, struct metapath *mp)
628 {
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];
632         u64 bn;
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;
636         int ret;
637         enum alloc_state state;
638         __be64 *ptr;
639         __be64 zero_bn = 0;
640
641         BUG_ON(mp->mp_aheight < 1);
642         BUG_ON(dibh == NULL);
643         BUG_ON(dblks < 1);
644
645         gfs2_trans_add_meta(ip->i_gl, dibh);
646
647         down_write(&ip->i_rw_mutex);
648
649         if (mp->mp_fheight == mp->mp_aheight) {
650                 /* Bottom indirect block exists */
651                 state = ALLOC_DATA;
652         } else {
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;
658                 } else {
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);
664                 }
665         }
666
667         /* start of the second part of the function (state machine) */
668
669         blks = dblks + iblks;
670         i = mp->mp_aheight;
671         do {
672                 n = blks - alloced;
673                 ret = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
674                 if (ret)
675                         goto out;
676                 alloced += n;
677                 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
678                         gfs2_trans_add_unrevoke(sdp, bn, n);
679                 switch (state) {
680                 /* Growing height of tree */
681                 case ALLOC_GROW_HEIGHT:
682                         if (i == 1) {
683                                 ptr = (__be64 *)(dibh->b_data +
684                                                  sizeof(struct gfs2_dinode));
685                                 zero_bn = *ptr;
686                         }
687                         for (; i - 1 < mp->mp_fheight - ip->i_height && n > 0;
688                              i++, n--)
689                                 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
690                         if (i - 1 == mp->mp_fheight - ip->i_height) {
691                                 i--;
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) +
697                                                 sizeof(__be64));
698                                 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
699                                         sizeof(struct gfs2_meta_header));
700                                 *ptr = zero_bn;
701                                 state = ALLOC_GROW_DEPTH;
702                                 for(i = branch_start; i < mp->mp_fheight; i++) {
703                                         if (mp->mp_bh[i] == NULL)
704                                                 break;
705                                         brelse(mp->mp_bh[i]);
706                                         mp->mp_bh[i] = NULL;
707                                 }
708                                 i = branch_start;
709                         }
710                         if (n == 0)
711                                 break;
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)
720                                 state = ALLOC_DATA;
721                         if (n == 0)
722                                 break;
723                 /* Tree complete, adding data blocks */
724                 case ALLOC_DATA:
725                         BUG_ON(n > dblks);
726                         BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
727                         gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
728                         dblks = n;
729                         ptr = metapointer(end_of_metadata, mp);
730                         iomap->addr = bn << inode->i_blkbits;
731                         iomap->flags |= IOMAP_F_MERGED | IOMAP_F_NEW;
732                         while (n-- > 0)
733                                 *ptr++ = cpu_to_be64(bn++);
734                         break;
735                 }
736         } while (iomap->addr == IOMAP_NULL_ADDR);
737
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);
743 out:
744         up_write(&ip->i_rw_mutex);
745         return ret;
746 }
747
748 #define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE
749
750 /**
751  * gfs2_alloc_size - Compute the maximum allocation size
752  * @inode: The inode
753  * @mp: The metapath
754  * @size: Requested size in blocks
755  *
756  * Compute the maximum size of the next allocation at @mp.
757  *
758  * Returns: size in blocks
759  */
760 static u64 gfs2_alloc_size(struct inode *inode, struct metapath *mp, u64 size)
761 {
762         struct gfs2_inode *ip = GFS2_I(inode);
763         struct gfs2_sbd *sdp = GFS2_SB(inode);
764         const __be64 *first, *ptr, *end;
765
766         /*
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.
772          */
773
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];
778                 if (size > maxsize)
779                         size = maxsize;
780                 return size;
781         }
782
783         first = metapointer(ip->i_height - 1, mp);
784         end = metaend(ip->i_height - 1, mp);
785         if (end - first > size)
786                 end = first + size;
787         for (ptr = first; ptr < end; ptr++) {
788                 if (*ptr)
789                         break;
790         }
791         return ptr - first;
792 }
793
794 /**
795  * gfs2_iomap_get - Map blocks from an inode to disk blocks
796  * @inode: The inode
797  * @pos: Starting position in bytes
798  * @length: Length to map, in bytes
799  * @flags: iomap flags
800  * @iomap: The iomap structure
801  * @mp: The metapath
802  *
803  * Returns: errno
804  */
805 static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length,
806                           unsigned flags, struct iomap *iomap,
807                           struct metapath *mp)
808 {
809         struct gfs2_inode *ip = GFS2_I(inode);
810         struct gfs2_sbd *sdp = GFS2_SB(inode);
811         loff_t size = i_size_read(inode);
812         __be64 *ptr;
813         sector_t lblock;
814         sector_t lblock_stop;
815         int ret;
816         int eob;
817         u64 len;
818         struct buffer_head *dibh = NULL, *bh;
819         u8 height;
820
821         if (!length)
822                 return -EINVAL;
823
824         down_read(&ip->i_rw_mutex);
825
826         ret = gfs2_meta_inode_buffer(ip, &dibh);
827         if (ret)
828                 goto unlock;
829         iomap->private = dibh;
830
831         if (gfs2_is_stuffed(ip)) {
832                 if (flags & IOMAP_WRITE) {
833                         loff_t max_size = gfs2_max_stuffed_size(ip);
834
835                         if (pos + length > max_size)
836                                 goto unstuff;
837                         iomap->length = max_size;
838                 } else {
839                         if (pos >= size) {
840                                 if (flags & IOMAP_REPORT) {
841                                         ret = -ENOENT;
842                                         goto unlock;
843                                 } else {
844                                         /* report a hole */
845                                         iomap->offset = pos;
846                                         iomap->length = length;
847                                         goto do_alloc;
848                                 }
849                         }
850                         iomap->length = size;
851                 }
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);
856                 goto out;
857         }
858
859 unstuff:
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;
865
866         get_bh(dibh);
867         mp->mp_bh[0] = dibh;
868
869         height = ip->i_height;
870         while ((lblock + 1) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])
871                 height++;
872         find_metapath(sdp, lblock, mp, height);
873         if (height > ip->i_height || gfs2_is_stuffed(ip))
874                 goto do_alloc;
875
876         ret = lookup_metapath(ip, mp);
877         if (ret)
878                 goto unlock;
879
880         if (mp->mp_aheight != ip->i_height)
881                 goto do_alloc;
882
883         ptr = metapointer(ip->i_height - 1, mp);
884         if (*ptr == 0)
885                 goto do_alloc;
886
887         bh = mp->mp_bh[ip->i_height - 1];
888         len = gfs2_extent_length(bh, ptr, len, &eob);
889
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;
894         if (eob)
895                 iomap->flags |= IOMAP_F_GFS2_BOUNDARY;
896
897 out:
898         iomap->bdev = inode->i_sb->s_bdev;
899 unlock:
900         up_read(&ip->i_rw_mutex);
901         if (ret && dibh)
902                 brelse(dibh);
903         return ret;
904
905 do_alloc:
906         iomap->addr = IOMAP_NULL_ADDR;
907         iomap->type = IOMAP_HOLE;
908         if (flags & IOMAP_REPORT) {
909                 if (pos >= size)
910                         ret = -ENOENT;
911                 else if (height == ip->i_height)
912                         ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
913                 else
914                         iomap->length = size - pos;
915         } else if (flags & IOMAP_WRITE) {
916                 u64 alloc_size;
917
918                 if (flags & IOMAP_DIRECT)
919                         goto out;  /* (see gfs2_file_direct_write) */
920
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;
925         } else {
926                 if (pos < size && height == ip->i_height)
927                         ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
928         }
929         goto out;
930 }
931
932 static int gfs2_write_lock(struct inode *inode)
933 {
934         struct gfs2_inode *ip = GFS2_I(inode);
935         struct gfs2_sbd *sdp = GFS2_SB(inode);
936         int error;
937
938         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
939         error = gfs2_glock_nq(&ip->i_gh);
940         if (error)
941                 goto out_uninit;
942         if (&ip->i_inode == sdp->sd_rindex) {
943                 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
944
945                 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
946                                            GL_NOCACHE, &m_ip->i_gh);
947                 if (error)
948                         goto out_unlock;
949         }
950         return 0;
951
952 out_unlock:
953         gfs2_glock_dq(&ip->i_gh);
954 out_uninit:
955         gfs2_holder_uninit(&ip->i_gh);
956         return error;
957 }
958
959 static void gfs2_write_unlock(struct inode *inode)
960 {
961         struct gfs2_inode *ip = GFS2_I(inode);
962         struct gfs2_sbd *sdp = GFS2_SB(inode);
963
964         if (&ip->i_inode == sdp->sd_rindex) {
965                 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
966
967                 gfs2_glock_dq_uninit(&m_ip->i_gh);
968         }
969         gfs2_glock_dq_uninit(&ip->i_gh);
970 }
971
972 static void gfs2_iomap_journaled_page_done(struct inode *inode, loff_t pos,
973                                 unsigned copied, struct page *page,
974                                 struct iomap *iomap)
975 {
976         struct gfs2_inode *ip = GFS2_I(inode);
977
978         gfs2_page_add_databufs(ip, page, offset_in_page(pos), copied);
979 }
980
981 static int gfs2_iomap_begin_write(struct inode *inode, loff_t pos,
982                                   loff_t length, unsigned flags,
983                                   struct iomap *iomap)
984 {
985         struct metapath mp = { .mp_aheight = 1, };
986         struct gfs2_inode *ip = GFS2_I(inode);
987         struct gfs2_sbd *sdp = GFS2_SB(inode);
988         unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
989         bool unstuff, alloc_required;
990         int ret;
991
992         ret = gfs2_write_lock(inode);
993         if (ret)
994                 return ret;
995
996         unstuff = gfs2_is_stuffed(ip) &&
997                   pos + length > gfs2_max_stuffed_size(ip);
998
999         ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
1000         if (ret)
1001                 goto out_release;
1002
1003         alloc_required = unstuff || iomap->type == IOMAP_HOLE;
1004
1005         if (alloc_required || gfs2_is_jdata(ip))
1006                 gfs2_write_calc_reserv(ip, iomap->length, &data_blocks,
1007                                        &ind_blocks);
1008
1009         if (alloc_required) {
1010                 struct gfs2_alloc_parms ap = {
1011                         .target = data_blocks + ind_blocks
1012                 };
1013
1014                 ret = gfs2_quota_lock_check(ip, &ap);
1015                 if (ret)
1016                         goto out_release;
1017
1018                 ret = gfs2_inplace_reserve(ip, &ap);
1019                 if (ret)
1020                         goto out_qunlock;
1021         }
1022
1023         rblocks = RES_DINODE + ind_blocks;
1024         if (gfs2_is_jdata(ip))
1025                 rblocks += data_blocks;
1026         if (ind_blocks || data_blocks)
1027                 rblocks += RES_STATFS + RES_QUOTA;
1028         if (inode == sdp->sd_rindex)
1029                 rblocks += 2 * RES_STATFS;
1030         if (alloc_required)
1031                 rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
1032
1033         ret = gfs2_trans_begin(sdp, rblocks, iomap->length >> inode->i_blkbits);
1034         if (ret)
1035                 goto out_trans_fail;
1036
1037         if (unstuff) {
1038                 ret = gfs2_unstuff_dinode(ip, NULL);
1039                 if (ret)
1040                         goto out_trans_end;
1041                 release_metapath(&mp);
1042                 brelse(iomap->private);
1043                 iomap->private = NULL;
1044                 ret = gfs2_iomap_get(inode, iomap->offset, iomap->length,
1045                                      flags, iomap, &mp);
1046                 if (ret)
1047                         goto out_trans_end;
1048         }
1049
1050         if (iomap->type == IOMAP_HOLE) {
1051                 ret = gfs2_iomap_alloc(inode, iomap, flags, &mp);
1052                 if (ret) {
1053                         gfs2_trans_end(sdp);
1054                         gfs2_inplace_release(ip);
1055                         punch_hole(ip, iomap->offset, iomap->length);
1056                         goto out_qunlock;
1057                 }
1058         }
1059         release_metapath(&mp);
1060         if (!gfs2_is_stuffed(ip) && gfs2_is_jdata(ip))
1061                 iomap->page_done = gfs2_iomap_journaled_page_done;
1062         return 0;
1063
1064 out_trans_end:
1065         gfs2_trans_end(sdp);
1066 out_trans_fail:
1067         if (alloc_required)
1068                 gfs2_inplace_release(ip);
1069 out_qunlock:
1070         if (alloc_required)
1071                 gfs2_quota_unlock(ip);
1072 out_release:
1073         if (iomap->private)
1074                 brelse(iomap->private);
1075         release_metapath(&mp);
1076         gfs2_write_unlock(inode);
1077         return ret;
1078 }
1079
1080 static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
1081                             unsigned flags, struct iomap *iomap)
1082 {
1083         struct gfs2_inode *ip = GFS2_I(inode);
1084         struct metapath mp = { .mp_aheight = 1, };
1085         int ret;
1086
1087         iomap->flags |= IOMAP_F_BUFFER_HEAD;
1088
1089         trace_gfs2_iomap_start(ip, pos, length, flags);
1090         if ((flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT)) {
1091                 ret = gfs2_iomap_begin_write(inode, pos, length, flags, iomap);
1092         } else {
1093                 ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
1094                 release_metapath(&mp);
1095                 /*
1096                  * Silently fall back to buffered I/O for stuffed files or if
1097                  * we've hot a hole (see gfs2_file_direct_write).
1098                  */
1099                 if ((flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT) &&
1100                     iomap->type != IOMAP_MAPPED)
1101                         ret = -ENOTBLK;
1102         }
1103         trace_gfs2_iomap_end(ip, iomap, ret);
1104         return ret;
1105 }
1106
1107 static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length,
1108                           ssize_t written, unsigned flags, struct iomap *iomap)
1109 {
1110         struct gfs2_inode *ip = GFS2_I(inode);
1111         struct gfs2_sbd *sdp = GFS2_SB(inode);
1112         struct gfs2_trans *tr = current->journal_info;
1113         struct buffer_head *dibh = iomap->private;
1114
1115         if ((flags & (IOMAP_WRITE | IOMAP_DIRECT)) != IOMAP_WRITE)
1116                 goto out;
1117
1118         if (iomap->type != IOMAP_INLINE) {
1119                 gfs2_ordered_add_inode(ip);
1120
1121                 if (tr->tr_num_buf_new)
1122                         __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1123                 else
1124                         gfs2_trans_add_meta(ip->i_gl, dibh);
1125         }
1126
1127         if (inode == sdp->sd_rindex) {
1128                 adjust_fs_space(inode);
1129                 sdp->sd_rindex_uptodate = 0;
1130         }
1131
1132         gfs2_trans_end(sdp);
1133         gfs2_inplace_release(ip);
1134
1135         if (length != written && (iomap->flags & IOMAP_F_NEW)) {
1136                 /* Deallocate blocks that were just allocated. */
1137                 loff_t blockmask = i_blocksize(inode) - 1;
1138                 loff_t end = (pos + length) & ~blockmask;
1139
1140                 pos = (pos + written + blockmask) & ~blockmask;
1141                 if (pos < end) {
1142                         truncate_pagecache_range(inode, pos, end - 1);
1143                         punch_hole(ip, pos, end - pos);
1144                 }
1145         }
1146
1147         if (ip->i_qadata && ip->i_qadata->qa_qd_num)
1148                 gfs2_quota_unlock(ip);
1149         gfs2_write_unlock(inode);
1150
1151 out:
1152         if (dibh)
1153                 brelse(dibh);
1154         return 0;
1155 }
1156
1157 const struct iomap_ops gfs2_iomap_ops = {
1158         .iomap_begin = gfs2_iomap_begin,
1159         .iomap_end = gfs2_iomap_end,
1160 };
1161
1162 /**
1163  * gfs2_block_map - Map one or more blocks of an inode to a disk block
1164  * @inode: The inode
1165  * @lblock: The logical block number
1166  * @bh_map: The bh to be mapped
1167  * @create: True if its ok to alloc blocks to satify the request
1168  *
1169  * The size of the requested mapping is defined in bh_map->b_size.
1170  *
1171  * Clears buffer_mapped(bh_map) and leaves bh_map->b_size unchanged
1172  * when @lblock is not mapped.  Sets buffer_mapped(bh_map) and
1173  * bh_map->b_size to indicate the size of the mapping when @lblock and
1174  * successive blocks are mapped, up to the requested size.
1175  *
1176  * Sets buffer_boundary() if a read of metadata will be required
1177  * before the next block can be mapped. Sets buffer_new() if new
1178  * blocks were allocated.
1179  *
1180  * Returns: errno
1181  */
1182
1183 int gfs2_block_map(struct inode *inode, sector_t lblock,
1184                    struct buffer_head *bh_map, int create)
1185 {
1186         struct gfs2_inode *ip = GFS2_I(inode);
1187         loff_t pos = (loff_t)lblock << inode->i_blkbits;
1188         loff_t length = bh_map->b_size;
1189         struct metapath mp = { .mp_aheight = 1, };
1190         struct iomap iomap = { };
1191         int ret;
1192
1193         clear_buffer_mapped(bh_map);
1194         clear_buffer_new(bh_map);
1195         clear_buffer_boundary(bh_map);
1196         trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
1197
1198         if (create) {
1199                 ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, &iomap, &mp);
1200                 if (!ret && iomap.type == IOMAP_HOLE)
1201                         ret = gfs2_iomap_alloc(inode, &iomap, IOMAP_WRITE, &mp);
1202                 release_metapath(&mp);
1203         } else {
1204                 ret = gfs2_iomap_get(inode, pos, length, 0, &iomap, &mp);
1205                 release_metapath(&mp);
1206         }
1207         if (ret)
1208                 goto out;
1209
1210         if (iomap.length > bh_map->b_size) {
1211                 iomap.length = bh_map->b_size;
1212                 iomap.flags &= ~IOMAP_F_GFS2_BOUNDARY;
1213         }
1214         if (iomap.addr != IOMAP_NULL_ADDR)
1215                 map_bh(bh_map, inode->i_sb, iomap.addr >> inode->i_blkbits);
1216         bh_map->b_size = iomap.length;
1217         if (iomap.flags & IOMAP_F_GFS2_BOUNDARY)
1218                 set_buffer_boundary(bh_map);
1219         if (iomap.flags & IOMAP_F_NEW)
1220                 set_buffer_new(bh_map);
1221
1222 out:
1223         trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
1224         return ret;
1225 }
1226
1227 /*
1228  * Deprecated: do not use in new code
1229  */
1230 int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
1231 {
1232         struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
1233         int ret;
1234         int create = *new;
1235
1236         BUG_ON(!extlen);
1237         BUG_ON(!dblock);
1238         BUG_ON(!new);
1239
1240         bh.b_size = BIT(inode->i_blkbits + (create ? 0 : 5));
1241         ret = gfs2_block_map(inode, lblock, &bh, create);
1242         *extlen = bh.b_size >> inode->i_blkbits;
1243         *dblock = bh.b_blocknr;
1244         if (buffer_new(&bh))
1245                 *new = 1;
1246         else
1247                 *new = 0;
1248         return ret;
1249 }
1250
1251 /**
1252  * gfs2_block_zero_range - Deal with zeroing out data
1253  *
1254  * This is partly borrowed from ext3.
1255  */
1256 static int gfs2_block_zero_range(struct inode *inode, loff_t from,
1257                                  unsigned int length)
1258 {
1259         struct address_space *mapping = inode->i_mapping;
1260         struct gfs2_inode *ip = GFS2_I(inode);
1261         unsigned long index = from >> PAGE_SHIFT;
1262         unsigned offset = from & (PAGE_SIZE-1);
1263         unsigned blocksize, iblock, pos;
1264         struct buffer_head *bh;
1265         struct page *page;
1266         int err;
1267
1268         page = find_or_create_page(mapping, index, GFP_NOFS);
1269         if (!page)
1270                 return 0;
1271
1272         blocksize = inode->i_sb->s_blocksize;
1273         iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
1274
1275         if (!page_has_buffers(page))
1276                 create_empty_buffers(page, blocksize, 0);
1277
1278         /* Find the buffer that contains "offset" */
1279         bh = page_buffers(page);
1280         pos = blocksize;
1281         while (offset >= pos) {
1282                 bh = bh->b_this_page;
1283                 iblock++;
1284                 pos += blocksize;
1285         }
1286
1287         err = 0;
1288
1289         if (!buffer_mapped(bh)) {
1290                 gfs2_block_map(inode, iblock, bh, 0);
1291                 /* unmapped? It's a hole - nothing to do */
1292                 if (!buffer_mapped(bh))
1293                         goto unlock;
1294         }
1295
1296         /* Ok, it's mapped. Make sure it's up-to-date */
1297         if (PageUptodate(page))
1298                 set_buffer_uptodate(bh);
1299
1300         if (!buffer_uptodate(bh)) {
1301                 err = -EIO;
1302                 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1303                 wait_on_buffer(bh);
1304                 /* Uhhuh. Read error. Complain and punt. */
1305                 if (!buffer_uptodate(bh))
1306                         goto unlock;
1307                 err = 0;
1308         }
1309
1310         if (gfs2_is_jdata(ip))
1311                 gfs2_trans_add_data(ip->i_gl, bh);
1312         else
1313                 gfs2_ordered_add_inode(ip);
1314
1315         zero_user(page, offset, length);
1316         mark_buffer_dirty(bh);
1317 unlock:
1318         unlock_page(page);
1319         put_page(page);
1320         return err;
1321 }
1322
1323 #define GFS2_JTRUNC_REVOKES 8192
1324
1325 /**
1326  * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
1327  * @inode: The inode being truncated
1328  * @oldsize: The original (larger) size
1329  * @newsize: The new smaller size
1330  *
1331  * With jdata files, we have to journal a revoke for each block which is
1332  * truncated. As a result, we need to split this into separate transactions
1333  * if the number of pages being truncated gets too large.
1334  */
1335
1336 static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
1337 {
1338         struct gfs2_sbd *sdp = GFS2_SB(inode);
1339         u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1340         u64 chunk;
1341         int error;
1342
1343         while (oldsize != newsize) {
1344                 struct gfs2_trans *tr;
1345                 unsigned int offs;
1346
1347                 chunk = oldsize - newsize;
1348                 if (chunk > max_chunk)
1349                         chunk = max_chunk;
1350
1351                 offs = oldsize & ~PAGE_MASK;
1352                 if (offs && chunk > PAGE_SIZE)
1353                         chunk = offs + ((chunk - offs) & PAGE_MASK);
1354
1355                 truncate_pagecache(inode, oldsize - chunk);
1356                 oldsize -= chunk;
1357
1358                 tr = current->journal_info;
1359                 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
1360                         continue;
1361
1362                 gfs2_trans_end(sdp);
1363                 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1364                 if (error)
1365                         return error;
1366         }
1367
1368         return 0;
1369 }
1370
1371 static int trunc_start(struct inode *inode, u64 newsize)
1372 {
1373         struct gfs2_inode *ip = GFS2_I(inode);
1374         struct gfs2_sbd *sdp = GFS2_SB(inode);
1375         struct buffer_head *dibh = NULL;
1376         int journaled = gfs2_is_jdata(ip);
1377         u64 oldsize = inode->i_size;
1378         int error;
1379
1380         if (journaled)
1381                 error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1382         else
1383                 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1384         if (error)
1385                 return error;
1386
1387         error = gfs2_meta_inode_buffer(ip, &dibh);
1388         if (error)
1389                 goto out;
1390
1391         gfs2_trans_add_meta(ip->i_gl, dibh);
1392
1393         if (gfs2_is_stuffed(ip)) {
1394                 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1395         } else {
1396                 unsigned int blocksize = i_blocksize(inode);
1397                 unsigned int offs = newsize & (blocksize - 1);
1398                 if (offs) {
1399                         error = gfs2_block_zero_range(inode, newsize,
1400                                                       blocksize - offs);
1401                         if (error)
1402                                 goto out;
1403                 }
1404                 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
1405         }
1406
1407         i_size_write(inode, newsize);
1408         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1409         gfs2_dinode_out(ip, dibh->b_data);
1410
1411         if (journaled)
1412                 error = gfs2_journaled_truncate(inode, oldsize, newsize);
1413         else
1414                 truncate_pagecache(inode, newsize);
1415
1416 out:
1417         brelse(dibh);
1418         if (current->journal_info)
1419                 gfs2_trans_end(sdp);
1420         return error;
1421 }
1422
1423 int gfs2_iomap_get_alloc(struct inode *inode, loff_t pos, loff_t length,
1424                          struct iomap *iomap)
1425 {
1426         struct metapath mp = { .mp_aheight = 1, };
1427         int ret;
1428
1429         ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, iomap, &mp);
1430         if (!ret && iomap->type == IOMAP_HOLE)
1431                 ret = gfs2_iomap_alloc(inode, iomap, IOMAP_WRITE, &mp);
1432         release_metapath(&mp);
1433         return ret;
1434 }
1435
1436 /**
1437  * sweep_bh_for_rgrps - find an rgrp in a meta buffer and free blocks therein
1438  * @ip: inode
1439  * @rg_gh: holder of resource group glock
1440  * @bh: buffer head to sweep
1441  * @start: starting point in bh
1442  * @end: end point in bh
1443  * @meta: true if bh points to metadata (rather than data)
1444  * @btotal: place to keep count of total blocks freed
1445  *
1446  * We sweep a metadata buffer (provided by the metapath) for blocks we need to
1447  * free, and free them all. However, we do it one rgrp at a time. If this
1448  * block has references to multiple rgrps, we break it into individual
1449  * transactions. This allows other processes to use the rgrps while we're
1450  * focused on a single one, for better concurrency / performance.
1451  * At every transaction boundary, we rewrite the inode into the journal.
1452  * That way the bitmaps are kept consistent with the inode and we can recover
1453  * if we're interrupted by power-outages.
1454  *
1455  * Returns: 0, or return code if an error occurred.
1456  *          *btotal has the total number of blocks freed
1457  */
1458 static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh,
1459                               struct buffer_head *bh, __be64 *start, __be64 *end,
1460                               bool meta, u32 *btotal)
1461 {
1462         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1463         struct gfs2_rgrpd *rgd;
1464         struct gfs2_trans *tr;
1465         __be64 *p;
1466         int blks_outside_rgrp;
1467         u64 bn, bstart, isize_blks;
1468         s64 blen; /* needs to be s64 or gfs2_add_inode_blocks breaks */
1469         int ret = 0;
1470         bool buf_in_tr = false; /* buffer was added to transaction */
1471
1472 more_rgrps:
1473         rgd = NULL;
1474         if (gfs2_holder_initialized(rd_gh)) {
1475                 rgd = gfs2_glock2rgrp(rd_gh->gh_gl);
1476                 gfs2_assert_withdraw(sdp,
1477                              gfs2_glock_is_locked_by_me(rd_gh->gh_gl));
1478         }
1479         blks_outside_rgrp = 0;
1480         bstart = 0;
1481         blen = 0;
1482
1483         for (p = start; p < end; p++) {
1484                 if (!*p)
1485                         continue;
1486                 bn = be64_to_cpu(*p);
1487
1488                 if (rgd) {
1489                         if (!rgrp_contains_block(rgd, bn)) {
1490                                 blks_outside_rgrp++;
1491                                 continue;
1492                         }
1493                 } else {
1494                         rgd = gfs2_blk2rgrpd(sdp, bn, true);
1495                         if (unlikely(!rgd)) {
1496                                 ret = -EIO;
1497                                 goto out;
1498                         }
1499                         ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1500                                                  0, rd_gh);
1501                         if (ret)
1502                                 goto out;
1503
1504                         /* Must be done with the rgrp glock held: */
1505                         if (gfs2_rs_active(&ip->i_res) &&
1506                             rgd == ip->i_res.rs_rbm.rgd)
1507                                 gfs2_rs_deltree(&ip->i_res);
1508                 }
1509
1510                 /* The size of our transactions will be unknown until we
1511                    actually process all the metadata blocks that relate to
1512                    the rgrp. So we estimate. We know it can't be more than
1513                    the dinode's i_blocks and we don't want to exceed the
1514                    journal flush threshold, sd_log_thresh2. */
1515                 if (current->journal_info == NULL) {
1516                         unsigned int jblocks_rqsted, revokes;
1517
1518                         jblocks_rqsted = rgd->rd_length + RES_DINODE +
1519                                 RES_INDIRECT;
1520                         isize_blks = gfs2_get_inode_blocks(&ip->i_inode);
1521                         if (isize_blks > atomic_read(&sdp->sd_log_thresh2))
1522                                 jblocks_rqsted +=
1523                                         atomic_read(&sdp->sd_log_thresh2);
1524                         else
1525                                 jblocks_rqsted += isize_blks;
1526                         revokes = jblocks_rqsted;
1527                         if (meta)
1528                                 revokes += end - start;
1529                         else if (ip->i_depth)
1530                                 revokes += sdp->sd_inptrs;
1531                         ret = gfs2_trans_begin(sdp, jblocks_rqsted, revokes);
1532                         if (ret)
1533                                 goto out_unlock;
1534                         down_write(&ip->i_rw_mutex);
1535                 }
1536                 /* check if we will exceed the transaction blocks requested */
1537                 tr = current->journal_info;
1538                 if (tr->tr_num_buf_new + RES_STATFS +
1539                     RES_QUOTA >= atomic_read(&sdp->sd_log_thresh2)) {
1540                         /* We set blks_outside_rgrp to ensure the loop will
1541                            be repeated for the same rgrp, but with a new
1542                            transaction. */
1543                         blks_outside_rgrp++;
1544                         /* This next part is tricky. If the buffer was added
1545                            to the transaction, we've already set some block
1546                            pointers to 0, so we better follow through and free
1547                            them, or we will introduce corruption (so break).
1548                            This may be impossible, or at least rare, but I
1549                            decided to cover the case regardless.
1550
1551                            If the buffer was not added to the transaction
1552                            (this call), doing so would exceed our transaction
1553                            size, so we need to end the transaction and start a
1554                            new one (so goto). */
1555
1556                         if (buf_in_tr)
1557                                 break;
1558                         goto out_unlock;
1559                 }
1560
1561                 gfs2_trans_add_meta(ip->i_gl, bh);
1562                 buf_in_tr = true;
1563                 *p = 0;
1564                 if (bstart + blen == bn) {
1565                         blen++;
1566                         continue;
1567                 }
1568                 if (bstart) {
1569                         __gfs2_free_blocks(ip, rgd, bstart, (u32)blen, meta);
1570                         (*btotal) += blen;
1571                         gfs2_add_inode_blocks(&ip->i_inode, -blen);
1572                 }
1573                 bstart = bn;
1574                 blen = 1;
1575         }
1576         if (bstart) {
1577                 __gfs2_free_blocks(ip, rgd, bstart, (u32)blen, meta);
1578                 (*btotal) += blen;
1579                 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1580         }
1581 out_unlock:
1582         if (!ret && blks_outside_rgrp) { /* If buffer still has non-zero blocks
1583                                             outside the rgrp we just processed,
1584                                             do it all over again. */
1585                 if (current->journal_info) {
1586                         struct buffer_head *dibh;
1587
1588                         ret = gfs2_meta_inode_buffer(ip, &dibh);
1589                         if (ret)
1590                                 goto out;
1591
1592                         /* Every transaction boundary, we rewrite the dinode
1593                            to keep its di_blocks current in case of failure. */
1594                         ip->i_inode.i_mtime = ip->i_inode.i_ctime =
1595                                 current_time(&ip->i_inode);
1596                         gfs2_trans_add_meta(ip->i_gl, dibh);
1597                         gfs2_dinode_out(ip, dibh->b_data);
1598                         brelse(dibh);
1599                         up_write(&ip->i_rw_mutex);
1600                         gfs2_trans_end(sdp);
1601                 }
1602                 gfs2_glock_dq_uninit(rd_gh);
1603                 cond_resched();
1604                 goto more_rgrps;
1605         }
1606 out:
1607         return ret;
1608 }
1609
1610 static bool mp_eq_to_hgt(struct metapath *mp, __u16 *list, unsigned int h)
1611 {
1612         if (memcmp(mp->mp_list, list, h * sizeof(mp->mp_list[0])))
1613                 return false;
1614         return true;
1615 }
1616
1617 /**
1618  * find_nonnull_ptr - find a non-null pointer given a metapath and height
1619  * @mp: starting metapath
1620  * @h: desired height to search
1621  *
1622  * Assumes the metapath is valid (with buffers) out to height h.
1623  * Returns: true if a non-null pointer was found in the metapath buffer
1624  *          false if all remaining pointers are NULL in the buffer
1625  */
1626 static bool find_nonnull_ptr(struct gfs2_sbd *sdp, struct metapath *mp,
1627                              unsigned int h,
1628                              __u16 *end_list, unsigned int end_aligned)
1629 {
1630         struct buffer_head *bh = mp->mp_bh[h];
1631         __be64 *first, *ptr, *end;
1632
1633         first = metaptr1(h, mp);
1634         ptr = first + mp->mp_list[h];
1635         end = (__be64 *)(bh->b_data + bh->b_size);
1636         if (end_list && mp_eq_to_hgt(mp, end_list, h)) {
1637                 bool keep_end = h < end_aligned;
1638                 end = first + end_list[h] + keep_end;
1639         }
1640
1641         while (ptr < end) {
1642                 if (*ptr) { /* if we have a non-null pointer */
1643                         mp->mp_list[h] = ptr - first;
1644                         h++;
1645                         if (h < GFS2_MAX_META_HEIGHT)
1646                                 mp->mp_list[h] = 0;
1647                         return true;
1648                 }
1649                 ptr++;
1650         }
1651         return false;
1652 }
1653
1654 enum dealloc_states {
1655         DEALLOC_MP_FULL = 0,    /* Strip a metapath with all buffers read in */
1656         DEALLOC_MP_LOWER = 1,   /* lower the metapath strip height */
1657         DEALLOC_FILL_MP = 2,  /* Fill in the metapath to the given height. */
1658         DEALLOC_DONE = 3,       /* process complete */
1659 };
1660
1661 static inline void
1662 metapointer_range(struct metapath *mp, int height,
1663                   __u16 *start_list, unsigned int start_aligned,
1664                   __u16 *end_list, unsigned int end_aligned,
1665                   __be64 **start, __be64 **end)
1666 {
1667         struct buffer_head *bh = mp->mp_bh[height];
1668         __be64 *first;
1669
1670         first = metaptr1(height, mp);
1671         *start = first;
1672         if (mp_eq_to_hgt(mp, start_list, height)) {
1673                 bool keep_start = height < start_aligned;
1674                 *start = first + start_list[height] + keep_start;
1675         }
1676         *end = (__be64 *)(bh->b_data + bh->b_size);
1677         if (end_list && mp_eq_to_hgt(mp, end_list, height)) {
1678                 bool keep_end = height < end_aligned;
1679                 *end = first + end_list[height] + keep_end;
1680         }
1681 }
1682
1683 static inline bool walk_done(struct gfs2_sbd *sdp,
1684                              struct metapath *mp, int height,
1685                              __u16 *end_list, unsigned int end_aligned)
1686 {
1687         __u16 end;
1688
1689         if (end_list) {
1690                 bool keep_end = height < end_aligned;
1691                 if (!mp_eq_to_hgt(mp, end_list, height))
1692                         return false;
1693                 end = end_list[height] + keep_end;
1694         } else
1695                 end = (height > 0) ? sdp->sd_inptrs : sdp->sd_diptrs;
1696         return mp->mp_list[height] >= end;
1697 }
1698
1699 /**
1700  * punch_hole - deallocate blocks in a file
1701  * @ip: inode to truncate
1702  * @offset: the start of the hole
1703  * @length: the size of the hole (or 0 for truncate)
1704  *
1705  * Punch a hole into a file or truncate a file at a given position.  This
1706  * function operates in whole blocks (@offset and @length are rounded
1707  * accordingly); partially filled blocks must be cleared otherwise.
1708  *
1709  * This function works from the bottom up, and from the right to the left. In
1710  * other words, it strips off the highest layer (data) before stripping any of
1711  * the metadata. Doing it this way is best in case the operation is interrupted
1712  * by power failure, etc.  The dinode is rewritten in every transaction to
1713  * guarantee integrity.
1714  */
1715 static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length)
1716 {
1717         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1718         u64 maxsize = sdp->sd_heightsize[ip->i_height];
1719         struct metapath mp = {};
1720         struct buffer_head *dibh, *bh;
1721         struct gfs2_holder rd_gh;
1722         unsigned int bsize_shift = sdp->sd_sb.sb_bsize_shift;
1723         u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
1724         __u16 start_list[GFS2_MAX_META_HEIGHT];
1725         __u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
1726         unsigned int start_aligned, uninitialized_var(end_aligned);
1727         unsigned int strip_h = ip->i_height - 1;
1728         u32 btotal = 0;
1729         int ret, state;
1730         int mp_h; /* metapath buffers are read in to this height */
1731         u64 prev_bnr = 0;
1732         __be64 *start, *end;
1733
1734         if (offset >= maxsize) {
1735                 /*
1736                  * The starting point lies beyond the allocated meta-data;
1737                  * there are no blocks do deallocate.
1738                  */
1739                 return 0;
1740         }
1741
1742         /*
1743          * The start position of the hole is defined by lblock, start_list, and
1744          * start_aligned.  The end position of the hole is defined by lend,
1745          * end_list, and end_aligned.
1746          *
1747          * start_aligned and end_aligned define down to which height the start
1748          * and end positions are aligned to the metadata tree (i.e., the
1749          * position is a multiple of the metadata granularity at the height
1750          * above).  This determines at which heights additional meta pointers
1751          * needs to be preserved for the remaining data.
1752          */
1753
1754         if (length) {
1755                 u64 end_offset = offset + length;
1756                 u64 lend;
1757
1758                 /*
1759                  * Clip the end at the maximum file size for the given height:
1760                  * that's how far the metadata goes; files bigger than that
1761                  * will have additional layers of indirection.
1762                  */
1763                 if (end_offset > maxsize)
1764                         end_offset = maxsize;
1765                 lend = end_offset >> bsize_shift;
1766
1767                 if (lblock >= lend)
1768                         return 0;
1769
1770                 find_metapath(sdp, lend, &mp, ip->i_height);
1771                 end_list = __end_list;
1772                 memcpy(end_list, mp.mp_list, sizeof(mp.mp_list));
1773
1774                 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1775                         if (end_list[mp_h])
1776                                 break;
1777                 }
1778                 end_aligned = mp_h;
1779         }
1780
1781         find_metapath(sdp, lblock, &mp, ip->i_height);
1782         memcpy(start_list, mp.mp_list, sizeof(start_list));
1783
1784         for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1785                 if (start_list[mp_h])
1786                         break;
1787         }
1788         start_aligned = mp_h;
1789
1790         ret = gfs2_meta_inode_buffer(ip, &dibh);
1791         if (ret)
1792                 return ret;
1793
1794         mp.mp_bh[0] = dibh;
1795         ret = lookup_metapath(ip, &mp);
1796         if (ret)
1797                 goto out_metapath;
1798
1799         /* issue read-ahead on metadata */
1800         for (mp_h = 0; mp_h < mp.mp_aheight - 1; mp_h++) {
1801                 metapointer_range(&mp, mp_h, start_list, start_aligned,
1802                                   end_list, end_aligned, &start, &end);
1803                 gfs2_metapath_ra(ip->i_gl, start, end);
1804         }
1805
1806         if (mp.mp_aheight == ip->i_height)
1807                 state = DEALLOC_MP_FULL; /* We have a complete metapath */
1808         else
1809                 state = DEALLOC_FILL_MP; /* deal with partial metapath */
1810
1811         ret = gfs2_rindex_update(sdp);
1812         if (ret)
1813                 goto out_metapath;
1814
1815         ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1816         if (ret)
1817                 goto out_metapath;
1818         gfs2_holder_mark_uninitialized(&rd_gh);
1819
1820         mp_h = strip_h;
1821
1822         while (state != DEALLOC_DONE) {
1823                 switch (state) {
1824                 /* Truncate a full metapath at the given strip height.
1825                  * Note that strip_h == mp_h in order to be in this state. */
1826                 case DEALLOC_MP_FULL:
1827                         bh = mp.mp_bh[mp_h];
1828                         gfs2_assert_withdraw(sdp, bh);
1829                         if (gfs2_assert_withdraw(sdp,
1830                                                  prev_bnr != bh->b_blocknr)) {
1831                                 printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1832                                        "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1833                                        sdp->sd_fsname,
1834                                        (unsigned long long)ip->i_no_addr,
1835                                        prev_bnr, ip->i_height, strip_h, mp_h);
1836                         }
1837                         prev_bnr = bh->b_blocknr;
1838
1839                         if (gfs2_metatype_check(sdp, bh,
1840                                                 (mp_h ? GFS2_METATYPE_IN :
1841                                                         GFS2_METATYPE_DI))) {
1842                                 ret = -EIO;
1843                                 goto out;
1844                         }
1845
1846                         /*
1847                          * Below, passing end_aligned as 0 gives us the
1848                          * metapointer range excluding the end point: the end
1849                          * point is the first metapath we must not deallocate!
1850                          */
1851
1852                         metapointer_range(&mp, mp_h, start_list, start_aligned,
1853                                           end_list, 0 /* end_aligned */,
1854                                           &start, &end);
1855                         ret = sweep_bh_for_rgrps(ip, &rd_gh, mp.mp_bh[mp_h],
1856                                                  start, end,
1857                                                  mp_h != ip->i_height - 1,
1858                                                  &btotal);
1859
1860                         /* If we hit an error or just swept dinode buffer,
1861                            just exit. */
1862                         if (ret || !mp_h) {
1863                                 state = DEALLOC_DONE;
1864                                 break;
1865                         }
1866                         state = DEALLOC_MP_LOWER;
1867                         break;
1868
1869                 /* lower the metapath strip height */
1870                 case DEALLOC_MP_LOWER:
1871                         /* We're done with the current buffer, so release it,
1872                            unless it's the dinode buffer. Then back up to the
1873                            previous pointer. */
1874                         if (mp_h) {
1875                                 brelse(mp.mp_bh[mp_h]);
1876                                 mp.mp_bh[mp_h] = NULL;
1877                         }
1878                         /* If we can't get any lower in height, we've stripped
1879                            off all we can. Next step is to back up and start
1880                            stripping the previous level of metadata. */
1881                         if (mp_h == 0) {
1882                                 strip_h--;
1883                                 memcpy(mp.mp_list, start_list, sizeof(start_list));
1884                                 mp_h = strip_h;
1885                                 state = DEALLOC_FILL_MP;
1886                                 break;
1887                         }
1888                         mp.mp_list[mp_h] = 0;
1889                         mp_h--; /* search one metadata height down */
1890                         mp.mp_list[mp_h]++;
1891                         if (walk_done(sdp, &mp, mp_h, end_list, end_aligned))
1892                                 break;
1893                         /* Here we've found a part of the metapath that is not
1894                          * allocated. We need to search at that height for the
1895                          * next non-null pointer. */
1896                         if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) {
1897                                 state = DEALLOC_FILL_MP;
1898                                 mp_h++;
1899                         }
1900                         /* No more non-null pointers at this height. Back up
1901                            to the previous height and try again. */
1902                         break; /* loop around in the same state */
1903
1904                 /* Fill the metapath with buffers to the given height. */
1905                 case DEALLOC_FILL_MP:
1906                         /* Fill the buffers out to the current height. */
1907                         ret = fillup_metapath(ip, &mp, mp_h);
1908                         if (ret < 0)
1909                                 goto out;
1910
1911                         /* issue read-ahead on metadata */
1912                         if (mp.mp_aheight > 1) {
1913                                 for (; ret > 1; ret--) {
1914                                         metapointer_range(&mp, mp.mp_aheight - ret,
1915                                                           start_list, start_aligned,
1916                                                           end_list, end_aligned,
1917                                                           &start, &end);
1918                                         gfs2_metapath_ra(ip->i_gl, start, end);
1919                                 }
1920                         }
1921
1922                         /* If buffers found for the entire strip height */
1923                         if (mp.mp_aheight - 1 == strip_h) {
1924                                 state = DEALLOC_MP_FULL;
1925                                 break;
1926                         }
1927                         if (mp.mp_aheight < ip->i_height) /* We have a partial height */
1928                                 mp_h = mp.mp_aheight - 1;
1929
1930                         /* If we find a non-null block pointer, crawl a bit
1931                            higher up in the metapath and try again, otherwise
1932                            we need to look lower for a new starting point. */
1933                         if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned))
1934                                 mp_h++;
1935                         else
1936                                 state = DEALLOC_MP_LOWER;
1937                         break;
1938                 }
1939         }
1940
1941         if (btotal) {
1942                 if (current->journal_info == NULL) {
1943                         ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS +
1944                                                RES_QUOTA, 0);
1945                         if (ret)
1946                                 goto out;
1947                         down_write(&ip->i_rw_mutex);
1948                 }
1949                 gfs2_statfs_change(sdp, 0, +btotal, 0);
1950                 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
1951                                   ip->i_inode.i_gid);
1952                 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1953                 gfs2_trans_add_meta(ip->i_gl, dibh);
1954                 gfs2_dinode_out(ip, dibh->b_data);
1955                 up_write(&ip->i_rw_mutex);
1956                 gfs2_trans_end(sdp);
1957         }
1958
1959 out:
1960         if (gfs2_holder_initialized(&rd_gh))
1961                 gfs2_glock_dq_uninit(&rd_gh);
1962         if (current->journal_info) {
1963                 up_write(&ip->i_rw_mutex);
1964                 gfs2_trans_end(sdp);
1965                 cond_resched();
1966         }
1967         gfs2_quota_unhold(ip);
1968 out_metapath:
1969         release_metapath(&mp);
1970         return ret;
1971 }
1972
1973 static int trunc_end(struct gfs2_inode *ip)
1974 {
1975         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1976         struct buffer_head *dibh;
1977         int error;
1978
1979         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1980         if (error)
1981                 return error;
1982
1983         down_write(&ip->i_rw_mutex);
1984
1985         error = gfs2_meta_inode_buffer(ip, &dibh);
1986         if (error)
1987                 goto out;
1988
1989         if (!i_size_read(&ip->i_inode)) {
1990                 ip->i_height = 0;
1991                 ip->i_goal = ip->i_no_addr;
1992                 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1993                 gfs2_ordered_del_inode(ip);
1994         }
1995         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
1996         ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1997
1998         gfs2_trans_add_meta(ip->i_gl, dibh);
1999         gfs2_dinode_out(ip, dibh->b_data);
2000         brelse(dibh);
2001
2002 out:
2003         up_write(&ip->i_rw_mutex);
2004         gfs2_trans_end(sdp);
2005         return error;
2006 }
2007
2008 /**
2009  * do_shrink - make a file smaller
2010  * @inode: the inode
2011  * @newsize: the size to make the file
2012  *
2013  * Called with an exclusive lock on @inode. The @size must
2014  * be equal to or smaller than the current inode size.
2015  *
2016  * Returns: errno
2017  */
2018
2019 static int do_shrink(struct inode *inode, u64 newsize)
2020 {
2021         struct gfs2_inode *ip = GFS2_I(inode);
2022         int error;
2023
2024         error = trunc_start(inode, newsize);
2025         if (error < 0)
2026                 return error;
2027         if (gfs2_is_stuffed(ip))
2028                 return 0;
2029
2030         error = punch_hole(ip, newsize, 0);
2031         if (error == 0)
2032                 error = trunc_end(ip);
2033
2034         return error;
2035 }
2036
2037 void gfs2_trim_blocks(struct inode *inode)
2038 {
2039         int ret;
2040
2041         ret = do_shrink(inode, inode->i_size);
2042         WARN_ON(ret != 0);
2043 }
2044
2045 /**
2046  * do_grow - Touch and update inode size
2047  * @inode: The inode
2048  * @size: The new size
2049  *
2050  * This function updates the timestamps on the inode and
2051  * may also increase the size of the inode. This function
2052  * must not be called with @size any smaller than the current
2053  * inode size.
2054  *
2055  * Although it is not strictly required to unstuff files here,
2056  * earlier versions of GFS2 have a bug in the stuffed file reading
2057  * code which will result in a buffer overrun if the size is larger
2058  * than the max stuffed file size. In order to prevent this from
2059  * occurring, such files are unstuffed, but in other cases we can
2060  * just update the inode size directly.
2061  *
2062  * Returns: 0 on success, or -ve on error
2063  */
2064
2065 static int do_grow(struct inode *inode, u64 size)
2066 {
2067         struct gfs2_inode *ip = GFS2_I(inode);
2068         struct gfs2_sbd *sdp = GFS2_SB(inode);
2069         struct gfs2_alloc_parms ap = { .target = 1, };
2070         struct buffer_head *dibh;
2071         int error;
2072         int unstuff = 0;
2073
2074         if (gfs2_is_stuffed(ip) && size > gfs2_max_stuffed_size(ip)) {
2075                 error = gfs2_quota_lock_check(ip, &ap);
2076                 if (error)
2077                         return error;
2078
2079                 error = gfs2_inplace_reserve(ip, &ap);
2080                 if (error)
2081                         goto do_grow_qunlock;
2082                 unstuff = 1;
2083         }
2084
2085         error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
2086                                  (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
2087                                   0 : RES_QUOTA), 0);
2088         if (error)
2089                 goto do_grow_release;
2090
2091         if (unstuff) {
2092                 error = gfs2_unstuff_dinode(ip, NULL);
2093                 if (error)
2094                         goto do_end_trans;
2095         }
2096
2097         error = gfs2_meta_inode_buffer(ip, &dibh);
2098         if (error)
2099                 goto do_end_trans;
2100
2101         i_size_write(inode, size);
2102         ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
2103         gfs2_trans_add_meta(ip->i_gl, dibh);
2104         gfs2_dinode_out(ip, dibh->b_data);
2105         brelse(dibh);
2106
2107 do_end_trans:
2108         gfs2_trans_end(sdp);
2109 do_grow_release:
2110         if (unstuff) {
2111                 gfs2_inplace_release(ip);
2112 do_grow_qunlock:
2113                 gfs2_quota_unlock(ip);
2114         }
2115         return error;
2116 }
2117
2118 /**
2119  * gfs2_setattr_size - make a file a given size
2120  * @inode: the inode
2121  * @newsize: the size to make the file
2122  *
2123  * The file size can grow, shrink, or stay the same size. This
2124  * is called holding i_rwsem and an exclusive glock on the inode
2125  * in question.
2126  *
2127  * Returns: errno
2128  */
2129
2130 int gfs2_setattr_size(struct inode *inode, u64 newsize)
2131 {
2132         struct gfs2_inode *ip = GFS2_I(inode);
2133         int ret;
2134
2135         BUG_ON(!S_ISREG(inode->i_mode));
2136
2137         ret = inode_newsize_ok(inode, newsize);
2138         if (ret)
2139                 return ret;
2140
2141         inode_dio_wait(inode);
2142
2143         ret = gfs2_rsqa_alloc(ip);
2144         if (ret)
2145                 goto out;
2146
2147         if (newsize >= inode->i_size) {
2148                 ret = do_grow(inode, newsize);
2149                 goto out;
2150         }
2151
2152         ret = do_shrink(inode, newsize);
2153 out:
2154         gfs2_rsqa_delete(ip, NULL);
2155         return ret;
2156 }
2157
2158 int gfs2_truncatei_resume(struct gfs2_inode *ip)
2159 {
2160         int error;
2161         error = punch_hole(ip, i_size_read(&ip->i_inode), 0);
2162         if (!error)
2163                 error = trunc_end(ip);
2164         return error;
2165 }
2166
2167 int gfs2_file_dealloc(struct gfs2_inode *ip)
2168 {
2169         return punch_hole(ip, 0, 0);
2170 }
2171
2172 /**
2173  * gfs2_free_journal_extents - Free cached journal bmap info
2174  * @jd: The journal
2175  *
2176  */
2177
2178 void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
2179 {
2180         struct gfs2_journal_extent *jext;
2181
2182         while(!list_empty(&jd->extent_list)) {
2183                 jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
2184                 list_del(&jext->list);
2185                 kfree(jext);
2186         }
2187 }
2188
2189 /**
2190  * gfs2_add_jextent - Add or merge a new extent to extent cache
2191  * @jd: The journal descriptor
2192  * @lblock: The logical block at start of new extent
2193  * @dblock: The physical block at start of new extent
2194  * @blocks: Size of extent in fs blocks
2195  *
2196  * Returns: 0 on success or -ENOMEM
2197  */
2198
2199 static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
2200 {
2201         struct gfs2_journal_extent *jext;
2202
2203         if (!list_empty(&jd->extent_list)) {
2204                 jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
2205                 if ((jext->dblock + jext->blocks) == dblock) {
2206                         jext->blocks += blocks;
2207                         return 0;
2208                 }
2209         }
2210
2211         jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
2212         if (jext == NULL)
2213                 return -ENOMEM;
2214         jext->dblock = dblock;
2215         jext->lblock = lblock;
2216         jext->blocks = blocks;
2217         list_add_tail(&jext->list, &jd->extent_list);
2218         jd->nr_extents++;
2219         return 0;
2220 }
2221
2222 /**
2223  * gfs2_map_journal_extents - Cache journal bmap info
2224  * @sdp: The super block
2225  * @jd: The journal to map
2226  *
2227  * Create a reusable "extent" mapping from all logical
2228  * blocks to all physical blocks for the given journal.  This will save
2229  * us time when writing journal blocks.  Most journals will have only one
2230  * extent that maps all their logical blocks.  That's because gfs2.mkfs
2231  * arranges the journal blocks sequentially to maximize performance.
2232  * So the extent would map the first block for the entire file length.
2233  * However, gfs2_jadd can happen while file activity is happening, so
2234  * those journals may not be sequential.  Less likely is the case where
2235  * the users created their own journals by mounting the metafs and
2236  * laying it out.  But it's still possible.  These journals might have
2237  * several extents.
2238  *
2239  * Returns: 0 on success, or error on failure
2240  */
2241
2242 int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
2243 {
2244         u64 lblock = 0;
2245         u64 lblock_stop;
2246         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
2247         struct buffer_head bh;
2248         unsigned int shift = sdp->sd_sb.sb_bsize_shift;
2249         u64 size;
2250         int rc;
2251
2252         lblock_stop = i_size_read(jd->jd_inode) >> shift;
2253         size = (lblock_stop - lblock) << shift;
2254         jd->nr_extents = 0;
2255         WARN_ON(!list_empty(&jd->extent_list));
2256
2257         do {
2258                 bh.b_state = 0;
2259                 bh.b_blocknr = 0;
2260                 bh.b_size = size;
2261                 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
2262                 if (rc || !buffer_mapped(&bh))
2263                         goto fail;
2264                 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
2265                 if (rc)
2266                         goto fail;
2267                 size -= bh.b_size;
2268                 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2269         } while(size > 0);
2270
2271         fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
2272                 jd->nr_extents);
2273         return 0;
2274
2275 fail:
2276         fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
2277                 rc, jd->jd_jid,
2278                 (unsigned long long)(i_size_read(jd->jd_inode) - size),
2279                 jd->nr_extents);
2280         fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
2281                 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
2282                 bh.b_state, (unsigned long long)bh.b_size);
2283         gfs2_free_journal_extents(jd);
2284         return rc;
2285 }
2286
2287 /**
2288  * gfs2_write_alloc_required - figure out if a write will require an allocation
2289  * @ip: the file being written to
2290  * @offset: the offset to write to
2291  * @len: the number of bytes being written
2292  *
2293  * Returns: 1 if an alloc is required, 0 otherwise
2294  */
2295
2296 int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
2297                               unsigned int len)
2298 {
2299         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2300         struct buffer_head bh;
2301         unsigned int shift;
2302         u64 lblock, lblock_stop, size;
2303         u64 end_of_file;
2304
2305         if (!len)
2306                 return 0;
2307
2308         if (gfs2_is_stuffed(ip)) {
2309                 if (offset + len > gfs2_max_stuffed_size(ip))
2310                         return 1;
2311                 return 0;
2312         }
2313
2314         shift = sdp->sd_sb.sb_bsize_shift;
2315         BUG_ON(gfs2_is_dir(ip));
2316         end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
2317         lblock = offset >> shift;
2318         lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
2319         if (lblock_stop > end_of_file && ip != GFS2_I(sdp->sd_rindex))
2320                 return 1;
2321
2322         size = (lblock_stop - lblock) << shift;
2323         do {
2324                 bh.b_state = 0;
2325                 bh.b_size = size;
2326                 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
2327                 if (!buffer_mapped(&bh))
2328                         return 1;
2329                 size -= bh.b_size;
2330                 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2331         } while(size > 0);
2332
2333         return 0;
2334 }
2335
2336 static int stuffed_zero_range(struct inode *inode, loff_t offset, loff_t length)
2337 {
2338         struct gfs2_inode *ip = GFS2_I(inode);
2339         struct buffer_head *dibh;
2340         int error;
2341
2342         if (offset >= inode->i_size)
2343                 return 0;
2344         if (offset + length > inode->i_size)
2345                 length = inode->i_size - offset;
2346
2347         error = gfs2_meta_inode_buffer(ip, &dibh);
2348         if (error)
2349                 return error;
2350         gfs2_trans_add_meta(ip->i_gl, dibh);
2351         memset(dibh->b_data + sizeof(struct gfs2_dinode) + offset, 0,
2352                length);
2353         brelse(dibh);
2354         return 0;
2355 }
2356
2357 static int gfs2_journaled_truncate_range(struct inode *inode, loff_t offset,
2358                                          loff_t length)
2359 {
2360         struct gfs2_sbd *sdp = GFS2_SB(inode);
2361         loff_t max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
2362         int error;
2363
2364         while (length) {
2365                 struct gfs2_trans *tr;
2366                 loff_t chunk;
2367                 unsigned int offs;
2368
2369                 chunk = length;
2370                 if (chunk > max_chunk)
2371                         chunk = max_chunk;
2372
2373                 offs = offset & ~PAGE_MASK;
2374                 if (offs && chunk > PAGE_SIZE)
2375                         chunk = offs + ((chunk - offs) & PAGE_MASK);
2376
2377                 truncate_pagecache_range(inode, offset, chunk);
2378                 offset += chunk;
2379                 length -= chunk;
2380
2381                 tr = current->journal_info;
2382                 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
2383                         continue;
2384
2385                 gfs2_trans_end(sdp);
2386                 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
2387                 if (error)
2388                         return error;
2389         }
2390         return 0;
2391 }
2392
2393 int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length)
2394 {
2395         struct inode *inode = file_inode(file);
2396         struct gfs2_inode *ip = GFS2_I(inode);
2397         struct gfs2_sbd *sdp = GFS2_SB(inode);
2398         int error;
2399
2400         if (gfs2_is_jdata(ip))
2401                 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
2402                                          GFS2_JTRUNC_REVOKES);
2403         else
2404                 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
2405         if (error)
2406                 return error;
2407
2408         if (gfs2_is_stuffed(ip)) {
2409                 error = stuffed_zero_range(inode, offset, length);
2410                 if (error)
2411                         goto out;
2412         } else {
2413                 unsigned int start_off, end_len, blocksize;
2414
2415                 blocksize = i_blocksize(inode);
2416                 start_off = offset & (blocksize - 1);
2417                 end_len = (offset + length) & (blocksize - 1);
2418                 if (start_off) {
2419                         unsigned int len = length;
2420                         if (length > blocksize - start_off)
2421                                 len = blocksize - start_off;
2422                         error = gfs2_block_zero_range(inode, offset, len);
2423                         if (error)
2424                                 goto out;
2425                         if (start_off + length < blocksize)
2426                                 end_len = 0;
2427                 }
2428                 if (end_len) {
2429                         error = gfs2_block_zero_range(inode,
2430                                 offset + length - end_len, end_len);
2431                         if (error)
2432                                 goto out;
2433                 }
2434         }
2435
2436         if (gfs2_is_jdata(ip)) {
2437                 BUG_ON(!current->journal_info);
2438                 gfs2_journaled_truncate_range(inode, offset, length);
2439         } else
2440                 truncate_pagecache_range(inode, offset, offset + length - 1);
2441
2442         file_update_time(file);
2443         mark_inode_dirty(inode);
2444
2445         if (current->journal_info)
2446                 gfs2_trans_end(sdp);
2447
2448         if (!gfs2_is_stuffed(ip))
2449                 error = punch_hole(ip, offset, length);
2450
2451 out:
2452         if (current->journal_info)
2453                 gfs2_trans_end(sdp);
2454         return error;
2455 }