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 "super.h" 26 #include "trans.h" 27 #include "dir.h" 28 #include "util.h" 29 #include "trace_gfs2.h" 30 31 /* This doesn't need to be that large as max 64 bit pointers in a 4k 32 * block is 512, so __u16 is fine for that. It saves stack space to 33 * keep it small. 34 */ 35 struct metapath { 36 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT]; 37 __u16 mp_list[GFS2_MAX_META_HEIGHT]; 38 }; 39 40 struct strip_mine { 41 int sm_first; 42 unsigned int sm_height; 43 }; 44 45 /** 46 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page 47 * @ip: the inode 48 * @dibh: the dinode buffer 49 * @block: the block number that was allocated 50 * @page: The (optional) page. This is looked up if @page is NULL 51 * 52 * Returns: errno 53 */ 54 55 static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 56 u64 block, struct page *page) 57 { 58 struct inode *inode = &ip->i_inode; 59 struct buffer_head *bh; 60 int release = 0; 61 62 if (!page || page->index) { 63 page = grab_cache_page(inode->i_mapping, 0); 64 if (!page) 65 return -ENOMEM; 66 release = 1; 67 } 68 69 if (!PageUptodate(page)) { 70 void *kaddr = kmap(page); 71 u64 dsize = i_size_read(inode); 72 73 if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode))) 74 dsize = dibh->b_size - sizeof(struct gfs2_dinode); 75 76 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize); 77 memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize); 78 kunmap(page); 79 80 SetPageUptodate(page); 81 } 82 83 if (!page_has_buffers(page)) 84 create_empty_buffers(page, 1 << inode->i_blkbits, 85 (1 << BH_Uptodate)); 86 87 bh = page_buffers(page); 88 89 if (!buffer_mapped(bh)) 90 map_bh(bh, inode->i_sb, block); 91 92 set_buffer_uptodate(bh); 93 if (!gfs2_is_jdata(ip)) 94 mark_buffer_dirty(bh); 95 if (!gfs2_is_writeback(ip)) 96 gfs2_trans_add_bh(ip->i_gl, bh, 0); 97 98 if (release) { 99 unlock_page(page); 100 page_cache_release(page); 101 } 102 103 return 0; 104 } 105 106 /** 107 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big 108 * @ip: The GFS2 inode to unstuff 109 * @page: The (optional) page. This is looked up if the @page is NULL 110 * 111 * This routine unstuffs a dinode and returns it to a "normal" state such 112 * that the height can be grown in the traditional way. 113 * 114 * Returns: errno 115 */ 116 117 int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 118 { 119 struct buffer_head *bh, *dibh; 120 struct gfs2_dinode *di; 121 u64 block = 0; 122 int isdir = gfs2_is_dir(ip); 123 int error; 124 125 down_write(&ip->i_rw_mutex); 126 127 error = gfs2_meta_inode_buffer(ip, &dibh); 128 if (error) 129 goto out; 130 131 if (i_size_read(&ip->i_inode)) { 132 /* Get a free block, fill it with the stuffed data, 133 and write it out to disk */ 134 135 unsigned int n = 1; 136 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL); 137 if (error) 138 goto out_brelse; 139 if (isdir) { 140 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1); 141 error = gfs2_dir_get_new_buffer(ip, block, &bh); 142 if (error) 143 goto out_brelse; 144 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header), 145 dibh, sizeof(struct gfs2_dinode)); 146 brelse(bh); 147 } else { 148 error = gfs2_unstuffer_page(ip, dibh, block, page); 149 if (error) 150 goto out_brelse; 151 } 152 } 153 154 /* Set up the pointer to the new block */ 155 156 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 157 di = (struct gfs2_dinode *)dibh->b_data; 158 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 159 160 if (i_size_read(&ip->i_inode)) { 161 *(__be64 *)(di + 1) = cpu_to_be64(block); 162 gfs2_add_inode_blocks(&ip->i_inode, 1); 163 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode)); 164 } 165 166 ip->i_height = 1; 167 di->di_height = cpu_to_be16(1); 168 169 out_brelse: 170 brelse(dibh); 171 out: 172 up_write(&ip->i_rw_mutex); 173 return error; 174 } 175 176 177 /** 178 * find_metapath - Find path through the metadata tree 179 * @sdp: The superblock 180 * @mp: The metapath to return the result in 181 * @block: The disk block to look up 182 * @height: The pre-calculated height of the metadata tree 183 * 184 * This routine returns a struct metapath structure that defines a path 185 * through the metadata of inode "ip" to get to block "block". 186 * 187 * Example: 188 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a 189 * filesystem with a blocksize of 4096. 190 * 191 * find_metapath() would return a struct metapath structure set to: 192 * mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48, 193 * and mp_list[2] = 165. 194 * 195 * That means that in order to get to the block containing the byte at 196 * offset 101342453, we would load the indirect block pointed to by pointer 197 * 0 in the dinode. We would then load the indirect block pointed to by 198 * pointer 48 in that indirect block. We would then load the data block 199 * pointed to by pointer 165 in that indirect block. 200 * 201 * ---------------------------------------- 202 * | Dinode | | 203 * | | 4| 204 * | |0 1 2 3 4 5 9| 205 * | | 6| 206 * ---------------------------------------- 207 * | 208 * | 209 * V 210 * ---------------------------------------- 211 * | Indirect Block | 212 * | 5| 213 * | 4 4 4 4 4 5 5 1| 214 * |0 5 6 7 8 9 0 1 2| 215 * ---------------------------------------- 216 * | 217 * | 218 * V 219 * ---------------------------------------- 220 * | Indirect Block | 221 * | 1 1 1 1 1 5| 222 * | 6 6 6 6 6 1| 223 * |0 3 4 5 6 7 2| 224 * ---------------------------------------- 225 * | 226 * | 227 * V 228 * ---------------------------------------- 229 * | Data block containing offset | 230 * | 101342453 | 231 * | | 232 * | | 233 * ---------------------------------------- 234 * 235 */ 236 237 static void find_metapath(const struct gfs2_sbd *sdp, u64 block, 238 struct metapath *mp, unsigned int height) 239 { 240 unsigned int i; 241 242 for (i = height; i--;) 243 mp->mp_list[i] = do_div(block, sdp->sd_inptrs); 244 245 } 246 247 static inline unsigned int metapath_branch_start(const struct metapath *mp) 248 { 249 if (mp->mp_list[0] == 0) 250 return 2; 251 return 1; 252 } 253 254 /** 255 * metapointer - Return pointer to start of metadata in a buffer 256 * @height: The metadata height (0 = dinode) 257 * @mp: The metapath 258 * 259 * Return a pointer to the block number of the next height of the metadata 260 * tree given a buffer containing the pointer to the current height of the 261 * metadata tree. 262 */ 263 264 static inline __be64 *metapointer(unsigned int height, const struct metapath *mp) 265 { 266 struct buffer_head *bh = mp->mp_bh[height]; 267 unsigned int head_size = (height > 0) ? 268 sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode); 269 return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height]; 270 } 271 272 static void gfs2_metapath_ra(struct gfs2_glock *gl, 273 const struct buffer_head *bh, const __be64 *pos) 274 { 275 struct buffer_head *rabh; 276 const __be64 *endp = (const __be64 *)(bh->b_data + bh->b_size); 277 const __be64 *t; 278 279 for (t = pos; t < endp; t++) { 280 if (!*t) 281 continue; 282 283 rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE); 284 if (trylock_buffer(rabh)) { 285 if (!buffer_uptodate(rabh)) { 286 rabh->b_end_io = end_buffer_read_sync; 287 submit_bh(READA | REQ_META, rabh); 288 continue; 289 } 290 unlock_buffer(rabh); 291 } 292 brelse(rabh); 293 } 294 } 295 296 /** 297 * lookup_metapath - Walk the metadata tree to a specific point 298 * @ip: The inode 299 * @mp: The metapath 300 * 301 * Assumes that the inode's buffer has already been looked up and 302 * hooked onto mp->mp_bh[0] and that the metapath has been initialised 303 * by find_metapath(). 304 * 305 * If this function encounters part of the tree which has not been 306 * allocated, it returns the current height of the tree at the point 307 * at which it found the unallocated block. Blocks which are found are 308 * added to the mp->mp_bh[] list. 309 * 310 * Returns: error or height of metadata tree 311 */ 312 313 static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp) 314 { 315 unsigned int end_of_metadata = ip->i_height - 1; 316 unsigned int x; 317 __be64 *ptr; 318 u64 dblock; 319 int ret; 320 321 for (x = 0; x < end_of_metadata; x++) { 322 ptr = metapointer(x, mp); 323 dblock = be64_to_cpu(*ptr); 324 if (!dblock) 325 return x + 1; 326 327 ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, 0, &mp->mp_bh[x+1]); 328 if (ret) 329 return ret; 330 } 331 332 return ip->i_height; 333 } 334 335 static inline void release_metapath(struct metapath *mp) 336 { 337 int i; 338 339 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) { 340 if (mp->mp_bh[i] == NULL) 341 break; 342 brelse(mp->mp_bh[i]); 343 } 344 } 345 346 /** 347 * gfs2_extent_length - Returns length of an extent of blocks 348 * @start: Start of the buffer 349 * @len: Length of the buffer in bytes 350 * @ptr: Current position in the buffer 351 * @limit: Max extent length to return (0 = unlimited) 352 * @eob: Set to 1 if we hit "end of block" 353 * 354 * If the first block is zero (unallocated) it will return the number of 355 * unallocated blocks in the extent, otherwise it will return the number 356 * of contiguous blocks in the extent. 357 * 358 * Returns: The length of the extent (minimum of one block) 359 */ 360 361 static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, unsigned limit, int *eob) 362 { 363 const __be64 *end = (start + len); 364 const __be64 *first = ptr; 365 u64 d = be64_to_cpu(*ptr); 366 367 *eob = 0; 368 do { 369 ptr++; 370 if (ptr >= end) 371 break; 372 if (limit && --limit == 0) 373 break; 374 if (d) 375 d++; 376 } while(be64_to_cpu(*ptr) == d); 377 if (ptr >= end) 378 *eob = 1; 379 return (ptr - first); 380 } 381 382 static inline void bmap_lock(struct gfs2_inode *ip, int create) 383 { 384 if (create) 385 down_write(&ip->i_rw_mutex); 386 else 387 down_read(&ip->i_rw_mutex); 388 } 389 390 static inline void bmap_unlock(struct gfs2_inode *ip, int create) 391 { 392 if (create) 393 up_write(&ip->i_rw_mutex); 394 else 395 up_read(&ip->i_rw_mutex); 396 } 397 398 static inline __be64 *gfs2_indirect_init(struct metapath *mp, 399 struct gfs2_glock *gl, unsigned int i, 400 unsigned offset, u64 bn) 401 { 402 __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data + 403 ((i > 1) ? sizeof(struct gfs2_meta_header) : 404 sizeof(struct gfs2_dinode))); 405 BUG_ON(i < 1); 406 BUG_ON(mp->mp_bh[i] != NULL); 407 mp->mp_bh[i] = gfs2_meta_new(gl, bn); 408 gfs2_trans_add_bh(gl, mp->mp_bh[i], 1); 409 gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN); 410 gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header)); 411 ptr += offset; 412 *ptr = cpu_to_be64(bn); 413 return ptr; 414 } 415 416 enum alloc_state { 417 ALLOC_DATA = 0, 418 ALLOC_GROW_DEPTH = 1, 419 ALLOC_GROW_HEIGHT = 2, 420 /* ALLOC_UNSTUFF = 3, TBD and rather complicated */ 421 }; 422 423 /** 424 * gfs2_bmap_alloc - Build a metadata tree of the requested height 425 * @inode: The GFS2 inode 426 * @lblock: The logical starting block of the extent 427 * @bh_map: This is used to return the mapping details 428 * @mp: The metapath 429 * @sheight: The starting height (i.e. whats already mapped) 430 * @height: The height to build to 431 * @maxlen: The max number of data blocks to alloc 432 * 433 * In this routine we may have to alloc: 434 * i) Indirect blocks to grow the metadata tree height 435 * ii) Indirect blocks to fill in lower part of the metadata tree 436 * iii) Data blocks 437 * 438 * The function is in two parts. The first part works out the total 439 * number of blocks which we need. The second part does the actual 440 * allocation asking for an extent at a time (if enough contiguous free 441 * blocks are available, there will only be one request per bmap call) 442 * and uses the state machine to initialise the blocks in order. 443 * 444 * Returns: errno on error 445 */ 446 447 static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock, 448 struct buffer_head *bh_map, struct metapath *mp, 449 const unsigned int sheight, 450 const unsigned int height, 451 const unsigned int maxlen) 452 { 453 struct gfs2_inode *ip = GFS2_I(inode); 454 struct gfs2_sbd *sdp = GFS2_SB(inode); 455 struct super_block *sb = sdp->sd_vfs; 456 struct buffer_head *dibh = mp->mp_bh[0]; 457 u64 bn, dblock = 0; 458 unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0; 459 unsigned dblks = 0; 460 unsigned ptrs_per_blk; 461 const unsigned end_of_metadata = height - 1; 462 int ret; 463 int eob = 0; 464 enum alloc_state state; 465 __be64 *ptr; 466 __be64 zero_bn = 0; 467 468 BUG_ON(sheight < 1); 469 BUG_ON(dibh == NULL); 470 471 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 472 473 if (height == sheight) { 474 struct buffer_head *bh; 475 /* Bottom indirect block exists, find unalloced extent size */ 476 ptr = metapointer(end_of_metadata, mp); 477 bh = mp->mp_bh[end_of_metadata]; 478 dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, 479 &eob); 480 BUG_ON(dblks < 1); 481 state = ALLOC_DATA; 482 } else { 483 /* Need to allocate indirect blocks */ 484 ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs; 485 dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]); 486 if (height == ip->i_height) { 487 /* Writing into existing tree, extend tree down */ 488 iblks = height - sheight; 489 state = ALLOC_GROW_DEPTH; 490 } else { 491 /* Building up tree height */ 492 state = ALLOC_GROW_HEIGHT; 493 iblks = height - ip->i_height; 494 branch_start = metapath_branch_start(mp); 495 iblks += (height - branch_start); 496 } 497 } 498 499 /* start of the second part of the function (state machine) */ 500 501 blks = dblks + iblks; 502 i = sheight; 503 do { 504 int error; 505 n = blks - alloced; 506 error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL); 507 if (error) 508 return error; 509 alloced += n; 510 if (state != ALLOC_DATA || gfs2_is_jdata(ip)) 511 gfs2_trans_add_unrevoke(sdp, bn, n); 512 switch (state) { 513 /* Growing height of tree */ 514 case ALLOC_GROW_HEIGHT: 515 if (i == 1) { 516 ptr = (__be64 *)(dibh->b_data + 517 sizeof(struct gfs2_dinode)); 518 zero_bn = *ptr; 519 } 520 for (; i - 1 < height - ip->i_height && n > 0; i++, n--) 521 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++); 522 if (i - 1 == height - ip->i_height) { 523 i--; 524 gfs2_buffer_copy_tail(mp->mp_bh[i], 525 sizeof(struct gfs2_meta_header), 526 dibh, sizeof(struct gfs2_dinode)); 527 gfs2_buffer_clear_tail(dibh, 528 sizeof(struct gfs2_dinode) + 529 sizeof(__be64)); 530 ptr = (__be64 *)(mp->mp_bh[i]->b_data + 531 sizeof(struct gfs2_meta_header)); 532 *ptr = zero_bn; 533 state = ALLOC_GROW_DEPTH; 534 for(i = branch_start; i < height; i++) { 535 if (mp->mp_bh[i] == NULL) 536 break; 537 brelse(mp->mp_bh[i]); 538 mp->mp_bh[i] = NULL; 539 } 540 i = branch_start; 541 } 542 if (n == 0) 543 break; 544 /* Branching from existing tree */ 545 case ALLOC_GROW_DEPTH: 546 if (i > 1 && i < height) 547 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1); 548 for (; i < height && n > 0; i++, n--) 549 gfs2_indirect_init(mp, ip->i_gl, i, 550 mp->mp_list[i-1], bn++); 551 if (i == height) 552 state = ALLOC_DATA; 553 if (n == 0) 554 break; 555 /* Tree complete, adding data blocks */ 556 case ALLOC_DATA: 557 BUG_ON(n > dblks); 558 BUG_ON(mp->mp_bh[end_of_metadata] == NULL); 559 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1); 560 dblks = n; 561 ptr = metapointer(end_of_metadata, mp); 562 dblock = bn; 563 while (n-- > 0) 564 *ptr++ = cpu_to_be64(bn++); 565 if (buffer_zeronew(bh_map)) { 566 ret = sb_issue_zeroout(sb, dblock, dblks, 567 GFP_NOFS); 568 if (ret) { 569 fs_err(sdp, 570 "Failed to zero data buffers\n"); 571 clear_buffer_zeronew(bh_map); 572 } 573 } 574 break; 575 } 576 } while ((state != ALLOC_DATA) || !dblock); 577 578 ip->i_height = height; 579 gfs2_add_inode_blocks(&ip->i_inode, alloced); 580 gfs2_dinode_out(ip, mp->mp_bh[0]->b_data); 581 map_bh(bh_map, inode->i_sb, dblock); 582 bh_map->b_size = dblks << inode->i_blkbits; 583 set_buffer_new(bh_map); 584 return 0; 585 } 586 587 /** 588 * gfs2_block_map - Map a block from an inode to a disk block 589 * @inode: The inode 590 * @lblock: The logical block number 591 * @bh_map: The bh to be mapped 592 * @create: True if its ok to alloc blocks to satify the request 593 * 594 * Sets buffer_mapped() if successful, sets buffer_boundary() if a 595 * read of metadata will be required before the next block can be 596 * mapped. Sets buffer_new() if new blocks were allocated. 597 * 598 * Returns: errno 599 */ 600 601 int gfs2_block_map(struct inode *inode, sector_t lblock, 602 struct buffer_head *bh_map, int create) 603 { 604 struct gfs2_inode *ip = GFS2_I(inode); 605 struct gfs2_sbd *sdp = GFS2_SB(inode); 606 unsigned int bsize = sdp->sd_sb.sb_bsize; 607 const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits; 608 const u64 *arr = sdp->sd_heightsize; 609 __be64 *ptr; 610 u64 size; 611 struct metapath mp; 612 int ret; 613 int eob; 614 unsigned int len; 615 struct buffer_head *bh; 616 u8 height; 617 618 BUG_ON(maxlen == 0); 619 620 memset(mp.mp_bh, 0, sizeof(mp.mp_bh)); 621 bmap_lock(ip, create); 622 clear_buffer_mapped(bh_map); 623 clear_buffer_new(bh_map); 624 clear_buffer_boundary(bh_map); 625 trace_gfs2_bmap(ip, bh_map, lblock, create, 1); 626 if (gfs2_is_dir(ip)) { 627 bsize = sdp->sd_jbsize; 628 arr = sdp->sd_jheightsize; 629 } 630 631 ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]); 632 if (ret) 633 goto out; 634 635 height = ip->i_height; 636 size = (lblock + 1) * bsize; 637 while (size > arr[height]) 638 height++; 639 find_metapath(sdp, lblock, &mp, height); 640 ret = 1; 641 if (height > ip->i_height || gfs2_is_stuffed(ip)) 642 goto do_alloc; 643 ret = lookup_metapath(ip, &mp); 644 if (ret < 0) 645 goto out; 646 if (ret != ip->i_height) 647 goto do_alloc; 648 ptr = metapointer(ip->i_height - 1, &mp); 649 if (*ptr == 0) 650 goto do_alloc; 651 map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr)); 652 bh = mp.mp_bh[ip->i_height - 1]; 653 len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob); 654 bh_map->b_size = (len << inode->i_blkbits); 655 if (eob) 656 set_buffer_boundary(bh_map); 657 ret = 0; 658 out: 659 release_metapath(&mp); 660 trace_gfs2_bmap(ip, bh_map, lblock, create, ret); 661 bmap_unlock(ip, create); 662 return ret; 663 664 do_alloc: 665 /* All allocations are done here, firstly check create flag */ 666 if (!create) { 667 BUG_ON(gfs2_is_stuffed(ip)); 668 ret = 0; 669 goto out; 670 } 671 672 /* At this point ret is the tree depth of already allocated blocks */ 673 ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen); 674 goto out; 675 } 676 677 /* 678 * Deprecated: do not use in new code 679 */ 680 int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen) 681 { 682 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 }; 683 int ret; 684 int create = *new; 685 686 BUG_ON(!extlen); 687 BUG_ON(!dblock); 688 BUG_ON(!new); 689 690 bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5)); 691 ret = gfs2_block_map(inode, lblock, &bh, create); 692 *extlen = bh.b_size >> inode->i_blkbits; 693 *dblock = bh.b_blocknr; 694 if (buffer_new(&bh)) 695 *new = 1; 696 else 697 *new = 0; 698 return ret; 699 } 700 701 /** 702 * do_strip - Look for a layer a particular layer of the file and strip it off 703 * @ip: the inode 704 * @dibh: the dinode buffer 705 * @bh: A buffer of pointers 706 * @top: The first pointer in the buffer 707 * @bottom: One more than the last pointer 708 * @height: the height this buffer is at 709 * @data: a pointer to a struct strip_mine 710 * 711 * Returns: errno 712 */ 713 714 static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 715 struct buffer_head *bh, __be64 *top, __be64 *bottom, 716 unsigned int height, struct strip_mine *sm) 717 { 718 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 719 struct gfs2_rgrp_list rlist; 720 u64 bn, bstart; 721 u32 blen, btotal; 722 __be64 *p; 723 unsigned int rg_blocks = 0; 724 int metadata; 725 unsigned int revokes = 0; 726 int x; 727 int error = 0; 728 729 if (!*top) 730 sm->sm_first = 0; 731 732 if (height != sm->sm_height) 733 return 0; 734 735 if (sm->sm_first) { 736 top++; 737 sm->sm_first = 0; 738 } 739 740 metadata = (height != ip->i_height - 1); 741 if (metadata) 742 revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs; 743 else if (ip->i_depth) 744 revokes = sdp->sd_inptrs; 745 746 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list)); 747 bstart = 0; 748 blen = 0; 749 750 for (p = top; p < bottom; p++) { 751 if (!*p) 752 continue; 753 754 bn = be64_to_cpu(*p); 755 756 if (bstart + blen == bn) 757 blen++; 758 else { 759 if (bstart) 760 gfs2_rlist_add(ip, &rlist, bstart); 761 762 bstart = bn; 763 blen = 1; 764 } 765 } 766 767 if (bstart) 768 gfs2_rlist_add(ip, &rlist, bstart); 769 else 770 goto out; /* Nothing to do */ 771 772 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE); 773 774 for (x = 0; x < rlist.rl_rgrps; x++) { 775 struct gfs2_rgrpd *rgd; 776 rgd = rlist.rl_ghs[x].gh_gl->gl_object; 777 rg_blocks += rgd->rd_length; 778 } 779 780 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); 781 if (error) 782 goto out_rlist; 783 784 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + 785 RES_INDIRECT + RES_STATFS + RES_QUOTA, 786 revokes); 787 if (error) 788 goto out_rg_gunlock; 789 790 down_write(&ip->i_rw_mutex); 791 792 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 793 gfs2_trans_add_bh(ip->i_gl, bh, 1); 794 795 bstart = 0; 796 blen = 0; 797 btotal = 0; 798 799 for (p = top; p < bottom; p++) { 800 if (!*p) 801 continue; 802 803 bn = be64_to_cpu(*p); 804 805 if (bstart + blen == bn) 806 blen++; 807 else { 808 if (bstart) { 809 __gfs2_free_blocks(ip, bstart, blen, metadata); 810 btotal += blen; 811 } 812 813 bstart = bn; 814 blen = 1; 815 } 816 817 *p = 0; 818 gfs2_add_inode_blocks(&ip->i_inode, -1); 819 } 820 if (bstart) { 821 __gfs2_free_blocks(ip, bstart, blen, metadata); 822 btotal += blen; 823 } 824 825 gfs2_statfs_change(sdp, 0, +btotal, 0); 826 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid, 827 ip->i_inode.i_gid); 828 829 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME; 830 831 gfs2_dinode_out(ip, dibh->b_data); 832 833 up_write(&ip->i_rw_mutex); 834 835 gfs2_trans_end(sdp); 836 837 out_rg_gunlock: 838 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs); 839 out_rlist: 840 gfs2_rlist_free(&rlist); 841 out: 842 return error; 843 } 844 845 /** 846 * recursive_scan - recursively scan through the end of a file 847 * @ip: the inode 848 * @dibh: the dinode buffer 849 * @mp: the path through the metadata to the point to start 850 * @height: the height the recursion is at 851 * @block: the indirect block to look at 852 * @first: 1 if this is the first block 853 * @sm: data opaque to this function to pass to @bc 854 * 855 * When this is first called @height and @block should be zero and 856 * @first should be 1. 857 * 858 * Returns: errno 859 */ 860 861 static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh, 862 struct metapath *mp, unsigned int height, 863 u64 block, int first, struct strip_mine *sm) 864 { 865 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 866 struct buffer_head *bh = NULL; 867 __be64 *top, *bottom; 868 u64 bn; 869 int error; 870 int mh_size = sizeof(struct gfs2_meta_header); 871 872 if (!height) { 873 error = gfs2_meta_inode_buffer(ip, &bh); 874 if (error) 875 return error; 876 dibh = bh; 877 878 top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0]; 879 bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs; 880 } else { 881 error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh); 882 if (error) 883 return error; 884 885 top = (__be64 *)(bh->b_data + mh_size) + 886 (first ? mp->mp_list[height] : 0); 887 888 bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs; 889 } 890 891 error = do_strip(ip, dibh, bh, top, bottom, height, sm); 892 if (error) 893 goto out; 894 895 if (height < ip->i_height - 1) { 896 897 gfs2_metapath_ra(ip->i_gl, bh, top); 898 899 for (; top < bottom; top++, first = 0) { 900 if (!*top) 901 continue; 902 903 bn = be64_to_cpu(*top); 904 905 error = recursive_scan(ip, dibh, mp, height + 1, bn, 906 first, sm); 907 if (error) 908 break; 909 } 910 } 911 out: 912 brelse(bh); 913 return error; 914 } 915 916 917 /** 918 * gfs2_block_truncate_page - Deal with zeroing out data for truncate 919 * 920 * This is partly borrowed from ext3. 921 */ 922 static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from) 923 { 924 struct inode *inode = mapping->host; 925 struct gfs2_inode *ip = GFS2_I(inode); 926 unsigned long index = from >> PAGE_CACHE_SHIFT; 927 unsigned offset = from & (PAGE_CACHE_SIZE-1); 928 unsigned blocksize, iblock, length, pos; 929 struct buffer_head *bh; 930 struct page *page; 931 int err; 932 933 page = grab_cache_page(mapping, index); 934 if (!page) 935 return 0; 936 937 blocksize = inode->i_sb->s_blocksize; 938 length = blocksize - (offset & (blocksize - 1)); 939 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); 940 941 if (!page_has_buffers(page)) 942 create_empty_buffers(page, blocksize, 0); 943 944 /* Find the buffer that contains "offset" */ 945 bh = page_buffers(page); 946 pos = blocksize; 947 while (offset >= pos) { 948 bh = bh->b_this_page; 949 iblock++; 950 pos += blocksize; 951 } 952 953 err = 0; 954 955 if (!buffer_mapped(bh)) { 956 gfs2_block_map(inode, iblock, bh, 0); 957 /* unmapped? It's a hole - nothing to do */ 958 if (!buffer_mapped(bh)) 959 goto unlock; 960 } 961 962 /* Ok, it's mapped. Make sure it's up-to-date */ 963 if (PageUptodate(page)) 964 set_buffer_uptodate(bh); 965 966 if (!buffer_uptodate(bh)) { 967 err = -EIO; 968 ll_rw_block(READ, 1, &bh); 969 wait_on_buffer(bh); 970 /* Uhhuh. Read error. Complain and punt. */ 971 if (!buffer_uptodate(bh)) 972 goto unlock; 973 err = 0; 974 } 975 976 if (!gfs2_is_writeback(ip)) 977 gfs2_trans_add_bh(ip->i_gl, bh, 0); 978 979 zero_user(page, offset, length); 980 mark_buffer_dirty(bh); 981 unlock: 982 unlock_page(page); 983 page_cache_release(page); 984 return err; 985 } 986 987 static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize) 988 { 989 struct gfs2_inode *ip = GFS2_I(inode); 990 struct gfs2_sbd *sdp = GFS2_SB(inode); 991 struct address_space *mapping = inode->i_mapping; 992 struct buffer_head *dibh; 993 int journaled = gfs2_is_jdata(ip); 994 int error; 995 996 error = gfs2_trans_begin(sdp, 997 RES_DINODE + (journaled ? RES_JDATA : 0), 0); 998 if (error) 999 return error; 1000 1001 error = gfs2_meta_inode_buffer(ip, &dibh); 1002 if (error) 1003 goto out; 1004 1005 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1006 1007 if (gfs2_is_stuffed(ip)) { 1008 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize); 1009 } else { 1010 if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) { 1011 error = gfs2_block_truncate_page(mapping, newsize); 1012 if (error) 1013 goto out_brelse; 1014 } 1015 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG; 1016 } 1017 1018 i_size_write(inode, newsize); 1019 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME; 1020 gfs2_dinode_out(ip, dibh->b_data); 1021 1022 truncate_pagecache(inode, oldsize, newsize); 1023 out_brelse: 1024 brelse(dibh); 1025 out: 1026 gfs2_trans_end(sdp); 1027 return error; 1028 } 1029 1030 static int trunc_dealloc(struct gfs2_inode *ip, u64 size) 1031 { 1032 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1033 unsigned int height = ip->i_height; 1034 u64 lblock; 1035 struct metapath mp; 1036 int error; 1037 1038 if (!size) 1039 lblock = 0; 1040 else 1041 lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift; 1042 1043 find_metapath(sdp, lblock, &mp, ip->i_height); 1044 if (!gfs2_qadata_get(ip)) 1045 return -ENOMEM; 1046 1047 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 1048 if (error) 1049 goto out; 1050 1051 while (height--) { 1052 struct strip_mine sm; 1053 sm.sm_first = !!size; 1054 sm.sm_height = height; 1055 1056 error = recursive_scan(ip, NULL, &mp, 0, 0, 1, &sm); 1057 if (error) 1058 break; 1059 } 1060 1061 gfs2_quota_unhold(ip); 1062 1063 out: 1064 gfs2_qadata_put(ip); 1065 return error; 1066 } 1067 1068 static int trunc_end(struct gfs2_inode *ip) 1069 { 1070 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1071 struct buffer_head *dibh; 1072 int error; 1073 1074 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1075 if (error) 1076 return error; 1077 1078 down_write(&ip->i_rw_mutex); 1079 1080 error = gfs2_meta_inode_buffer(ip, &dibh); 1081 if (error) 1082 goto out; 1083 1084 if (!i_size_read(&ip->i_inode)) { 1085 ip->i_height = 0; 1086 ip->i_goal = ip->i_no_addr; 1087 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 1088 } 1089 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME; 1090 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG; 1091 1092 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1093 gfs2_dinode_out(ip, dibh->b_data); 1094 brelse(dibh); 1095 1096 out: 1097 up_write(&ip->i_rw_mutex); 1098 gfs2_trans_end(sdp); 1099 return error; 1100 } 1101 1102 /** 1103 * do_shrink - make a file smaller 1104 * @inode: the inode 1105 * @oldsize: the current inode size 1106 * @newsize: the size to make the file 1107 * 1108 * Called with an exclusive lock on @inode. The @size must 1109 * be equal to or smaller than the current inode size. 1110 * 1111 * Returns: errno 1112 */ 1113 1114 static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize) 1115 { 1116 struct gfs2_inode *ip = GFS2_I(inode); 1117 int error; 1118 1119 error = trunc_start(inode, oldsize, newsize); 1120 if (error < 0) 1121 return error; 1122 if (gfs2_is_stuffed(ip)) 1123 return 0; 1124 1125 error = trunc_dealloc(ip, newsize); 1126 if (error == 0) 1127 error = trunc_end(ip); 1128 1129 return error; 1130 } 1131 1132 void gfs2_trim_blocks(struct inode *inode) 1133 { 1134 u64 size = inode->i_size; 1135 int ret; 1136 1137 ret = do_shrink(inode, size, size); 1138 WARN_ON(ret != 0); 1139 } 1140 1141 /** 1142 * do_grow - Touch and update inode size 1143 * @inode: The inode 1144 * @size: The new size 1145 * 1146 * This function updates the timestamps on the inode and 1147 * may also increase the size of the inode. This function 1148 * must not be called with @size any smaller than the current 1149 * inode size. 1150 * 1151 * Although it is not strictly required to unstuff files here, 1152 * earlier versions of GFS2 have a bug in the stuffed file reading 1153 * code which will result in a buffer overrun if the size is larger 1154 * than the max stuffed file size. In order to prevent this from 1155 * occurring, such files are unstuffed, but in other cases we can 1156 * just update the inode size directly. 1157 * 1158 * Returns: 0 on success, or -ve on error 1159 */ 1160 1161 static int do_grow(struct inode *inode, u64 size) 1162 { 1163 struct gfs2_inode *ip = GFS2_I(inode); 1164 struct gfs2_sbd *sdp = GFS2_SB(inode); 1165 struct buffer_head *dibh; 1166 struct gfs2_qadata *qa = NULL; 1167 int error; 1168 1169 if (gfs2_is_stuffed(ip) && 1170 (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) { 1171 qa = gfs2_qadata_get(ip); 1172 if (qa == NULL) 1173 return -ENOMEM; 1174 1175 error = gfs2_quota_lock_check(ip); 1176 if (error) 1177 goto do_grow_alloc_put; 1178 1179 error = gfs2_inplace_reserve(ip, 1); 1180 if (error) 1181 goto do_grow_qunlock; 1182 } 1183 1184 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0); 1185 if (error) 1186 goto do_grow_release; 1187 1188 if (qa) { 1189 error = gfs2_unstuff_dinode(ip, NULL); 1190 if (error) 1191 goto do_end_trans; 1192 } 1193 1194 error = gfs2_meta_inode_buffer(ip, &dibh); 1195 if (error) 1196 goto do_end_trans; 1197 1198 i_size_write(inode, size); 1199 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME; 1200 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1201 gfs2_dinode_out(ip, dibh->b_data); 1202 brelse(dibh); 1203 1204 do_end_trans: 1205 gfs2_trans_end(sdp); 1206 do_grow_release: 1207 if (qa) { 1208 gfs2_inplace_release(ip); 1209 do_grow_qunlock: 1210 gfs2_quota_unlock(ip); 1211 do_grow_alloc_put: 1212 gfs2_qadata_put(ip); 1213 } 1214 return error; 1215 } 1216 1217 /** 1218 * gfs2_setattr_size - make a file a given size 1219 * @inode: the inode 1220 * @newsize: the size to make the file 1221 * 1222 * The file size can grow, shrink, or stay the same size. This 1223 * is called holding i_mutex and an exclusive glock on the inode 1224 * in question. 1225 * 1226 * Returns: errno 1227 */ 1228 1229 int gfs2_setattr_size(struct inode *inode, u64 newsize) 1230 { 1231 int ret; 1232 u64 oldsize; 1233 1234 BUG_ON(!S_ISREG(inode->i_mode)); 1235 1236 ret = inode_newsize_ok(inode, newsize); 1237 if (ret) 1238 return ret; 1239 1240 inode_dio_wait(inode); 1241 1242 oldsize = inode->i_size; 1243 if (newsize >= oldsize) 1244 return do_grow(inode, newsize); 1245 1246 return do_shrink(inode, oldsize, newsize); 1247 } 1248 1249 int gfs2_truncatei_resume(struct gfs2_inode *ip) 1250 { 1251 int error; 1252 error = trunc_dealloc(ip, i_size_read(&ip->i_inode)); 1253 if (!error) 1254 error = trunc_end(ip); 1255 return error; 1256 } 1257 1258 int gfs2_file_dealloc(struct gfs2_inode *ip) 1259 { 1260 return trunc_dealloc(ip, 0); 1261 } 1262 1263 /** 1264 * gfs2_write_alloc_required - figure out if a write will require an allocation 1265 * @ip: the file being written to 1266 * @offset: the offset to write to 1267 * @len: the number of bytes being written 1268 * 1269 * Returns: 1 if an alloc is required, 0 otherwise 1270 */ 1271 1272 int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset, 1273 unsigned int len) 1274 { 1275 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1276 struct buffer_head bh; 1277 unsigned int shift; 1278 u64 lblock, lblock_stop, size; 1279 u64 end_of_file; 1280 1281 if (!len) 1282 return 0; 1283 1284 if (gfs2_is_stuffed(ip)) { 1285 if (offset + len > 1286 sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) 1287 return 1; 1288 return 0; 1289 } 1290 1291 shift = sdp->sd_sb.sb_bsize_shift; 1292 BUG_ON(gfs2_is_dir(ip)); 1293 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift; 1294 lblock = offset >> shift; 1295 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift; 1296 if (lblock_stop > end_of_file) 1297 return 1; 1298 1299 size = (lblock_stop - lblock) << shift; 1300 do { 1301 bh.b_state = 0; 1302 bh.b_size = size; 1303 gfs2_block_map(&ip->i_inode, lblock, &bh, 0); 1304 if (!buffer_mapped(&bh)) 1305 return 1; 1306 size -= bh.b_size; 1307 lblock += (bh.b_size >> ip->i_inode.i_blkbits); 1308 } while(size > 0); 1309 1310 return 0; 1311 } 1312 1313