1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/fs.h> 20 #include <linux/pagemap.h> 21 #include <linux/highmem.h> 22 #include <linux/time.h> 23 #include <linux/init.h> 24 #include <linux/string.h> 25 #include <linux/backing-dev.h> 26 #include <linux/mpage.h> 27 #include <linux/falloc.h> 28 #include <linux/swap.h> 29 #include <linux/writeback.h> 30 #include <linux/statfs.h> 31 #include <linux/compat.h> 32 #include <linux/slab.h> 33 #include "ctree.h" 34 #include "disk-io.h" 35 #include "transaction.h" 36 #include "btrfs_inode.h" 37 #include "ioctl.h" 38 #include "print-tree.h" 39 #include "tree-log.h" 40 #include "locking.h" 41 #include "compat.h" 42 43 44 /* simple helper to fault in pages and copy. This should go away 45 * and be replaced with calls into generic code. 46 */ 47 static noinline int btrfs_copy_from_user(loff_t pos, int num_pages, 48 size_t write_bytes, 49 struct page **prepared_pages, 50 struct iov_iter *i) 51 { 52 size_t copied = 0; 53 size_t total_copied = 0; 54 int pg = 0; 55 int offset = pos & (PAGE_CACHE_SIZE - 1); 56 57 while (write_bytes > 0) { 58 size_t count = min_t(size_t, 59 PAGE_CACHE_SIZE - offset, write_bytes); 60 struct page *page = prepared_pages[pg]; 61 /* 62 * Copy data from userspace to the current page 63 * 64 * Disable pagefault to avoid recursive lock since 65 * the pages are already locked 66 */ 67 pagefault_disable(); 68 copied = iov_iter_copy_from_user_atomic(page, i, offset, count); 69 pagefault_enable(); 70 71 /* Flush processor's dcache for this page */ 72 flush_dcache_page(page); 73 74 /* 75 * if we get a partial write, we can end up with 76 * partially up to date pages. These add 77 * a lot of complexity, so make sure they don't 78 * happen by forcing this copy to be retried. 79 * 80 * The rest of the btrfs_file_write code will fall 81 * back to page at a time copies after we return 0. 82 */ 83 if (!PageUptodate(page) && copied < count) 84 copied = 0; 85 86 iov_iter_advance(i, copied); 87 write_bytes -= copied; 88 total_copied += copied; 89 90 /* Return to btrfs_file_aio_write to fault page */ 91 if (unlikely(copied == 0)) 92 break; 93 94 if (unlikely(copied < PAGE_CACHE_SIZE - offset)) { 95 offset += copied; 96 } else { 97 pg++; 98 offset = 0; 99 } 100 } 101 return total_copied; 102 } 103 104 /* 105 * unlocks pages after btrfs_file_write is done with them 106 */ 107 static noinline void btrfs_drop_pages(struct page **pages, size_t num_pages) 108 { 109 size_t i; 110 for (i = 0; i < num_pages; i++) { 111 /* page checked is some magic around finding pages that 112 * have been modified without going through btrfs_set_page_dirty 113 * clear it here 114 */ 115 ClearPageChecked(pages[i]); 116 unlock_page(pages[i]); 117 mark_page_accessed(pages[i]); 118 page_cache_release(pages[i]); 119 } 120 } 121 122 /* 123 * after copy_from_user, pages need to be dirtied and we need to make 124 * sure holes are created between the current EOF and the start of 125 * any next extents (if required). 126 * 127 * this also makes the decision about creating an inline extent vs 128 * doing real data extents, marking pages dirty and delalloc as required. 129 */ 130 static noinline int dirty_and_release_pages(struct btrfs_root *root, 131 struct file *file, 132 struct page **pages, 133 size_t num_pages, 134 loff_t pos, 135 size_t write_bytes) 136 { 137 int err = 0; 138 int i; 139 struct inode *inode = fdentry(file)->d_inode; 140 u64 num_bytes; 141 u64 start_pos; 142 u64 end_of_last_block; 143 u64 end_pos = pos + write_bytes; 144 loff_t isize = i_size_read(inode); 145 146 start_pos = pos & ~((u64)root->sectorsize - 1); 147 num_bytes = (write_bytes + pos - start_pos + 148 root->sectorsize - 1) & ~((u64)root->sectorsize - 1); 149 150 end_of_last_block = start_pos + num_bytes - 1; 151 err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block, 152 NULL); 153 if (err) 154 return err; 155 156 for (i = 0; i < num_pages; i++) { 157 struct page *p = pages[i]; 158 SetPageUptodate(p); 159 ClearPageChecked(p); 160 set_page_dirty(p); 161 } 162 163 /* 164 * we've only changed i_size in ram, and we haven't updated 165 * the disk i_size. There is no need to log the inode 166 * at this time. 167 */ 168 if (end_pos > isize) 169 i_size_write(inode, end_pos); 170 return 0; 171 } 172 173 /* 174 * this drops all the extents in the cache that intersect the range 175 * [start, end]. Existing extents are split as required. 176 */ 177 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 178 int skip_pinned) 179 { 180 struct extent_map *em; 181 struct extent_map *split = NULL; 182 struct extent_map *split2 = NULL; 183 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 184 u64 len = end - start + 1; 185 int ret; 186 int testend = 1; 187 unsigned long flags; 188 int compressed = 0; 189 190 WARN_ON(end < start); 191 if (end == (u64)-1) { 192 len = (u64)-1; 193 testend = 0; 194 } 195 while (1) { 196 if (!split) 197 split = alloc_extent_map(GFP_NOFS); 198 if (!split2) 199 split2 = alloc_extent_map(GFP_NOFS); 200 BUG_ON(!split || !split2); 201 202 write_lock(&em_tree->lock); 203 em = lookup_extent_mapping(em_tree, start, len); 204 if (!em) { 205 write_unlock(&em_tree->lock); 206 break; 207 } 208 flags = em->flags; 209 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) { 210 if (testend && em->start + em->len >= start + len) { 211 free_extent_map(em); 212 write_unlock(&em_tree->lock); 213 break; 214 } 215 start = em->start + em->len; 216 if (testend) 217 len = start + len - (em->start + em->len); 218 free_extent_map(em); 219 write_unlock(&em_tree->lock); 220 continue; 221 } 222 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 223 clear_bit(EXTENT_FLAG_PINNED, &em->flags); 224 remove_extent_mapping(em_tree, em); 225 226 if (em->block_start < EXTENT_MAP_LAST_BYTE && 227 em->start < start) { 228 split->start = em->start; 229 split->len = start - em->start; 230 split->orig_start = em->orig_start; 231 split->block_start = em->block_start; 232 233 if (compressed) 234 split->block_len = em->block_len; 235 else 236 split->block_len = split->len; 237 238 split->bdev = em->bdev; 239 split->flags = flags; 240 split->compress_type = em->compress_type; 241 ret = add_extent_mapping(em_tree, split); 242 BUG_ON(ret); 243 free_extent_map(split); 244 split = split2; 245 split2 = NULL; 246 } 247 if (em->block_start < EXTENT_MAP_LAST_BYTE && 248 testend && em->start + em->len > start + len) { 249 u64 diff = start + len - em->start; 250 251 split->start = start + len; 252 split->len = em->start + em->len - (start + len); 253 split->bdev = em->bdev; 254 split->flags = flags; 255 split->compress_type = em->compress_type; 256 257 if (compressed) { 258 split->block_len = em->block_len; 259 split->block_start = em->block_start; 260 split->orig_start = em->orig_start; 261 } else { 262 split->block_len = split->len; 263 split->block_start = em->block_start + diff; 264 split->orig_start = split->start; 265 } 266 267 ret = add_extent_mapping(em_tree, split); 268 BUG_ON(ret); 269 free_extent_map(split); 270 split = NULL; 271 } 272 write_unlock(&em_tree->lock); 273 274 /* once for us */ 275 free_extent_map(em); 276 /* once for the tree*/ 277 free_extent_map(em); 278 } 279 if (split) 280 free_extent_map(split); 281 if (split2) 282 free_extent_map(split2); 283 return 0; 284 } 285 286 /* 287 * this is very complex, but the basic idea is to drop all extents 288 * in the range start - end. hint_block is filled in with a block number 289 * that would be a good hint to the block allocator for this file. 290 * 291 * If an extent intersects the range but is not entirely inside the range 292 * it is either truncated or split. Anything entirely inside the range 293 * is deleted from the tree. 294 */ 295 int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode, 296 u64 start, u64 end, u64 *hint_byte, int drop_cache) 297 { 298 struct btrfs_root *root = BTRFS_I(inode)->root; 299 struct extent_buffer *leaf; 300 struct btrfs_file_extent_item *fi; 301 struct btrfs_path *path; 302 struct btrfs_key key; 303 struct btrfs_key new_key; 304 u64 search_start = start; 305 u64 disk_bytenr = 0; 306 u64 num_bytes = 0; 307 u64 extent_offset = 0; 308 u64 extent_end = 0; 309 int del_nr = 0; 310 int del_slot = 0; 311 int extent_type; 312 int recow; 313 int ret; 314 315 if (drop_cache) 316 btrfs_drop_extent_cache(inode, start, end - 1, 0); 317 318 path = btrfs_alloc_path(); 319 if (!path) 320 return -ENOMEM; 321 322 while (1) { 323 recow = 0; 324 ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino, 325 search_start, -1); 326 if (ret < 0) 327 break; 328 if (ret > 0 && path->slots[0] > 0 && search_start == start) { 329 leaf = path->nodes[0]; 330 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); 331 if (key.objectid == inode->i_ino && 332 key.type == BTRFS_EXTENT_DATA_KEY) 333 path->slots[0]--; 334 } 335 ret = 0; 336 next_slot: 337 leaf = path->nodes[0]; 338 if (path->slots[0] >= btrfs_header_nritems(leaf)) { 339 BUG_ON(del_nr > 0); 340 ret = btrfs_next_leaf(root, path); 341 if (ret < 0) 342 break; 343 if (ret > 0) { 344 ret = 0; 345 break; 346 } 347 leaf = path->nodes[0]; 348 recow = 1; 349 } 350 351 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 352 if (key.objectid > inode->i_ino || 353 key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= end) 354 break; 355 356 fi = btrfs_item_ptr(leaf, path->slots[0], 357 struct btrfs_file_extent_item); 358 extent_type = btrfs_file_extent_type(leaf, fi); 359 360 if (extent_type == BTRFS_FILE_EXTENT_REG || 361 extent_type == BTRFS_FILE_EXTENT_PREALLOC) { 362 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 363 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); 364 extent_offset = btrfs_file_extent_offset(leaf, fi); 365 extent_end = key.offset + 366 btrfs_file_extent_num_bytes(leaf, fi); 367 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 368 extent_end = key.offset + 369 btrfs_file_extent_inline_len(leaf, fi); 370 } else { 371 WARN_ON(1); 372 extent_end = search_start; 373 } 374 375 if (extent_end <= search_start) { 376 path->slots[0]++; 377 goto next_slot; 378 } 379 380 search_start = max(key.offset, start); 381 if (recow) { 382 btrfs_release_path(root, path); 383 continue; 384 } 385 386 /* 387 * | - range to drop - | 388 * | -------- extent -------- | 389 */ 390 if (start > key.offset && end < extent_end) { 391 BUG_ON(del_nr > 0); 392 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 393 394 memcpy(&new_key, &key, sizeof(new_key)); 395 new_key.offset = start; 396 ret = btrfs_duplicate_item(trans, root, path, 397 &new_key); 398 if (ret == -EAGAIN) { 399 btrfs_release_path(root, path); 400 continue; 401 } 402 if (ret < 0) 403 break; 404 405 leaf = path->nodes[0]; 406 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 407 struct btrfs_file_extent_item); 408 btrfs_set_file_extent_num_bytes(leaf, fi, 409 start - key.offset); 410 411 fi = btrfs_item_ptr(leaf, path->slots[0], 412 struct btrfs_file_extent_item); 413 414 extent_offset += start - key.offset; 415 btrfs_set_file_extent_offset(leaf, fi, extent_offset); 416 btrfs_set_file_extent_num_bytes(leaf, fi, 417 extent_end - start); 418 btrfs_mark_buffer_dirty(leaf); 419 420 if (disk_bytenr > 0) { 421 ret = btrfs_inc_extent_ref(trans, root, 422 disk_bytenr, num_bytes, 0, 423 root->root_key.objectid, 424 new_key.objectid, 425 start - extent_offset); 426 BUG_ON(ret); 427 *hint_byte = disk_bytenr; 428 } 429 key.offset = start; 430 } 431 /* 432 * | ---- range to drop ----- | 433 * | -------- extent -------- | 434 */ 435 if (start <= key.offset && end < extent_end) { 436 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 437 438 memcpy(&new_key, &key, sizeof(new_key)); 439 new_key.offset = end; 440 btrfs_set_item_key_safe(trans, root, path, &new_key); 441 442 extent_offset += end - key.offset; 443 btrfs_set_file_extent_offset(leaf, fi, extent_offset); 444 btrfs_set_file_extent_num_bytes(leaf, fi, 445 extent_end - end); 446 btrfs_mark_buffer_dirty(leaf); 447 if (disk_bytenr > 0) { 448 inode_sub_bytes(inode, end - key.offset); 449 *hint_byte = disk_bytenr; 450 } 451 break; 452 } 453 454 search_start = extent_end; 455 /* 456 * | ---- range to drop ----- | 457 * | -------- extent -------- | 458 */ 459 if (start > key.offset && end >= extent_end) { 460 BUG_ON(del_nr > 0); 461 BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE); 462 463 btrfs_set_file_extent_num_bytes(leaf, fi, 464 start - key.offset); 465 btrfs_mark_buffer_dirty(leaf); 466 if (disk_bytenr > 0) { 467 inode_sub_bytes(inode, extent_end - start); 468 *hint_byte = disk_bytenr; 469 } 470 if (end == extent_end) 471 break; 472 473 path->slots[0]++; 474 goto next_slot; 475 } 476 477 /* 478 * | ---- range to drop ----- | 479 * | ------ extent ------ | 480 */ 481 if (start <= key.offset && end >= extent_end) { 482 if (del_nr == 0) { 483 del_slot = path->slots[0]; 484 del_nr = 1; 485 } else { 486 BUG_ON(del_slot + del_nr != path->slots[0]); 487 del_nr++; 488 } 489 490 if (extent_type == BTRFS_FILE_EXTENT_INLINE) { 491 inode_sub_bytes(inode, 492 extent_end - key.offset); 493 extent_end = ALIGN(extent_end, 494 root->sectorsize); 495 } else if (disk_bytenr > 0) { 496 ret = btrfs_free_extent(trans, root, 497 disk_bytenr, num_bytes, 0, 498 root->root_key.objectid, 499 key.objectid, key.offset - 500 extent_offset); 501 BUG_ON(ret); 502 inode_sub_bytes(inode, 503 extent_end - key.offset); 504 *hint_byte = disk_bytenr; 505 } 506 507 if (end == extent_end) 508 break; 509 510 if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) { 511 path->slots[0]++; 512 goto next_slot; 513 } 514 515 ret = btrfs_del_items(trans, root, path, del_slot, 516 del_nr); 517 BUG_ON(ret); 518 519 del_nr = 0; 520 del_slot = 0; 521 522 btrfs_release_path(root, path); 523 continue; 524 } 525 526 BUG_ON(1); 527 } 528 529 if (del_nr > 0) { 530 ret = btrfs_del_items(trans, root, path, del_slot, del_nr); 531 BUG_ON(ret); 532 } 533 534 btrfs_free_path(path); 535 return ret; 536 } 537 538 static int extent_mergeable(struct extent_buffer *leaf, int slot, 539 u64 objectid, u64 bytenr, u64 orig_offset, 540 u64 *start, u64 *end) 541 { 542 struct btrfs_file_extent_item *fi; 543 struct btrfs_key key; 544 u64 extent_end; 545 546 if (slot < 0 || slot >= btrfs_header_nritems(leaf)) 547 return 0; 548 549 btrfs_item_key_to_cpu(leaf, &key, slot); 550 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY) 551 return 0; 552 553 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 554 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG || 555 btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr || 556 btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset || 557 btrfs_file_extent_compression(leaf, fi) || 558 btrfs_file_extent_encryption(leaf, fi) || 559 btrfs_file_extent_other_encoding(leaf, fi)) 560 return 0; 561 562 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 563 if ((*start && *start != key.offset) || (*end && *end != extent_end)) 564 return 0; 565 566 *start = key.offset; 567 *end = extent_end; 568 return 1; 569 } 570 571 /* 572 * Mark extent in the range start - end as written. 573 * 574 * This changes extent type from 'pre-allocated' to 'regular'. If only 575 * part of extent is marked as written, the extent will be split into 576 * two or three. 577 */ 578 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 579 struct inode *inode, u64 start, u64 end) 580 { 581 struct btrfs_root *root = BTRFS_I(inode)->root; 582 struct extent_buffer *leaf; 583 struct btrfs_path *path; 584 struct btrfs_file_extent_item *fi; 585 struct btrfs_key key; 586 struct btrfs_key new_key; 587 u64 bytenr; 588 u64 num_bytes; 589 u64 extent_end; 590 u64 orig_offset; 591 u64 other_start; 592 u64 other_end; 593 u64 split; 594 int del_nr = 0; 595 int del_slot = 0; 596 int recow; 597 int ret; 598 599 btrfs_drop_extent_cache(inode, start, end - 1, 0); 600 601 path = btrfs_alloc_path(); 602 BUG_ON(!path); 603 again: 604 recow = 0; 605 split = start; 606 key.objectid = inode->i_ino; 607 key.type = BTRFS_EXTENT_DATA_KEY; 608 key.offset = split; 609 610 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 611 if (ret < 0) 612 goto out; 613 if (ret > 0 && path->slots[0] > 0) 614 path->slots[0]--; 615 616 leaf = path->nodes[0]; 617 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 618 BUG_ON(key.objectid != inode->i_ino || 619 key.type != BTRFS_EXTENT_DATA_KEY); 620 fi = btrfs_item_ptr(leaf, path->slots[0], 621 struct btrfs_file_extent_item); 622 BUG_ON(btrfs_file_extent_type(leaf, fi) != 623 BTRFS_FILE_EXTENT_PREALLOC); 624 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 625 BUG_ON(key.offset > start || extent_end < end); 626 627 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 628 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); 629 orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi); 630 memcpy(&new_key, &key, sizeof(new_key)); 631 632 if (start == key.offset && end < extent_end) { 633 other_start = 0; 634 other_end = start; 635 if (extent_mergeable(leaf, path->slots[0] - 1, 636 inode->i_ino, bytenr, orig_offset, 637 &other_start, &other_end)) { 638 new_key.offset = end; 639 btrfs_set_item_key_safe(trans, root, path, &new_key); 640 fi = btrfs_item_ptr(leaf, path->slots[0], 641 struct btrfs_file_extent_item); 642 btrfs_set_file_extent_num_bytes(leaf, fi, 643 extent_end - end); 644 btrfs_set_file_extent_offset(leaf, fi, 645 end - orig_offset); 646 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 647 struct btrfs_file_extent_item); 648 btrfs_set_file_extent_num_bytes(leaf, fi, 649 end - other_start); 650 btrfs_mark_buffer_dirty(leaf); 651 goto out; 652 } 653 } 654 655 if (start > key.offset && end == extent_end) { 656 other_start = end; 657 other_end = 0; 658 if (extent_mergeable(leaf, path->slots[0] + 1, 659 inode->i_ino, bytenr, orig_offset, 660 &other_start, &other_end)) { 661 fi = btrfs_item_ptr(leaf, path->slots[0], 662 struct btrfs_file_extent_item); 663 btrfs_set_file_extent_num_bytes(leaf, fi, 664 start - key.offset); 665 path->slots[0]++; 666 new_key.offset = start; 667 btrfs_set_item_key_safe(trans, root, path, &new_key); 668 669 fi = btrfs_item_ptr(leaf, path->slots[0], 670 struct btrfs_file_extent_item); 671 btrfs_set_file_extent_num_bytes(leaf, fi, 672 other_end - start); 673 btrfs_set_file_extent_offset(leaf, fi, 674 start - orig_offset); 675 btrfs_mark_buffer_dirty(leaf); 676 goto out; 677 } 678 } 679 680 while (start > key.offset || end < extent_end) { 681 if (key.offset == start) 682 split = end; 683 684 new_key.offset = split; 685 ret = btrfs_duplicate_item(trans, root, path, &new_key); 686 if (ret == -EAGAIN) { 687 btrfs_release_path(root, path); 688 goto again; 689 } 690 BUG_ON(ret < 0); 691 692 leaf = path->nodes[0]; 693 fi = btrfs_item_ptr(leaf, path->slots[0] - 1, 694 struct btrfs_file_extent_item); 695 btrfs_set_file_extent_num_bytes(leaf, fi, 696 split - key.offset); 697 698 fi = btrfs_item_ptr(leaf, path->slots[0], 699 struct btrfs_file_extent_item); 700 701 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset); 702 btrfs_set_file_extent_num_bytes(leaf, fi, 703 extent_end - split); 704 btrfs_mark_buffer_dirty(leaf); 705 706 ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0, 707 root->root_key.objectid, 708 inode->i_ino, orig_offset); 709 BUG_ON(ret); 710 711 if (split == start) { 712 key.offset = start; 713 } else { 714 BUG_ON(start != key.offset); 715 path->slots[0]--; 716 extent_end = end; 717 } 718 recow = 1; 719 } 720 721 other_start = end; 722 other_end = 0; 723 if (extent_mergeable(leaf, path->slots[0] + 1, 724 inode->i_ino, bytenr, orig_offset, 725 &other_start, &other_end)) { 726 if (recow) { 727 btrfs_release_path(root, path); 728 goto again; 729 } 730 extent_end = other_end; 731 del_slot = path->slots[0] + 1; 732 del_nr++; 733 ret = btrfs_free_extent(trans, root, bytenr, num_bytes, 734 0, root->root_key.objectid, 735 inode->i_ino, orig_offset); 736 BUG_ON(ret); 737 } 738 other_start = 0; 739 other_end = start; 740 if (extent_mergeable(leaf, path->slots[0] - 1, 741 inode->i_ino, bytenr, orig_offset, 742 &other_start, &other_end)) { 743 if (recow) { 744 btrfs_release_path(root, path); 745 goto again; 746 } 747 key.offset = other_start; 748 del_slot = path->slots[0]; 749 del_nr++; 750 ret = btrfs_free_extent(trans, root, bytenr, num_bytes, 751 0, root->root_key.objectid, 752 inode->i_ino, orig_offset); 753 BUG_ON(ret); 754 } 755 if (del_nr == 0) { 756 fi = btrfs_item_ptr(leaf, path->slots[0], 757 struct btrfs_file_extent_item); 758 btrfs_set_file_extent_type(leaf, fi, 759 BTRFS_FILE_EXTENT_REG); 760 btrfs_mark_buffer_dirty(leaf); 761 } else { 762 fi = btrfs_item_ptr(leaf, del_slot - 1, 763 struct btrfs_file_extent_item); 764 btrfs_set_file_extent_type(leaf, fi, 765 BTRFS_FILE_EXTENT_REG); 766 btrfs_set_file_extent_num_bytes(leaf, fi, 767 extent_end - key.offset); 768 btrfs_mark_buffer_dirty(leaf); 769 770 ret = btrfs_del_items(trans, root, path, del_slot, del_nr); 771 BUG_ON(ret); 772 } 773 out: 774 btrfs_free_path(path); 775 return 0; 776 } 777 778 /* 779 * on error we return an unlocked page and the error value 780 * on success we return a locked page and 0 781 */ 782 static int prepare_uptodate_page(struct page *page, u64 pos) 783 { 784 int ret = 0; 785 786 if ((pos & (PAGE_CACHE_SIZE - 1)) && !PageUptodate(page)) { 787 ret = btrfs_readpage(NULL, page); 788 if (ret) 789 return ret; 790 lock_page(page); 791 if (!PageUptodate(page)) { 792 unlock_page(page); 793 return -EIO; 794 } 795 } 796 return 0; 797 } 798 799 /* 800 * this gets pages into the page cache and locks them down, it also properly 801 * waits for data=ordered extents to finish before allowing the pages to be 802 * modified. 803 */ 804 static noinline int prepare_pages(struct btrfs_root *root, struct file *file, 805 struct page **pages, size_t num_pages, 806 loff_t pos, unsigned long first_index, 807 unsigned long last_index, size_t write_bytes) 808 { 809 struct extent_state *cached_state = NULL; 810 int i; 811 unsigned long index = pos >> PAGE_CACHE_SHIFT; 812 struct inode *inode = fdentry(file)->d_inode; 813 int err = 0; 814 int faili = 0; 815 u64 start_pos; 816 u64 last_pos; 817 818 start_pos = pos & ~((u64)root->sectorsize - 1); 819 last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT; 820 821 if (start_pos > inode->i_size) { 822 err = btrfs_cont_expand(inode, i_size_read(inode), start_pos); 823 if (err) 824 return err; 825 } 826 827 again: 828 for (i = 0; i < num_pages; i++) { 829 pages[i] = grab_cache_page(inode->i_mapping, index + i); 830 if (!pages[i]) { 831 faili = i - 1; 832 err = -ENOMEM; 833 goto fail; 834 } 835 836 if (i == 0) 837 err = prepare_uptodate_page(pages[i], pos); 838 if (i == num_pages - 1) 839 err = prepare_uptodate_page(pages[i], 840 pos + write_bytes); 841 if (err) { 842 page_cache_release(pages[i]); 843 faili = i - 1; 844 goto fail; 845 } 846 wait_on_page_writeback(pages[i]); 847 } 848 err = 0; 849 if (start_pos < inode->i_size) { 850 struct btrfs_ordered_extent *ordered; 851 lock_extent_bits(&BTRFS_I(inode)->io_tree, 852 start_pos, last_pos - 1, 0, &cached_state, 853 GFP_NOFS); 854 ordered = btrfs_lookup_first_ordered_extent(inode, 855 last_pos - 1); 856 if (ordered && 857 ordered->file_offset + ordered->len > start_pos && 858 ordered->file_offset < last_pos) { 859 btrfs_put_ordered_extent(ordered); 860 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 861 start_pos, last_pos - 1, 862 &cached_state, GFP_NOFS); 863 for (i = 0; i < num_pages; i++) { 864 unlock_page(pages[i]); 865 page_cache_release(pages[i]); 866 } 867 btrfs_wait_ordered_range(inode, start_pos, 868 last_pos - start_pos); 869 goto again; 870 } 871 if (ordered) 872 btrfs_put_ordered_extent(ordered); 873 874 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos, 875 last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC | 876 EXTENT_DO_ACCOUNTING, 0, 0, &cached_state, 877 GFP_NOFS); 878 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 879 start_pos, last_pos - 1, &cached_state, 880 GFP_NOFS); 881 } 882 for (i = 0; i < num_pages; i++) { 883 clear_page_dirty_for_io(pages[i]); 884 set_page_extent_mapped(pages[i]); 885 WARN_ON(!PageLocked(pages[i])); 886 } 887 return 0; 888 fail: 889 while (faili >= 0) { 890 unlock_page(pages[faili]); 891 page_cache_release(pages[faili]); 892 faili--; 893 } 894 return err; 895 896 } 897 898 static noinline ssize_t __btrfs_buffered_write(struct file *file, 899 struct iov_iter *i, 900 loff_t pos) 901 { 902 struct inode *inode = fdentry(file)->d_inode; 903 struct btrfs_root *root = BTRFS_I(inode)->root; 904 struct page **pages = NULL; 905 unsigned long first_index; 906 unsigned long last_index; 907 size_t num_written = 0; 908 int nrptrs; 909 int ret; 910 911 nrptrs = min((iov_iter_count(i) + PAGE_CACHE_SIZE - 1) / 912 PAGE_CACHE_SIZE, PAGE_CACHE_SIZE / 913 (sizeof(struct page *))); 914 pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL); 915 if (!pages) 916 return -ENOMEM; 917 918 first_index = pos >> PAGE_CACHE_SHIFT; 919 last_index = (pos + iov_iter_count(i)) >> PAGE_CACHE_SHIFT; 920 921 while (iov_iter_count(i) > 0) { 922 size_t offset = pos & (PAGE_CACHE_SIZE - 1); 923 size_t write_bytes = min(iov_iter_count(i), 924 nrptrs * (size_t)PAGE_CACHE_SIZE - 925 offset); 926 size_t num_pages = (write_bytes + offset + 927 PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; 928 size_t dirty_pages; 929 size_t copied; 930 931 WARN_ON(num_pages > nrptrs); 932 933 /* 934 * Fault pages before locking them in prepare_pages 935 * to avoid recursive lock 936 */ 937 if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) { 938 ret = -EFAULT; 939 break; 940 } 941 942 ret = btrfs_delalloc_reserve_space(inode, 943 num_pages << PAGE_CACHE_SHIFT); 944 if (ret) 945 break; 946 947 /* 948 * This is going to setup the pages array with the number of 949 * pages we want, so we don't really need to worry about the 950 * contents of pages from loop to loop 951 */ 952 ret = prepare_pages(root, file, pages, num_pages, 953 pos, first_index, last_index, 954 write_bytes); 955 if (ret) { 956 btrfs_delalloc_release_space(inode, 957 num_pages << PAGE_CACHE_SHIFT); 958 break; 959 } 960 961 copied = btrfs_copy_from_user(pos, num_pages, 962 write_bytes, pages, i); 963 964 /* 965 * if we have trouble faulting in the pages, fall 966 * back to one page at a time 967 */ 968 if (copied < write_bytes) 969 nrptrs = 1; 970 971 if (copied == 0) 972 dirty_pages = 0; 973 else 974 dirty_pages = (copied + offset + 975 PAGE_CACHE_SIZE - 1) >> 976 PAGE_CACHE_SHIFT; 977 978 /* 979 * If we had a short copy we need to release the excess delaloc 980 * bytes we reserved. We need to increment outstanding_extents 981 * because btrfs_delalloc_release_space will decrement it, but 982 * we still have an outstanding extent for the chunk we actually 983 * managed to copy. 984 */ 985 if (num_pages > dirty_pages) { 986 if (copied > 0) 987 atomic_inc( 988 &BTRFS_I(inode)->outstanding_extents); 989 btrfs_delalloc_release_space(inode, 990 (num_pages - dirty_pages) << 991 PAGE_CACHE_SHIFT); 992 } 993 994 if (copied > 0) { 995 ret = dirty_and_release_pages(root, file, pages, 996 dirty_pages, pos, 997 copied); 998 if (ret) { 999 btrfs_delalloc_release_space(inode, 1000 dirty_pages << PAGE_CACHE_SHIFT); 1001 btrfs_drop_pages(pages, num_pages); 1002 break; 1003 } 1004 } 1005 1006 btrfs_drop_pages(pages, num_pages); 1007 1008 cond_resched(); 1009 1010 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1011 dirty_pages); 1012 if (dirty_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1) 1013 btrfs_btree_balance_dirty(root, 1); 1014 btrfs_throttle(root); 1015 1016 pos += copied; 1017 num_written += copied; 1018 } 1019 1020 kfree(pages); 1021 1022 return num_written ? num_written : ret; 1023 } 1024 1025 static ssize_t __btrfs_direct_write(struct kiocb *iocb, 1026 const struct iovec *iov, 1027 unsigned long nr_segs, loff_t pos, 1028 loff_t *ppos, size_t count, size_t ocount) 1029 { 1030 struct file *file = iocb->ki_filp; 1031 struct inode *inode = fdentry(file)->d_inode; 1032 struct iov_iter i; 1033 ssize_t written; 1034 ssize_t written_buffered; 1035 loff_t endbyte; 1036 int err; 1037 1038 written = generic_file_direct_write(iocb, iov, &nr_segs, pos, ppos, 1039 count, ocount); 1040 1041 /* 1042 * the generic O_DIRECT will update in-memory i_size after the 1043 * DIOs are done. But our endio handlers that update the on 1044 * disk i_size never update past the in memory i_size. So we 1045 * need one more update here to catch any additions to the 1046 * file 1047 */ 1048 if (inode->i_size != BTRFS_I(inode)->disk_i_size) { 1049 btrfs_ordered_update_i_size(inode, inode->i_size, NULL); 1050 mark_inode_dirty(inode); 1051 } 1052 1053 if (written < 0 || written == count) 1054 return written; 1055 1056 pos += written; 1057 count -= written; 1058 iov_iter_init(&i, iov, nr_segs, count, written); 1059 written_buffered = __btrfs_buffered_write(file, &i, pos); 1060 if (written_buffered < 0) { 1061 err = written_buffered; 1062 goto out; 1063 } 1064 endbyte = pos + written_buffered - 1; 1065 err = filemap_write_and_wait_range(file->f_mapping, pos, endbyte); 1066 if (err) 1067 goto out; 1068 written += written_buffered; 1069 *ppos = pos + written_buffered; 1070 invalidate_mapping_pages(file->f_mapping, pos >> PAGE_CACHE_SHIFT, 1071 endbyte >> PAGE_CACHE_SHIFT); 1072 out: 1073 return written ? written : err; 1074 } 1075 1076 static ssize_t btrfs_file_aio_write(struct kiocb *iocb, 1077 const struct iovec *iov, 1078 unsigned long nr_segs, loff_t pos) 1079 { 1080 struct file *file = iocb->ki_filp; 1081 struct inode *inode = fdentry(file)->d_inode; 1082 struct btrfs_root *root = BTRFS_I(inode)->root; 1083 loff_t *ppos = &iocb->ki_pos; 1084 ssize_t num_written = 0; 1085 ssize_t err = 0; 1086 size_t count, ocount; 1087 1088 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE); 1089 1090 mutex_lock(&inode->i_mutex); 1091 1092 err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ); 1093 if (err) { 1094 mutex_unlock(&inode->i_mutex); 1095 goto out; 1096 } 1097 count = ocount; 1098 1099 current->backing_dev_info = inode->i_mapping->backing_dev_info; 1100 err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode)); 1101 if (err) { 1102 mutex_unlock(&inode->i_mutex); 1103 goto out; 1104 } 1105 1106 if (count == 0) { 1107 mutex_unlock(&inode->i_mutex); 1108 goto out; 1109 } 1110 1111 err = file_remove_suid(file); 1112 if (err) { 1113 mutex_unlock(&inode->i_mutex); 1114 goto out; 1115 } 1116 1117 /* 1118 * If BTRFS flips readonly due to some impossible error 1119 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR), 1120 * although we have opened a file as writable, we have 1121 * to stop this write operation to ensure FS consistency. 1122 */ 1123 if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { 1124 mutex_unlock(&inode->i_mutex); 1125 err = -EROFS; 1126 goto out; 1127 } 1128 1129 file_update_time(file); 1130 BTRFS_I(inode)->sequence++; 1131 1132 if (unlikely(file->f_flags & O_DIRECT)) { 1133 num_written = __btrfs_direct_write(iocb, iov, nr_segs, 1134 pos, ppos, count, ocount); 1135 } else { 1136 struct iov_iter i; 1137 1138 iov_iter_init(&i, iov, nr_segs, count, num_written); 1139 1140 num_written = __btrfs_buffered_write(file, &i, pos); 1141 if (num_written > 0) 1142 *ppos = pos + num_written; 1143 } 1144 1145 mutex_unlock(&inode->i_mutex); 1146 1147 /* 1148 * we want to make sure fsync finds this change 1149 * but we haven't joined a transaction running right now. 1150 * 1151 * Later on, someone is sure to update the inode and get the 1152 * real transid recorded. 1153 * 1154 * We set last_trans now to the fs_info generation + 1, 1155 * this will either be one more than the running transaction 1156 * or the generation used for the next transaction if there isn't 1157 * one running right now. 1158 */ 1159 BTRFS_I(inode)->last_trans = root->fs_info->generation + 1; 1160 if (num_written > 0 || num_written == -EIOCBQUEUED) { 1161 err = generic_write_sync(file, pos, num_written); 1162 if (err < 0 && num_written > 0) 1163 num_written = err; 1164 } 1165 out: 1166 current->backing_dev_info = NULL; 1167 return num_written ? num_written : err; 1168 } 1169 1170 int btrfs_release_file(struct inode *inode, struct file *filp) 1171 { 1172 /* 1173 * ordered_data_close is set by settattr when we are about to truncate 1174 * a file from a non-zero size to a zero size. This tries to 1175 * flush down new bytes that may have been written if the 1176 * application were using truncate to replace a file in place. 1177 */ 1178 if (BTRFS_I(inode)->ordered_data_close) { 1179 BTRFS_I(inode)->ordered_data_close = 0; 1180 btrfs_add_ordered_operation(NULL, BTRFS_I(inode)->root, inode); 1181 if (inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT) 1182 filemap_flush(inode->i_mapping); 1183 } 1184 if (filp->private_data) 1185 btrfs_ioctl_trans_end(filp); 1186 return 0; 1187 } 1188 1189 /* 1190 * fsync call for both files and directories. This logs the inode into 1191 * the tree log instead of forcing full commits whenever possible. 1192 * 1193 * It needs to call filemap_fdatawait so that all ordered extent updates are 1194 * in the metadata btree are up to date for copying to the log. 1195 * 1196 * It drops the inode mutex before doing the tree log commit. This is an 1197 * important optimization for directories because holding the mutex prevents 1198 * new operations on the dir while we write to disk. 1199 */ 1200 int btrfs_sync_file(struct file *file, int datasync) 1201 { 1202 struct dentry *dentry = file->f_path.dentry; 1203 struct inode *inode = dentry->d_inode; 1204 struct btrfs_root *root = BTRFS_I(inode)->root; 1205 int ret = 0; 1206 struct btrfs_trans_handle *trans; 1207 1208 trace_btrfs_sync_file(file, datasync); 1209 1210 /* we wait first, since the writeback may change the inode */ 1211 root->log_batch++; 1212 /* the VFS called filemap_fdatawrite for us */ 1213 btrfs_wait_ordered_range(inode, 0, (u64)-1); 1214 root->log_batch++; 1215 1216 /* 1217 * check the transaction that last modified this inode 1218 * and see if its already been committed 1219 */ 1220 if (!BTRFS_I(inode)->last_trans) 1221 goto out; 1222 1223 /* 1224 * if the last transaction that changed this file was before 1225 * the current transaction, we can bail out now without any 1226 * syncing 1227 */ 1228 mutex_lock(&root->fs_info->trans_mutex); 1229 if (BTRFS_I(inode)->last_trans <= 1230 root->fs_info->last_trans_committed) { 1231 BTRFS_I(inode)->last_trans = 0; 1232 mutex_unlock(&root->fs_info->trans_mutex); 1233 goto out; 1234 } 1235 mutex_unlock(&root->fs_info->trans_mutex); 1236 1237 /* 1238 * ok we haven't committed the transaction yet, lets do a commit 1239 */ 1240 if (file->private_data) 1241 btrfs_ioctl_trans_end(file); 1242 1243 trans = btrfs_start_transaction(root, 0); 1244 if (IS_ERR(trans)) { 1245 ret = PTR_ERR(trans); 1246 goto out; 1247 } 1248 1249 ret = btrfs_log_dentry_safe(trans, root, dentry); 1250 if (ret < 0) 1251 goto out; 1252 1253 /* we've logged all the items and now have a consistent 1254 * version of the file in the log. It is possible that 1255 * someone will come in and modify the file, but that's 1256 * fine because the log is consistent on disk, and we 1257 * have references to all of the file's extents 1258 * 1259 * It is possible that someone will come in and log the 1260 * file again, but that will end up using the synchronization 1261 * inside btrfs_sync_log to keep things safe. 1262 */ 1263 mutex_unlock(&dentry->d_inode->i_mutex); 1264 1265 if (ret != BTRFS_NO_LOG_SYNC) { 1266 if (ret > 0) { 1267 ret = btrfs_commit_transaction(trans, root); 1268 } else { 1269 ret = btrfs_sync_log(trans, root); 1270 if (ret == 0) 1271 ret = btrfs_end_transaction(trans, root); 1272 else 1273 ret = btrfs_commit_transaction(trans, root); 1274 } 1275 } else { 1276 ret = btrfs_end_transaction(trans, root); 1277 } 1278 mutex_lock(&dentry->d_inode->i_mutex); 1279 out: 1280 return ret > 0 ? -EIO : ret; 1281 } 1282 1283 static const struct vm_operations_struct btrfs_file_vm_ops = { 1284 .fault = filemap_fault, 1285 .page_mkwrite = btrfs_page_mkwrite, 1286 }; 1287 1288 static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma) 1289 { 1290 struct address_space *mapping = filp->f_mapping; 1291 1292 if (!mapping->a_ops->readpage) 1293 return -ENOEXEC; 1294 1295 file_accessed(filp); 1296 vma->vm_ops = &btrfs_file_vm_ops; 1297 vma->vm_flags |= VM_CAN_NONLINEAR; 1298 1299 return 0; 1300 } 1301 1302 static long btrfs_fallocate(struct file *file, int mode, 1303 loff_t offset, loff_t len) 1304 { 1305 struct inode *inode = file->f_path.dentry->d_inode; 1306 struct extent_state *cached_state = NULL; 1307 u64 cur_offset; 1308 u64 last_byte; 1309 u64 alloc_start; 1310 u64 alloc_end; 1311 u64 alloc_hint = 0; 1312 u64 locked_end; 1313 u64 mask = BTRFS_I(inode)->root->sectorsize - 1; 1314 struct extent_map *em; 1315 int ret; 1316 1317 alloc_start = offset & ~mask; 1318 alloc_end = (offset + len + mask) & ~mask; 1319 1320 /* We only support the FALLOC_FL_KEEP_SIZE mode */ 1321 if (mode & ~FALLOC_FL_KEEP_SIZE) 1322 return -EOPNOTSUPP; 1323 1324 /* 1325 * wait for ordered IO before we have any locks. We'll loop again 1326 * below with the locks held. 1327 */ 1328 btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start); 1329 1330 mutex_lock(&inode->i_mutex); 1331 ret = inode_newsize_ok(inode, alloc_end); 1332 if (ret) 1333 goto out; 1334 1335 if (alloc_start > inode->i_size) { 1336 ret = btrfs_cont_expand(inode, i_size_read(inode), 1337 alloc_start); 1338 if (ret) 1339 goto out; 1340 } 1341 1342 ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start); 1343 if (ret) 1344 goto out; 1345 1346 locked_end = alloc_end - 1; 1347 while (1) { 1348 struct btrfs_ordered_extent *ordered; 1349 1350 /* the extent lock is ordered inside the running 1351 * transaction 1352 */ 1353 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, 1354 locked_end, 0, &cached_state, GFP_NOFS); 1355 ordered = btrfs_lookup_first_ordered_extent(inode, 1356 alloc_end - 1); 1357 if (ordered && 1358 ordered->file_offset + ordered->len > alloc_start && 1359 ordered->file_offset < alloc_end) { 1360 btrfs_put_ordered_extent(ordered); 1361 unlock_extent_cached(&BTRFS_I(inode)->io_tree, 1362 alloc_start, locked_end, 1363 &cached_state, GFP_NOFS); 1364 /* 1365 * we can't wait on the range with the transaction 1366 * running or with the extent lock held 1367 */ 1368 btrfs_wait_ordered_range(inode, alloc_start, 1369 alloc_end - alloc_start); 1370 } else { 1371 if (ordered) 1372 btrfs_put_ordered_extent(ordered); 1373 break; 1374 } 1375 } 1376 1377 cur_offset = alloc_start; 1378 while (1) { 1379 em = btrfs_get_extent(inode, NULL, 0, cur_offset, 1380 alloc_end - cur_offset, 0); 1381 BUG_ON(IS_ERR(em) || !em); 1382 last_byte = min(extent_map_end(em), alloc_end); 1383 last_byte = (last_byte + mask) & ~mask; 1384 if (em->block_start == EXTENT_MAP_HOLE || 1385 (cur_offset >= inode->i_size && 1386 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { 1387 ret = btrfs_prealloc_file_range(inode, mode, cur_offset, 1388 last_byte - cur_offset, 1389 1 << inode->i_blkbits, 1390 offset + len, 1391 &alloc_hint); 1392 if (ret < 0) { 1393 free_extent_map(em); 1394 break; 1395 } 1396 } 1397 free_extent_map(em); 1398 1399 cur_offset = last_byte; 1400 if (cur_offset >= alloc_end) { 1401 ret = 0; 1402 break; 1403 } 1404 } 1405 unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end, 1406 &cached_state, GFP_NOFS); 1407 1408 btrfs_free_reserved_data_space(inode, alloc_end - alloc_start); 1409 out: 1410 mutex_unlock(&inode->i_mutex); 1411 return ret; 1412 } 1413 1414 const struct file_operations btrfs_file_operations = { 1415 .llseek = generic_file_llseek, 1416 .read = do_sync_read, 1417 .write = do_sync_write, 1418 .aio_read = generic_file_aio_read, 1419 .splice_read = generic_file_splice_read, 1420 .aio_write = btrfs_file_aio_write, 1421 .mmap = btrfs_file_mmap, 1422 .open = generic_file_open, 1423 .release = btrfs_release_file, 1424 .fsync = btrfs_sync_file, 1425 .fallocate = btrfs_fallocate, 1426 .unlocked_ioctl = btrfs_ioctl, 1427 #ifdef CONFIG_COMPAT 1428 .compat_ioctl = btrfs_ioctl, 1429 #endif 1430 }; 1431