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