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