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