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/sched.h> 11 #include <linux/slab.h> 12 #include <linux/spinlock.h> 13 #include <linux/completion.h> 14 #include <linux/buffer_head.h> 15 #include <linux/gfs2_ondisk.h> 16 #include <linux/crc32.h> 17 #include <linux/lm_interface.h> 18 19 #include "gfs2.h" 20 #include "incore.h" 21 #include "bmap.h" 22 #include "glock.h" 23 #include "inode.h" 24 #include "meta_io.h" 25 #include "quota.h" 26 #include "rgrp.h" 27 #include "trans.h" 28 #include "dir.h" 29 #include "util.h" 30 #include "ops_address.h" 31 32 /* This doesn't need to be that large as max 64 bit pointers in a 4k 33 * block is 512, so __u16 is fine for that. It saves stack space to 34 * keep it small. 35 */ 36 struct metapath { 37 __u16 mp_list[GFS2_MAX_META_HEIGHT]; 38 }; 39 40 typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh, 41 struct buffer_head *bh, u64 *top, 42 u64 *bottom, unsigned int height, 43 void *data); 44 45 struct strip_mine { 46 int sm_first; 47 unsigned int sm_height; 48 }; 49 50 /** 51 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page 52 * @ip: the inode 53 * @dibh: the dinode buffer 54 * @block: the block number that was allocated 55 * @private: any locked page held by the caller process 56 * 57 * Returns: errno 58 */ 59 60 static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 61 u64 block, struct page *page) 62 { 63 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 64 struct inode *inode = &ip->i_inode; 65 struct buffer_head *bh; 66 int release = 0; 67 68 if (!page || page->index) { 69 page = grab_cache_page(inode->i_mapping, 0); 70 if (!page) 71 return -ENOMEM; 72 release = 1; 73 } 74 75 if (!PageUptodate(page)) { 76 void *kaddr = kmap(page); 77 78 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), 79 ip->i_di.di_size); 80 memset(kaddr + ip->i_di.di_size, 0, 81 PAGE_CACHE_SIZE - ip->i_di.di_size); 82 kunmap(page); 83 84 SetPageUptodate(page); 85 } 86 87 if (!page_has_buffers(page)) 88 create_empty_buffers(page, 1 << inode->i_blkbits, 89 (1 << BH_Uptodate)); 90 91 bh = page_buffers(page); 92 93 if (!buffer_mapped(bh)) 94 map_bh(bh, inode->i_sb, block); 95 96 set_buffer_uptodate(bh); 97 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) 98 gfs2_trans_add_bh(ip->i_gl, bh, 0); 99 mark_buffer_dirty(bh); 100 101 if (release) { 102 unlock_page(page); 103 page_cache_release(page); 104 } 105 106 return 0; 107 } 108 109 /** 110 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big 111 * @ip: The GFS2 inode to unstuff 112 * @unstuffer: the routine that handles unstuffing a non-zero length file 113 * @private: private data for the unstuffer 114 * 115 * This routine unstuffs a dinode and returns it to a "normal" state such 116 * that the height can be grown in the traditional way. 117 * 118 * Returns: errno 119 */ 120 121 int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 122 { 123 struct buffer_head *bh, *dibh; 124 struct gfs2_dinode *di; 125 u64 block = 0; 126 int isdir = gfs2_is_dir(ip); 127 int error; 128 129 down_write(&ip->i_rw_mutex); 130 131 error = gfs2_meta_inode_buffer(ip, &dibh); 132 if (error) 133 goto out; 134 135 if (ip->i_di.di_size) { 136 /* Get a free block, fill it with the stuffed data, 137 and write it out to disk */ 138 139 if (isdir) { 140 block = gfs2_alloc_meta(ip); 141 142 error = gfs2_dir_get_new_buffer(ip, block, &bh); 143 if (error) 144 goto out_brelse; 145 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header), 146 dibh, sizeof(struct gfs2_dinode)); 147 brelse(bh); 148 } else { 149 block = gfs2_alloc_data(ip); 150 151 error = gfs2_unstuffer_page(ip, dibh, block, page); 152 if (error) 153 goto out_brelse; 154 } 155 } 156 157 /* Set up the pointer to the new block */ 158 159 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 160 di = (struct gfs2_dinode *)dibh->b_data; 161 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 162 163 if (ip->i_di.di_size) { 164 *(__be64 *)(di + 1) = cpu_to_be64(block); 165 ip->i_di.di_blocks++; 166 di->di_blocks = cpu_to_be64(ip->i_di.di_blocks); 167 } 168 169 ip->i_di.di_height = 1; 170 di->di_height = cpu_to_be16(1); 171 172 out_brelse: 173 brelse(dibh); 174 out: 175 up_write(&ip->i_rw_mutex); 176 return error; 177 } 178 179 /** 180 * calc_tree_height - Calculate the height of a metadata tree 181 * @ip: The GFS2 inode 182 * @size: The proposed size of the file 183 * 184 * Work out how tall a metadata tree needs to be in order to accommodate a 185 * file of a particular size. If size is less than the current size of 186 * the inode, then the current size of the inode is used instead of the 187 * supplied one. 188 * 189 * Returns: the height the tree should be 190 */ 191 192 static unsigned int calc_tree_height(struct gfs2_inode *ip, u64 size) 193 { 194 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 195 u64 *arr; 196 unsigned int max, height; 197 198 if (ip->i_di.di_size > size) 199 size = ip->i_di.di_size; 200 201 if (gfs2_is_dir(ip)) { 202 arr = sdp->sd_jheightsize; 203 max = sdp->sd_max_jheight; 204 } else { 205 arr = sdp->sd_heightsize; 206 max = sdp->sd_max_height; 207 } 208 209 for (height = 0; height < max; height++) 210 if (arr[height] >= size) 211 break; 212 213 return height; 214 } 215 216 /** 217 * build_height - Build a metadata tree of the requested height 218 * @ip: The GFS2 inode 219 * @height: The height to build to 220 * 221 * 222 * Returns: errno 223 */ 224 225 static int build_height(struct inode *inode, unsigned height) 226 { 227 struct gfs2_inode *ip = GFS2_I(inode); 228 unsigned new_height = height - ip->i_di.di_height; 229 struct buffer_head *dibh; 230 struct buffer_head *blocks[GFS2_MAX_META_HEIGHT]; 231 struct gfs2_dinode *di; 232 int error; 233 u64 *bp; 234 u64 bn; 235 unsigned n; 236 237 if (height <= ip->i_di.di_height) 238 return 0; 239 240 error = gfs2_meta_inode_buffer(ip, &dibh); 241 if (error) 242 return error; 243 244 for(n = 0; n < new_height; n++) { 245 bn = gfs2_alloc_meta(ip); 246 blocks[n] = gfs2_meta_new(ip->i_gl, bn); 247 gfs2_trans_add_bh(ip->i_gl, blocks[n], 1); 248 } 249 250 n = 0; 251 bn = blocks[0]->b_blocknr; 252 if (new_height > 1) { 253 for(; n < new_height-1; n++) { 254 gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN, 255 GFS2_FORMAT_IN); 256 gfs2_buffer_clear_tail(blocks[n], 257 sizeof(struct gfs2_meta_header)); 258 bp = (u64 *)(blocks[n]->b_data + 259 sizeof(struct gfs2_meta_header)); 260 *bp = cpu_to_be64(blocks[n+1]->b_blocknr); 261 brelse(blocks[n]); 262 blocks[n] = NULL; 263 } 264 } 265 gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN, GFS2_FORMAT_IN); 266 gfs2_buffer_copy_tail(blocks[n], sizeof(struct gfs2_meta_header), 267 dibh, sizeof(struct gfs2_dinode)); 268 brelse(blocks[n]); 269 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 270 di = (struct gfs2_dinode *)dibh->b_data; 271 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 272 *(__be64 *)(di + 1) = cpu_to_be64(bn); 273 ip->i_di.di_height += new_height; 274 ip->i_di.di_blocks += new_height; 275 di->di_height = cpu_to_be16(ip->i_di.di_height); 276 di->di_blocks = cpu_to_be64(ip->i_di.di_blocks); 277 brelse(dibh); 278 return error; 279 } 280 281 /** 282 * find_metapath - Find path through the metadata tree 283 * @ip: The inode pointer 284 * @mp: The metapath to return the result in 285 * @block: The disk block to look up 286 * 287 * This routine returns a struct metapath structure that defines a path 288 * through the metadata of inode "ip" to get to block "block". 289 * 290 * Example: 291 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a 292 * filesystem with a blocksize of 4096. 293 * 294 * find_metapath() would return a struct metapath structure set to: 295 * mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48, 296 * and mp_list[2] = 165. 297 * 298 * That means that in order to get to the block containing the byte at 299 * offset 101342453, we would load the indirect block pointed to by pointer 300 * 0 in the dinode. We would then load the indirect block pointed to by 301 * pointer 48 in that indirect block. We would then load the data block 302 * pointed to by pointer 165 in that indirect block. 303 * 304 * ---------------------------------------- 305 * | Dinode | | 306 * | | 4| 307 * | |0 1 2 3 4 5 9| 308 * | | 6| 309 * ---------------------------------------- 310 * | 311 * | 312 * V 313 * ---------------------------------------- 314 * | Indirect Block | 315 * | 5| 316 * | 4 4 4 4 4 5 5 1| 317 * |0 5 6 7 8 9 0 1 2| 318 * ---------------------------------------- 319 * | 320 * | 321 * V 322 * ---------------------------------------- 323 * | Indirect Block | 324 * | 1 1 1 1 1 5| 325 * | 6 6 6 6 6 1| 326 * |0 3 4 5 6 7 2| 327 * ---------------------------------------- 328 * | 329 * | 330 * V 331 * ---------------------------------------- 332 * | Data block containing offset | 333 * | 101342453 | 334 * | | 335 * | | 336 * ---------------------------------------- 337 * 338 */ 339 340 static void find_metapath(struct gfs2_inode *ip, u64 block, 341 struct metapath *mp) 342 { 343 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 344 u64 b = block; 345 unsigned int i; 346 347 for (i = ip->i_di.di_height; i--;) 348 mp->mp_list[i] = do_div(b, sdp->sd_inptrs); 349 350 } 351 352 /** 353 * metapointer - Return pointer to start of metadata in a buffer 354 * @bh: The buffer 355 * @height: The metadata height (0 = dinode) 356 * @mp: The metapath 357 * 358 * Return a pointer to the block number of the next height of the metadata 359 * tree given a buffer containing the pointer to the current height of the 360 * metadata tree. 361 */ 362 363 static inline u64 *metapointer(struct buffer_head *bh, int *boundary, 364 unsigned int height, const struct metapath *mp) 365 { 366 unsigned int head_size = (height > 0) ? 367 sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode); 368 u64 *ptr; 369 *boundary = 0; 370 ptr = ((u64 *)(bh->b_data + head_size)) + mp->mp_list[height]; 371 if (ptr + 1 == (u64 *)(bh->b_data + bh->b_size)) 372 *boundary = 1; 373 return ptr; 374 } 375 376 /** 377 * lookup_block - Get the next metadata block in metadata tree 378 * @ip: The GFS2 inode 379 * @bh: Buffer containing the pointers to metadata blocks 380 * @height: The height of the tree (0 = dinode) 381 * @mp: The metapath 382 * @create: Non-zero if we may create a new meatdata block 383 * @new: Used to indicate if we did create a new metadata block 384 * @block: the returned disk block number 385 * 386 * Given a metatree, complete to a particular height, checks to see if the next 387 * height of the tree exists. If not the next height of the tree is created. 388 * The block number of the next height of the metadata tree is returned. 389 * 390 */ 391 392 static int lookup_block(struct gfs2_inode *ip, struct buffer_head *bh, 393 unsigned int height, struct metapath *mp, int create, 394 int *new, u64 *block) 395 { 396 int boundary; 397 u64 *ptr = metapointer(bh, &boundary, height, mp); 398 399 if (*ptr) { 400 *block = be64_to_cpu(*ptr); 401 return boundary; 402 } 403 404 *block = 0; 405 406 if (!create) 407 return 0; 408 409 if (height == ip->i_di.di_height - 1 && !gfs2_is_dir(ip)) 410 *block = gfs2_alloc_data(ip); 411 else 412 *block = gfs2_alloc_meta(ip); 413 414 gfs2_trans_add_bh(ip->i_gl, bh, 1); 415 416 *ptr = cpu_to_be64(*block); 417 ip->i_di.di_blocks++; 418 419 *new = 1; 420 return 0; 421 } 422 423 /** 424 * gfs2_block_pointers - Map a block from an inode to a disk block 425 * @inode: The inode 426 * @lblock: The logical block number 427 * @map_bh: The bh to be mapped 428 * @mp: metapath to use 429 * 430 * Find the block number on the current device which corresponds to an 431 * inode's block. If the block had to be created, "new" will be set. 432 * 433 * Returns: errno 434 */ 435 436 static int gfs2_block_pointers(struct inode *inode, u64 lblock, int create, 437 struct buffer_head *bh_map, struct metapath *mp, 438 unsigned int maxlen) 439 { 440 struct gfs2_inode *ip = GFS2_I(inode); 441 struct gfs2_sbd *sdp = GFS2_SB(inode); 442 struct buffer_head *bh; 443 unsigned int bsize; 444 unsigned int height; 445 unsigned int end_of_metadata; 446 unsigned int x; 447 int error = 0; 448 int new = 0; 449 u64 dblock = 0; 450 int boundary; 451 452 BUG_ON(maxlen == 0); 453 454 if (gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip))) 455 return 0; 456 457 bsize = gfs2_is_dir(ip) ? sdp->sd_jbsize : sdp->sd_sb.sb_bsize; 458 459 height = calc_tree_height(ip, (lblock + 1) * bsize); 460 if (ip->i_di.di_height < height) { 461 if (!create) 462 return 0; 463 464 error = build_height(inode, height); 465 if (error) 466 return error; 467 } 468 469 find_metapath(ip, lblock, mp); 470 end_of_metadata = ip->i_di.di_height - 1; 471 472 error = gfs2_meta_inode_buffer(ip, &bh); 473 if (error) 474 return error; 475 476 for (x = 0; x < end_of_metadata; x++) { 477 lookup_block(ip, bh, x, mp, create, &new, &dblock); 478 brelse(bh); 479 if (!dblock) 480 return 0; 481 482 error = gfs2_meta_indirect_buffer(ip, x+1, dblock, new, &bh); 483 if (error) 484 return error; 485 } 486 487 boundary = lookup_block(ip, bh, end_of_metadata, mp, create, &new, &dblock); 488 clear_buffer_mapped(bh_map); 489 clear_buffer_new(bh_map); 490 clear_buffer_boundary(bh_map); 491 492 if (dblock) { 493 map_bh(bh_map, inode->i_sb, dblock); 494 if (boundary) 495 set_buffer_boundary(bh); 496 if (new) { 497 struct buffer_head *dibh; 498 error = gfs2_meta_inode_buffer(ip, &dibh); 499 if (!error) { 500 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 501 gfs2_dinode_out(&ip->i_di, dibh->b_data); 502 brelse(dibh); 503 } 504 set_buffer_new(bh_map); 505 goto out_brelse; 506 } 507 while(--maxlen && !buffer_boundary(bh_map)) { 508 u64 eblock; 509 510 mp->mp_list[end_of_metadata]++; 511 boundary = lookup_block(ip, bh, end_of_metadata, mp, 0, &new, &eblock); 512 if (eblock != ++dblock) 513 break; 514 bh_map->b_size += (1 << inode->i_blkbits); 515 if (boundary) 516 set_buffer_boundary(bh_map); 517 } 518 } 519 out_brelse: 520 brelse(bh); 521 return 0; 522 } 523 524 525 static inline void bmap_lock(struct inode *inode, int create) 526 { 527 struct gfs2_inode *ip = GFS2_I(inode); 528 if (create) 529 down_write(&ip->i_rw_mutex); 530 else 531 down_read(&ip->i_rw_mutex); 532 } 533 534 static inline void bmap_unlock(struct inode *inode, int create) 535 { 536 struct gfs2_inode *ip = GFS2_I(inode); 537 if (create) 538 up_write(&ip->i_rw_mutex); 539 else 540 up_read(&ip->i_rw_mutex); 541 } 542 543 int gfs2_block_map(struct inode *inode, u64 lblock, int create, 544 struct buffer_head *bh, unsigned int maxlen) 545 { 546 struct metapath mp; 547 int ret; 548 549 bmap_lock(inode, create); 550 ret = gfs2_block_pointers(inode, lblock, create, bh, &mp, maxlen); 551 bmap_unlock(inode, create); 552 return ret; 553 } 554 555 int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen) 556 { 557 struct metapath mp; 558 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0, .b_size = 0 }; 559 int ret; 560 int create = *new; 561 562 BUG_ON(!extlen); 563 BUG_ON(!dblock); 564 BUG_ON(!new); 565 566 bmap_lock(inode, create); 567 ret = gfs2_block_pointers(inode, lblock, create, &bh, &mp, 32); 568 bmap_unlock(inode, create); 569 *extlen = bh.b_size >> inode->i_blkbits; 570 *dblock = bh.b_blocknr; 571 if (buffer_new(&bh)) 572 *new = 1; 573 else 574 *new = 0; 575 return ret; 576 } 577 578 /** 579 * recursive_scan - recursively scan through the end of a file 580 * @ip: the inode 581 * @dibh: the dinode buffer 582 * @mp: the path through the metadata to the point to start 583 * @height: the height the recursion is at 584 * @block: the indirect block to look at 585 * @first: 1 if this is the first block 586 * @bc: the call to make for each piece of metadata 587 * @data: data opaque to this function to pass to @bc 588 * 589 * When this is first called @height and @block should be zero and 590 * @first should be 1. 591 * 592 * Returns: errno 593 */ 594 595 static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh, 596 struct metapath *mp, unsigned int height, 597 u64 block, int first, block_call_t bc, 598 void *data) 599 { 600 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 601 struct buffer_head *bh = NULL; 602 u64 *top, *bottom; 603 u64 bn; 604 int error; 605 int mh_size = sizeof(struct gfs2_meta_header); 606 607 if (!height) { 608 error = gfs2_meta_inode_buffer(ip, &bh); 609 if (error) 610 return error; 611 dibh = bh; 612 613 top = (u64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0]; 614 bottom = (u64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs; 615 } else { 616 error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh); 617 if (error) 618 return error; 619 620 top = (u64 *)(bh->b_data + mh_size) + 621 (first ? mp->mp_list[height] : 0); 622 623 bottom = (u64 *)(bh->b_data + mh_size) + sdp->sd_inptrs; 624 } 625 626 error = bc(ip, dibh, bh, top, bottom, height, data); 627 if (error) 628 goto out; 629 630 if (height < ip->i_di.di_height - 1) 631 for (; top < bottom; top++, first = 0) { 632 if (!*top) 633 continue; 634 635 bn = be64_to_cpu(*top); 636 637 error = recursive_scan(ip, dibh, mp, height + 1, bn, 638 first, bc, data); 639 if (error) 640 break; 641 } 642 643 out: 644 brelse(bh); 645 return error; 646 } 647 648 /** 649 * do_strip - Look for a layer a particular layer of the file and strip it off 650 * @ip: the inode 651 * @dibh: the dinode buffer 652 * @bh: A buffer of pointers 653 * @top: The first pointer in the buffer 654 * @bottom: One more than the last pointer 655 * @height: the height this buffer is at 656 * @data: a pointer to a struct strip_mine 657 * 658 * Returns: errno 659 */ 660 661 static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 662 struct buffer_head *bh, u64 *top, u64 *bottom, 663 unsigned int height, void *data) 664 { 665 struct strip_mine *sm = data; 666 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 667 struct gfs2_rgrp_list rlist; 668 u64 bn, bstart; 669 u32 blen; 670 u64 *p; 671 unsigned int rg_blocks = 0; 672 int metadata; 673 unsigned int revokes = 0; 674 int x; 675 int error; 676 677 if (!*top) 678 sm->sm_first = 0; 679 680 if (height != sm->sm_height) 681 return 0; 682 683 if (sm->sm_first) { 684 top++; 685 sm->sm_first = 0; 686 } 687 688 metadata = (height != ip->i_di.di_height - 1); 689 if (metadata) 690 revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs; 691 692 error = gfs2_rindex_hold(sdp, &ip->i_alloc.al_ri_gh); 693 if (error) 694 return error; 695 696 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list)); 697 bstart = 0; 698 blen = 0; 699 700 for (p = top; p < bottom; p++) { 701 if (!*p) 702 continue; 703 704 bn = be64_to_cpu(*p); 705 706 if (bstart + blen == bn) 707 blen++; 708 else { 709 if (bstart) 710 gfs2_rlist_add(sdp, &rlist, bstart); 711 712 bstart = bn; 713 blen = 1; 714 } 715 } 716 717 if (bstart) 718 gfs2_rlist_add(sdp, &rlist, bstart); 719 else 720 goto out; /* Nothing to do */ 721 722 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE, 0); 723 724 for (x = 0; x < rlist.rl_rgrps; x++) { 725 struct gfs2_rgrpd *rgd; 726 rgd = rlist.rl_ghs[x].gh_gl->gl_object; 727 rg_blocks += rgd->rd_ri.ri_length; 728 } 729 730 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); 731 if (error) 732 goto out_rlist; 733 734 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + 735 RES_INDIRECT + RES_STATFS + RES_QUOTA, 736 revokes); 737 if (error) 738 goto out_rg_gunlock; 739 740 down_write(&ip->i_rw_mutex); 741 742 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 743 gfs2_trans_add_bh(ip->i_gl, bh, 1); 744 745 bstart = 0; 746 blen = 0; 747 748 for (p = top; p < bottom; p++) { 749 if (!*p) 750 continue; 751 752 bn = be64_to_cpu(*p); 753 754 if (bstart + blen == bn) 755 blen++; 756 else { 757 if (bstart) { 758 if (metadata) 759 gfs2_free_meta(ip, bstart, blen); 760 else 761 gfs2_free_data(ip, bstart, blen); 762 } 763 764 bstart = bn; 765 blen = 1; 766 } 767 768 *p = 0; 769 if (!ip->i_di.di_blocks) 770 gfs2_consist_inode(ip); 771 ip->i_di.di_blocks--; 772 } 773 if (bstart) { 774 if (metadata) 775 gfs2_free_meta(ip, bstart, blen); 776 else 777 gfs2_free_data(ip, bstart, blen); 778 } 779 780 ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds(); 781 782 gfs2_dinode_out(&ip->i_di, dibh->b_data); 783 784 up_write(&ip->i_rw_mutex); 785 786 gfs2_trans_end(sdp); 787 788 out_rg_gunlock: 789 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs); 790 out_rlist: 791 gfs2_rlist_free(&rlist); 792 out: 793 gfs2_glock_dq_uninit(&ip->i_alloc.al_ri_gh); 794 return error; 795 } 796 797 /** 798 * do_grow - Make a file look bigger than it is 799 * @ip: the inode 800 * @size: the size to set the file to 801 * 802 * Called with an exclusive lock on @ip. 803 * 804 * Returns: errno 805 */ 806 807 static int do_grow(struct gfs2_inode *ip, u64 size) 808 { 809 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 810 struct gfs2_alloc *al; 811 struct buffer_head *dibh; 812 unsigned int h; 813 int error; 814 815 al = gfs2_alloc_get(ip); 816 817 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 818 if (error) 819 goto out; 820 821 error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid); 822 if (error) 823 goto out_gunlock_q; 824 825 al->al_requested = sdp->sd_max_height + RES_DATA; 826 827 error = gfs2_inplace_reserve(ip); 828 if (error) 829 goto out_gunlock_q; 830 831 error = gfs2_trans_begin(sdp, 832 sdp->sd_max_height + al->al_rgd->rd_ri.ri_length + 833 RES_JDATA + RES_DINODE + RES_STATFS + RES_QUOTA, 0); 834 if (error) 835 goto out_ipres; 836 837 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) { 838 if (gfs2_is_stuffed(ip)) { 839 error = gfs2_unstuff_dinode(ip, NULL); 840 if (error) 841 goto out_end_trans; 842 } 843 844 h = calc_tree_height(ip, size); 845 if (ip->i_di.di_height < h) { 846 down_write(&ip->i_rw_mutex); 847 error = build_height(&ip->i_inode, h); 848 up_write(&ip->i_rw_mutex); 849 if (error) 850 goto out_end_trans; 851 } 852 } 853 854 ip->i_di.di_size = size; 855 ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds(); 856 857 error = gfs2_meta_inode_buffer(ip, &dibh); 858 if (error) 859 goto out_end_trans; 860 861 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 862 gfs2_dinode_out(&ip->i_di, dibh->b_data); 863 brelse(dibh); 864 865 out_end_trans: 866 gfs2_trans_end(sdp); 867 out_ipres: 868 gfs2_inplace_release(ip); 869 out_gunlock_q: 870 gfs2_quota_unlock(ip); 871 out: 872 gfs2_alloc_put(ip); 873 return error; 874 } 875 876 877 /** 878 * gfs2_block_truncate_page - Deal with zeroing out data for truncate 879 * 880 * This is partly borrowed from ext3. 881 */ 882 static int gfs2_block_truncate_page(struct address_space *mapping) 883 { 884 struct inode *inode = mapping->host; 885 struct gfs2_inode *ip = GFS2_I(inode); 886 struct gfs2_sbd *sdp = GFS2_SB(inode); 887 loff_t from = inode->i_size; 888 unsigned long index = from >> PAGE_CACHE_SHIFT; 889 unsigned offset = from & (PAGE_CACHE_SIZE-1); 890 unsigned blocksize, iblock, length, pos; 891 struct buffer_head *bh; 892 struct page *page; 893 void *kaddr; 894 int err; 895 896 page = grab_cache_page(mapping, index); 897 if (!page) 898 return 0; 899 900 blocksize = inode->i_sb->s_blocksize; 901 length = blocksize - (offset & (blocksize - 1)); 902 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); 903 904 if (!page_has_buffers(page)) 905 create_empty_buffers(page, blocksize, 0); 906 907 /* Find the buffer that contains "offset" */ 908 bh = page_buffers(page); 909 pos = blocksize; 910 while (offset >= pos) { 911 bh = bh->b_this_page; 912 iblock++; 913 pos += blocksize; 914 } 915 916 err = 0; 917 918 if (!buffer_mapped(bh)) { 919 gfs2_get_block(inode, iblock, bh, 0); 920 /* unmapped? It's a hole - nothing to do */ 921 if (!buffer_mapped(bh)) 922 goto unlock; 923 } 924 925 /* Ok, it's mapped. Make sure it's up-to-date */ 926 if (PageUptodate(page)) 927 set_buffer_uptodate(bh); 928 929 if (!buffer_uptodate(bh)) { 930 err = -EIO; 931 ll_rw_block(READ, 1, &bh); 932 wait_on_buffer(bh); 933 /* Uhhuh. Read error. Complain and punt. */ 934 if (!buffer_uptodate(bh)) 935 goto unlock; 936 } 937 938 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) 939 gfs2_trans_add_bh(ip->i_gl, bh, 0); 940 941 kaddr = kmap_atomic(page, KM_USER0); 942 memset(kaddr + offset, 0, length); 943 flush_dcache_page(page); 944 kunmap_atomic(kaddr, KM_USER0); 945 946 unlock: 947 unlock_page(page); 948 page_cache_release(page); 949 return err; 950 } 951 952 static int trunc_start(struct gfs2_inode *ip, u64 size) 953 { 954 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 955 struct buffer_head *dibh; 956 int journaled = gfs2_is_jdata(ip); 957 int error; 958 959 error = gfs2_trans_begin(sdp, 960 RES_DINODE + (journaled ? RES_JDATA : 0), 0); 961 if (error) 962 return error; 963 964 error = gfs2_meta_inode_buffer(ip, &dibh); 965 if (error) 966 goto out; 967 968 if (gfs2_is_stuffed(ip)) { 969 ip->i_di.di_size = size; 970 ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds(); 971 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 972 gfs2_dinode_out(&ip->i_di, dibh->b_data); 973 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + size); 974 error = 1; 975 976 } else { 977 if (size & (u64)(sdp->sd_sb.sb_bsize - 1)) 978 error = gfs2_block_truncate_page(ip->i_inode.i_mapping); 979 980 if (!error) { 981 ip->i_di.di_size = size; 982 ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds(); 983 ip->i_di.di_flags |= GFS2_DIF_TRUNC_IN_PROG; 984 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 985 gfs2_dinode_out(&ip->i_di, dibh->b_data); 986 } 987 } 988 989 brelse(dibh); 990 991 out: 992 gfs2_trans_end(sdp); 993 return error; 994 } 995 996 static int trunc_dealloc(struct gfs2_inode *ip, u64 size) 997 { 998 unsigned int height = ip->i_di.di_height; 999 u64 lblock; 1000 struct metapath mp; 1001 int error; 1002 1003 if (!size) 1004 lblock = 0; 1005 else 1006 lblock = (size - 1) >> GFS2_SB(&ip->i_inode)->sd_sb.sb_bsize_shift; 1007 1008 find_metapath(ip, lblock, &mp); 1009 gfs2_alloc_get(ip); 1010 1011 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 1012 if (error) 1013 goto out; 1014 1015 while (height--) { 1016 struct strip_mine sm; 1017 sm.sm_first = !!size; 1018 sm.sm_height = height; 1019 1020 error = recursive_scan(ip, NULL, &mp, 0, 0, 1, do_strip, &sm); 1021 if (error) 1022 break; 1023 } 1024 1025 gfs2_quota_unhold(ip); 1026 1027 out: 1028 gfs2_alloc_put(ip); 1029 return error; 1030 } 1031 1032 static int trunc_end(struct gfs2_inode *ip) 1033 { 1034 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1035 struct buffer_head *dibh; 1036 int error; 1037 1038 error = gfs2_trans_begin(sdp, RES_DINODE, 0); 1039 if (error) 1040 return error; 1041 1042 down_write(&ip->i_rw_mutex); 1043 1044 error = gfs2_meta_inode_buffer(ip, &dibh); 1045 if (error) 1046 goto out; 1047 1048 if (!ip->i_di.di_size) { 1049 ip->i_di.di_height = 0; 1050 ip->i_di.di_goal_meta = 1051 ip->i_di.di_goal_data = 1052 ip->i_num.no_addr; 1053 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); 1054 } 1055 ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds(); 1056 ip->i_di.di_flags &= ~GFS2_DIF_TRUNC_IN_PROG; 1057 1058 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 1059 gfs2_dinode_out(&ip->i_di, dibh->b_data); 1060 brelse(dibh); 1061 1062 out: 1063 up_write(&ip->i_rw_mutex); 1064 gfs2_trans_end(sdp); 1065 return error; 1066 } 1067 1068 /** 1069 * do_shrink - make a file smaller 1070 * @ip: the inode 1071 * @size: the size to make the file 1072 * @truncator: function to truncate the last partial block 1073 * 1074 * Called with an exclusive lock on @ip. 1075 * 1076 * Returns: errno 1077 */ 1078 1079 static int do_shrink(struct gfs2_inode *ip, u64 size) 1080 { 1081 int error; 1082 1083 error = trunc_start(ip, size); 1084 if (error < 0) 1085 return error; 1086 if (error > 0) 1087 return 0; 1088 1089 error = trunc_dealloc(ip, size); 1090 if (!error) 1091 error = trunc_end(ip); 1092 1093 return error; 1094 } 1095 1096 /** 1097 * gfs2_truncatei - make a file a given size 1098 * @ip: the inode 1099 * @size: the size to make the file 1100 * @truncator: function to truncate the last partial block 1101 * 1102 * The file size can grow, shrink, or stay the same size. 1103 * 1104 * Returns: errno 1105 */ 1106 1107 int gfs2_truncatei(struct gfs2_inode *ip, u64 size) 1108 { 1109 int error; 1110 1111 if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), S_ISREG(ip->i_di.di_mode))) 1112 return -EINVAL; 1113 1114 if (size > ip->i_di.di_size) 1115 error = do_grow(ip, size); 1116 else 1117 error = do_shrink(ip, size); 1118 1119 return error; 1120 } 1121 1122 int gfs2_truncatei_resume(struct gfs2_inode *ip) 1123 { 1124 int error; 1125 error = trunc_dealloc(ip, ip->i_di.di_size); 1126 if (!error) 1127 error = trunc_end(ip); 1128 return error; 1129 } 1130 1131 int gfs2_file_dealloc(struct gfs2_inode *ip) 1132 { 1133 return trunc_dealloc(ip, 0); 1134 } 1135 1136 /** 1137 * gfs2_write_calc_reserv - calculate number of blocks needed to write to a file 1138 * @ip: the file 1139 * @len: the number of bytes to be written to the file 1140 * @data_blocks: returns the number of data blocks required 1141 * @ind_blocks: returns the number of indirect blocks required 1142 * 1143 */ 1144 1145 void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len, 1146 unsigned int *data_blocks, unsigned int *ind_blocks) 1147 { 1148 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1149 unsigned int tmp; 1150 1151 if (gfs2_is_dir(ip)) { 1152 *data_blocks = DIV_ROUND_UP(len, sdp->sd_jbsize) + 2; 1153 *ind_blocks = 3 * (sdp->sd_max_jheight - 1); 1154 } else { 1155 *data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3; 1156 *ind_blocks = 3 * (sdp->sd_max_height - 1); 1157 } 1158 1159 for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) { 1160 tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs); 1161 *ind_blocks += tmp; 1162 } 1163 } 1164 1165 /** 1166 * gfs2_write_alloc_required - figure out if a write will require an allocation 1167 * @ip: the file being written to 1168 * @offset: the offset to write to 1169 * @len: the number of bytes being written 1170 * @alloc_required: set to 1 if an alloc is required, 0 otherwise 1171 * 1172 * Returns: errno 1173 */ 1174 1175 int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset, 1176 unsigned int len, int *alloc_required) 1177 { 1178 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1179 u64 lblock, lblock_stop, dblock; 1180 u32 extlen; 1181 int new = 0; 1182 int error = 0; 1183 1184 *alloc_required = 0; 1185 1186 if (!len) 1187 return 0; 1188 1189 if (gfs2_is_stuffed(ip)) { 1190 if (offset + len > 1191 sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) 1192 *alloc_required = 1; 1193 return 0; 1194 } 1195 1196 if (gfs2_is_dir(ip)) { 1197 unsigned int bsize = sdp->sd_jbsize; 1198 lblock = offset; 1199 do_div(lblock, bsize); 1200 lblock_stop = offset + len + bsize - 1; 1201 do_div(lblock_stop, bsize); 1202 } else { 1203 unsigned int shift = sdp->sd_sb.sb_bsize_shift; 1204 lblock = offset >> shift; 1205 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift; 1206 } 1207 1208 for (; lblock < lblock_stop; lblock += extlen) { 1209 error = gfs2_extent_map(&ip->i_inode, lblock, &new, &dblock, &extlen); 1210 if (error) 1211 return error; 1212 1213 if (!dblock) { 1214 *alloc_required = 1; 1215 return 0; 1216 } 1217 } 1218 1219 return 0; 1220 } 1221 1222