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