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