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