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 unsigned int bsize = 1 << bsize_shift; 1722 u64 lblock = (offset + bsize - 1) >> bsize_shift; 1723 __u16 start_list[GFS2_MAX_META_HEIGHT]; 1724 __u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL; 1725 unsigned int start_aligned, end_aligned; 1726 unsigned int strip_h = ip->i_height - 1; 1727 u32 btotal = 0; 1728 int ret, state; 1729 int mp_h; /* metapath buffers are read in to this height */ 1730 u64 prev_bnr = 0; 1731 __be64 *start, *end; 1732 1733 if (offset + bsize - 1 >= maxsize) { 1734 /* 1735 * The starting point lies beyond the allocated metadata; 1736 * there are no blocks to deallocate. 1737 */ 1738 return 0; 1739 } 1740 1741 /* 1742 * The start position of the hole is defined by lblock, start_list, and 1743 * start_aligned. The end position of the hole is defined by lend, 1744 * end_list, and end_aligned. 1745 * 1746 * start_aligned and end_aligned define down to which height the start 1747 * and end positions are aligned to the metadata tree (i.e., the 1748 * position is a multiple of the metadata granularity at the height 1749 * above). This determines at which heights additional meta pointers 1750 * needs to be preserved for the remaining data. 1751 */ 1752 1753 if (length) { 1754 u64 end_offset = offset + length; 1755 u64 lend; 1756 1757 /* 1758 * Clip the end at the maximum file size for the given height: 1759 * that's how far the metadata goes; files bigger than that 1760 * will have additional layers of indirection. 1761 */ 1762 if (end_offset > maxsize) 1763 end_offset = maxsize; 1764 lend = end_offset >> bsize_shift; 1765 1766 if (lblock >= lend) 1767 return 0; 1768 1769 find_metapath(sdp, lend, &mp, ip->i_height); 1770 end_list = __end_list; 1771 memcpy(end_list, mp.mp_list, sizeof(mp.mp_list)); 1772 1773 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) { 1774 if (end_list[mp_h]) 1775 break; 1776 } 1777 end_aligned = mp_h; 1778 } 1779 1780 find_metapath(sdp, lblock, &mp, ip->i_height); 1781 memcpy(start_list, mp.mp_list, sizeof(start_list)); 1782 1783 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) { 1784 if (start_list[mp_h]) 1785 break; 1786 } 1787 start_aligned = mp_h; 1788 1789 ret = gfs2_meta_inode_buffer(ip, &dibh); 1790 if (ret) 1791 return ret; 1792 1793 mp.mp_bh[0] = dibh; 1794 ret = lookup_metapath(ip, &mp); 1795 if (ret) 1796 goto out_metapath; 1797 1798 /* issue read-ahead on metadata */ 1799 for (mp_h = 0; mp_h < mp.mp_aheight - 1; mp_h++) { 1800 metapointer_range(&mp, mp_h, start_list, start_aligned, 1801 end_list, end_aligned, &start, &end); 1802 gfs2_metapath_ra(ip->i_gl, start, end); 1803 } 1804 1805 if (mp.mp_aheight == ip->i_height) 1806 state = DEALLOC_MP_FULL; /* We have a complete metapath */ 1807 else 1808 state = DEALLOC_FILL_MP; /* deal with partial metapath */ 1809 1810 ret = gfs2_rindex_update(sdp); 1811 if (ret) 1812 goto out_metapath; 1813 1814 ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE); 1815 if (ret) 1816 goto out_metapath; 1817 gfs2_holder_mark_uninitialized(&rd_gh); 1818 1819 mp_h = strip_h; 1820 1821 while (state != DEALLOC_DONE) { 1822 switch (state) { 1823 /* Truncate a full metapath at the given strip height. 1824 * Note that strip_h == mp_h in order to be in this state. */ 1825 case DEALLOC_MP_FULL: 1826 bh = mp.mp_bh[mp_h]; 1827 gfs2_assert_withdraw(sdp, bh); 1828 if (gfs2_assert_withdraw(sdp, 1829 prev_bnr != bh->b_blocknr)) { 1830 fs_emerg(sdp, "inode %llu, block:%llu, i_h:%u," 1831 "s_h:%u, mp_h:%u\n", 1832 (unsigned long long)ip->i_no_addr, 1833 prev_bnr, ip->i_height, strip_h, mp_h); 1834 } 1835 prev_bnr = bh->b_blocknr; 1836 1837 if (gfs2_metatype_check(sdp, bh, 1838 (mp_h ? GFS2_METATYPE_IN : 1839 GFS2_METATYPE_DI))) { 1840 ret = -EIO; 1841 goto out; 1842 } 1843 1844 /* 1845 * Below, passing end_aligned as 0 gives us the 1846 * metapointer range excluding the end point: the end 1847 * point is the first metapath we must not deallocate! 1848 */ 1849 1850 metapointer_range(&mp, mp_h, start_list, start_aligned, 1851 end_list, 0 /* end_aligned */, 1852 &start, &end); 1853 ret = sweep_bh_for_rgrps(ip, &rd_gh, mp.mp_bh[mp_h], 1854 start, end, 1855 mp_h != ip->i_height - 1, 1856 &btotal); 1857 1858 /* If we hit an error or just swept dinode buffer, 1859 just exit. */ 1860 if (ret || !mp_h) { 1861 state = DEALLOC_DONE; 1862 break; 1863 } 1864 state = DEALLOC_MP_LOWER; 1865 break; 1866 1867 /* lower the metapath strip height */ 1868 case DEALLOC_MP_LOWER: 1869 /* We're done with the current buffer, so release it, 1870 unless it's the dinode buffer. Then back up to the 1871 previous pointer. */ 1872 if (mp_h) { 1873 brelse(mp.mp_bh[mp_h]); 1874 mp.mp_bh[mp_h] = NULL; 1875 } 1876 /* If we can't get any lower in height, we've stripped 1877 off all we can. Next step is to back up and start 1878 stripping the previous level of metadata. */ 1879 if (mp_h == 0) { 1880 strip_h--; 1881 memcpy(mp.mp_list, start_list, sizeof(start_list)); 1882 mp_h = strip_h; 1883 state = DEALLOC_FILL_MP; 1884 break; 1885 } 1886 mp.mp_list[mp_h] = 0; 1887 mp_h--; /* search one metadata height down */ 1888 mp.mp_list[mp_h]++; 1889 if (walk_done(sdp, &mp, mp_h, end_list, end_aligned)) 1890 break; 1891 /* Here we've found a part of the metapath that is not 1892 * allocated. We need to search at that height for the 1893 * next non-null pointer. */ 1894 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) { 1895 state = DEALLOC_FILL_MP; 1896 mp_h++; 1897 } 1898 /* No more non-null pointers at this height. Back up 1899 to the previous height and try again. */ 1900 break; /* loop around in the same state */ 1901 1902 /* Fill the metapath with buffers to the given height. */ 1903 case DEALLOC_FILL_MP: 1904 /* Fill the buffers out to the current height. */ 1905 ret = fillup_metapath(ip, &mp, mp_h); 1906 if (ret < 0) 1907 goto out; 1908 1909 /* On the first pass, issue read-ahead on metadata. */ 1910 if (mp.mp_aheight > 1 && strip_h == ip->i_height - 1) { 1911 unsigned int height = mp.mp_aheight - 1; 1912 1913 /* No read-ahead for data blocks. */ 1914 if (mp.mp_aheight - 1 == strip_h) 1915 height--; 1916 1917 for (; height >= mp.mp_aheight - ret; height--) { 1918 metapointer_range(&mp, height, 1919 start_list, start_aligned, 1920 end_list, end_aligned, 1921 &start, &end); 1922 gfs2_metapath_ra(ip->i_gl, start, end); 1923 } 1924 } 1925 1926 /* If buffers found for the entire strip height */ 1927 if (mp.mp_aheight - 1 == strip_h) { 1928 state = DEALLOC_MP_FULL; 1929 break; 1930 } 1931 if (mp.mp_aheight < ip->i_height) /* We have a partial height */ 1932 mp_h = mp.mp_aheight - 1; 1933 1934 /* If we find a non-null block pointer, crawl a bit 1935 higher up in the metapath and try again, otherwise 1936 we need to look lower for a new starting point. */ 1937 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) 1938 mp_h++; 1939 else 1940 state = DEALLOC_MP_LOWER; 1941 break; 1942 } 1943 } 1944 1945 if (btotal) { 1946 if (current->journal_info == NULL) { 1947 ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + 1948 RES_QUOTA, 0); 1949 if (ret) 1950 goto out; 1951 down_write(&ip->i_rw_mutex); 1952 } 1953 gfs2_statfs_change(sdp, 0, +btotal, 0); 1954 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid, 1955 ip->i_inode.i_gid); 1956 inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&ip->i_inode)); 1957 gfs2_trans_add_meta(ip->i_gl, dibh); 1958 gfs2_dinode_out(ip, dibh->b_data); 1959 up_write(&ip->i_rw_mutex); 1960 gfs2_trans_end(sdp); 1961 } 1962 1963out: 1964 if (gfs2_holder_initialized(&rd_gh)) 1965 gfs2_glock_dq_uninit(&rd_gh); 1966 if (current->journal_info) { 1967 up_write(&ip->i_rw_mutex); 1968 gfs2_trans_end(sdp); 1969 cond_resched(); 1970 } 1971 gfs2_quota_unhold(ip); 1972out_metapath: 1973 release_metapath(&mp); 1974 return ret; 1975} 1976 1977static int trunc_end(struct gfs2_inode *ip) 1978{ 1979 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1980 struct buffer_head *dibh; 1981 int error; 1982 1983 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1984 if (error) 1985 return error; 1986 1987 down_write(&ip->i_rw_mutex); 1988 1989 error = gfs2_meta_inode_buffer(ip, &dibh); 1990 if (error) 1991 goto out; 1992 1993 if (!i_size_read(&ip->i_inode)) { 1994 ip->i_height = 0; 1995 ip->i_goal = ip->i_no_addr; 1996 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 1997 gfs2_ordered_del_inode(ip); 1998 } 1999 inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&ip->i_inode)); 2000 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG; 2001 2002 gfs2_trans_add_meta(ip->i_gl, dibh); 2003 gfs2_dinode_out(ip, dibh->b_data); 2004 brelse(dibh); 2005 2006out: 2007 up_write(&ip->i_rw_mutex); 2008 gfs2_trans_end(sdp); 2009 return error; 2010} 2011 2012/** 2013 * do_shrink - make a file smaller 2014 * @inode: the inode 2015 * @newsize: the size to make the file 2016 * 2017 * Called with an exclusive lock on @inode. The @size must 2018 * be equal to or smaller than the current inode size. 2019 * 2020 * Returns: errno 2021 */ 2022 2023static int do_shrink(struct inode *inode, u64 newsize) 2024{ 2025 struct gfs2_inode *ip = GFS2_I(inode); 2026 int error; 2027 2028 error = trunc_start(inode, newsize); 2029 if (error < 0) 2030 return error; 2031 if (gfs2_is_stuffed(ip)) 2032 return 0; 2033 2034 error = punch_hole(ip, newsize, 0); 2035 if (error == 0) 2036 error = trunc_end(ip); 2037 2038 return error; 2039} 2040 2041/** 2042 * do_grow - Touch and update inode size 2043 * @inode: The inode 2044 * @size: The new size 2045 * 2046 * This function updates the timestamps on the inode and 2047 * may also increase the size of the inode. This function 2048 * must not be called with @size any smaller than the current 2049 * inode size. 2050 * 2051 * Although it is not strictly required to unstuff files here, 2052 * earlier versions of GFS2 have a bug in the stuffed file reading 2053 * code which will result in a buffer overrun if the size is larger 2054 * than the max stuffed file size. In order to prevent this from 2055 * occurring, such files are unstuffed, but in other cases we can 2056 * just update the inode size directly. 2057 * 2058 * Returns: 0 on success, or -ve on error 2059 */ 2060 2061static int do_grow(struct inode *inode, u64 size) 2062{ 2063 struct gfs2_inode *ip = GFS2_I(inode); 2064 struct gfs2_sbd *sdp = GFS2_SB(inode); 2065 struct gfs2_alloc_parms ap = { .target = 1, }; 2066 struct buffer_head *dibh; 2067 int error; 2068 int unstuff = 0; 2069 2070 if (gfs2_is_stuffed(ip) && size > gfs2_max_stuffed_size(ip)) { 2071 error = gfs2_quota_lock_check(ip, &ap); 2072 if (error) 2073 return error; 2074 2075 error = gfs2_inplace_reserve(ip, &ap); 2076 if (error) 2077 goto do_grow_qunlock; 2078 unstuff = 1; 2079 } 2080 2081 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT + 2082 (unstuff && 2083 gfs2_is_jdata(ip) ? RES_JDATA : 0) + 2084 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ? 2085 0 : RES_QUOTA), 0); 2086 if (error) 2087 goto do_grow_release; 2088 2089 if (unstuff) { 2090 error = gfs2_unstuff_dinode(ip); 2091 if (error) 2092 goto do_end_trans; 2093 } 2094 2095 error = gfs2_meta_inode_buffer(ip, &dibh); 2096 if (error) 2097 goto do_end_trans; 2098 2099 truncate_setsize(inode, size); 2100 inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&ip->i_inode)); 2101 gfs2_trans_add_meta(ip->i_gl, dibh); 2102 gfs2_dinode_out(ip, dibh->b_data); 2103 brelse(dibh); 2104 2105do_end_trans: 2106 gfs2_trans_end(sdp); 2107do_grow_release: 2108 if (unstuff) { 2109 gfs2_inplace_release(ip); 2110do_grow_qunlock: 2111 gfs2_quota_unlock(ip); 2112 } 2113 return error; 2114} 2115 2116/** 2117 * gfs2_setattr_size - make a file a given size 2118 * @inode: the inode 2119 * @newsize: the size to make the file 2120 * 2121 * The file size can grow, shrink, or stay the same size. This 2122 * is called holding i_rwsem and an exclusive glock on the inode 2123 * in question. 2124 * 2125 * Returns: errno 2126 */ 2127 2128int gfs2_setattr_size(struct inode *inode, u64 newsize) 2129{ 2130 struct gfs2_inode *ip = GFS2_I(inode); 2131 int ret; 2132 2133 BUG_ON(!S_ISREG(inode->i_mode)); 2134 2135 ret = inode_newsize_ok(inode, newsize); 2136 if (ret) 2137 return ret; 2138 2139 inode_dio_wait(inode); 2140 2141 ret = gfs2_qa_get(ip); 2142 if (ret) 2143 goto out; 2144 2145 if (newsize >= inode->i_size) { 2146 ret = do_grow(inode, newsize); 2147 goto out; 2148 } 2149 2150 ret = do_shrink(inode, newsize); 2151out: 2152 gfs2_rs_delete(ip); 2153 gfs2_qa_put(ip); 2154 return ret; 2155} 2156 2157int gfs2_truncatei_resume(struct gfs2_inode *ip) 2158{ 2159 int error; 2160 error = punch_hole(ip, i_size_read(&ip->i_inode), 0); 2161 if (!error) 2162 error = trunc_end(ip); 2163 return error; 2164} 2165 2166int gfs2_file_dealloc(struct gfs2_inode *ip) 2167{ 2168 return punch_hole(ip, 0, 0); 2169} 2170 2171/** 2172 * gfs2_free_journal_extents - Free cached journal bmap info 2173 * @jd: The journal 2174 * 2175 */ 2176 2177void gfs2_free_journal_extents(struct gfs2_jdesc *jd) 2178{ 2179 struct gfs2_journal_extent *jext; 2180 2181 while(!list_empty(&jd->extent_list)) { 2182 jext = list_first_entry(&jd->extent_list, struct gfs2_journal_extent, list); 2183 list_del(&jext->list); 2184 kfree(jext); 2185 } 2186} 2187 2188/** 2189 * gfs2_add_jextent - Add or merge a new extent to extent cache 2190 * @jd: The journal descriptor 2191 * @lblock: The logical block at start of new extent 2192 * @dblock: The physical block at start of new extent 2193 * @blocks: Size of extent in fs blocks 2194 * 2195 * Returns: 0 on success or -ENOMEM 2196 */ 2197 2198static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks) 2199{ 2200 struct gfs2_journal_extent *jext; 2201 2202 if (!list_empty(&jd->extent_list)) { 2203 jext = list_last_entry(&jd->extent_list, struct gfs2_journal_extent, list); 2204 if ((jext->dblock + jext->blocks) == dblock) { 2205 jext->blocks += blocks; 2206 return 0; 2207 } 2208 } 2209 2210 jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS); 2211 if (jext == NULL) 2212 return -ENOMEM; 2213 jext->dblock = dblock; 2214 jext->lblock = lblock; 2215 jext->blocks = blocks; 2216 list_add_tail(&jext->list, &jd->extent_list); 2217 jd->nr_extents++; 2218 return 0; 2219} 2220 2221/** 2222 * gfs2_map_journal_extents - Cache journal bmap info 2223 * @sdp: The super block 2224 * @jd: The journal to map 2225 * 2226 * Create a reusable "extent" mapping from all logical 2227 * blocks to all physical blocks for the given journal. This will save 2228 * us time when writing journal blocks. Most journals will have only one 2229 * extent that maps all their logical blocks. That's because gfs2.mkfs 2230 * arranges the journal blocks sequentially to maximize performance. 2231 * So the extent would map the first block for the entire file length. 2232 * However, gfs2_jadd can happen while file activity is happening, so 2233 * those journals may not be sequential. Less likely is the case where 2234 * the users created their own journals by mounting the metafs and 2235 * laying it out. But it's still possible. These journals might have 2236 * several extents. 2237 * 2238 * Returns: 0 on success, or error on failure 2239 */ 2240 2241int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd) 2242{ 2243 u64 lblock = 0; 2244 u64 lblock_stop; 2245 struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 2246 struct buffer_head bh; 2247 unsigned int shift = sdp->sd_sb.sb_bsize_shift; 2248 u64 size; 2249 int rc; 2250 ktime_t start, end; 2251 2252 start = ktime_get(); 2253 lblock_stop = i_size_read(jd->jd_inode) >> shift; 2254 size = (lblock_stop - lblock) << shift; 2255 jd->nr_extents = 0; 2256 WARN_ON(!list_empty(&jd->extent_list)); 2257 2258 do { 2259 bh.b_state = 0; 2260 bh.b_blocknr = 0; 2261 bh.b_size = size; 2262 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0); 2263 if (rc || !buffer_mapped(&bh)) 2264 goto fail; 2265 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift); 2266 if (rc) 2267 goto fail; 2268 size -= bh.b_size; 2269 lblock += (bh.b_size >> ip->i_inode.i_blkbits); 2270 } while(size > 0); 2271 2272 end = ktime_get(); 2273 fs_info(sdp, "journal %d mapped with %u extents in %lldms\n", jd->jd_jid, 2274 jd->nr_extents, ktime_ms_delta(end, start)); 2275 return 0; 2276 2277fail: 2278 fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n", 2279 rc, jd->jd_jid, 2280 (unsigned long long)(i_size_read(jd->jd_inode) - size), 2281 jd->nr_extents); 2282 fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n", 2283 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr, 2284 bh.b_state, (unsigned long long)bh.b_size); 2285 gfs2_free_journal_extents(jd); 2286 return rc; 2287} 2288 2289/** 2290 * gfs2_write_alloc_required - figure out if a write will require an allocation 2291 * @ip: the file being written to 2292 * @offset: the offset to write to 2293 * @len: the number of bytes being written 2294 * 2295 * Returns: 1 if an alloc is required, 0 otherwise 2296 */ 2297 2298int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset, 2299 unsigned int len) 2300{ 2301 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 2302 struct buffer_head bh; 2303 unsigned int shift; 2304 u64 lblock, lblock_stop, size; 2305 u64 end_of_file; 2306 2307 if (!len) 2308 return 0; 2309 2310 if (gfs2_is_stuffed(ip)) { 2311 if (offset + len > gfs2_max_stuffed_size(ip)) 2312 return 1; 2313 return 0; 2314 } 2315 2316 shift = sdp->sd_sb.sb_bsize_shift; 2317 BUG_ON(gfs2_is_dir(ip)); 2318 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift; 2319 lblock = offset >> shift; 2320 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift; 2321 if (lblock_stop > end_of_file && ip != GFS2_I(sdp->sd_rindex)) 2322 return 1; 2323 2324 size = (lblock_stop - lblock) << shift; 2325 do { 2326 bh.b_state = 0; 2327 bh.b_size = size; 2328 gfs2_block_map(&ip->i_inode, lblock, &bh, 0); 2329 if (!buffer_mapped(&bh)) 2330 return 1; 2331 size -= bh.b_size; 2332 lblock += (bh.b_size >> ip->i_inode.i_blkbits); 2333 } while(size > 0); 2334 2335 return 0; 2336} 2337 2338static int stuffed_zero_range(struct inode *inode, loff_t offset, loff_t length) 2339{ 2340 struct gfs2_inode *ip = GFS2_I(inode); 2341 struct buffer_head *dibh; 2342 int error; 2343 2344 if (offset >= inode->i_size) 2345 return 0; 2346 if (offset + length > inode->i_size) 2347 length = inode->i_size - offset; 2348 2349 error = gfs2_meta_inode_buffer(ip, &dibh); 2350 if (error) 2351 return error; 2352 gfs2_trans_add_meta(ip->i_gl, dibh); 2353 memset(dibh->b_data + sizeof(struct gfs2_dinode) + offset, 0, 2354 length); 2355 brelse(dibh); 2356 return 0; 2357} 2358 2359static int gfs2_journaled_truncate_range(struct inode *inode, loff_t offset, 2360 loff_t length) 2361{ 2362 struct gfs2_sbd *sdp = GFS2_SB(inode); 2363 loff_t max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize; 2364 int error; 2365 2366 while (length) { 2367 struct gfs2_trans *tr; 2368 loff_t chunk; 2369 unsigned int offs; 2370 2371 chunk = length; 2372 if (chunk > max_chunk) 2373 chunk = max_chunk; 2374 2375 offs = offset & ~PAGE_MASK; 2376 if (offs && chunk > PAGE_SIZE) 2377 chunk = offs + ((chunk - offs) & PAGE_MASK); 2378 2379 truncate_pagecache_range(inode, offset, chunk); 2380 offset += chunk; 2381 length -= chunk; 2382 2383 tr = current->journal_info; 2384 if (!test_bit(TR_TOUCHED, &tr->tr_flags)) 2385 continue; 2386 2387 gfs2_trans_end(sdp); 2388 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES); 2389 if (error) 2390 return error; 2391 } 2392 return 0; 2393} 2394 2395int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length) 2396{ 2397 struct inode *inode = file_inode(file); 2398 struct gfs2_inode *ip = GFS2_I(inode); 2399 struct gfs2_sbd *sdp = GFS2_SB(inode); 2400 unsigned int blocksize = i_blocksize(inode); 2401 loff_t start, end; 2402 int error; 2403 2404 if (!gfs2_is_stuffed(ip)) { 2405 unsigned int start_off, end_len; 2406 2407 start_off = offset & (blocksize - 1); 2408 end_len = (offset + length) & (blocksize - 1); 2409 if (start_off) { 2410 unsigned int len = length; 2411 if (length > blocksize - start_off) 2412 len = blocksize - start_off; 2413 error = gfs2_block_zero_range(inode, offset, len); 2414 if (error) 2415 goto out; 2416 if (start_off + length < blocksize) 2417 end_len = 0; 2418 } 2419 if (end_len) { 2420 error = gfs2_block_zero_range(inode, 2421 offset + length - end_len, end_len); 2422 if (error) 2423 goto out; 2424 } 2425 } 2426 2427 start = round_down(offset, blocksize); 2428 end = round_up(offset + length, blocksize) - 1; 2429 error = filemap_write_and_wait_range(inode->i_mapping, start, end); 2430 if (error) 2431 return error; 2432 2433 if (gfs2_is_jdata(ip)) 2434 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA, 2435 GFS2_JTRUNC_REVOKES); 2436 else 2437 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 2438 if (error) 2439 return error; 2440 2441 if (gfs2_is_stuffed(ip)) { 2442 error = stuffed_zero_range(inode, offset, length); 2443 if (error) 2444 goto out; 2445 } 2446 2447 if (gfs2_is_jdata(ip)) { 2448 BUG_ON(!current->journal_info); 2449 gfs2_journaled_truncate_range(inode, offset, length); 2450 } else 2451 truncate_pagecache_range(inode, offset, offset + length - 1); 2452 2453 file_update_time(file); 2454 mark_inode_dirty(inode); 2455 2456 if (current->journal_info) 2457 gfs2_trans_end(sdp); 2458 2459 if (!gfs2_is_stuffed(ip)) 2460 error = punch_hole(ip, offset, length); 2461 2462out: 2463 if (current->journal_info) 2464 gfs2_trans_end(sdp); 2465 return error; 2466} 2467 2468static int gfs2_map_blocks(struct iomap_writepage_ctx *wpc, struct inode *inode, 2469 loff_t offset, unsigned int len) 2470{ 2471 int ret; 2472 2473 if (WARN_ON_ONCE(gfs2_is_stuffed(GFS2_I(inode)))) 2474 return -EIO; 2475 2476 if (offset >= wpc->iomap.offset && 2477 offset < wpc->iomap.offset + wpc->iomap.length) 2478 return 0; 2479 2480 memset(&wpc->iomap, 0, sizeof(wpc->iomap)); 2481 ret = gfs2_iomap_get(inode, offset, INT_MAX, &wpc->iomap); 2482 return ret; 2483} 2484 2485const struct iomap_writeback_ops gfs2_writeback_ops = { 2486 .map_blocks = gfs2_map_blocks, 2487}; 2488