fs/btrfs/inode.c

   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/kernel.h>
  20 #include <linux/bio.h>
  21 #include <linux/buffer_head.h>
  22 #include <linux/file.h>
  23 #include <linux/fs.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/highmem.h>
  26 #include <linux/time.h>
  27 #include <linux/init.h>
  28 #include <linux/string.h>
  29 #include <linux/backing-dev.h>
  30 #include <linux/mpage.h>
  31 #include <linux/swap.h>
  32 #include <linux/writeback.h>
  33 #include <linux/statfs.h>
  34 #include <linux/compat.h>
  35 #include <linux/bit_spinlock.h>
  36 #include <linux/xattr.h>
  37 #include <linux/posix_acl.h>
  38 #include <linux/falloc.h>
  39 #include <linux/slab.h>
  40 #include "compat.h"
  41 #include "ctree.h"
  42 #include "disk-io.h"
  43 #include "transaction.h"
  44 #include "btrfs_inode.h"
  45 #include "ioctl.h"
  46 #include "print-tree.h"
  47 #include "volumes.h"
  48 #include "ordered-data.h"
  49 #include "xattr.h"
  50 #include "tree-log.h"
  51 #include "compression.h"
  52 #include "locking.h"
  53 #include "free-space-cache.h"
  54
  55 struct btrfs_iget_args {
  56         u64 ino;
  57         struct btrfs_root *root;
  58 };
  59
  60 static const struct inode_operations btrfs_dir_inode_operations;
  61 static const struct inode_operations btrfs_symlink_inode_operations;
  62 static const struct inode_operations btrfs_dir_ro_inode_operations;
  63 static const struct inode_operations btrfs_special_inode_operations;
  64 static const struct inode_operations btrfs_file_inode_operations;
  65 static const struct address_space_operations btrfs_aops;
  66 static const struct address_space_operations btrfs_symlink_aops;
  67 static const struct file_operations btrfs_dir_file_operations;
  68 static struct extent_io_ops btrfs_extent_io_ops;
  69
  70 static struct kmem_cache *btrfs_inode_cachep;
  71 struct kmem_cache *btrfs_trans_handle_cachep;
  72 struct kmem_cache *btrfs_transaction_cachep;
  73 struct kmem_cache *btrfs_path_cachep;
  74 struct kmem_cache *btrfs_free_space_cachep;
  75
  76 #define S_SHIFT 12
  77 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  78         [S_IFREG >> S_SHIFT]    = BTRFS_FT_REG_FILE,
  79         [S_IFDIR >> S_SHIFT]    = BTRFS_FT_DIR,
  80         [S_IFCHR >> S_SHIFT]    = BTRFS_FT_CHRDEV,
  81         [S_IFBLK >> S_SHIFT]    = BTRFS_FT_BLKDEV,
  82         [S_IFIFO >> S_SHIFT]    = BTRFS_FT_FIFO,
  83         [S_IFSOCK >> S_SHIFT]   = BTRFS_FT_SOCK,
  84         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
  85 };
  86
  87 static int btrfs_setsize(struct inode *inode, loff_t newsize);
  88 static int btrfs_truncate(struct inode *inode);
  89 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
  90 static noinline int cow_file_range(struct inode *inode,
  91                                    struct page *locked_page,
  92                                    u64 start, u64 end, int *page_started,
  93                                    unsigned long *nr_written, int unlock);
  94
  95 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
  96                                      struct inode *inode,  struct inode *dir)
  97 {
  98         int err;
  99
 100         err = btrfs_init_acl(trans, inode, dir);
 101         if (!err)
 102                 err = btrfs_xattr_security_init(trans, inode, dir);
 103         return err;
 104 }
 105
 106 /*
 107  * this does all the hard work for inserting an inline extent into
 108  * the btree.  The caller should have done a btrfs_drop_extents so that
 109  * no overlapping inline items exist in the btree
 110  */
 111 static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
 112                                 struct btrfs_root *root, struct inode *inode,
 113                                 u64 start, size_t size, size_t compressed_size,
 114                                 struct page **compressed_pages)
 115 {
 116         struct btrfs_key key;
 117         struct btrfs_path *path;
 118         struct extent_buffer *leaf;
 119         struct page *page = NULL;
 120         char *kaddr;
 121         unsigned long ptr;
 122         struct btrfs_file_extent_item *ei;
 123         int err = 0;
 124         int ret;
 125         size_t cur_size = size;
 126         size_t datasize;
 127         unsigned long offset;
 128         int compress_type = BTRFS_COMPRESS_NONE;
 129
 130         if (compressed_size && compressed_pages) {
 131                 compress_type = root->fs_info->compress_type;
 132                 cur_size = compressed_size;
 133         }
 134
 135         path = btrfs_alloc_path();
 136         if (!path)
 137                 return -ENOMEM;
 138
 139         path->leave_spinning = 1;
 140         btrfs_set_trans_block_group(trans, inode);
 141
 142         key.objectid = inode->i_ino;
 143         key.offset = start;
 144         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
 145         datasize = btrfs_file_extent_calc_inline_size(cur_size);
 146
 147         inode_add_bytes(inode, size);
 148         ret = btrfs_insert_empty_item(trans, root, path, &key,
 149                                       datasize);
 150         BUG_ON(ret);
 151         if (ret) {
 152                 err = ret;
 153                 goto fail;
 154         }
 155         leaf = path->nodes[0];
 156         ei = btrfs_item_ptr(leaf, path->slots[0],
 157                             struct btrfs_file_extent_item);
 158         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
 159         btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
 160         btrfs_set_file_extent_encryption(leaf, ei, 0);
 161         btrfs_set_file_extent_other_encoding(leaf, ei, 0);
 162         btrfs_set_file_extent_ram_bytes(leaf, ei, size);
 163         ptr = btrfs_file_extent_inline_start(ei);
 164
 165         if (compress_type != BTRFS_COMPRESS_NONE) {
 166                 struct page *cpage;
 167                 int i = 0;
 168                 while (compressed_size > 0) {
 169                         cpage = compressed_pages[i];
 170                         cur_size = min_t(unsigned long, compressed_size,
 171                                        PAGE_CACHE_SIZE);
 172
 173                         kaddr = kmap_atomic(cpage, KM_USER0);
 174                         write_extent_buffer(leaf, kaddr, ptr, cur_size);
 175                         kunmap_atomic(kaddr, KM_USER0);
 176
 177                         i++;
 178                         ptr += cur_size;
 179                         compressed_size -= cur_size;
 180                 }
 181                 btrfs_set_file_extent_compression(leaf, ei,
 182                                                   compress_type);
 183         } else {
 184                 page = find_get_page(inode->i_mapping,
 185                                      start >> PAGE_CACHE_SHIFT);
 186                 btrfs_set_file_extent_compression(leaf, ei, 0);
 187                 kaddr = kmap_atomic(page, KM_USER0);
 188                 offset = start & (PAGE_CACHE_SIZE - 1);
 189                 write_extent_buffer(leaf, kaddr + offset, ptr, size);
 190                 kunmap_atomic(kaddr, KM_USER0);
 191                 page_cache_release(page);
 192         }
 193         btrfs_mark_buffer_dirty(leaf);
 194         btrfs_free_path(path);
 195
 196         /*
 197          * we're an inline extent, so nobody can
 198          * extend the file past i_size without locking
 199          * a page we already have locked.
 200          *
 201          * We must do any isize and inode updates
 202          * before we unlock the pages.  Otherwise we
 203          * could end up racing with unlink.
 204          */
 205         BTRFS_I(inode)->disk_i_size = inode->i_size;
 206         btrfs_update_inode(trans, root, inode);
 207
 208         return 0;
 209 fail:
 210         btrfs_free_path(path);
 211         return err;
 212 }
 213
 214
 215 /*
 216  * conditionally insert an inline extent into the file.  This
 217  * does the checks required to make sure the data is small enough
 218  * to fit as an inline extent.
 219  */
 220 static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
 221                                  struct btrfs_root *root,
 222                                  struct inode *inode, u64 start, u64 end,
 223                                  size_t compressed_size,
 224                                  struct page **compressed_pages)
 225 {
 226         u64 isize = i_size_read(inode);
 227         u64 actual_end = min(end + 1, isize);
 228         u64 inline_len = actual_end - start;
 229         u64 aligned_end = (end + root->sectorsize - 1) &
 230                         ~((u64)root->sectorsize - 1);
 231         u64 hint_byte;
 232         u64 data_len = inline_len;
 233         int ret;
 234
 235         if (compressed_size)
 236                 data_len = compressed_size;
 237
 238         if (start > 0 ||
 239             actual_end >= PAGE_CACHE_SIZE ||
 240             data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
 241             (!compressed_size &&
 242             (actual_end & (root->sectorsize - 1)) == 0) ||
 243             end + 1 < isize ||
 244             data_len > root->fs_info->max_inline) {
 245                 return 1;
 246         }
 247
 248         ret = btrfs_drop_extents(trans, inode, start, aligned_end,
 249                                  &hint_byte, 1);
 250         BUG_ON(ret);
 251
 252         if (isize > actual_end)
 253                 inline_len = min_t(u64, isize, actual_end);
 254         ret = insert_inline_extent(trans, root, inode, start,
 255                                    inline_len, compressed_size,
 256                                    compressed_pages);
 257         BUG_ON(ret);
 258         btrfs_delalloc_release_metadata(inode, end + 1 - start);
 259         btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
 260         return 0;
 261 }
 262
 263 struct async_extent {
 264         u64 start;
 265         u64 ram_size;
 266         u64 compressed_size;
 267         struct page **pages;
 268         unsigned long nr_pages;
 269         int compress_type;
 270         struct list_head list;
 271 };
 272
 273 struct async_cow {
 274         struct inode *inode;
 275         struct btrfs_root *root;
 276         struct page *locked_page;
 277         u64 start;
 278         u64 end;
 279         struct list_head extents;
 280         struct btrfs_work work;
 281 };
 282
 283 static noinline int add_async_extent(struct async_cow *cow,
 284                                      u64 start, u64 ram_size,
 285                                      u64 compressed_size,
 286                                      struct page **pages,
 287                                      unsigned long nr_pages,
 288                                      int compress_type)
 289 {
 290         struct async_extent *async_extent;
 291
 292         async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
 293         async_extent->start = start;
 294         async_extent->ram_size = ram_size;
 295         async_extent->compressed_size = compressed_size;
 296         async_extent->pages = pages;
 297         async_extent->nr_pages = nr_pages;
 298         async_extent->compress_type = compress_type;
 299         list_add_tail(&async_extent->list, &cow->extents);
 300         return 0;
 301 }
 302
 303 /*
 304  * we create compressed extents in two phases.  The first
 305  * phase compresses a range of pages that have already been
 306  * locked (both pages and state bits are locked).
 307  *
 308  * This is done inside an ordered work queue, and the compression
 309  * is spread across many cpus.  The actual IO submission is step
 310  * two, and the ordered work queue takes care of making sure that
 311  * happens in the same order things were put onto the queue by
 312  * writepages and friends.
 313  *
 314  * If this code finds it can't get good compression, it puts an
 315  * entry onto the work queue to write the uncompressed bytes.  This
 316  * makes sure that both compressed inodes and uncompressed inodes
 317  * are written in the same order that pdflush sent them down.
 318  */
 319 static noinline int compress_file_range(struct inode *inode,
 320                                         struct page *locked_page,
 321                                         u64 start, u64 end,
 322                                         struct async_cow *async_cow,
 323                                         int *num_added)
 324 {
 325         struct btrfs_root *root = BTRFS_I(inode)->root;
 326         struct btrfs_trans_handle *trans;
 327         u64 num_bytes;
 328         u64 blocksize = root->sectorsize;
 329         u64 actual_end;
 330         u64 isize = i_size_read(inode);
 331         int ret = 0;
 332         struct page **pages = NULL;
 333         unsigned long nr_pages;
 334         unsigned long nr_pages_ret = 0;
 335         unsigned long total_compressed = 0;
 336         unsigned long total_in = 0;
 337         unsigned long max_compressed = 128 * 1024;
 338         unsigned long max_uncompressed = 128 * 1024;
 339         int i;
 340         int will_compress;
 341         int compress_type = root->fs_info->compress_type;
 342
 343         actual_end = min_t(u64, isize, end + 1);
 344 again:
 345         will_compress = 0;
 346         nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
 347         nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
 348
 349         /*
 350          * we don't want to send crud past the end of i_size through
 351          * compression, that's just a waste of CPU time.  So, if the
 352          * end of the file is before the start of our current
 353          * requested range of bytes, we bail out to the uncompressed
 354          * cleanup code that can deal with all of this.
 355          *
 356          * It isn't really the fastest way to fix things, but this is a
 357          * very uncommon corner.
 358          */
 359         if (actual_end <= start)
 360                 goto cleanup_and_bail_uncompressed;
 361
 362         total_compressed = actual_end - start;
 363
 364         /* we want to make sure that amount of ram required to uncompress
 365          * an extent is reasonable, so we limit the total size in ram
 366          * of a compressed extent to 128k.  This is a crucial number
 367          * because it also controls how easily we can spread reads across
 368          * cpus for decompression.
 369          *
 370          * We also want to make sure the amount of IO required to do
 371          * a random read is reasonably small, so we limit the size of
 372          * a compressed extent to 128k.
 373          */
 374         total_compressed = min(total_compressed, max_uncompressed);
 375         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
 376         num_bytes = max(blocksize,  num_bytes);
 377         total_in = 0;
 378         ret = 0;
 379
 380         /*
 381          * we do compression for mount -o compress and when the
 382          * inode has not been flagged as nocompress.  This flag can
 383          * change at any time if we discover bad compression ratios.
 384          */
 385         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
 386             (btrfs_test_opt(root, COMPRESS) ||
 387              (BTRFS_I(inode)->force_compress))) {
 388                 WARN_ON(pages);
 389                 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
 390
 391                 if (BTRFS_I(inode)->force_compress)
 392                         compress_type = BTRFS_I(inode)->force_compress;
 393
 394                 ret = btrfs_compress_pages(compress_type,
 395                                            inode->i_mapping, start,
 396                                            total_compressed, pages,
 397                                            nr_pages, &nr_pages_ret,
 398                                            &total_in,
 399                                            &total_compressed,
 400                                            max_compressed);
 401
 402                 if (!ret) {
 403                         unsigned long offset = total_compressed &
 404                                 (PAGE_CACHE_SIZE - 1);
 405                         struct page *page = pages[nr_pages_ret - 1];
 406                         char *kaddr;
 407
 408                         /* zero the tail end of the last page, we might be
 409                          * sending it down to disk
 410                          */
 411                         if (offset) {
 412                                 kaddr = kmap_atomic(page, KM_USER0);
 413                                 memset(kaddr + offset, 0,
 414                                        PAGE_CACHE_SIZE - offset);
 415                                 kunmap_atomic(kaddr, KM_USER0);
 416                         }
 417                         will_compress = 1;
 418                 }
 419         }
 420         if (start == 0) {
 421                 trans = btrfs_join_transaction(root, 1);
 422                 BUG_ON(IS_ERR(trans));
 423                 btrfs_set_trans_block_group(trans, inode);
 424                 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 425
 426                 /* lets try to make an inline extent */
 427                 if (ret || total_in < (actual_end - start)) {
 428                         /* we didn't compress the entire range, try
 429                          * to make an uncompressed inline extent.
 430                          */
 431                         ret = cow_file_range_inline(trans, root, inode,
 432                                                     start, end, 0, NULL);
 433                 } else {
 434                         /* try making a compressed inline extent */
 435                         ret = cow_file_range_inline(trans, root, inode,
 436                                                     start, end,
 437                                                     total_compressed, pages);
 438                 }
 439                 if (ret == 0) {
 440                         /*
 441                          * inline extent creation worked, we don't need
 442                          * to create any more async work items.  Unlock
 443                          * and free up our temp pages.
 444                          */
 445                         extent_clear_unlock_delalloc(inode,
 446                              &BTRFS_I(inode)->io_tree,
 447                              start, end, NULL,
 448                              EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
 449                              EXTENT_CLEAR_DELALLOC |
 450                              EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
 451
 452                         btrfs_end_transaction(trans, root);
 453                         goto free_pages_out;
 454                 }
 455                 btrfs_end_transaction(trans, root);
 456         }
 457
 458         if (will_compress) {
 459                 /*
 460                  * we aren't doing an inline extent round the compressed size
 461                  * up to a block size boundary so the allocator does sane
 462                  * things
 463                  */
 464                 total_compressed = (total_compressed + blocksize - 1) &
 465                         ~(blocksize - 1);
 466
 467                 /*
 468                  * one last check to make sure the compression is really a
 469                  * win, compare the page count read with the blocks on disk
 470                  */
 471                 total_in = (total_in + PAGE_CACHE_SIZE - 1) &
 472                         ~(PAGE_CACHE_SIZE - 1);
 473                 if (total_compressed >= total_in) {
 474                         will_compress = 0;
 475                 } else {
 476                         num_bytes = total_in;
 477                 }
 478         }
 479         if (!will_compress && pages) {
 480                 /*
 481                  * the compression code ran but failed to make things smaller,
 482                  * free any pages it allocated and our page pointer array
 483                  */
 484                 for (i = 0; i < nr_pages_ret; i++) {
 485                         WARN_ON(pages[i]->mapping);
 486                         page_cache_release(pages[i]);
 487                 }
 488                 kfree(pages);
 489                 pages = NULL;
 490                 total_compressed = 0;
 491                 nr_pages_ret = 0;
 492
 493                 /* flag the file so we don't compress in the future */
 494                 if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
 495                     !(BTRFS_I(inode)->force_compress)) {
 496                         BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
 497                 }
 498         }
 499         if (will_compress) {
 500                 *num_added += 1;
 501
 502                 /* the async work queues will take care of doing actual
 503                  * allocation on disk for these compressed pages,
 504                  * and will submit them to the elevator.
 505                  */
 506                 add_async_extent(async_cow, start, num_bytes,
 507                                  total_compressed, pages, nr_pages_ret,
 508                                  compress_type);
 509
 510                 if (start + num_bytes < end) {
 511                         start += num_bytes;
 512                         pages = NULL;
 513                         cond_resched();
 514                         goto again;
 515                 }
 516         } else {
 517 cleanup_and_bail_uncompressed:
 518                 /*
 519                  * No compression, but we still need to write the pages in
 520                  * the file we've been given so far.  redirty the locked
 521                  * page if it corresponds to our extent and set things up
 522                  * for the async work queue to run cow_file_range to do
 523                  * the normal delalloc dance
 524                  */
 525                 if (page_offset(locked_page) >= start &&
 526                     page_offset(locked_page) <= end) {
 527                         __set_page_dirty_nobuffers(locked_page);
 528                         /* unlocked later on in the async handlers */
 529                 }
 530                 add_async_extent(async_cow, start, end - start + 1,
 531                                  0, NULL, 0, BTRFS_COMPRESS_NONE);
 532                 *num_added += 1;
 533         }
 534
 535 out:
 536         return 0;
 537
 538 free_pages_out:
 539         for (i = 0; i < nr_pages_ret; i++) {
 540                 WARN_ON(pages[i]->mapping);
 541                 page_cache_release(pages[i]);
 542         }
 543         kfree(pages);
 544
 545         goto out;
 546 }
 547
 548 /*
 549  * phase two of compressed writeback.  This is the ordered portion
 550  * of the code, which only gets called in the order the work was
 551  * queued.  We walk all the async extents created by compress_file_range
 552  * and send them down to the disk.
 553  */
 554 static noinline int submit_compressed_extents(struct inode *inode,
 555                                               struct async_cow *async_cow)
 556 {
 557         struct async_extent *async_extent;
 558         u64 alloc_hint = 0;
 559         struct btrfs_trans_handle *trans;
 560         struct btrfs_key ins;
 561         struct extent_map *em;
 562         struct btrfs_root *root = BTRFS_I(inode)->root;
 563         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 564         struct extent_io_tree *io_tree;
 565         int ret = 0;
 566
 567         if (list_empty(&async_cow->extents))
 568                 return 0;
 569
 570
 571         while (!list_empty(&async_cow->extents)) {
 572                 async_extent = list_entry(async_cow->extents.next,
 573                                           struct async_extent, list);
 574                 list_del(&async_extent->list);
 575
 576                 io_tree = &BTRFS_I(inode)->io_tree;
 577
 578 retry:
 579                 /* did the compression code fall back to uncompressed IO? */
 580                 if (!async_extent->pages) {
 581                         int page_started = 0;
 582                         unsigned long nr_written = 0;
 583
 584                         lock_extent(io_tree, async_extent->start,
 585                                          async_extent->start +
 586                                          async_extent->ram_size - 1, GFP_NOFS);
 587
 588                         /* allocate blocks */
 589                         ret = cow_file_range(inode, async_cow->locked_page,
 590                                              async_extent->start,
 591                                              async_extent->start +
 592                                              async_extent->ram_size - 1,
 593                                              &page_started, &nr_written, 0);
 594
 595                         /*
 596                          * if page_started, cow_file_range inserted an
 597                          * inline extent and took care of all the unlocking
 598                          * and IO for us.  Otherwise, we need to submit
 599                          * all those pages down to the drive.
 600                          */
 601                         if (!page_started && !ret)
 602                                 extent_write_locked_range(io_tree,
 603                                                   inode, async_extent->start,
 604                                                   async_extent->start +
 605                                                   async_extent->ram_size - 1,
 606                                                   btrfs_get_extent,
 607                                                   WB_SYNC_ALL);
 608                         kfree(async_extent);
 609                         cond_resched();
 610                         continue;
 611                 }
 612
 613                 lock_extent(io_tree, async_extent->start,
 614                             async_extent->start + async_extent->ram_size - 1,
 615                             GFP_NOFS);
 616
 617                 trans = btrfs_join_transaction(root, 1);
 618                 BUG_ON(IS_ERR(trans));
 619                 ret = btrfs_reserve_extent(trans, root,
 620                                            async_extent->compressed_size,
 621                                            async_extent->compressed_size,
 622                                            0, alloc_hint,
 623                                            (u64)-1, &ins, 1);
 624                 btrfs_end_transaction(trans, root);
 625
 626                 if (ret) {
 627                         int i;
 628                         for (i = 0; i < async_extent->nr_pages; i++) {
 629                                 WARN_ON(async_extent->pages[i]->mapping);
 630                                 page_cache_release(async_extent->pages[i]);
 631                         }
 632                         kfree(async_extent->pages);
 633                         async_extent->nr_pages = 0;
 634                         async_extent->pages = NULL;
 635                         unlock_extent(io_tree, async_extent->start,
 636                                       async_extent->start +
 637                                       async_extent->ram_size - 1, GFP_NOFS);
 638                         goto retry;
 639                 }
 640
 641                 /*
 642                  * here we're doing allocation and writeback of the
 643                  * compressed pages
 644                  */
 645                 btrfs_drop_extent_cache(inode, async_extent->start,
 646                                         async_extent->start +
 647                                         async_extent->ram_size - 1, 0);
 648
 649                 em = alloc_extent_map(GFP_NOFS);
 650                 BUG_ON(!em);
 651                 em->start = async_extent->start;
 652                 em->len = async_extent->ram_size;
 653                 em->orig_start = em->start;
 654
 655                 em->block_start = ins.objectid;
 656                 em->block_len = ins.offset;
 657                 em->bdev = root->fs_info->fs_devices->latest_bdev;
 658                 em->compress_type = async_extent->compress_type;
 659                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
 660                 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
 661
 662                 while (1) {
 663                         write_lock(&em_tree->lock);
 664                         ret = add_extent_mapping(em_tree, em);
 665                         write_unlock(&em_tree->lock);
 666                         if (ret != -EEXIST) {
 667                                 free_extent_map(em);
 668                                 break;
 669                         }
 670                         btrfs_drop_extent_cache(inode, async_extent->start,
 671                                                 async_extent->start +
 672                                                 async_extent->ram_size - 1, 0);
 673                 }
 674
 675                 ret = btrfs_add_ordered_extent_compress(inode,
 676                                                 async_extent->start,
 677                                                 ins.objectid,
 678                                                 async_extent->ram_size,
 679                                                 ins.offset,
 680                                                 BTRFS_ORDERED_COMPRESSED,
 681                                                 async_extent->compress_type);
 682                 BUG_ON(ret);
 683
 684                 /*
 685                  * clear dirty, set writeback and unlock the pages.
 686                  */
 687                 extent_clear_unlock_delalloc(inode,
 688                                 &BTRFS_I(inode)->io_tree,
 689                                 async_extent->start,
 690                                 async_extent->start +
 691                                 async_extent->ram_size - 1,
 692                                 NULL, EXTENT_CLEAR_UNLOCK_PAGE |
 693                                 EXTENT_CLEAR_UNLOCK |
 694                                 EXTENT_CLEAR_DELALLOC |
 695                                 EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
 696
 697                 ret = btrfs_submit_compressed_write(inode,
 698                                     async_extent->start,
 699                                     async_extent->ram_size,
 700                                     ins.objectid,
 701                                     ins.offset, async_extent->pages,
 702                                     async_extent->nr_pages);
 703
 704                 BUG_ON(ret);
 705                 alloc_hint = ins.objectid + ins.offset;
 706                 kfree(async_extent);
 707                 cond_resched();
 708         }
 709
 710         return 0;
 711 }
 712
 713 static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
 714                                       u64 num_bytes)
 715 {
 716         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 717         struct extent_map *em;
 718         u64 alloc_hint = 0;
 719
 720         read_lock(&em_tree->lock);
 721         em = search_extent_mapping(em_tree, start, num_bytes);
 722         if (em) {
 723                 /*
 724                  * if block start isn't an actual block number then find the
 725                  * first block in this inode and use that as a hint.  If that
 726                  * block is also bogus then just don't worry about it.
 727                  */
 728                 if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
 729                         free_extent_map(em);
 730                         em = search_extent_mapping(em_tree, 0, 0);
 731                         if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
 732                                 alloc_hint = em->block_start;
 733                         if (em)
 734                                 free_extent_map(em);
 735                 } else {
 736                         alloc_hint = em->block_start;
 737                         free_extent_map(em);
 738                 }
 739         }
 740         read_unlock(&em_tree->lock);
 741
 742         return alloc_hint;
 743 }
 744
 745 /*
 746  * when extent_io.c finds a delayed allocation range in the file,
 747  * the call backs end up in this code.  The basic idea is to
 748  * allocate extents on disk for the range, and create ordered data structs
 749  * in ram to track those extents.
 750  *
 751  * locked_page is the page that writepage had locked already.  We use
 752  * it to make sure we don't do extra locks or unlocks.
 753  *
 754  * *page_started is set to one if we unlock locked_page and do everything
 755  * required to start IO on it.  It may be clean and already done with
 756  * IO when we return.
 757  */
 758 static noinline int cow_file_range(struct inode *inode,
 759                                    struct page *locked_page,
 760                                    u64 start, u64 end, int *page_started,
 761                                    unsigned long *nr_written,
 762                                    int unlock)
 763 {
 764         struct btrfs_root *root = BTRFS_I(inode)->root;
 765         struct btrfs_trans_handle *trans;
 766         u64 alloc_hint = 0;
 767         u64 num_bytes;
 768         unsigned long ram_size;
 769         u64 disk_num_bytes;
 770         u64 cur_alloc_size;
 771         u64 blocksize = root->sectorsize;
 772         struct btrfs_key ins;
 773         struct extent_map *em;
 774         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 775         int ret = 0;
 776
 777         BUG_ON(root == root->fs_info->tree_root);
 778         trans = btrfs_join_transaction(root, 1);
 779         BUG_ON(IS_ERR(trans));
 780         btrfs_set_trans_block_group(trans, inode);
 781         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 782
 783         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
 784         num_bytes = max(blocksize,  num_bytes);
 785         disk_num_bytes = num_bytes;
 786         ret = 0;
 787
 788         if (start == 0) {
 789                 /* lets try to make an inline extent */
 790                 ret = cow_file_range_inline(trans, root, inode,
 791                                             start, end, 0, NULL);
 792                 if (ret == 0) {
 793                         extent_clear_unlock_delalloc(inode,
 794                                      &BTRFS_I(inode)->io_tree,
 795                                      start, end, NULL,
 796                                      EXTENT_CLEAR_UNLOCK_PAGE |
 797                                      EXTENT_CLEAR_UNLOCK |
 798                                      EXTENT_CLEAR_DELALLOC |
 799                                      EXTENT_CLEAR_DIRTY |
 800                                      EXTENT_SET_WRITEBACK |
 801                                      EXTENT_END_WRITEBACK);
 802
 803                         *nr_written = *nr_written +
 804                              (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
 805                         *page_started = 1;
 806                         ret = 0;
 807                         goto out;
 808                 }
 809         }
 810
 811         BUG_ON(disk_num_bytes >
 812                btrfs_super_total_bytes(&root->fs_info->super_copy));
 813
 814         alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
 815         btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
 816
 817         while (disk_num_bytes > 0) {
 818                 unsigned long op;
 819
 820                 cur_alloc_size = disk_num_bytes;
 821                 ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
 822                                            root->sectorsize, 0, alloc_hint,
 823                                            (u64)-1, &ins, 1);
 824                 BUG_ON(ret);
 825
 826                 em = alloc_extent_map(GFP_NOFS);
 827                 BUG_ON(!em);
 828                 em->start = start;
 829                 em->orig_start = em->start;
 830                 ram_size = ins.offset;
 831                 em->len = ins.offset;
 832
 833                 em->block_start = ins.objectid;
 834                 em->block_len = ins.offset;
 835                 em->bdev = root->fs_info->fs_devices->latest_bdev;
 836                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
 837
 838                 while (1) {
 839                         write_lock(&em_tree->lock);
 840                         ret = add_extent_mapping(em_tree, em);
 841                         write_unlock(&em_tree->lock);
 842                         if (ret != -EEXIST) {
 843                                 free_extent_map(em);
 844                                 break;
 845                         }
 846                         btrfs_drop_extent_cache(inode, start,
 847                                                 start + ram_size - 1, 0);
 848                 }
 849
 850                 cur_alloc_size = ins.offset;
 851                 ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
 852                                                ram_size, cur_alloc_size, 0);
 853                 BUG_ON(ret);
 854
 855                 if (root->root_key.objectid ==
 856                     BTRFS_DATA_RELOC_TREE_OBJECTID) {
 857                         ret = btrfs_reloc_clone_csums(inode, start,
 858                                                       cur_alloc_size);
 859                         BUG_ON(ret);
 860                 }
 861
 862                 if (disk_num_bytes < cur_alloc_size)
 863                         break;
 864
 865                 /* we're not doing compressed IO, don't unlock the first
 866                  * page (which the caller expects to stay locked), don't
 867                  * clear any dirty bits and don't set any writeback bits
 868                  *
 869                  * Do set the Private2 bit so we know this page was properly
 870                  * setup for writepage
 871                  */
 872                 op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
 873                 op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
 874                         EXTENT_SET_PRIVATE2;
 875
 876                 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
 877                                              start, start + ram_size - 1,
 878                                              locked_page, op);
 879                 disk_num_bytes -= cur_alloc_size;
 880                 num_bytes -= cur_alloc_size;
 881                 alloc_hint = ins.objectid + ins.offset;
 882                 start += cur_alloc_size;
 883         }
 884 out:
 885         ret = 0;
 886         btrfs_end_transaction(trans, root);
 887
 888         return ret;
 889 }
 890
 891 /*
 892  * work queue call back to started compression on a file and pages
 893  */
 894 static noinline void async_cow_start(struct btrfs_work *work)
 895 {
 896         struct async_cow *async_cow;
 897         int num_added = 0;
 898         async_cow = container_of(work, struct async_cow, work);
 899
 900         compress_file_range(async_cow->inode, async_cow->locked_page,
 901                             async_cow->start, async_cow->end, async_cow,
 902                             &num_added);
 903         if (num_added == 0)
 904                 async_cow->inode = NULL;
 905 }
 906
 907 /*
 908  * work queue call back to submit previously compressed pages
 909  */
 910 static noinline void async_cow_submit(struct btrfs_work *work)
 911 {
 912         struct async_cow *async_cow;
 913         struct btrfs_root *root;
 914         unsigned long nr_pages;
 915
 916         async_cow = container_of(work, struct async_cow, work);
 917
 918         root = async_cow->root;
 919         nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
 920                 PAGE_CACHE_SHIFT;
 921
 922         atomic_sub(nr_pages, &root->fs_info->async_delalloc_pages);
 923
 924         if (atomic_read(&root->fs_info->async_delalloc_pages) <
 925             5 * 1042 * 1024 &&
 926             waitqueue_active(&root->fs_info->async_submit_wait))
 927                 wake_up(&root->fs_info->async_submit_wait);
 928
 929         if (async_cow->inode)
 930                 submit_compressed_extents(async_cow->inode, async_cow);
 931 }
 932
 933 static noinline void async_cow_free(struct btrfs_work *work)
 934 {
 935         struct async_cow *async_cow;
 936         async_cow = container_of(work, struct async_cow, work);
 937         kfree(async_cow);
 938 }
 939
 940 static int cow_file_range_async(struct inode *inode, struct page *locked_page,
 941                                 u64 start, u64 end, int *page_started,
 942                                 unsigned long *nr_written)
 943 {
 944         struct async_cow *async_cow;
 945         struct btrfs_root *root = BTRFS_I(inode)->root;
 946         unsigned long nr_pages;
 947         u64 cur_end;
 948         int limit = 10 * 1024 * 1042;
 949
 950         clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
 951                          1, 0, NULL, GFP_NOFS);
 952         while (start < end) {
 953                 async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
 954                 async_cow->inode = inode;
 955                 async_cow->root = root;
 956                 async_cow->locked_page = locked_page;
 957                 async_cow->start = start;
 958
 959                 if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
 960                         cur_end = end;
 961                 else
 962                         cur_end = min(end, start + 512 * 1024 - 1);
 963
 964                 async_cow->end = cur_end;
 965                 INIT_LIST_HEAD(&async_cow->extents);
 966
 967                 async_cow->work.func = async_cow_start;
 968                 async_cow->work.ordered_func = async_cow_submit;
 969                 async_cow->work.ordered_free = async_cow_free;
 970                 async_cow->work.flags = 0;
 971
 972                 nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
 973                         PAGE_CACHE_SHIFT;
 974                 atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
 975
 976                 btrfs_queue_worker(&root->fs_info->delalloc_workers,
 977                                    &async_cow->work);
 978
 979                 if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
 980                         wait_event(root->fs_info->async_submit_wait,
 981                            (atomic_read(&root->fs_info->async_delalloc_pages) <
 982                             limit));
 983                 }
 984
 985                 while (atomic_read(&root->fs_info->async_submit_draining) &&
 986                       atomic_read(&root->fs_info->async_delalloc_pages)) {
 987                         wait_event(root->fs_info->async_submit_wait,
 988                           (atomic_read(&root->fs_info->async_delalloc_pages) ==
 989                            0));
 990                 }
 991
 992                 *nr_written += nr_pages;
 993                 start = cur_end + 1;
 994         }
 995         *page_started = 1;
 996         return 0;
 997 }
 998
 999 static noinline int csum_exist_in_range(struct btrfs_root *root,
1000                                         u64 bytenr, u64 num_bytes)
1001 {
1002         int ret;
1003         struct btrfs_ordered_sum *sums;
1004         LIST_HEAD(list);
1005
1006         ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
1007                                        bytenr + num_bytes - 1, &list);
1008         if (ret == 0 && list_empty(&list))
1009                 return 0;
1010
1011         while (!list_empty(&list)) {
1012                 sums = list_entry(list.next, struct btrfs_ordered_sum, list);
1013                 list_del(&sums->list);
1014                 kfree(sums);
1015         }
1016         return 1;
1017 }
1018
1019 /*
1020  * when nowcow writeback call back.  This checks for snapshots or COW copies
1021  * of the extents that exist in the file, and COWs the file as required.
1022  *
1023  * If no cow copies or snapshots exist, we write directly to the existing
1024  * blocks on disk
1025  */
1026 static noinline int run_delalloc_nocow(struct inode *inode,
1027                                        struct page *locked_page,
1028                               u64 start, u64 end, int *page_started, int force,
1029                               unsigned long *nr_written)
1030 {
1031         struct btrfs_root *root = BTRFS_I(inode)->root;
1032         struct btrfs_trans_handle *trans;
1033         struct extent_buffer *leaf;
1034         struct btrfs_path *path;
1035         struct btrfs_file_extent_item *fi;
1036         struct btrfs_key found_key;
1037         u64 cow_start;
1038         u64 cur_offset;
1039         u64 extent_end;
1040         u64 extent_offset;
1041         u64 disk_bytenr;
1042         u64 num_bytes;
1043         int extent_type;
1044         int ret;
1045         int type;
1046         int nocow;
1047         int check_prev = 1;
1048         bool nolock = false;
1049
1050         path = btrfs_alloc_path();
1051         BUG_ON(!path);
1052         if (root == root->fs_info->tree_root) {
1053                 nolock = true;
1054                 trans = btrfs_join_transaction_nolock(root, 1);
1055         } else {
1056                 trans = btrfs_join_transaction(root, 1);
1057         }
1058         BUG_ON(IS_ERR(trans));
1059
1060         cow_start = (u64)-1;
1061         cur_offset = start;
1062         while (1) {
1063                 ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
1064                                                cur_offset, 0);
1065                 BUG_ON(ret < 0);
1066                 if (ret > 0 && path->slots[0] > 0 && check_prev) {
1067                         leaf = path->nodes[0];
1068                         btrfs_item_key_to_cpu(leaf, &found_key,
1069                                               path->slots[0] - 1);
1070                         if (found_key.objectid == inode->i_ino &&
1071                             found_key.type == BTRFS_EXTENT_DATA_KEY)
1072                                 path->slots[0]--;
1073                 }
1074                 check_prev = 0;
1075 next_slot:
1076                 leaf = path->nodes[0];
1077                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1078                         ret = btrfs_next_leaf(root, path);
1079                         if (ret < 0)
1080                                 BUG_ON(1);
1081                         if (ret > 0)
1082                                 break;
1083                         leaf = path->nodes[0];
1084                 }
1085
1086                 nocow = 0;
1087                 disk_bytenr = 0;
1088                 num_bytes = 0;
1089                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1090
1091                 if (found_key.objectid > inode->i_ino ||
1092                     found_key.type > BTRFS_EXTENT_DATA_KEY ||
1093                     found_key.offset > end)
1094                         break;
1095
1096                 if (found_key.offset > cur_offset) {
1097                         extent_end = found_key.offset;
1098                         extent_type = 0;
1099                         goto out_check;
1100                 }
1101
1102                 fi = btrfs_item_ptr(leaf, path->slots[0],
1103                                     struct btrfs_file_extent_item);
1104                 extent_type = btrfs_file_extent_type(leaf, fi);
1105
1106                 if (extent_type == BTRFS_FILE_EXTENT_REG ||
1107                     extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1108                         disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1109                         extent_offset = btrfs_file_extent_offset(leaf, fi);
1110                         extent_end = found_key.offset +
1111                                 btrfs_file_extent_num_bytes(leaf, fi);
1112                         if (extent_end <= start) {
1113                                 path->slots[0]++;
1114                                 goto next_slot;
1115                         }
1116                         if (disk_bytenr == 0)
1117                                 goto out_check;
1118                         if (btrfs_file_extent_compression(leaf, fi) ||
1119                             btrfs_file_extent_encryption(leaf, fi) ||
1120                             btrfs_file_extent_other_encoding(leaf, fi))
1121                                 goto out_check;
1122                         if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
1123                                 goto out_check;
1124                         if (btrfs_extent_readonly(root, disk_bytenr))
1125                                 goto out_check;
1126                         if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
1127                                                   found_key.offset -
1128                                                   extent_offset, disk_bytenr))
1129                                 goto out_check;
1130                         disk_bytenr += extent_offset;
1131                         disk_bytenr += cur_offset - found_key.offset;
1132                         num_bytes = min(end + 1, extent_end) - cur_offset;
1133                         /*
1134                          * force cow if csum exists in the range.
1135                          * this ensure that csum for a given extent are
1136                          * either valid or do not exist.
1137                          */
1138                         if (csum_exist_in_range(root, disk_bytenr, num_bytes))
1139                                 goto out_check;
1140                         nocow = 1;
1141                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1142                         extent_end = found_key.offset +
1143                                 btrfs_file_extent_inline_len(leaf, fi);
1144                         extent_end = ALIGN(extent_end, root->sectorsize);
1145                 } else {
1146                         BUG_ON(1);
1147                 }
1148 out_check:
1149                 if (extent_end <= start) {
1150                         path->slots[0]++;
1151                         goto next_slot;
1152                 }
1153                 if (!nocow) {
1154                         if (cow_start == (u64)-1)
1155                                 cow_start = cur_offset;
1156                         cur_offset = extent_end;
1157                         if (cur_offset > end)
1158                                 break;
1159                         path->slots[0]++;
1160                         goto next_slot;
1161                 }
1162
1163                 btrfs_release_path(root, path);
1164                 if (cow_start != (u64)-1) {
1165                         ret = cow_file_range(inode, locked_page, cow_start,
1166                                         found_key.offset - 1, page_started,
1167                                         nr_written, 1);
1168                         BUG_ON(ret);
1169                         cow_start = (u64)-1;
1170                 }
1171
1172                 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1173                         struct extent_map *em;
1174                         struct extent_map_tree *em_tree;
1175                         em_tree = &BTRFS_I(inode)->extent_tree;
1176                         em = alloc_extent_map(GFP_NOFS);
1177                         BUG_ON(!em);
1178                         em->start = cur_offset;
1179                         em->orig_start = em->start;
1180                         em->len = num_bytes;
1181                         em->block_len = num_bytes;
1182                         em->block_start = disk_bytenr;
1183                         em->bdev = root->fs_info->fs_devices->latest_bdev;
1184                         set_bit(EXTENT_FLAG_PINNED, &em->flags);
1185                         while (1) {
1186                                 write_lock(&em_tree->lock);
1187                                 ret = add_extent_mapping(em_tree, em);
1188                                 write_unlock(&em_tree->lock);
1189                                 if (ret != -EEXIST) {
1190                                         free_extent_map(em);
1191                                         break;
1192                                 }
1193                                 btrfs_drop_extent_cache(inode, em->start,
1194                                                 em->start + em->len - 1, 0);
1195                         }
1196                         type = BTRFS_ORDERED_PREALLOC;
1197                 } else {
1198                         type = BTRFS_ORDERED_NOCOW;
1199                 }
1200
1201                 ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1202                                                num_bytes, num_bytes, type);
1203                 BUG_ON(ret);
1204
1205                 if (root->root_key.objectid ==
1206                     BTRFS_DATA_RELOC_TREE_OBJECTID) {
1207                         ret = btrfs_reloc_clone_csums(inode, cur_offset,
1208                                                       num_bytes);
1209                         BUG_ON(ret);
1210                 }
1211
1212                 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1213                                 cur_offset, cur_offset + num_bytes - 1,
1214                                 locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
1215                                 EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
1216                                 EXTENT_SET_PRIVATE2);
1217                 cur_offset = extent_end;
1218                 if (cur_offset > end)
1219                         break;
1220         }
1221         btrfs_release_path(root, path);
1222
1223         if (cur_offset <= end && cow_start == (u64)-1)
1224                 cow_start = cur_offset;
1225         if (cow_start != (u64)-1) {
1226                 ret = cow_file_range(inode, locked_page, cow_start, end,
1227                                      page_started, nr_written, 1);
1228                 BUG_ON(ret);
1229         }
1230
1231         if (nolock) {
1232                 ret = btrfs_end_transaction_nolock(trans, root);
1233                 BUG_ON(ret);
1234         } else {
1235                 ret = btrfs_end_transaction(trans, root);
1236                 BUG_ON(ret);
1237         }
1238         btrfs_free_path(path);
1239         return 0;
1240 }
1241
1242 /*
1243  * extent_io.c call back to do delayed allocation processing
1244  */
1245 static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1246                               u64 start, u64 end, int *page_started,
1247                               unsigned long *nr_written)
1248 {
1249         int ret;
1250         struct btrfs_root *root = BTRFS_I(inode)->root;
1251
1252         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)
1253                 ret = run_delalloc_nocow(inode, locked_page, start, end,
1254                                          page_started, 1, nr_written);
1255         else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)
1256                 ret = run_delalloc_nocow(inode, locked_page, start, end,
1257                                          page_started, 0, nr_written);
1258         else if (!btrfs_test_opt(root, COMPRESS) &&
1259                  !(BTRFS_I(inode)->force_compress))
1260                 ret = cow_file_range(inode, locked_page, start, end,
1261                                       page_started, nr_written, 1);
1262         else
1263                 ret = cow_file_range_async(inode, locked_page, start, end,
1264                                            page_started, nr_written);
1265         return ret;
1266 }
1267
1268 static int btrfs_split_extent_hook(struct inode *inode,
1269                                    struct extent_state *orig, u64 split)
1270 {
1271         /* not delalloc, ignore it */
1272         if (!(orig->state & EXTENT_DELALLOC))
1273                 return 0;
1274
1275         atomic_inc(&BTRFS_I(inode)->outstanding_extents);
1276         return 0;
1277 }
1278
1279 /*
1280  * extent_io.c merge_extent_hook, used to track merged delayed allocation
1281  * extents so we can keep track of new extents that are just merged onto old
1282  * extents, such as when we are doing sequential writes, so we can properly
1283  * account for the metadata space we'll need.
1284  */
1285 static int btrfs_merge_extent_hook(struct inode *inode,
1286                                    struct extent_state *new,
1287                                    struct extent_state *other)
1288 {
1289         /* not delalloc, ignore it */
1290         if (!(other->state & EXTENT_DELALLOC))
1291                 return 0;
1292
1293         atomic_dec(&BTRFS_I(inode)->outstanding_extents);
1294         return 0;
1295 }
1296
1297 /*
1298  * extent_io.c set_bit_hook, used to track delayed allocation
1299  * bytes in this file, and to maintain the list of inodes that
1300  * have pending delalloc work to be done.
1301  */
1302 static int btrfs_set_bit_hook(struct inode *inode,
1303                               struct extent_state *state, int *bits)
1304 {
1305
1306         /*
1307          * set_bit and clear bit hooks normally require _irqsave/restore
1308          * but in this case, we are only testeing for the DELALLOC
1309          * bit, which is only set or cleared with irqs on
1310          */
1311         if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1312                 struct btrfs_root *root = BTRFS_I(inode)->root;
1313                 u64 len = state->end + 1 - state->start;
1314                 int do_list = (root->root_key.objectid !=
1315                                BTRFS_ROOT_TREE_OBJECTID);
1316
1317                 if (*bits & EXTENT_FIRST_DELALLOC)
1318                         *bits &= ~EXTENT_FIRST_DELALLOC;
1319                 else
1320                         atomic_inc(&BTRFS_I(inode)->outstanding_extents);
1321
1322                 spin_lock(&root->fs_info->delalloc_lock);
1323                 BTRFS_I(inode)->delalloc_bytes += len;
1324                 root->fs_info->delalloc_bytes += len;
1325                 if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1326                         list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
1327                                       &root->fs_info->delalloc_inodes);
1328                 }
1329                 spin_unlock(&root->fs_info->delalloc_lock);
1330         }
1331         return 0;
1332 }
1333
1334 /*
1335  * extent_io.c clear_bit_hook, see set_bit_hook for why
1336  */
1337 static int btrfs_clear_bit_hook(struct inode *inode,
1338                                 struct extent_state *state, int *bits)
1339 {
1340         /*
1341          * set_bit and clear bit hooks normally require _irqsave/restore
1342          * but in this case, we are only testeing for the DELALLOC
1343          * bit, which is only set or cleared with irqs on
1344          */
1345         if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1346                 struct btrfs_root *root = BTRFS_I(inode)->root;
1347                 u64 len = state->end + 1 - state->start;
1348                 int do_list = (root->root_key.objectid !=
1349                                BTRFS_ROOT_TREE_OBJECTID);
1350
1351                 if (*bits & EXTENT_FIRST_DELALLOC)
1352                         *bits &= ~EXTENT_FIRST_DELALLOC;
1353                 else if (!(*bits & EXTENT_DO_ACCOUNTING))
1354                         atomic_dec(&BTRFS_I(inode)->outstanding_extents);
1355
1356                 if (*bits & EXTENT_DO_ACCOUNTING)
1357                         btrfs_delalloc_release_metadata(inode, len);
1358
1359                 if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
1360                     && do_list)
1361                         btrfs_free_reserved_data_space(inode, len);
1362
1363                 spin_lock(&root->fs_info->delalloc_lock);
1364                 root->fs_info->delalloc_bytes -= len;
1365                 BTRFS_I(inode)->delalloc_bytes -= len;
1366
1367                 if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1368                     !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1369                         list_del_init(&BTRFS_I(inode)->delalloc_inodes);
1370                 }
1371                 spin_unlock(&root->fs_info->delalloc_lock);
1372         }
1373         return 0;
1374 }
1375
1376 /*
1377  * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
1378  * we don't create bios that span stripes or chunks
1379  */
1380 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1381                          size_t size, struct bio *bio,
1382                          unsigned long bio_flags)
1383 {
1384         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1385         struct btrfs_mapping_tree *map_tree;
1386         u64 logical = (u64)bio->bi_sector << 9;
1387         u64 length = 0;
1388         u64 map_length;
1389         int ret;
1390
1391         if (bio_flags & EXTENT_BIO_COMPRESSED)
1392                 return 0;
1393
1394         length = bio->bi_size;
1395         map_tree = &root->fs_info->mapping_tree;
1396         map_length = length;
1397         ret = btrfs_map_block(map_tree, READ, logical,
1398                               &map_length, NULL, 0);
1399
1400         if (map_length < length + size)
1401                 return 1;
1402         return ret;
1403 }
1404
1405 /*
1406  * in order to insert checksums into the metadata in large chunks,
1407  * we wait until bio submission time.   All the pages in the bio are
1408  * checksummed and sums are attached onto the ordered extent record.
1409  *
1410  * At IO completion time the cums attached on the ordered extent record
1411  * are inserted into the btree
1412  */
1413 static int __btrfs_submit_bio_start(struct inode *inode, int rw,
1414                                     struct bio *bio, int mirror_num,
1415                                     unsigned long bio_flags,
1416                                     u64 bio_offset)
1417 {
1418         struct btrfs_root *root = BTRFS_I(inode)->root;
1419         int ret = 0;
1420
1421         ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1422         BUG_ON(ret);
1423         return 0;
1424 }
1425
1426 /*
1427  * in order to insert checksums into the metadata in large chunks,
1428  * we wait until bio submission time.   All the pages in the bio are
1429  * checksummed and sums are attached onto the ordered extent record.
1430  *
1431  * At IO completion time the cums attached on the ordered extent record
1432  * are inserted into the btree
1433  */
1434 static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1435                           int mirror_num, unsigned long bio_flags,
1436                           u64 bio_offset)
1437 {
1438         struct btrfs_root *root = BTRFS_I(inode)->root;
1439         return btrfs_map_bio(root, rw, bio, mirror_num, 1);
1440 }
1441
1442 /*
1443  * extent_io.c submission hook. This does the right thing for csum calculation
1444  * on write, or reading the csums from the tree before a read
1445  */
1446 static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1447                           int mirror_num, unsigned long bio_flags,
1448                           u64 bio_offset)
1449 {
1450         struct btrfs_root *root = BTRFS_I(inode)->root;
1451         int ret = 0;
1452         int skip_sum;
1453
1454         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1455
1456         if (root == root->fs_info->tree_root)
1457                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 2);
1458         else
1459                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
1460         BUG_ON(ret);
1461
1462         if (!(rw & REQ_WRITE)) {
1463                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
1464                         return btrfs_submit_compressed_read(inode, bio,
1465                                                     mirror_num, bio_flags);
1466                 } else if (!skip_sum)
1467                         btrfs_lookup_bio_sums(root, inode, bio, NULL);
1468                 goto mapit;
1469         } else if (!skip_sum) {
1470                 /* csum items have already been cloned */
1471                 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
1472                         goto mapit;
1473                 /* we're doing a write, do the async checksumming */
1474                 return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1475                                    inode, rw, bio, mirror_num,
1476                                    bio_flags, bio_offset,
1477                                    __btrfs_submit_bio_start,
1478                                    __btrfs_submit_bio_done);
1479         }
1480
1481 mapit:
1482         return btrfs_map_bio(root, rw, bio, mirror_num, 0);
1483 }
1484
1485 /*
1486  * given a list of ordered sums record them in the inode.  This happens
1487  * at IO completion time based on sums calculated at bio submission time.
1488  */
1489 static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1490                              struct inode *inode, u64 file_offset,
1491                              struct list_head *list)
1492 {
1493         struct btrfs_ordered_sum *sum;
1494
1495         btrfs_set_trans_block_group(trans, inode);
1496
1497         list_for_each_entry(sum, list, list) {
1498                 btrfs_csum_file_blocks(trans,
1499                        BTRFS_I(inode)->root->fs_info->csum_root, sum);
1500         }
1501         return 0;
1502 }
1503
1504 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
1505                               struct extent_state **cached_state)
1506 {
1507         if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
1508                 WARN_ON(1);
1509         return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1510                                    cached_state, GFP_NOFS);
1511 }
1512
1513 /* see btrfs_writepage_start_hook for details on why this is required */
1514 struct btrfs_writepage_fixup {
1515         struct page *page;
1516         struct btrfs_work work;
1517 };
1518
1519 static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1520 {
1521         struct btrfs_writepage_fixup *fixup;
1522         struct btrfs_ordered_extent *ordered;
1523         struct extent_state *cached_state = NULL;
1524         struct page *page;
1525         struct inode *inode;
1526         u64 page_start;
1527         u64 page_end;
1528
1529         fixup = container_of(work, struct btrfs_writepage_fixup, work);
1530         page = fixup->page;
1531 again:
1532         lock_page(page);
1533         if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
1534                 ClearPageChecked(page);
1535                 goto out_page;
1536         }
1537
1538         inode = page->mapping->host;
1539         page_start = page_offset(page);
1540         page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;
1541
1542         lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1543                          &cached_state, GFP_NOFS);
1544
1545         /* already ordered? We're done */
1546         if (PagePrivate2(page))
1547                 goto out;
1548
1549         ordered = btrfs_lookup_ordered_extent(inode, page_start);
1550         if (ordered) {
1551                 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
1552                                      page_end, &cached_state, GFP_NOFS);
1553                 unlock_page(page);
1554                 btrfs_start_ordered_extent(inode, ordered, 1);
1555                 goto again;
1556         }
1557
1558         BUG();
1559         btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1560         ClearPageChecked(page);
1561 out:
1562         unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
1563                              &cached_state, GFP_NOFS);
1564 out_page:
1565         unlock_page(page);
1566         page_cache_release(page);
1567         kfree(fixup);
1568 }
1569
1570 /*
1571  * There are a few paths in the higher layers of the kernel that directly
1572  * set the page dirty bit without asking the filesystem if it is a
1573  * good idea.  This causes problems because we want to make sure COW
1574  * properly happens and the data=ordered rules are followed.
1575  *
1576  * In our case any range that doesn't have the ORDERED bit set
1577  * hasn't been properly setup for IO.  We kick off an async process
1578  * to fix it up.  The async helper will wait for ordered extents, set
1579  * the delalloc bit and make it safe to write the page.
1580  */
1581 static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1582 {
1583         struct inode *inode = page->mapping->host;
1584         struct btrfs_writepage_fixup *fixup;
1585         struct btrfs_root *root = BTRFS_I(inode)->root;
1586
1587         /* this page is properly in the ordered list */
1588         if (TestClearPagePrivate2(page))
1589                 return 0;
1590
1591         if (PageChecked(page))
1592                 return -EAGAIN;
1593
1594         fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
1595         if (!fixup)
1596                 return -EAGAIN;
1597
1598         SetPageChecked(page);
1599         page_cache_get(page);
1600         fixup->work.func = btrfs_writepage_fixup_worker;
1601         fixup->page = page;
1602         btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
1603         return -EAGAIN;
1604 }
1605
1606 static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
1607                                        struct inode *inode, u64 file_pos,
1608                                        u64 disk_bytenr, u64 disk_num_bytes,
1609                                        u64 num_bytes, u64 ram_bytes,
1610                                        u8 compression, u8 encryption,
1611                                        u16 other_encoding, int extent_type)
1612 {
1613         struct btrfs_root *root = BTRFS_I(inode)->root;
1614         struct btrfs_file_extent_item *fi;
1615         struct btrfs_path *path;
1616         struct extent_buffer *leaf;
1617         struct btrfs_key ins;
1618         u64 hint;
1619         int ret;
1620
1621         path = btrfs_alloc_path();
1622         BUG_ON(!path);
1623
1624         path->leave_spinning = 1;
1625
1626         /*
1627          * we may be replacing one extent in the tree with another.
1628          * The new extent is pinned in the extent map, and we don't want
1629          * to drop it from the cache until it is completely in the btree.
1630          *
1631          * So, tell btrfs_drop_extents to leave this extent in the cache.
1632          * the caller is expected to unpin it and allow it to be merged
1633          * with the others.
1634          */
1635         ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
1636                                  &hint, 0);
1637         BUG_ON(ret);
1638
1639         ins.objectid = inode->i_ino;
1640         ins.offset = file_pos;
1641         ins.type = BTRFS_EXTENT_DATA_KEY;
1642         ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1643         BUG_ON(ret);
1644         leaf = path->nodes[0];
1645         fi = btrfs_item_ptr(leaf, path->slots[0],
1646                             struct btrfs_file_extent_item);
1647         btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1648         btrfs_set_file_extent_type(leaf, fi, extent_type);
1649         btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
1650         btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
1651         btrfs_set_file_extent_offset(leaf, fi, 0);
1652         btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
1653         btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
1654         btrfs_set_file_extent_compression(leaf, fi, compression);
1655         btrfs_set_file_extent_encryption(leaf, fi, encryption);
1656         btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
1657
1658         btrfs_unlock_up_safe(path, 1);
1659         btrfs_set_lock_blocking(leaf);
1660
1661         btrfs_mark_buffer_dirty(leaf);
1662
1663         inode_add_bytes(inode, num_bytes);
1664
1665         ins.objectid = disk_bytenr;
1666         ins.offset = disk_num_bytes;
1667         ins.type = BTRFS_EXTENT_ITEM_KEY;
1668         ret = btrfs_alloc_reserved_file_extent(trans, root,
1669                                         root->root_key.objectid,
1670                                         inode->i_ino, file_pos, &ins);
1671         BUG_ON(ret);
1672         btrfs_free_path(path);
1673
1674         return 0;
1675 }
1676
1677 /*
1678  * helper function for btrfs_finish_ordered_io, this
1679  * just reads in some of the csum leaves to prime them into ram
1680  * before we start the transaction.  It limits the amount of btree
1681  * reads required while inside the transaction.
1682  */
1683 /* as ordered data IO finishes, this gets called so we can finish
1684  * an ordered extent if the range of bytes in the file it covers are
1685  * fully written.
1686  */
1687 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1688 {
1689         struct btrfs_root *root = BTRFS_I(inode)->root;
1690         struct btrfs_trans_handle *trans = NULL;
1691         struct btrfs_ordered_extent *ordered_extent = NULL;
1692         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1693         struct extent_state *cached_state = NULL;
1694         int compress_type = 0;
1695         int ret;
1696         bool nolock = false;
1697
1698         ret = btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
1699                                              end - start + 1);
1700         if (!ret)
1701                 return 0;
1702         BUG_ON(!ordered_extent);
1703
1704         nolock = (root == root->fs_info->tree_root);
1705
1706         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
1707                 BUG_ON(!list_empty(&ordered_extent->list));
1708                 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1709                 if (!ret) {
1710                         if (nolock)
1711                                 trans = btrfs_join_transaction_nolock(root, 1);
1712                         else
1713                                 trans = btrfs_join_transaction(root, 1);
1714                         BUG_ON(IS_ERR(trans));
1715                         btrfs_set_trans_block_group(trans, inode);
1716                         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1717                         ret = btrfs_update_inode(trans, root, inode);
1718                         BUG_ON(ret);
1719                 }
1720                 goto out;
1721         }
1722
1723         lock_extent_bits(io_tree, ordered_extent->file_offset,
1724                          ordered_extent->file_offset + ordered_extent->len - 1,
1725                          0, &cached_state, GFP_NOFS);
1726
1727         if (nolock)
1728                 trans = btrfs_join_transaction_nolock(root, 1);
1729         else
1730                 trans = btrfs_join_transaction(root, 1);
1731         BUG_ON(IS_ERR(trans));
1732         btrfs_set_trans_block_group(trans, inode);
1733         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1734
1735         if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
1736                 compress_type = ordered_extent->compress_type;
1737         if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1738                 BUG_ON(compress_type);
1739                 ret = btrfs_mark_extent_written(trans, inode,
1740                                                 ordered_extent->file_offset,
1741                                                 ordered_extent->file_offset +
1742                                                 ordered_extent->len);
1743                 BUG_ON(ret);
1744         } else {
1745                 BUG_ON(root == root->fs_info->tree_root);
1746                 ret = insert_reserved_file_extent(trans, inode,
1747                                                 ordered_extent->file_offset,
1748                                                 ordered_extent->start,
1749                                                 ordered_extent->disk_len,
1750                                                 ordered_extent->len,
1751                                                 ordered_extent->len,
1752                                                 compress_type, 0, 0,
1753                                                 BTRFS_FILE_EXTENT_REG);
1754                 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
1755                                    ordered_extent->file_offset,
1756                                    ordered_extent->len);
1757                 BUG_ON(ret);
1758         }
1759         unlock_extent_cached(io_tree, ordered_extent->file_offset,
1760                              ordered_extent->file_offset +
1761                              ordered_extent->len - 1, &cached_state, GFP_NOFS);
1762
1763         add_pending_csums(trans, inode, ordered_extent->file_offset,
1764                           &ordered_extent->list);
1765
1766         btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1767         ret = btrfs_update_inode(trans, root, inode);
1768         BUG_ON(ret);
1769 out:
1770         if (nolock) {
1771                 if (trans)
1772                         btrfs_end_transaction_nolock(trans, root);
1773         } else {
1774                 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
1775                 if (trans)
1776                         btrfs_end_transaction(trans, root);
1777         }
1778
1779         /* once for us */
1780         btrfs_put_ordered_extent(ordered_extent);
1781         /* once for the tree */
1782         btrfs_put_ordered_extent(ordered_extent);
1783
1784         return 0;
1785 }
1786
1787 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1788                                 struct extent_state *state, int uptodate)
1789 {
1790         ClearPagePrivate2(page);
1791         return btrfs_finish_ordered_io(page->mapping->host, start, end);
1792 }
1793
1794 /*
1795  * When IO fails, either with EIO or csum verification fails, we
1796  * try other mirrors that might have a good copy of the data.  This
1797  * io_failure_record is used to record state as we go through all the
1798  * mirrors.  If another mirror has good data, the page is set up to date
1799  * and things continue.  If a good mirror can't be found, the original
1800  * bio end_io callback is called to indicate things have failed.
1801  */
1802 struct io_failure_record {
1803         struct page *page;
1804         u64 start;
1805         u64 len;
1806         u64 logical;
1807         unsigned long bio_flags;
1808         int last_mirror;
1809 };
1810
1811 static int btrfs_io_failed_hook(struct bio *failed_bio,
1812                          struct page *page, u64 start, u64 end,
1813                          struct extent_state *state)
1814 {
1815         struct io_failure_record *failrec = NULL;
1816         u64 private;
1817         struct extent_map *em;
1818         struct inode *inode = page->mapping->host;
1819         struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
1820         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1821         struct bio *bio;
1822         int num_copies;
1823         int ret;
1824         int rw;
1825         u64 logical;
1826
1827         ret = get_state_private(failure_tree, start, &private);
1828         if (ret) {
1829                 failrec = kmalloc(sizeof(*failrec), GFP_NOFS);
1830                 if (!failrec)
1831                         return -ENOMEM;
1832                 failrec->start = start;
1833                 failrec->len = end - start + 1;
1834                 failrec->last_mirror = 0;
1835                 failrec->bio_flags = 0;
1836
1837                 read_lock(&em_tree->lock);
1838                 em = lookup_extent_mapping(em_tree, start, failrec->len);
1839                 if (em->start > start || em->start + em->len < start) {
1840                         free_extent_map(em);
1841                         em = NULL;
1842                 }
1843                 read_unlock(&em_tree->lock);
1844
1845                 if (!em || IS_ERR(em)) {
1846                         kfree(failrec);
1847                         return -EIO;
1848                 }
1849                 logical = start - em->start;
1850                 logical = em->block_start + logical;
1851                 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
1852                         logical = em->block_start;
1853                         failrec->bio_flags = EXTENT_BIO_COMPRESSED;
1854                         extent_set_compress_type(&failrec->bio_flags,
1855                                                  em->compress_type);
1856                 }
1857                 failrec->logical = logical;
1858                 free_extent_map(em);
1859                 set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
1860                                 EXTENT_DIRTY, GFP_NOFS);
1861                 set_state_private(failure_tree, start,
1862                                  (u64)(unsigned long)failrec);
1863         } else {
1864                 failrec = (struct io_failure_record *)(unsigned long)private;
1865         }
1866         num_copies = btrfs_num_copies(
1867                               &BTRFS_I(inode)->root->fs_info->mapping_tree,
1868                               failrec->logical, failrec->len);
1869         failrec->last_mirror++;
1870         if (!state) {
1871                 spin_lock(&BTRFS_I(inode)->io_tree.lock);
1872                 state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
1873                                                     failrec->start,
1874                                                     EXTENT_LOCKED);
1875                 if (state && state->start != failrec->start)
1876                         state = NULL;
1877                 spin_unlock(&BTRFS_I(inode)->io_tree.lock);
1878         }
1879         if (!state || failrec->last_mirror > num_copies) {
1880                 set_state_private(failure_tree, failrec->start, 0);
1881                 clear_extent_bits(failure_tree, failrec->start,
1882                                   failrec->start + failrec->len - 1,
1883                                   EXTENT_LOCKED | EXTENT_DIRTY, GFP_NOFS);
1884                 kfree(failrec);
1885                 return -EIO;
1886         }
1887         bio = bio_alloc(GFP_NOFS, 1);
1888         bio->bi_private = state;
1889         bio->bi_end_io = failed_bio->bi_end_io;
1890         bio->bi_sector = failrec->logical >> 9;
1891         bio->bi_bdev = failed_bio->bi_bdev;
1892         bio->bi_size = 0;
1893
1894         bio_add_page(bio, page, failrec->len, start - page_offset(page));
1895         if (failed_bio->bi_rw & REQ_WRITE)
1896                 rw = WRITE;
1897         else
1898                 rw = READ;
1899
1900         BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
1901                                                       failrec->last_mirror,
1902                                                       failrec->bio_flags, 0);
1903         return 0;
1904 }
1905
1906 /*
1907  * each time an IO finishes, we do a fast check in the IO failure tree
1908  * to see if we need to process or clean up an io_failure_record
1909  */
1910 static int btrfs_clean_io_failures(struct inode *inode, u64 start)
1911 {
1912         u64 private;
1913         u64 private_failure;
1914         struct io_failure_record *failure;
1915         int ret;
1916
1917         private = 0;
1918         if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
1919                              (u64)-1, 1, EXTENT_DIRTY, 0)) {
1920                 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
1921                                         start, &private_failure);
1922                 if (ret == 0) {
1923                         failure = (struct io_failure_record *)(unsigned long)
1924                                    private_failure;
1925                         set_state_private(&BTRFS_I(inode)->io_failure_tree,
1926                                           failure->start, 0);
1927                         clear_extent_bits(&BTRFS_I(inode)->io_failure_tree,
1928                                           failure->start,
1929                                           failure->start + failure->len - 1,
1930                                           EXTENT_DIRTY | EXTENT_LOCKED,
1931                                           GFP_NOFS);
1932                         kfree(failure);
1933                 }
1934         }
1935         return 0;
1936 }
1937
1938 /*
1939  * when reads are done, we need to check csums to verify the data is correct
1940  * if there's a match, we allow the bio to finish.  If not, we go through
1941  * the io_failure_record routines to find good copies
1942  */
1943 static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1944                                struct extent_state *state)
1945 {
1946         size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1947         struct inode *inode = page->mapping->host;
1948         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1949         char *kaddr;
1950         u64 private = ~(u32)0;
1951         int ret;
1952         struct btrfs_root *root = BTRFS_I(inode)->root;
1953         u32 csum = ~(u32)0;
1954
1955         if (PageChecked(page)) {
1956                 ClearPageChecked(page);
1957                 goto good;
1958         }
1959
1960         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
1961                 return 0;
1962
1963         if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
1964             test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
1965                 clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
1966                                   GFP_NOFS);
1967                 return 0;
1968         }
1969
1970         if (state && state->start == start) {
1971                 private = state->private;
1972                 ret = 0;
1973         } else {
1974                 ret = get_state_private(io_tree, start, &private);
1975         }
1976         kaddr = kmap_atomic(page, KM_USER0);
1977         if (ret)
1978                 goto zeroit;
1979
1980         csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
1981         btrfs_csum_final(csum, (char *)&csum);
1982         if (csum != private)
1983                 goto zeroit;
1984
1985         kunmap_atomic(kaddr, KM_USER0);
1986 good:
1987         /* if the io failure tree for this inode is non-empty,
1988          * check to see if we've recovered from a failed IO
1989          */
1990         btrfs_clean_io_failures(inode, start);
1991         return 0;
1992
1993 zeroit:
1994         if (printk_ratelimit()) {
1995                 printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
1996                        "private %llu\n", page->mapping->host->i_ino,
1997                        (unsigned long long)start, csum,
1998                        (unsigned long long)private);
1999         }
2000         memset(kaddr + offset, 1, end - start + 1);
2001         flush_dcache_page(page);
2002         kunmap_atomic(kaddr, KM_USER0);
2003         if (private == 0)
2004                 return 0;
2005         return -EIO;
2006 }
2007
2008 struct delayed_iput {
2009         struct list_head list;
2010         struct inode *inode;
2011 };
2012
2013 void btrfs_add_delayed_iput(struct inode *inode)
2014 {
2015         struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
2016         struct delayed_iput *delayed;
2017
2018         if (atomic_add_unless(&inode->i_count, -1, 1))
2019                 return;
2020
2021         delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
2022         delayed->inode = inode;
2023
2024         spin_lock(&fs_info->delayed_iput_lock);
2025         list_add_tail(&delayed->list, &fs_info->delayed_iputs);
2026         spin_unlock(&fs_info->delayed_iput_lock);
2027 }
2028
2029 void btrfs_run_delayed_iputs(struct btrfs_root *root)
2030 {
2031         LIST_HEAD(list);
2032         struct btrfs_fs_info *fs_info = root->fs_info;
2033         struct delayed_iput *delayed;
2034         int empty;
2035
2036         spin_lock(&fs_info->delayed_iput_lock);
2037         empty = list_empty(&fs_info->delayed_iputs);
2038         spin_unlock(&fs_info->delayed_iput_lock);
2039         if (empty)
2040                 return;
2041
2042         down_read(&root->fs_info->cleanup_work_sem);
2043         spin_lock(&fs_info->delayed_iput_lock);
2044         list_splice_init(&fs_info->delayed_iputs, &list);
2045         spin_unlock(&fs_info->delayed_iput_lock);
2046
2047         while (!list_empty(&list)) {
2048                 delayed = list_entry(list.next, struct delayed_iput, list);
2049                 list_del(&delayed->list);
2050                 iput(delayed->inode);
2051                 kfree(delayed);
2052         }
2053         up_read(&root->fs_info->cleanup_work_sem);
2054 }
2055
2056 /*
2057  * calculate extra metadata reservation when snapshotting a subvolume
2058  * contains orphan files.
2059  */
2060 void btrfs_orphan_pre_snapshot(struct btrfs_trans_handle *trans,
2061                                 struct btrfs_pending_snapshot *pending,
2062                                 u64 *bytes_to_reserve)
2063 {
2064         struct btrfs_root *root;
2065         struct btrfs_block_rsv *block_rsv;
2066         u64 num_bytes;
2067         int index;
2068
2069         root = pending->root;
2070         if (!root->orphan_block_rsv || list_empty(&root->orphan_list))
2071                 return;
2072
2073         block_rsv = root->orphan_block_rsv;
2074
2075         /* orphan block reservation for the snapshot */
2076         num_bytes = block_rsv->size;
2077
2078         /*
2079          * after the snapshot is created, COWing tree blocks may use more
2080          * space than it frees. So we should make sure there is enough
2081          * reserved space.
2082          */
2083         index = trans->transid & 0x1;
2084         if (block_rsv->reserved + block_rsv->freed[index] < block_rsv->size) {
2085                 num_bytes += block_rsv->size -
2086                              (block_rsv->reserved + block_rsv->freed[index]);
2087         }
2088
2089         *bytes_to_reserve += num_bytes;
2090 }
2091
2092 void btrfs_orphan_post_snapshot(struct btrfs_trans_handle *trans,
2093                                 struct btrfs_pending_snapshot *pending)
2094 {
2095         struct btrfs_root *root = pending->root;
2096         struct btrfs_root *snap = pending->snap;
2097         struct btrfs_block_rsv *block_rsv;
2098         u64 num_bytes;
2099         int index;
2100         int ret;
2101
2102         if (!root->orphan_block_rsv || list_empty(&root->orphan_list))
2103                 return;
2104
2105         /* refill source subvolume's orphan block reservation */
2106         block_rsv = root->orphan_block_rsv;
2107         index = trans->transid & 0x1;
2108         if (block_rsv->reserved + block_rsv->freed[index] < block_rsv->size) {
2109                 num_bytes = block_rsv->size -
2110                             (block_rsv->reserved + block_rsv->freed[index]);
2111                 ret = btrfs_block_rsv_migrate(&pending->block_rsv,
2112                                               root->orphan_block_rsv,
2113                                               num_bytes);
2114                 BUG_ON(ret);
2115         }
2116
2117         /* setup orphan block reservation for the snapshot */
2118         block_rsv = btrfs_alloc_block_rsv(snap);
2119         BUG_ON(!block_rsv);
2120
2121         btrfs_add_durable_block_rsv(root->fs_info, block_rsv);
2122         snap->orphan_block_rsv = block_rsv;
2123
2124         num_bytes = root->orphan_block_rsv->size;
2125         ret = btrfs_block_rsv_migrate(&pending->block_rsv,
2126                                       block_rsv, num_bytes);
2127         BUG_ON(ret);
2128
2129 #if 0
2130         /* insert orphan item for the snapshot */
2131         WARN_ON(!root->orphan_item_inserted);
2132         ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
2133                                        snap->root_key.objectid);
2134         BUG_ON(ret);
2135         snap->orphan_item_inserted = 1;
2136 #endif
2137 }
2138
2139 enum btrfs_orphan_cleanup_state {
2140         ORPHAN_CLEANUP_STARTED  = 1,
2141         ORPHAN_CLEANUP_DONE     = 2,
2142 };
2143
2144 /*
2145  * This is called in transaction commmit time. If there are no orphan
2146  * files in the subvolume, it removes orphan item and frees block_rsv
2147  * structure.
2148  */
2149 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
2150                               struct btrfs_root *root)
2151 {
2152         int ret;
2153
2154         if (!list_empty(&root->orphan_list) ||
2155             root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
2156                 return;
2157
2158         if (root->orphan_item_inserted &&
2159             btrfs_root_refs(&root->root_item) > 0) {
2160                 ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
2161                                             root->root_key.objectid);
2162                 BUG_ON(ret);
2163                 root->orphan_item_inserted = 0;
2164         }
2165
2166         if (root->orphan_block_rsv) {
2167                 WARN_ON(root->orphan_block_rsv->size > 0);
2168                 btrfs_free_block_rsv(root, root->orphan_block_rsv);
2169                 root->orphan_block_rsv = NULL;
2170         }
2171 }
2172
2173 /*
2174  * This creates an orphan entry for the given inode in case something goes
2175  * wrong in the middle of an unlink/truncate.
2176  *
2177  * NOTE: caller of this function should reserve 5 units of metadata for
2178  *       this function.
2179  */
2180 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
2181 {
2182         struct btrfs_root *root = BTRFS_I(inode)->root;
2183         struct btrfs_block_rsv *block_rsv = NULL;
2184         int reserve = 0;
2185         int insert = 0;
2186         int ret;
2187
2188         if (!root->orphan_block_rsv) {
2189                 block_rsv = btrfs_alloc_block_rsv(root);
2190                 BUG_ON(!block_rsv);
2191         }
2192
2193         spin_lock(&root->orphan_lock);
2194         if (!root->orphan_block_rsv) {
2195                 root->orphan_block_rsv = block_rsv;
2196         } else if (block_rsv) {
2197                 btrfs_free_block_rsv(root, block_rsv);
2198                 block_rsv = NULL;
2199         }
2200
2201         if (list_empty(&BTRFS_I(inode)->i_orphan)) {
2202                 list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
2203 #if 0
2204                 /*
2205                  * For proper ENOSPC handling, we should do orphan
2206                  * cleanup when mounting. But this introduces backward
2207                  * compatibility issue.
2208                  */
2209                 if (!xchg(&root->orphan_item_inserted, 1))
2210                         insert = 2;
2211                 else
2212                         insert = 1;
2213 #endif
2214                 insert = 1;
2215         } else {
2216                 WARN_ON(!BTRFS_I(inode)->orphan_meta_reserved);
2217         }
2218
2219         if (!BTRFS_I(inode)->orphan_meta_reserved) {
2220                 BTRFS_I(inode)->orphan_meta_reserved = 1;
2221                 reserve = 1;
2222         }
2223         spin_unlock(&root->orphan_lock);
2224
2225         if (block_rsv)
2226                 btrfs_add_durable_block_rsv(root->fs_info, block_rsv);
2227
2228         /* grab metadata reservation from transaction handle */
2229         if (reserve) {
2230                 ret = btrfs_orphan_reserve_metadata(trans, inode);
2231                 BUG_ON(ret);
2232         }
2233
2234         /* insert an orphan item to track this unlinked/truncated file */
2235         if (insert >= 1) {
2236                 ret = btrfs_insert_orphan_item(trans, root, inode->i_ino);
2237                 BUG_ON(ret);
2238         }
2239
2240         /* insert an orphan item to track subvolume contains orphan files */
2241         if (insert >= 2) {
2242                 ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
2243                                                root->root_key.objectid);
2244                 BUG_ON(ret);
2245         }
2246         return 0;
2247 }
2248
2249 /*
2250  * We have done the truncate/delete so we can go ahead and remove the orphan
2251  * item for this particular inode.
2252  */
2253 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
2254 {
2255         struct btrfs_root *root = BTRFS_I(inode)->root;
2256         int delete_item = 0;
2257         int release_rsv = 0;
2258         int ret = 0;
2259
2260         spin_lock(&root->orphan_lock);
2261         if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
2262                 list_del_init(&BTRFS_I(inode)->i_orphan);
2263                 delete_item = 1;
2264         }
2265
2266         if (BTRFS_I(inode)->orphan_meta_reserved) {
2267                 BTRFS_I(inode)->orphan_meta_reserved = 0;
2268                 release_rsv = 1;
2269         }
2270         spin_unlock(&root->orphan_lock);
2271
2272         if (trans && delete_item) {
2273                 ret = btrfs_del_orphan_item(trans, root, inode->i_ino);
2274                 BUG_ON(ret);
2275         }
2276
2277         if (release_rsv)
2278                 btrfs_orphan_release_metadata(inode);
2279
2280         return 0;
2281 }
2282
2283 /*
2284  * this cleans up any orphans that may be left on the list from the last use
2285  * of this root.
2286  */
2287 int btrfs_orphan_cleanup(struct btrfs_root *root)
2288 {
2289         struct btrfs_path *path;
2290         struct extent_buffer *leaf;
2291         struct btrfs_key key, found_key;
2292         struct btrfs_trans_handle *trans;
2293         struct inode *inode;
2294         int ret = 0, nr_unlink = 0, nr_truncate = 0;
2295
2296         if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
2297                 return 0;
2298
2299         path = btrfs_alloc_path();
2300         if (!path) {
2301                 ret = -ENOMEM;
2302                 goto out;
2303         }
2304         path->reada = -1;
2305
2306         key.objectid = BTRFS_ORPHAN_OBJECTID;
2307         btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
2308         key.offset = (u64)-1;
2309
2310         while (1) {
2311                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2312                 if (ret < 0)
2313                         goto out;
2314
2315                 /*
2316                  * if ret == 0 means we found what we were searching for, which
2317                  * is weird, but possible, so only screw with path if we didnt
2318                  * find the key and see if we have stuff that matches
2319                  */
2320                 if (ret > 0) {
2321                         ret = 0;
2322                         if (path->slots[0] == 0)
2323                                 break;
2324                         path->slots[0]--;
2325                 }
2326
2327                 /* pull out the item */
2328                 leaf = path->nodes[0];
2329                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2330
2331                 /* make sure the item matches what we want */
2332                 if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
2333                         break;
2334                 if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
2335                         break;
2336
2337                 /* release the path since we're done with it */
2338                 btrfs_release_path(root, path);
2339
2340                 /*
2341                  * this is where we are basically btrfs_lookup, without the
2342                  * crossing root thing.  we store the inode number in the
2343                  * offset of the orphan item.
2344                  */
2345                 found_key.objectid = found_key.offset;
2346                 found_key.type = BTRFS_INODE_ITEM_KEY;
2347                 found_key.offset = 0;
2348                 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
2349                 if (IS_ERR(inode)) {
2350                         ret = PTR_ERR(inode);
2351                         goto out;
2352                 }
2353
2354                 /*
2355                  * add this inode to the orphan list so btrfs_orphan_del does
2356                  * the proper thing when we hit it
2357                  */
2358                 spin_lock(&root->orphan_lock);
2359                 list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
2360                 spin_unlock(&root->orphan_lock);
2361
2362                 /*
2363                  * if this is a bad inode, means we actually succeeded in
2364                  * removing the inode, but not the orphan record, which means
2365                  * we need to manually delete the orphan since iput will just
2366                  * do a destroy_inode
2367                  */
2368                 if (is_bad_inode(inode)) {
2369                         trans = btrfs_start_transaction(root, 0);
2370                         if (IS_ERR(trans)) {
2371                                 ret = PTR_ERR(trans);
2372                                 goto out;
2373                         }
2374                         btrfs_orphan_del(trans, inode);
2375                         btrfs_end_transaction(trans, root);
2376                         iput(inode);
2377                         continue;
2378                 }
2379
2380                 /* if we have links, this was a truncate, lets do that */
2381                 if (inode->i_nlink) {
2382                         if (!S_ISREG(inode->i_mode)) {
2383                                 WARN_ON(1);
2384                                 iput(inode);
2385                                 continue;
2386                         }
2387                         nr_truncate++;
2388                         ret = btrfs_truncate(inode);
2389                 } else {
2390                         nr_unlink++;
2391                 }
2392
2393                 /* this will do delete_inode and everything for us */
2394                 iput(inode);
2395                 if (ret)
2396                         goto out;
2397         }
2398         root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
2399
2400         if (root->orphan_block_rsv)
2401                 btrfs_block_rsv_release(root, root->orphan_block_rsv,
2402                                         (u64)-1);
2403
2404         if (root->orphan_block_rsv || root->orphan_item_inserted) {
2405                 trans = btrfs_join_transaction(root, 1);
2406                 if (!IS_ERR(trans))
2407                         btrfs_end_transaction(trans, root);
2408         }
2409
2410         if (nr_unlink)
2411                 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
2412         if (nr_truncate)
2413                 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
2414
2415 out:
2416         if (ret)
2417                 printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
2418         btrfs_free_path(path);
2419         return ret;
2420 }
2421
2422 /*
2423  * very simple check to peek ahead in the leaf looking for xattrs.  If we
2424  * don't find any xattrs, we know there can't be any acls.
2425  *
2426  * slot is the slot the inode is in, objectid is the objectid of the inode
2427  */
2428 static noinline int acls_after_inode_item(struct extent_buffer *leaf,
2429                                           int slot, u64 objectid)
2430 {
2431         u32 nritems = btrfs_header_nritems(leaf);
2432         struct btrfs_key found_key;
2433         int scanned = 0;
2434
2435         slot++;
2436         while (slot < nritems) {
2437                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
2438
2439                 /* we found a different objectid, there must not be acls */
2440                 if (found_key.objectid != objectid)
2441                         return 0;
2442
2443                 /* we found an xattr, assume we've got an acl */
2444                 if (found_key.type == BTRFS_XATTR_ITEM_KEY)
2445                         return 1;
2446
2447                 /*
2448                  * we found a key greater than an xattr key, there can't
2449                  * be any acls later on
2450                  */
2451                 if (found_key.type > BTRFS_XATTR_ITEM_KEY)
2452                         return 0;
2453
2454                 slot++;
2455                 scanned++;
2456
2457                 /*
2458                  * it goes inode, inode backrefs, xattrs, extents,
2459                  * so if there are a ton of hard links to an inode there can
2460                  * be a lot of backrefs.  Don't waste time searching too hard,
2461                  * this is just an optimization
2462                  */
2463                 if (scanned >= 8)
2464                         break;
2465         }
2466         /* we hit the end of the leaf before we found an xattr or
2467          * something larger than an xattr.  We have to assume the inode
2468          * has acls
2469          */
2470         return 1;
2471 }
2472
2473 /*
2474  * read an inode from the btree into the in-memory inode
2475  */
2476 static void btrfs_read_locked_inode(struct inode *inode)
2477 {
2478         struct btrfs_path *path;
2479         struct extent_buffer *leaf;
2480         struct btrfs_inode_item *inode_item;
2481         struct btrfs_timespec *tspec;
2482         struct btrfs_root *root = BTRFS_I(inode)->root;
2483         struct btrfs_key location;
2484         int maybe_acls;
2485         u64 alloc_group_block;
2486         u32 rdev;
2487         int ret;
2488
2489         path = btrfs_alloc_path();
2490         BUG_ON(!path);
2491         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
2492
2493         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2494         if (ret)
2495                 goto make_bad;
2496
2497         leaf = path->nodes[0];
2498         inode_item = btrfs_item_ptr(leaf, path->slots[0],
2499                                     struct btrfs_inode_item);
2500
2501         inode->i_mode = btrfs_inode_mode(leaf, inode_item);
2502         inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
2503         inode->i_uid = btrfs_inode_uid(leaf, inode_item);
2504         inode->i_gid = btrfs_inode_gid(leaf, inode_item);
2505         btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2506
2507         tspec = btrfs_inode_atime(inode_item);
2508         inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2509         inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2510
2511         tspec = btrfs_inode_mtime(inode_item);
2512         inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2513         inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2514
2515         tspec = btrfs_inode_ctime(inode_item);
2516         inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2517         inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2518
2519         inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2520         BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2521         BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2522         inode->i_generation = BTRFS_I(inode)->generation;
2523         inode->i_rdev = 0;
2524         rdev = btrfs_inode_rdev(leaf, inode_item);
2525
2526         BTRFS_I(inode)->index_cnt = (u64)-1;
2527         BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2528
2529         alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
2530
2531         /*
2532          * try to precache a NULL acl entry for files that don't have
2533          * any xattrs or acls
2534          */
2535         maybe_acls = acls_after_inode_item(leaf, path->slots[0], inode->i_ino);
2536         if (!maybe_acls)
2537                 cache_no_acl(inode);
2538
2539         BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
2540                                                 alloc_group_block, 0);
2541         btrfs_free_path(path);
2542         inode_item = NULL;
2543
2544         switch (inode->i_mode & S_IFMT) {
2545         case S_IFREG:
2546                 inode->i_mapping->a_ops = &btrfs_aops;
2547                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2548                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
2549                 inode->i_fop = &btrfs_file_operations;
2550                 inode->i_op = &btrfs_file_inode_operations;
2551                 break;
2552         case S_IFDIR:
2553                 inode->i_fop = &btrfs_dir_file_operations;
2554                 if (root == root->fs_info->tree_root)
2555                         inode->i_op = &btrfs_dir_ro_inode_operations;
2556                 else
2557                         inode->i_op = &btrfs_dir_inode_operations;
2558                 break;
2559         case S_IFLNK:
2560                 inode->i_op = &btrfs_symlink_inode_operations;
2561                 inode->i_mapping->a_ops = &btrfs_symlink_aops;
2562                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2563                 break;
2564         default:
2565                 inode->i_op = &btrfs_special_inode_operations;
2566                 init_special_inode(inode, inode->i_mode, rdev);
2567                 break;
2568         }
2569
2570         btrfs_update_iflags(inode);
2571         return;
2572
2573 make_bad:
2574         btrfs_free_path(path);
2575         make_bad_inode(inode);
2576 }
2577
2578 /*
2579  * given a leaf and an inode, copy the inode fields into the leaf
2580  */
2581 static void fill_inode_item(struct btrfs_trans_handle *trans,
2582                             struct extent_buffer *leaf,
2583                             struct btrfs_inode_item *item,
2584                             struct inode *inode)
2585 {
2586         btrfs_set_inode_uid(leaf, item, inode->i_uid);
2587         btrfs_set_inode_gid(leaf, item, inode->i_gid);
2588         btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2589         btrfs_set_inode_mode(leaf, item, inode->i_mode);
2590         btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
2591
2592         btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
2593                                inode->i_atime.tv_sec);
2594         btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
2595                                 inode->i_atime.tv_nsec);
2596
2597         btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
2598                                inode->i_mtime.tv_sec);
2599         btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
2600                                 inode->i_mtime.tv_nsec);
2601
2602         btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
2603                                inode->i_ctime.tv_sec);
2604         btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
2605                                 inode->i_ctime.tv_nsec);
2606
2607         btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2608         btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2609         btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2610         btrfs_set_inode_transid(leaf, item, trans->transid);
2611         btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
2612         btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2613         btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
2614 }
2615
2616 /*
2617  * copy everything in the in-memory inode into the btree.
2618  */
2619 noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
2620                                 struct btrfs_root *root, struct inode *inode)
2621 {
2622         struct btrfs_inode_item *inode_item;
2623         struct btrfs_path *path;
2624         struct extent_buffer *leaf;
2625         int ret;
2626
2627         path = btrfs_alloc_path();
2628         BUG_ON(!path);
2629         path->leave_spinning = 1;
2630         ret = btrfs_lookup_inode(trans, root, path,
2631                                  &BTRFS_I(inode)->location, 1);
2632         if (ret) {
2633                 if (ret > 0)
2634                         ret = -ENOENT;
2635                 goto failed;
2636         }
2637
2638         btrfs_unlock_up_safe(path, 1);
2639         leaf = path->nodes[0];
2640         inode_item = btrfs_item_ptr(leaf, path->slots[0],
2641                                   struct btrfs_inode_item);
2642
2643         fill_inode_item(trans, leaf, inode_item, inode);
2644         btrfs_mark_buffer_dirty(leaf);
2645         btrfs_set_inode_last_trans(trans, inode);
2646         ret = 0;
2647 failed:
2648         btrfs_free_path(path);
2649         return ret;
2650 }
2651
2652
2653 /*
2654  * unlink helper that gets used here in inode.c and in the tree logging
2655  * recovery code.  It remove a link in a directory with a given name, and
2656  * also drops the back refs in the inode to the directory
2657  */
2658 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2659                        struct btrfs_root *root,
2660                        struct inode *dir, struct inode *inode,
2661                        const char *name, int name_len)
2662 {
2663         struct btrfs_path *path;
2664         int ret = 0;
2665         struct extent_buffer *leaf;
2666         struct btrfs_dir_item *di;
2667         struct btrfs_key key;
2668         u64 index;
2669
2670         path = btrfs_alloc_path();
2671         if (!path) {
2672                 ret = -ENOMEM;
2673                 goto out;
2674         }
2675
2676         path->leave_spinning = 1;
2677         di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
2678                                     name, name_len, -1);
2679         if (IS_ERR(di)) {
2680                 ret = PTR_ERR(di);
2681                 goto err;
2682         }
2683         if (!di) {
2684                 ret = -ENOENT;
2685                 goto err;
2686         }
2687         leaf = path->nodes[0];
2688         btrfs_dir_item_key_to_cpu(leaf, di, &key);
2689         ret = btrfs_delete_one_dir_name(trans, root, path, di);
2690         if (ret)
2691                 goto err;
2692         btrfs_release_path(root, path);
2693
2694         ret = btrfs_del_inode_ref(trans, root, name, name_len,
2695                                   inode->i_ino,
2696                                   dir->i_ino, &index);
2697         if (ret) {
2698                 printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2699                        "inode %lu parent %lu\n", name_len, name,
2700                        inode->i_ino, dir->i_ino);
2701                 goto err;
2702         }
2703
2704         di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
2705                                          index, name, name_len, -1);
2706         if (IS_ERR(di)) {
2707                 ret = PTR_ERR(di);
2708                 goto err;
2709         }
2710         if (!di) {
2711                 ret = -ENOENT;
2712                 goto err;
2713         }
2714         ret = btrfs_delete_one_dir_name(trans, root, path, di);
2715         btrfs_release_path(root, path);
2716
2717         ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
2718                                          inode, dir->i_ino);
2719         BUG_ON(ret != 0 && ret != -ENOENT);
2720
2721         ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
2722                                            dir, index);
2723         if (ret == -ENOENT)
2724                 ret = 0;
2725 err:
2726         btrfs_free_path(path);
2727         if (ret)
2728                 goto out;
2729
2730         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
2731         inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
2732         btrfs_update_inode(trans, root, dir);
2733         btrfs_drop_nlink(inode);
2734         ret = btrfs_update_inode(trans, root, inode);
2735 out:
2736         return ret;
2737 }
2738
2739 /* helper to check if there is any shared block in the path */
2740 static int check_path_shared(struct btrfs_root *root,
2741                              struct btrfs_path *path)
2742 {
2743         struct extent_buffer *eb;
2744         int level;
2745         u64 refs = 1;
2746
2747         for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2748                 int ret;
2749
2750                 if (!path->nodes[level])
2751                         break;
2752                 eb = path->nodes[level];
2753                 if (!btrfs_block_can_be_shared(root, eb))
2754                         continue;
2755                 ret = btrfs_lookup_extent_info(NULL, root, eb->start, eb->len,
2756                                                &refs, NULL);
2757                 if (refs > 1)
2758                         return 1;
2759         }
2760         return 0;
2761 }
2762
2763 /*
2764  * helper to start transaction for unlink and rmdir.
2765  *
2766  * unlink and rmdir are special in btrfs, they do not always free space.
2767  * so in enospc case, we should make sure they will free space before
2768  * allowing them to use the global metadata reservation.
2769  */
2770 static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
2771                                                        struct dentry *dentry)
2772 {
2773         struct btrfs_trans_handle *trans;
2774         struct btrfs_root *root = BTRFS_I(dir)->root;
2775         struct btrfs_path *path;
2776         struct btrfs_inode_ref *ref;
2777         struct btrfs_dir_item *di;
2778         struct inode *inode = dentry->d_inode;
2779         u64 index;
2780         int check_link = 1;
2781         int err = -ENOSPC;
2782         int ret;
2783
2784         trans = btrfs_start_transaction(root, 10);
2785         if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
2786                 return trans;
2787
2788         if (inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
2789                 return ERR_PTR(-ENOSPC);
2790
2791         /* check if there is someone else holds reference */
2792         if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
2793                 return ERR_PTR(-ENOSPC);
2794
2795         if (atomic_read(&inode->i_count) > 2)
2796                 return ERR_PTR(-ENOSPC);
2797
2798         if (xchg(&root->fs_info->enospc_unlink, 1))
2799                 return ERR_PTR(-ENOSPC);
2800
2801         path = btrfs_alloc_path();
2802         if (!path) {
2803                 root->fs_info->enospc_unlink = 0;
2804                 return ERR_PTR(-ENOMEM);
2805         }
2806
2807         trans = btrfs_start_transaction(root, 0);
2808         if (IS_ERR(trans)) {
2809                 btrfs_free_path(path);
2810                 root->fs_info->enospc_unlink = 0;
2811                 return trans;
2812         }
2813
2814         path->skip_locking = 1;
2815         path->search_commit_root = 1;
2816
2817         ret = btrfs_lookup_inode(trans, root, path,
2818                                 &BTRFS_I(dir)->location, 0);
2819         if (ret < 0) {
2820                 err = ret;
2821                 goto out;
2822         }
2823         if (ret == 0) {
2824                 if (check_path_shared(root, path))
2825                         goto out;
2826         } else {
2827                 check_link = 0;
2828         }
2829         btrfs_release_path(root, path);
2830
2831         ret = btrfs_lookup_inode(trans, root, path,
2832                                 &BTRFS_I(inode)->location, 0);
2833         if (ret < 0) {
2834                 err = ret;
2835                 goto out;
2836         }
2837         if (ret == 0) {
2838                 if (check_path_shared(root, path))
2839                         goto out;
2840         } else {
2841                 check_link = 0;
2842         }
2843         btrfs_release_path(root, path);
2844
2845         if (ret == 0 && S_ISREG(inode->i_mode)) {
2846                 ret = btrfs_lookup_file_extent(trans, root, path,
2847                                                inode->i_ino, (u64)-1, 0);
2848                 if (ret < 0) {
2849                         err = ret;
2850                         goto out;
2851                 }
2852                 BUG_ON(ret == 0);
2853                 if (check_path_shared(root, path))
2854                         goto out;
2855                 btrfs_release_path(root, path);
2856         }
2857
2858         if (!check_link) {
2859                 err = 0;
2860                 goto out;
2861         }
2862
2863         di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
2864                                 dentry->d_name.name, dentry->d_name.len, 0);
2865         if (IS_ERR(di)) {
2866                 err = PTR_ERR(di);
2867                 goto out;
2868         }
2869         if (di) {
2870                 if (check_path_shared(root, path))
2871                         goto out;
2872         } else {
2873                 err = 0;
2874                 goto out;
2875         }
2876         btrfs_release_path(root, path);
2877
2878         ref = btrfs_lookup_inode_ref(trans, root, path,
2879                                 dentry->d_name.name, dentry->d_name.len,
2880                                 inode->i_ino, dir->i_ino, 0);
2881         if (IS_ERR(ref)) {
2882                 err = PTR_ERR(ref);
2883                 goto out;
2884         }
2885         BUG_ON(!ref);
2886         if (check_path_shared(root, path))
2887                 goto out;
2888         index = btrfs_inode_ref_index(path->nodes[0], ref);
2889         btrfs_release_path(root, path);
2890
2891         di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino, index,
2892                                 dentry->d_name.name, dentry->d_name.len, 0);
2893         if (IS_ERR(di)) {
2894                 err = PTR_ERR(di);
2895                 goto out;
2896         }
2897         BUG_ON(ret == -ENOENT);
2898         if (check_path_shared(root, path))
2899                 goto out;
2900
2901         err = 0;
2902 out:
2903         btrfs_free_path(path);
2904         if (err) {
2905                 btrfs_end_transaction(trans, root);
2906                 root->fs_info->enospc_unlink = 0;
2907                 return ERR_PTR(err);
2908         }
2909
2910         trans->block_rsv = &root->fs_info->global_block_rsv;
2911         return trans;
2912 }
2913
2914 static void __unlink_end_trans(struct btrfs_trans_handle *trans,
2915                                struct btrfs_root *root)
2916 {
2917         if (trans->block_rsv == &root->fs_info->global_block_rsv) {
2918                 BUG_ON(!root->fs_info->enospc_unlink);
2919                 root->fs_info->enospc_unlink = 0;
2920         }
2921         btrfs_end_transaction_throttle(trans, root);
2922 }
2923
2924 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
2925 {
2926         struct btrfs_root *root = BTRFS_I(dir)->root;
2927         struct btrfs_trans_handle *trans;
2928         struct inode *inode = dentry->d_inode;
2929         int ret;
2930         unsigned long nr = 0;
2931
2932         trans = __unlink_start_trans(dir, dentry);
2933         if (IS_ERR(trans))
2934                 return PTR_ERR(trans);
2935
2936         btrfs_set_trans_block_group(trans, dir);
2937
2938         btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
2939
2940         ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
2941                                  dentry->d_name.name, dentry->d_name.len);
2942         BUG_ON(ret);
2943
2944         if (inode->i_nlink == 0) {
2945                 ret = btrfs_orphan_add(trans, inode);
2946                 BUG_ON(ret);
2947         }
2948
2949         nr = trans->blocks_used;
2950         __unlink_end_trans(trans, root);
2951         btrfs_btree_balance_dirty(root, nr);
2952         return ret;
2953 }
2954
2955 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
2956                         struct btrfs_root *root,
2957                         struct inode *dir, u64 objectid,
2958                         const char *name, int name_len)
2959 {
2960         struct btrfs_path *path;
2961         struct extent_buffer *leaf;
2962         struct btrfs_dir_item *di;
2963         struct btrfs_key key;
2964         u64 index;
2965         int ret;
2966
2967         path = btrfs_alloc_path();
2968         if (!path)
2969                 return -ENOMEM;
2970
2971         di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
2972                                    name, name_len, -1);
2973         BUG_ON(!di || IS_ERR(di));
2974
2975         leaf = path->nodes[0];
2976         btrfs_dir_item_key_to_cpu(leaf, di, &key);
2977         WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
2978         ret = btrfs_delete_one_dir_name(trans, root, path, di);
2979         BUG_ON(ret);
2980         btrfs_release_path(root, path);
2981
2982         ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
2983                                  objectid, root->root_key.objectid,
2984                                  dir->i_ino, &index, name, name_len);
2985         if (ret < 0) {
2986                 BUG_ON(ret != -ENOENT);
2987                 di = btrfs_search_dir_index_item(root, path, dir->i_ino,
2988                                                  name, name_len);
2989                 BUG_ON(!di || IS_ERR(di));
2990
2991                 leaf = path->nodes[0];
2992                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2993                 btrfs_release_path(root, path);
2994                 index = key.offset;
2995         }
2996
2997         di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
2998                                          index, name, name_len, -1);
2999         BUG_ON(!di || IS_ERR(di));
3000
3001         leaf = path->nodes[0];
3002         btrfs_dir_item_key_to_cpu(leaf, di, &key);
3003         WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
3004         ret = btrfs_delete_one_dir_name(trans, root, path, di);
3005         BUG_ON(ret);
3006         btrfs_release_path(root, path);
3007
3008         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3009         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3010         ret = btrfs_update_inode(trans, root, dir);
3011         BUG_ON(ret);
3012
3013         btrfs_free_path(path);
3014         return 0;
3015 }
3016
3017 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
3018 {
3019         struct inode *inode = dentry->d_inode;
3020         int err = 0;
3021         struct btrfs_root *root = BTRFS_I(dir)->root;
3022         struct btrfs_trans_handle *trans;
3023         unsigned long nr = 0;
3024
3025         if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
3026             inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
3027                 return -ENOTEMPTY;
3028
3029         trans = __unlink_start_trans(dir, dentry);
3030         if (IS_ERR(trans))
3031                 return PTR_ERR(trans);
3032
3033         btrfs_set_trans_block_group(trans, dir);
3034
3035         if (unlikely(inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
3036                 err = btrfs_unlink_subvol(trans, root, dir,
3037                                           BTRFS_I(inode)->location.objectid,
3038                                           dentry->d_name.name,
3039                                           dentry->d_name.len);
3040                 goto out;
3041         }
3042
3043         err = btrfs_orphan_add(trans, inode);
3044         if (err)
3045                 goto out;
3046
3047         /* now the directory is empty */
3048         err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
3049                                  dentry->d_name.name, dentry->d_name.len);
3050         if (!err)
3051                 btrfs_i_size_write(inode, 0);
3052 out:
3053         nr = trans->blocks_used;
3054         __unlink_end_trans(trans, root);
3055         btrfs_btree_balance_dirty(root, nr);
3056
3057         return err;
3058 }
3059
3060 #if 0
3061 /*
3062  * when truncating bytes in a file, it is possible to avoid reading
3063  * the leaves that contain only checksum items.  This can be the
3064  * majority of the IO required to delete a large file, but it must
3065  * be done carefully.
3066  *
3067  * The keys in the level just above the leaves are checked to make sure
3068  * the lowest key in a given leaf is a csum key, and starts at an offset
3069  * after the new  size.
3070  *
3071  * Then the key for the next leaf is checked to make sure it also has
3072  * a checksum item for the same file.  If it does, we know our target leaf
3073  * contains only checksum items, and it can be safely freed without reading
3074  * it.
3075  *
3076  * This is just an optimization targeted at large files.  It may do
3077  * nothing.  It will return 0 unless things went badly.
3078  */
3079 static noinline int drop_csum_leaves(struct btrfs_trans_handle *trans,
3080                                      struct btrfs_root *root,
3081                                      struct btrfs_path *path,
3082                                      struct inode *inode, u64 new_size)
3083 {
3084         struct btrfs_key key;
3085         int ret;
3086         int nritems;
3087         struct btrfs_key found_key;
3088         struct btrfs_key other_key;
3089         struct btrfs_leaf_ref *ref;
3090         u64 leaf_gen;
3091         u64 leaf_start;
3092
3093         path->lowest_level = 1;
3094         key.objectid = inode->i_ino;
3095         key.type = BTRFS_CSUM_ITEM_KEY;
3096         key.offset = new_size;
3097 again:
3098         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3099         if (ret < 0)
3100                 goto out;
3101
3102         if (path->nodes[1] == NULL) {
3103                 ret = 0;
3104                 goto out;
3105         }
3106         ret = 0;
3107         btrfs_node_key_to_cpu(path->nodes[1], &found_key, path->slots[1]);
3108         nritems = btrfs_header_nritems(path->nodes[1]);
3109
3110         if (!nritems)
3111                 goto out;
3112
3113         if (path->slots[1] >= nritems)
3114                 goto next_node;
3115
3116         /* did we find a key greater than anything we want to delete? */
3117         if (found_key.objectid > inode->i_ino ||
3118            (found_key.objectid == inode->i_ino && found_key.type > key.type))
3119                 goto out;
3120
3121         /* we check the next key in the node to make sure the leave contains
3122          * only checksum items.  This comparison doesn't work if our
3123          * leaf is the last one in the node
3124          */
3125         if (path->slots[1] + 1 >= nritems) {
3126 next_node:
3127                 /* search forward from the last key in the node, this
3128                  * will bring us into the next node in the tree
3129                  */
3130                 btrfs_node_key_to_cpu(path->nodes[1], &found_key, nritems - 1);
3131
3132                 /* unlikely, but we inc below, so check to be safe */
3133                 if (found_key.offset == (u64)-1)
3134                         goto out;
3135
3136                 /* search_forward needs a path with locks held, do the
3137                  * search again for the original key.  It is possible
3138                  * this will race with a balance and return a path that
3139                  * we could modify, but this drop is just an optimization
3140                  * and is allowed to miss some leaves.
3141                  */
3142                 btrfs_release_path(root, path);
3143                 found_key.offset++;
3144
3145                 /* setup a max key for search_forward */
3146                 other_key.offset = (u64)-1;
3147                 other_key.type = key.type;
3148                 other_key.objectid = key.objectid;
3149
3150                 path->keep_locks = 1;
3151                 ret = btrfs_search_forward(root, &found_key, &other_key,
3152                                            path, 0, 0);
3153                 path->keep_locks = 0;
3154                 if (ret || found_key.objectid != key.objectid ||
3155                     found_key.type != key.type) {
3156                         ret = 0;
3157                         goto out;
3158                 }
3159
3160                 key.offset = found_key.offset;
3161                 btrfs_release_path(root, path);
3162                 cond_resched();
3163                 goto again;
3164         }
3165
3166         /* we know there's one more slot after us in the tree,
3167          * read that key so we can verify it is also a checksum item
3168          */
3169         btrfs_node_key_to_cpu(path->nodes[1], &other_key, path->slots[1] + 1);
3170
3171         if (found_key.objectid < inode->i_ino)
3172                 goto next_key;
3173
3174         if (found_key.type != key.type || found_key.offset < new_size)
3175                 goto next_key;
3176
3177         /*
3178          * if the key for the next leaf isn't a csum key from this objectid,
3179          * we can't be sure there aren't good items inside this leaf.
3180          * Bail out
3181          */
3182         if (other_key.objectid != inode->i_ino || other_key.type != key.type)
3183                 goto out;
3184
3185         leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);
3186         leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);
3187         /*
3188          * it is safe to delete this leaf, it contains only
3189          * csum items from this inode at an offset >= new_size
3190          */
3191         ret = btrfs_del_leaf(trans, root, path, leaf_start);
3192         BUG_ON(ret);
3193
3194         if (root->ref_cows && leaf_gen < trans->transid) {
3195                 ref = btrfs_alloc_leaf_ref(root, 0);
3196                 if (ref) {
3197                         ref->root_gen = root->root_key.offset;
3198                         ref->bytenr = leaf_start;
3199                         ref->owner = 0;
3200                         ref->generation = leaf_gen;
3201                         ref->nritems = 0;
3202
3203                         btrfs_sort_leaf_ref(ref);
3204
3205                         ret = btrfs_add_leaf_ref(root, ref, 0);
3206                         WARN_ON(ret);
3207                         btrfs_free_leaf_ref(root, ref);
3208                 } else {
3209                         WARN_ON(1);
3210                 }
3211         }
3212 next_key:
3213         btrfs_release_path(root, path);
3214
3215         if (other_key.objectid == inode->i_ino &&
3216             other_key.type == key.type && other_key.offset > key.offset) {
3217                 key.offset = other_key.offset;
3218                 cond_resched();
3219                 goto again;
3220         }
3221         ret = 0;
3222 out:
3223         /* fixup any changes we've made to the path */
3224         path->lowest_level = 0;
3225         path->keep_locks = 0;
3226         btrfs_release_path(root, path);
3227         return ret;
3228 }
3229
3230 #endif
3231
3232 /*
3233  * this can truncate away extent items, csum items and directory items.
3234  * It starts at a high offset and removes keys until it can't find
3235  * any higher than new_size
3236  *
3237  * csum items that cross the new i_size are truncated to the new size
3238  * as well.
3239  *
3240  * min_type is the minimum key type to truncate down to.  If set to 0, this
3241  * will kill all the items on this inode, including the INODE_ITEM_KEY.
3242  */
3243 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3244                                struct btrfs_root *root,
3245                                struct inode *inode,
3246                                u64 new_size, u32 min_type)
3247 {
3248         struct btrfs_path *path;
3249         struct extent_buffer *leaf;
3250         struct btrfs_file_extent_item *fi;
3251         struct btrfs_key key;
3252         struct btrfs_key found_key;
3253         u64 extent_start = 0;
3254         u64 extent_num_bytes = 0;
3255         u64 extent_offset = 0;
3256         u64 item_end = 0;
3257         u64 mask = root->sectorsize - 1;
3258         u32 found_type = (u8)-1;
3259         int found_extent;
3260         int del_item;
3261         int pending_del_nr = 0;
3262         int pending_del_slot = 0;
3263         int extent_type = -1;
3264         int encoding;
3265         int ret;
3266         int err = 0;
3267
3268         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
3269
3270         if (root->ref_cows || root == root->fs_info->tree_root)
3271                 btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
3272
3273         path = btrfs_alloc_path();
3274         BUG_ON(!path);
3275         path->reada = -1;
3276
3277         key.objectid = inode->i_ino;
3278         key.offset = (u64)-1;
3279         key.type = (u8)-1;
3280
3281 search_again:
3282         path->leave_spinning = 1;
3283         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3284         if (ret < 0) {
3285                 err = ret;
3286                 goto out;
3287         }
3288
3289         if (ret > 0) {
3290                 /* there are no items in the tree for us to truncate, we're
3291                  * done
3292                  */
3293                 if (path->slots[0] == 0)
3294                         goto out;
3295                 path->slots[0]--;
3296         }
3297
3298         while (1) {
3299                 fi = NULL;
3300                 leaf = path->nodes[0];
3301                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
3302                 found_type = btrfs_key_type(&found_key);
3303                 encoding = 0;
3304
3305                 if (found_key.objectid != inode->i_ino)
3306                         break;
3307
3308                 if (found_type < min_type)
3309                         break;
3310
3311                 item_end = found_key.offset;
3312                 if (found_type == BTRFS_EXTENT_DATA_KEY) {
3313                         fi = btrfs_item_ptr(leaf, path->slots[0],
3314                                             struct btrfs_file_extent_item);
3315                         extent_type = btrfs_file_extent_type(leaf, fi);
3316                         encoding = btrfs_file_extent_compression(leaf, fi);
3317                         encoding |= btrfs_file_extent_encryption(leaf, fi);
3318                         encoding |= btrfs_file_extent_other_encoding(leaf, fi);
3319
3320                         if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3321                                 item_end +=
3322                                     btrfs_file_extent_num_bytes(leaf, fi);
3323                         } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3324                                 item_end += btrfs_file_extent_inline_len(leaf,
3325                                                                          fi);
3326                         }
3327                         item_end--;
3328                 }
3329                 if (found_type > min_type) {
3330                         del_item = 1;
3331                 } else {
3332                         if (item_end < new_size)
3333                                 break;
3334                         if (found_key.offset >= new_size)
3335                                 del_item = 1;
3336                         else
3337                                 del_item = 0;
3338                 }
3339                 found_extent = 0;
3340                 /* FIXME, shrink the extent if the ref count is only 1 */
3341                 if (found_type != BTRFS_EXTENT_DATA_KEY)
3342                         goto delete;
3343
3344                 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3345                         u64 num_dec;
3346                         extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
3347                         if (!del_item && !encoding) {
3348                                 u64 orig_num_bytes =
3349                                         btrfs_file_extent_num_bytes(leaf, fi);
3350                                 extent_num_bytes = new_size -
3351                                         found_key.offset + root->sectorsize - 1;
3352                                 extent_num_bytes = extent_num_bytes &
3353                                         ~((u64)root->sectorsize - 1);
3354                                 btrfs_set_file_extent_num_bytes(leaf, fi,
3355                                                          extent_num_bytes);
3356                                 num_dec = (orig_num_bytes -
3357                                            extent_num_bytes);
3358                                 if (root->ref_cows && extent_start != 0)
3359                                         inode_sub_bytes(inode, num_dec);
3360                                 btrfs_mark_buffer_dirty(leaf);
3361                         } else {
3362                                 extent_num_bytes =
3363                                         btrfs_file_extent_disk_num_bytes(leaf,
3364                                                                          fi);
3365                                 extent_offset = found_key.offset -
3366                                         btrfs_file_extent_offset(leaf, fi);
3367
3368                                 /* FIXME blocksize != 4096 */
3369                                 num_dec = btrfs_file_extent_num_bytes(leaf, fi);
3370                                 if (extent_start != 0) {
3371                                         found_extent = 1;
3372                                         if (root->ref_cows)
3373                                                 inode_sub_bytes(inode, num_dec);
3374                                 }
3375                         }
3376                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3377                         /*
3378                          * we can't truncate inline items that have had
3379                          * special encodings
3380                          */
3381                         if (!del_item &&
3382                             btrfs_file_extent_compression(leaf, fi) == 0 &&
3383                             btrfs_file_extent_encryption(leaf, fi) == 0 &&
3384                             btrfs_file_extent_other_encoding(leaf, fi) == 0) {
3385                                 u32 size = new_size - found_key.offset;
3386
3387                                 if (root->ref_cows) {
3388                                         inode_sub_bytes(inode, item_end + 1 -
3389                                                         new_size);
3390                                 }
3391                                 size =
3392                                     btrfs_file_extent_calc_inline_size(size);
3393                                 ret = btrfs_truncate_item(trans, root, path,
3394                                                           size, 1);
3395                                 BUG_ON(ret);
3396                         } else if (root->ref_cows) {
3397                                 inode_sub_bytes(inode, item_end + 1 -
3398                                                 found_key.offset);
3399                         }
3400                 }
3401 delete:
3402                 if (del_item) {
3403                         if (!pending_del_nr) {
3404                                 /* no pending yet, add ourselves */
3405                                 pending_del_slot = path->slots[0];
3406                                 pending_del_nr = 1;
3407                         } else if (pending_del_nr &&
3408                                    path->slots[0] + 1 == pending_del_slot) {
3409                                 /* hop on the pending chunk */
3410                                 pending_del_nr++;
3411                                 pending_del_slot = path->slots[0];
3412                         } else {
3413                                 BUG();
3414                         }
3415                 } else {
3416                         break;
3417                 }
3418                 if (found_extent && (root->ref_cows ||
3419                                      root == root->fs_info->tree_root)) {
3420                         btrfs_set_path_blocking(path);
3421                         ret = btrfs_free_extent(trans, root, extent_start,
3422                                                 extent_num_bytes, 0,
3423                                                 btrfs_header_owner(leaf),
3424                                                 inode->i_ino, extent_offset);
3425                         BUG_ON(ret);
3426                 }
3427
3428                 if (found_type == BTRFS_INODE_ITEM_KEY)
3429                         break;
3430
3431                 if (path->slots[0] == 0 ||
3432                     path->slots[0] != pending_del_slot) {
3433                         if (root->ref_cows) {
3434                                 err = -EAGAIN;
3435                                 goto out;
3436                         }
3437                         if (pending_del_nr) {
3438                                 ret = btrfs_del_items(trans, root, path,
3439                                                 pending_del_slot,
3440                                                 pending_del_nr);
3441                                 BUG_ON(ret);
3442                                 pending_del_nr = 0;
3443                         }
3444                         btrfs_release_path(root, path);
3445                         goto search_again;
3446                 } else {
3447                         path->slots[0]--;
3448                 }
3449         }
3450 out:
3451         if (pending_del_nr) {
3452                 ret = btrfs_del_items(trans, root, path, pending_del_slot,
3453                                       pending_del_nr);
3454                 BUG_ON(ret);
3455         }
3456         btrfs_free_path(path);
3457         return err;
3458 }
3459
3460 /*
3461  * taken from block_truncate_page, but does cow as it zeros out
3462  * any bytes left in the last page in the file.
3463  */
3464 static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
3465 {
3466         struct inode *inode = mapping->host;
3467         struct btrfs_root *root = BTRFS_I(inode)->root;
3468         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3469         struct btrfs_ordered_extent *ordered;
3470         struct extent_state *cached_state = NULL;
3471         char *kaddr;
3472         u32 blocksize = root->sectorsize;
3473         pgoff_t index = from >> PAGE_CACHE_SHIFT;
3474         unsigned offset = from & (PAGE_CACHE_SIZE-1);
3475         struct page *page;
3476         int ret = 0;
3477         u64 page_start;
3478         u64 page_end;
3479
3480         if ((offset & (blocksize - 1)) == 0)
3481                 goto out;
3482         ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
3483         if (ret)
3484                 goto out;
3485
3486         ret = -ENOMEM;
3487 again:
3488         page = grab_cache_page(mapping, index);
3489         if (!page) {
3490                 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
3491                 goto out;
3492         }
3493
3494         page_start = page_offset(page);
3495         page_end = page_start + PAGE_CACHE_SIZE - 1;
3496
3497         if (!PageUptodate(page)) {
3498                 ret = btrfs_readpage(NULL, page);
3499                 lock_page(page);
3500                 if (page->mapping != mapping) {
3501                         unlock_page(page);
3502                         page_cache_release(page);
3503                         goto again;
3504                 }
3505                 if (!PageUptodate(page)) {
3506                         ret = -EIO;
3507                         goto out_unlock;
3508                 }
3509         }
3510         wait_on_page_writeback(page);
3511
3512         lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state,
3513                          GFP_NOFS);
3514         set_page_extent_mapped(page);
3515
3516         ordered = btrfs_lookup_ordered_extent(inode, page_start);
3517         if (ordered) {
3518                 unlock_extent_cached(io_tree, page_start, page_end,
3519                                      &cached_state, GFP_NOFS);
3520                 unlock_page(page);
3521                 page_cache_release(page);
3522                 btrfs_start_ordered_extent(inode, ordered, 1);
3523                 btrfs_put_ordered_extent(ordered);
3524                 goto again;
3525         }
3526
3527         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
3528                           EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
3529                           0, 0, &cached_state, GFP_NOFS);
3530
3531         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
3532                                         &cached_state);
3533         if (ret) {
3534                 unlock_extent_cached(io_tree, page_start, page_end,
3535                                      &cached_state, GFP_NOFS);
3536                 goto out_unlock;
3537         }
3538
3539         ret = 0;
3540         if (offset != PAGE_CACHE_SIZE) {
3541                 kaddr = kmap(page);
3542                 memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
3543                 flush_dcache_page(page);
3544                 kunmap(page);
3545         }
3546         ClearPageChecked(page);
3547         set_page_dirty(page);
3548         unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
3549                              GFP_NOFS);
3550
3551 out_unlock:
3552         if (ret)
3553                 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
3554         unlock_page(page);
3555         page_cache_release(page);
3556 out:
3557         return ret;
3558 }
3559
3560 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
3561 {
3562         struct btrfs_trans_handle *trans;
3563         struct btrfs_root *root = BTRFS_I(inode)->root;
3564         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3565         struct extent_map *em = NULL;
3566         struct extent_state *cached_state = NULL;
3567         u64 mask = root->sectorsize - 1;
3568         u64 hole_start = (oldsize + mask) & ~mask;
3569         u64 block_end = (size + mask) & ~mask;
3570         u64 last_byte;
3571         u64 cur_offset;
3572         u64 hole_size;
3573         int err = 0;
3574
3575         if (size <= hole_start)
3576                 return 0;
3577
3578         while (1) {
3579                 struct btrfs_ordered_extent *ordered;
3580                 btrfs_wait_ordered_range(inode, hole_start,
3581                                          block_end - hole_start);
3582                 lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
3583                                  &cached_state, GFP_NOFS);
3584                 ordered = btrfs_lookup_ordered_extent(inode, hole_start);
3585                 if (!ordered)
3586                         break;
3587                 unlock_extent_cached(io_tree, hole_start, block_end - 1,
3588                                      &cached_state, GFP_NOFS);
3589                 btrfs_put_ordered_extent(ordered);
3590         }
3591
3592         cur_offset = hole_start;
3593         while (1) {
3594                 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
3595                                 block_end - cur_offset, 0);
3596                 BUG_ON(IS_ERR(em) || !em);
3597                 last_byte = min(extent_map_end(em), block_end);
3598                 last_byte = (last_byte + mask) & ~mask;
3599                 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
3600                         u64 hint_byte = 0;
3601                         hole_size = last_byte - cur_offset;
3602
3603                         trans = btrfs_start_transaction(root, 2);
3604                         if (IS_ERR(trans)) {
3605                                 err = PTR_ERR(trans);
3606                                 break;
3607                         }
3608                         btrfs_set_trans_block_group(trans, inode);
3609
3610                         err = btrfs_drop_extents(trans, inode, cur_offset,
3611                                                  cur_offset + hole_size,
3612                                                  &hint_byte, 1);
3613                         if (err)
3614                                 break;
3615
3616                         err = btrfs_insert_file_extent(trans, root,
3617                                         inode->i_ino, cur_offset, 0,
3618                                         0, hole_size, 0, hole_size,
3619                                         0, 0, 0);
3620                         if (err)
3621                                 break;
3622
3623                         btrfs_drop_extent_cache(inode, hole_start,
3624                                         last_byte - 1, 0);
3625
3626                         btrfs_end_transaction(trans, root);
3627                 }
3628                 free_extent_map(em);
3629                 em = NULL;
3630                 cur_offset = last_byte;
3631                 if (cur_offset >= block_end)
3632                         break;
3633         }
3634
3635         free_extent_map(em);
3636         unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
3637                              GFP_NOFS);
3638         return err;
3639 }
3640
3641 static int btrfs_setsize(struct inode *inode, loff_t newsize)
3642 {
3643         struct btrfs_root *root = BTRFS_I(inode)->root;
3644         struct btrfs_trans_handle *trans;
3645         loff_t oldsize = i_size_read(inode);
3646         unsigned long nr;
3647         int ret;
3648
3649         if (newsize == oldsize)
3650                 return 0;
3651
3652         trans = btrfs_start_transaction(root, 5);
3653         if (IS_ERR(trans))
3654                 return PTR_ERR(trans);
3655
3656         btrfs_set_trans_block_group(trans, inode);
3657
3658         ret = btrfs_orphan_add(trans, inode);
3659         if (ret) {
3660                 btrfs_end_transaction(trans, root);
3661                 return ret;
3662         }
3663
3664         nr = trans->blocks_used;
3665         btrfs_end_transaction(trans, root);
3666         btrfs_btree_balance_dirty(root, nr);
3667
3668         if (newsize > oldsize) {
3669                 i_size_write(inode, newsize);
3670                 btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
3671                 truncate_pagecache(inode, oldsize, newsize);
3672                 ret = btrfs_cont_expand(inode, oldsize, newsize);
3673                 if (ret) {
3674                         btrfs_setsize(inode, oldsize);
3675                         return ret;
3676                 }
3677
3678                 trans = btrfs_start_transaction(root, 0);
3679                 if (IS_ERR(trans))
3680                         return PTR_ERR(trans);
3681
3682                 btrfs_set_trans_block_group(trans, inode);
3683                 trans->block_rsv = root->orphan_block_rsv;
3684                 BUG_ON(!trans->block_rsv);
3685
3686                 /*
3687                  * If this fails just leave the orphan item so that it can get
3688                  * cleaned up next time we mount.
3689                  */
3690                 ret = btrfs_update_inode(trans, root, inode);
3691                 if (ret) {
3692                         btrfs_end_transaction(trans, root);
3693                         return ret;
3694                 }
3695                 if (inode->i_nlink > 0)
3696                         ret = btrfs_orphan_del(trans, inode);
3697                 nr = trans->blocks_used;
3698                 btrfs_end_transaction(trans, root);
3699                 btrfs_btree_balance_dirty(root, nr);
3700         } else {
3701
3702                 /*
3703                  * We're truncating a file that used to have good data down to
3704                  * zero. Make sure it gets into the ordered flush list so that
3705                  * any new writes get down to disk quickly.
3706                  */
3707                 if (newsize == 0)
3708                         BTRFS_I(inode)->ordered_data_close = 1;
3709
3710                 /* we don't support swapfiles, so vmtruncate shouldn't fail */
3711                 truncate_setsize(inode, newsize);
3712                 ret = btrfs_truncate(inode);
3713         }
3714
3715         return ret;
3716 }
3717
3718 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
3719 {
3720         struct inode *inode = dentry->d_inode;
3721         struct btrfs_root *root = BTRFS_I(inode)->root;
3722         int err;
3723
3724         if (btrfs_root_readonly(root))
3725                 return -EROFS;
3726
3727         err = inode_change_ok(inode, attr);
3728         if (err)
3729                 return err;
3730
3731         if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
3732                 err = btrfs_setsize(inode, attr->ia_size);
3733                 if (err)
3734                         return err;
3735         }
3736
3737         if (attr->ia_valid) {
3738                 setattr_copy(inode, attr);
3739                 mark_inode_dirty(inode);
3740
3741                 if (attr->ia_valid & ATTR_MODE)
3742                         err = btrfs_acl_chmod(inode);
3743         }
3744
3745         return err;
3746 }
3747
3748 void btrfs_evict_inode(struct inode *inode)
3749 {
3750         struct btrfs_trans_handle *trans;
3751         struct btrfs_root *root = BTRFS_I(inode)->root;
3752         unsigned long nr;
3753         int ret;
3754
3755         truncate_inode_pages(&inode->i_data, 0);
3756         if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
3757                                root == root->fs_info->tree_root))
3758                 goto no_delete;
3759
3760         if (is_bad_inode(inode)) {
3761                 btrfs_orphan_del(NULL, inode);
3762                 goto no_delete;
3763         }
3764         /* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
3765         btrfs_wait_ordered_range(inode, 0, (u64)-1);
3766
3767         if (root->fs_info->log_root_recovering) {
3768                 BUG_ON(!list_empty(&BTRFS_I(inode)->i_orphan));
3769                 goto no_delete;
3770         }
3771
3772         if (inode->i_nlink > 0) {
3773                 BUG_ON(btrfs_root_refs(&root->root_item) != 0);
3774                 goto no_delete;
3775         }
3776
3777         btrfs_i_size_write(inode, 0);
3778
3779         while (1) {
3780                 trans = btrfs_start_transaction(root, 0);
3781                 BUG_ON(IS_ERR(trans));
3782                 btrfs_set_trans_block_group(trans, inode);
3783                 trans->block_rsv = root->orphan_block_rsv;
3784
3785                 ret = btrfs_block_rsv_check(trans, root,
3786                                             root->orphan_block_rsv, 0, 5);
3787                 if (ret) {
3788                         BUG_ON(ret != -EAGAIN);
3789                         ret = btrfs_commit_transaction(trans, root);
3790                         BUG_ON(ret);
3791                         continue;
3792                 }
3793
3794                 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
3795                 if (ret != -EAGAIN)
3796                         break;
3797
3798                 nr = trans->blocks_used;
3799                 btrfs_end_transaction(trans, root);
3800                 trans = NULL;
3801                 btrfs_btree_balance_dirty(root, nr);
3802
3803         }
3804
3805         if (ret == 0) {
3806                 ret = btrfs_orphan_del(trans, inode);
3807                 BUG_ON(ret);
3808         }
3809
3810         nr = trans->blocks_used;
3811         btrfs_end_transaction(trans, root);
3812         btrfs_btree_balance_dirty(root, nr);
3813 no_delete:
3814         end_writeback(inode);
3815         return;
3816 }
3817
3818 /*
3819  * this returns the key found in the dir entry in the location pointer.
3820  * If no dir entries were found, location->objectid is 0.
3821  */
3822 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
3823                                struct btrfs_key *location)
3824 {
3825         const char *name = dentry->d_name.name;
3826         int namelen = dentry->d_name.len;
3827         struct btrfs_dir_item *di;
3828         struct btrfs_path *path;
3829         struct btrfs_root *root = BTRFS_I(dir)->root;
3830         int ret = 0;
3831
3832         path = btrfs_alloc_path();
3833         BUG_ON(!path);
3834
3835         di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
3836                                     namelen, 0);
3837         if (IS_ERR(di))
3838                 ret = PTR_ERR(di);
3839
3840         if (!di || IS_ERR(di))
3841                 goto out_err;
3842
3843         btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
3844 out:
3845         btrfs_free_path(path);
3846         return ret;
3847 out_err:
3848         location->objectid = 0;
3849         goto out;
3850 }
3851
3852 /*
3853  * when we hit a tree root in a directory, the btrfs part of the inode
3854  * needs to be changed to reflect the root directory of the tree root.  This
3855  * is kind of like crossing a mount point.
3856  */
3857 static int fixup_tree_root_location(struct btrfs_root *root,
3858                                     struct inode *dir,
3859                                     struct dentry *dentry,
3860                                     struct btrfs_key *location,
3861                                     struct btrfs_root **sub_root)
3862 {
3863         struct btrfs_path *path;
3864         struct btrfs_root *new_root;
3865         struct btrfs_root_ref *ref;
3866         struct extent_buffer *leaf;
3867         int ret;
3868         int err = 0;
3869
3870         path = btrfs_alloc_path();
3871         if (!path) {
3872                 err = -ENOMEM;
3873                 goto out;
3874         }
3875
3876         err = -ENOENT;
3877         ret = btrfs_find_root_ref(root->fs_info->tree_root, path,
3878                                   BTRFS_I(dir)->root->root_key.objectid,
3879                                   location->objectid);
3880         if (ret) {
3881                 if (ret < 0)
3882                         err = ret;
3883                 goto out;
3884         }
3885
3886         leaf = path->nodes[0];
3887         ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
3888         if (btrfs_root_ref_dirid(leaf, ref) != dir->i_ino ||
3889             btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
3890                 goto out;
3891
3892         ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
3893                                    (unsigned long)(ref + 1),
3894                                    dentry->d_name.len);
3895         if (ret)
3896                 goto out;
3897
3898         btrfs_release_path(root->fs_info->tree_root, path);
3899
3900         new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
3901         if (IS_ERR(new_root)) {
3902                 err = PTR_ERR(new_root);
3903                 goto out;
3904         }
3905
3906         if (btrfs_root_refs(&new_root->root_item) == 0) {
3907                 err = -ENOENT;
3908                 goto out;
3909         }
3910
3911         *sub_root = new_root;
3912         location->objectid = btrfs_root_dirid(&new_root->root_item);
3913         location->type = BTRFS_INODE_ITEM_KEY;
3914         location->offset = 0;
3915         err = 0;
3916 out:
3917         btrfs_free_path(path);
3918         return err;
3919 }
3920
3921 static void inode_tree_add(struct inode *inode)
3922 {
3923         struct btrfs_root *root = BTRFS_I(inode)->root;
3924         struct btrfs_inode *entry;
3925         struct rb_node **p;
3926         struct rb_node *parent;
3927 again:
3928         p = &root->inode_tree.rb_node;
3929         parent = NULL;
3930
3931         if (inode_unhashed(inode))
3932                 return;
3933
3934         spin_lock(&root->inode_lock);
3935         while (*p) {
3936                 parent = *p;
3937                 entry = rb_entry(parent, struct btrfs_inode, rb_node);
3938
3939                 if (inode->i_ino < entry->vfs_inode.i_ino)
3940                         p = &parent->rb_left;
3941                 else if (inode->i_ino > entry->vfs_inode.i_ino)
3942                         p = &parent->rb_right;
3943                 else {
3944                         WARN_ON(!(entry->vfs_inode.i_state &
3945                                   (I_WILL_FREE | I_FREEING)));
3946                         rb_erase(parent, &root->inode_tree);
3947                         RB_CLEAR_NODE(parent);
3948                         spin_unlock(&root->inode_lock);
3949                         goto again;
3950                 }
3951         }
3952         rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
3953         rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
3954         spin_unlock(&root->inode_lock);
3955 }
3956
3957 static void inode_tree_del(struct inode *inode)
3958 {
3959         struct btrfs_root *root = BTRFS_I(inode)->root;
3960         int empty = 0;
3961
3962         spin_lock(&root->inode_lock);
3963         if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
3964                 rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
3965                 RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
3966                 empty = RB_EMPTY_ROOT(&root->inode_tree);
3967         }
3968         spin_unlock(&root->inode_lock);
3969
3970         /*
3971          * Free space cache has inodes in the tree root, but the tree root has a
3972          * root_refs of 0, so this could end up dropping the tree root as a
3973          * snapshot, so we need the extra !root->fs_info->tree_root check to
3974          * make sure we don't drop it.
3975          */
3976         if (empty && btrfs_root_refs(&root->root_item) == 0 &&
3977             root != root->fs_info->tree_root) {
3978                 synchronize_srcu(&root->fs_info->subvol_srcu);
3979                 spin_lock(&root->inode_lock);
3980                 empty = RB_EMPTY_ROOT(&root->inode_tree);
3981                 spin_unlock(&root->inode_lock);
3982                 if (empty)
3983                         btrfs_add_dead_root(root);
3984         }
3985 }
3986
3987 int btrfs_invalidate_inodes(struct btrfs_root *root)
3988 {
3989         struct rb_node *node;
3990         struct rb_node *prev;
3991         struct btrfs_inode *entry;
3992         struct inode *inode;
3993         u64 objectid = 0;
3994
3995         WARN_ON(btrfs_root_refs(&root->root_item) != 0);
3996
3997         spin_lock(&root->inode_lock);
3998 again:
3999         node = root->inode_tree.rb_node;
4000         prev = NULL;
4001         while (node) {
4002                 prev = node;
4003                 entry = rb_entry(node, struct btrfs_inode, rb_node);
4004
4005                 if (objectid < entry->vfs_inode.i_ino)
4006                         node = node->rb_left;
4007                 else if (objectid > entry->vfs_inode.i_ino)
4008                         node = node->rb_right;
4009                 else
4010                         break;
4011         }
4012         if (!node) {
4013                 while (prev) {
4014                         entry = rb_entry(prev, struct btrfs_inode, rb_node);
4015                         if (objectid <= entry->vfs_inode.i_ino) {
4016                                 node = prev;
4017                                 break;
4018                         }
4019                         prev = rb_next(prev);
4020                 }
4021         }
4022         while (node) {
4023                 entry = rb_entry(node, struct btrfs_inode, rb_node);
4024                 objectid = entry->vfs_inode.i_ino + 1;
4025                 inode = igrab(&entry->vfs_inode);
4026                 if (inode) {
4027                         spin_unlock(&root->inode_lock);
4028                         if (atomic_read(&inode->i_count) > 1)
4029                                 d_prune_aliases(inode);
4030                         /*
4031                          * btrfs_drop_inode will have it removed from
4032                          * the inode cache when its usage count
4033                          * hits zero.
4034                          */
4035                         iput(inode);
4036                         cond_resched();
4037                         spin_lock(&root->inode_lock);
4038                         goto again;
4039                 }
4040
4041                 if (cond_resched_lock(&root->inode_lock))
4042                         goto again;
4043
4044                 node = rb_next(node);
4045         }
4046         spin_unlock(&root->inode_lock);
4047         return 0;
4048 }
4049
4050 static int btrfs_init_locked_inode(struct inode *inode, void *p)
4051 {
4052         struct btrfs_iget_args *args = p;
4053         inode->i_ino = args->ino;
4054         BTRFS_I(inode)->root = args->root;
4055         btrfs_set_inode_space_info(args->root, inode);
4056         return 0;
4057 }
4058
4059 static int btrfs_find_actor(struct inode *inode, void *opaque)
4060 {
4061         struct btrfs_iget_args *args = opaque;
4062         return args->ino == inode->i_ino &&
4063                 args->root == BTRFS_I(inode)->root;
4064 }
4065
4066 static struct inode *btrfs_iget_locked(struct super_block *s,
4067                                        u64 objectid,
4068                                        struct btrfs_root *root)
4069 {
4070         struct inode *inode;
4071         struct btrfs_iget_args args;
4072         args.ino = objectid;
4073         args.root = root;
4074
4075         inode = iget5_locked(s, objectid, btrfs_find_actor,
4076                              btrfs_init_locked_inode,
4077                              (void *)&args);
4078         return inode;
4079 }
4080
4081 /* Get an inode object given its location and corresponding root.
4082  * Returns in *is_new if the inode was read from disk
4083  */
4084 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
4085                          struct btrfs_root *root, int *new)
4086 {
4087         struct inode *inode;
4088
4089         inode = btrfs_iget_locked(s, location->objectid, root);
4090         if (!inode)
4091                 return ERR_PTR(-ENOMEM);
4092
4093         if (inode->i_state & I_NEW) {
4094                 BTRFS_I(inode)->root = root;
4095                 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
4096                 btrfs_read_locked_inode(inode);
4097
4098                 inode_tree_add(inode);
4099                 unlock_new_inode(inode);
4100                 if (new)
4101                         *new = 1;
4102         }
4103
4104         return inode;
4105 }
4106
4107 static struct inode *new_simple_dir(struct super_block *s,
4108                                     struct btrfs_key *key,
4109                                     struct btrfs_root *root)
4110 {
4111         struct inode *inode = new_inode(s);
4112
4113         if (!inode)
4114                 return ERR_PTR(-ENOMEM);
4115
4116         BTRFS_I(inode)->root = root;
4117         memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
4118         BTRFS_I(inode)->dummy_inode = 1;
4119
4120         inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
4121         inode->i_op = &simple_dir_inode_operations;
4122         inode->i_fop = &simple_dir_operations;
4123         inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
4124         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
4125
4126         return inode;
4127 }
4128
4129 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
4130 {
4131         struct inode *inode;
4132         struct btrfs_root *root = BTRFS_I(dir)->root;
4133         struct btrfs_root *sub_root = root;
4134         struct btrfs_key location;
4135         int index;
4136         int ret;
4137
4138         if (dentry->d_name.len > BTRFS_NAME_LEN)
4139                 return ERR_PTR(-ENAMETOOLONG);
4140
4141         ret = btrfs_inode_by_name(dir, dentry, &location);
4142
4143         if (ret < 0)
4144                 return ERR_PTR(ret);
4145
4146         if (location.objectid == 0)
4147                 return NULL;
4148
4149         if (location.type == BTRFS_INODE_ITEM_KEY) {
4150                 inode = btrfs_iget(dir->i_sb, &location, root, NULL);
4151                 return inode;
4152         }
4153
4154         BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);
4155
4156         index = srcu_read_lock(&root->fs_info->subvol_srcu);
4157         ret = fixup_tree_root_location(root, dir, dentry,
4158                                        &location, &sub_root);
4159         if (ret < 0) {
4160                 if (ret != -ENOENT)
4161                         inode = ERR_PTR(ret);
4162                 else
4163                         inode = new_simple_dir(dir->i_sb, &location, sub_root);
4164         } else {
4165                 inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
4166         }
4167         srcu_read_unlock(&root->fs_info->subvol_srcu, index);
4168
4169         if (!IS_ERR(inode) && root != sub_root) {
4170                 down_read(&root->fs_info->cleanup_work_sem);
4171                 if (!(inode->i_sb->s_flags & MS_RDONLY))
4172                         ret = btrfs_orphan_cleanup(sub_root);
4173                 up_read(&root->fs_info->cleanup_work_sem);
4174                 if (ret)
4175                         inode = ERR_PTR(ret);
4176         }
4177
4178         return inode;
4179 }
4180
4181 static int btrfs_dentry_delete(const struct dentry *dentry)
4182 {
4183         struct btrfs_root *root;
4184
4185         if (!dentry->d_inode && !IS_ROOT(dentry))
4186                 dentry = dentry->d_parent;
4187
4188         if (dentry->d_inode) {
4189                 root = BTRFS_I(dentry->d_inode)->root;
4190                 if (btrfs_root_refs(&root->root_item) == 0)
4191                         return 1;
4192         }
4193         return 0;
4194 }
4195
4196 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
4197                                    struct nameidata *nd)
4198 {
4199         struct inode *inode;
4200
4201         inode = btrfs_lookup_dentry(dir, dentry);
4202         if (IS_ERR(inode))
4203                 return ERR_CAST(inode);
4204
4205         return d_splice_alias(inode, dentry);
4206 }
4207
4208 static unsigned char btrfs_filetype_table[] = {
4209         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
4210 };
4211
4212 static int btrfs_real_readdir(struct file *filp, void *dirent,
4213                               filldir_t filldir)
4214 {
4215         struct inode *inode = filp->f_dentry->d_inode;
4216         struct btrfs_root *root = BTRFS_I(inode)->root;
4217         struct btrfs_item *item;
4218         struct btrfs_dir_item *di;
4219         struct btrfs_key key;
4220         struct btrfs_key found_key;
4221         struct btrfs_path *path;
4222         int ret;
4223         u32 nritems;
4224         struct extent_buffer *leaf;
4225         int slot;
4226         int advance;
4227         unsigned char d_type;
4228         int over = 0;
4229         u32 di_cur;
4230         u32 di_total;
4231         u32 di_len;
4232         int key_type = BTRFS_DIR_INDEX_KEY;
4233         char tmp_name[32];
4234         char *name_ptr;
4235         int name_len;
4236
4237         /* FIXME, use a real flag for deciding about the key type */
4238         if (root->fs_info->tree_root == root)
4239                 key_type = BTRFS_DIR_ITEM_KEY;
4240
4241         /* special case for "." */
4242         if (filp->f_pos == 0) {
4243                 over = filldir(dirent, ".", 1,
4244                                1, inode->i_ino,
4245                                DT_DIR);
4246                 if (over)
4247                         return 0;
4248                 filp->f_pos = 1;
4249         }
4250         /* special case for .., just use the back ref */
4251         if (filp->f_pos == 1) {
4252                 u64 pino = parent_ino(filp->f_path.dentry);
4253                 over = filldir(dirent, "..", 2,
4254                                2, pino, DT_DIR);
4255                 if (over)
4256                         return 0;
4257                 filp->f_pos = 2;
4258         }
4259         path = btrfs_alloc_path();
4260         path->reada = 2;
4261
4262         btrfs_set_key_type(&key, key_type);
4263         key.offset = filp->f_pos;
4264         key.objectid = inode->i_ino;
4265
4266         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4267         if (ret < 0)
4268                 goto err;
4269         advance = 0;
4270
4271         while (1) {
4272                 leaf = path->nodes[0];
4273                 nritems = btrfs_header_nritems(leaf);
4274                 slot = path->slots[0];
4275                 if (advance || slot >= nritems) {
4276                         if (slot >= nritems - 1) {
4277                                 ret = btrfs_next_leaf(root, path);
4278                                 if (ret)
4279                                         break;
4280                                 leaf = path->nodes[0];
4281                                 nritems = btrfs_header_nritems(leaf);
4282                                 slot = path->slots[0];
4283                         } else {
4284                                 slot++;
4285                                 path->slots[0]++;
4286                         }
4287                 }
4288
4289                 advance = 1;
4290                 item = btrfs_item_nr(leaf, slot);
4291                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
4292
4293                 if (found_key.objectid != key.objectid)
4294                         break;
4295                 if (btrfs_key_type(&found_key) != key_type)
4296                         break;
4297                 if (found_key.offset < filp->f_pos)
4298                         continue;
4299
4300                 filp->f_pos = found_key.offset;
4301
4302                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
4303                 di_cur = 0;
4304                 di_total = btrfs_item_size(leaf, item);
4305
4306                 while (di_cur < di_total) {
4307                         struct btrfs_key location;
4308
4309                         name_len = btrfs_dir_name_len(leaf, di);
4310                         if (name_len <= sizeof(tmp_name)) {
4311                                 name_ptr = tmp_name;
4312                         } else {
4313                                 name_ptr = kmalloc(name_len, GFP_NOFS);
4314                                 if (!name_ptr) {
4315                                         ret = -ENOMEM;
4316                                         goto err;
4317                                 }
4318                         }
4319                         read_extent_buffer(leaf, name_ptr,
4320                                            (unsigned long)(di + 1), name_len);
4321
4322                         d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
4323                         btrfs_dir_item_key_to_cpu(leaf, di, &location);
4324
4325                         /* is this a reference to our own snapshot? If so
4326                          * skip it
4327                          */
4328                         if (location.type == BTRFS_ROOT_ITEM_KEY &&
4329                             location.objectid == root->root_key.objectid) {
4330                                 over = 0;
4331                                 goto skip;
4332                         }
4333                         over = filldir(dirent, name_ptr, name_len,
4334                                        found_key.offset, location.objectid,
4335                                        d_type);
4336
4337 skip:
4338                         if (name_ptr != tmp_name)
4339                                 kfree(name_ptr);
4340
4341                         if (over)
4342                                 goto nopos;
4343                         di_len = btrfs_dir_name_len(leaf, di) +
4344                                  btrfs_dir_data_len(leaf, di) + sizeof(*di);
4345                         di_cur += di_len;
4346                         di = (struct btrfs_dir_item *)((char *)di + di_len);
4347                 }
4348         }
4349
4350         /* Reached end of directory/root. Bump pos past the last item. */
4351         if (key_type == BTRFS_DIR_INDEX_KEY)
4352                 /*
4353                  * 32-bit glibc will use getdents64, but then strtol -
4354                  * so the last number we can serve is this.
4355                  */
4356                 filp->f_pos = 0x7fffffff;
4357         else
4358                 filp->f_pos++;
4359 nopos:
4360         ret = 0;
4361 err:
4362         btrfs_free_path(path);
4363         return ret;
4364 }
4365
4366 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
4367 {
4368         struct btrfs_root *root = BTRFS_I(inode)->root;
4369         struct btrfs_trans_handle *trans;
4370         int ret = 0;
4371         bool nolock = false;
4372
4373         if (BTRFS_I(inode)->dummy_inode)
4374                 return 0;
4375
4376         smp_mb();
4377         nolock = (root->fs_info->closing && root == root->fs_info->tree_root);
4378
4379         if (wbc->sync_mode == WB_SYNC_ALL) {
4380                 if (nolock)
4381                         trans = btrfs_join_transaction_nolock(root, 1);
4382                 else
4383                         trans = btrfs_join_transaction(root, 1);
4384                 if (IS_ERR(trans))
4385                         return PTR_ERR(trans);
4386                 btrfs_set_trans_block_group(trans, inode);
4387                 if (nolock)
4388                         ret = btrfs_end_transaction_nolock(trans, root);
4389                 else
4390                         ret = btrfs_commit_transaction(trans, root);
4391         }
4392         return ret;
4393 }
4394
4395 /*
4396  * This is somewhat expensive, updating the tree every time the
4397  * inode changes.  But, it is most likely to find the inode in cache.
4398  * FIXME, needs more benchmarking...there are no reasons other than performance
4399  * to keep or drop this code.
4400  */
4401 void btrfs_dirty_inode(struct inode *inode)
4402 {
4403         struct btrfs_root *root = BTRFS_I(inode)->root;
4404         struct btrfs_trans_handle *trans;
4405         int ret;
4406
4407         if (BTRFS_I(inode)->dummy_inode)
4408                 return;
4409
4410         trans = btrfs_join_transaction(root, 1);
4411         BUG_ON(IS_ERR(trans));
4412         btrfs_set_trans_block_group(trans, inode);
4413
4414         ret = btrfs_update_inode(trans, root, inode);
4415         if (ret && ret == -ENOSPC) {
4416                 /* whoops, lets try again with the full transaction */
4417                 btrfs_end_transaction(trans, root);
4418                 trans = btrfs_start_transaction(root, 1);
4419                 if (IS_ERR(trans)) {
4420                         if (printk_ratelimit()) {
4421                                 printk(KERN_ERR "btrfs: fail to "
4422                                        "dirty  inode %lu error %ld\n",
4423                                        inode->i_ino, PTR_ERR(trans));
4424                         }
4425                         return;
4426                 }
4427                 btrfs_set_trans_block_group(trans, inode);
4428
4429                 ret = btrfs_update_inode(trans, root, inode);
4430                 if (ret) {
4431                         if (printk_ratelimit()) {
4432                                 printk(KERN_ERR "btrfs: fail to "
4433                                        "dirty  inode %lu error %d\n",
4434                                        inode->i_ino, ret);
4435                         }
4436                 }
4437         }
4438         btrfs_end_transaction(trans, root);
4439 }
4440
4441 /*
4442  * find the highest existing sequence number in a directory
4443  * and then set the in-memory index_cnt variable to reflect
4444  * free sequence numbers
4445  */
4446 static int btrfs_set_inode_index_count(struct inode *inode)
4447 {
4448         struct btrfs_root *root = BTRFS_I(inode)->root;
4449         struct btrfs_key key, found_key;
4450         struct btrfs_path *path;
4451         struct extent_buffer *leaf;
4452         int ret;
4453
4454         key.objectid = inode->i_ino;
4455         btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
4456         key.offset = (u64)-1;
4457
4458         path = btrfs_alloc_path();
4459         if (!path)
4460                 return -ENOMEM;
4461
4462         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4463         if (ret < 0)
4464                 goto out;
4465         /* FIXME: we should be able to handle this */
4466         if (ret == 0)
4467                 goto out;
4468         ret = 0;
4469
4470         /*
4471          * MAGIC NUMBER EXPLANATION:
4472          * since we search a directory based on f_pos we have to start at 2
4473          * since '.' and '..' have f_pos of 0 and 1 respectively, so everybody
4474          * else has to start at 2
4475          */
4476         if (path->slots[0] == 0) {
4477                 BTRFS_I(inode)->index_cnt = 2;
4478                 goto out;
4479         }
4480
4481         path->slots[0]--;
4482
4483         leaf = path->nodes[0];
4484         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
4485
4486         if (found_key.objectid != inode->i_ino ||
4487             btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
4488                 BTRFS_I(inode)->index_cnt = 2;
4489                 goto out;
4490         }
4491
4492         BTRFS_I(inode)->index_cnt = found_key.offset + 1;
4493 out:
4494         btrfs_free_path(path);
4495         return ret;
4496 }
4497
4498 /*
4499  * helper to find a free sequence number in a given directory.  This current
4500  * code is very simple, later versions will do smarter things in the btree
4501  */
4502 int btrfs_set_inode_index(struct inode *dir, u64 *index)
4503 {
4504         int ret = 0;
4505
4506         if (BTRFS_I(dir)->index_cnt == (u64)-1) {
4507                 ret = btrfs_set_inode_index_count(dir);
4508                 if (ret)
4509                         return ret;
4510         }
4511
4512         *index = BTRFS_I(dir)->index_cnt;
4513         BTRFS_I(dir)->index_cnt++;
4514
4515         return ret;
4516 }
4517
4518 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
4519                                      struct btrfs_root *root,
4520                                      struct inode *dir,
4521                                      const char *name, int name_len,
4522                                      u64 ref_objectid, u64 objectid,
4523                                      u64 alloc_hint, int mode, u64 *index)
4524 {
4525         struct inode *inode;
4526         struct btrfs_inode_item *inode_item;
4527         struct btrfs_key *location;
4528         struct btrfs_path *path;
4529         struct btrfs_inode_ref *ref;
4530         struct btrfs_key key[2];
4531         u32 sizes[2];
4532         unsigned long ptr;
4533         int ret;
4534         int owner;
4535
4536         path = btrfs_alloc_path();
4537         BUG_ON(!path);
4538
4539         inode = new_inode(root->fs_info->sb);
4540         if (!inode)
4541                 return ERR_PTR(-ENOMEM);
4542
4543         if (dir) {
4544                 ret = btrfs_set_inode_index(dir, index);
4545                 if (ret) {
4546                         iput(inode);
4547                         return ERR_PTR(ret);
4548                 }
4549         }
4550         /*
4551          * index_cnt is ignored for everything but a dir,
4552          * btrfs_get_inode_index_count has an explanation for the magic
4553          * number
4554          */
4555         BTRFS_I(inode)->index_cnt = 2;
4556         BTRFS_I(inode)->root = root;
4557         BTRFS_I(inode)->generation = trans->transid;
4558         inode->i_generation = BTRFS_I(inode)->generation;
4559         btrfs_set_inode_space_info(root, inode);
4560
4561         if (mode & S_IFDIR)
4562                 owner = 0;
4563         else
4564                 owner = 1;
4565         BTRFS_I(inode)->block_group =
4566                         btrfs_find_block_group(root, 0, alloc_hint, owner);
4567
4568         key[0].objectid = objectid;
4569         btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
4570         key[0].offset = 0;
4571
4572         key[1].objectid = objectid;
4573         btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
4574         key[1].offset = ref_objectid;
4575
4576         sizes[0] = sizeof(struct btrfs_inode_item);
4577         sizes[1] = name_len + sizeof(*ref);
4578
4579         path->leave_spinning = 1;
4580         ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
4581         if (ret != 0)
4582                 goto fail;
4583
4584         inode_init_owner(inode, dir, mode);
4585         inode->i_ino = objectid;
4586         inode_set_bytes(inode, 0);
4587         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
4588         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
4589                                   struct btrfs_inode_item);
4590         fill_inode_item(trans, path->nodes[0], inode_item, inode);
4591
4592         ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
4593                              struct btrfs_inode_ref);
4594         btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
4595         btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
4596         ptr = (unsigned long)(ref + 1);
4597         write_extent_buffer(path->nodes[0], name, ptr, name_len);
4598
4599         btrfs_mark_buffer_dirty(path->nodes[0]);
4600         btrfs_free_path(path);
4601
4602         location = &BTRFS_I(inode)->location;
4603         location->objectid = objectid;
4604         location->offset = 0;
4605         btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
4606
4607         btrfs_inherit_iflags(inode, dir);
4608
4609         if ((mode & S_IFREG)) {
4610                 if (btrfs_test_opt(root, NODATASUM))
4611                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
4612                 if (btrfs_test_opt(root, NODATACOW))
4613                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
4614         }
4615
4616         insert_inode_hash(inode);
4617         inode_tree_add(inode);
4618         return inode;
4619 fail:
4620         if (dir)
4621                 BTRFS_I(dir)->index_cnt--;
4622         btrfs_free_path(path);
4623         iput(inode);
4624         return ERR_PTR(ret);
4625 }
4626
4627 static inline u8 btrfs_inode_type(struct inode *inode)
4628 {
4629         return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
4630 }
4631
4632 /*
4633  * utility function to add 'inode' into 'parent_inode' with
4634  * a give name and a given sequence number.
4635  * if 'add_backref' is true, also insert a backref from the
4636  * inode to the parent directory.
4637  */
4638 int btrfs_add_link(struct btrfs_trans_handle *trans,
4639                    struct inode *parent_inode, struct inode *inode,
4640                    const char *name, int name_len, int add_backref, u64 index)
4641 {
4642         int ret = 0;
4643         struct btrfs_key key;
4644         struct btrfs_root *root = BTRFS_I(parent_inode)->root;
4645
4646         if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
4647                 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
4648         } else {
4649                 key.objectid = inode->i_ino;
4650                 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
4651                 key.offset = 0;
4652         }
4653
4654         if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
4655                 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
4656                                          key.objectid, root->root_key.objectid,
4657                                          parent_inode->i_ino,
4658                                          index, name, name_len);
4659         } else if (add_backref) {
4660                 ret = btrfs_insert_inode_ref(trans, root,
4661                                              name, name_len, inode->i_ino,
4662                                              parent_inode->i_ino, index);
4663         }
4664
4665         if (ret == 0) {
4666                 ret = btrfs_insert_dir_item(trans, root, name, name_len,
4667                                             parent_inode->i_ino, &key,
4668                                             btrfs_inode_type(inode), index);
4669                 BUG_ON(ret);
4670
4671                 btrfs_i_size_write(parent_inode, parent_inode->i_size +
4672                                    name_len * 2);
4673                 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
4674                 ret = btrfs_update_inode(trans, root, parent_inode);
4675         }
4676         return ret;
4677 }
4678
4679 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
4680                             struct inode *dir, struct dentry *dentry,
4681                             struct inode *inode, int backref, u64 index)
4682 {
4683         int err = btrfs_add_link(trans, dir, inode,
4684                                  dentry->d_name.name, dentry->d_name.len,
4685                                  backref, index);
4686         if (!err) {
4687                 d_instantiate(dentry, inode);
4688                 return 0;
4689         }
4690         if (err > 0)
4691                 err = -EEXIST;
4692         return err;
4693 }
4694
4695 static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
4696                         int mode, dev_t rdev)
4697 {
4698         struct btrfs_trans_handle *trans;
4699         struct btrfs_root *root = BTRFS_I(dir)->root;
4700         struct inode *inode = NULL;
4701         int err;
4702         int drop_inode = 0;
4703         u64 objectid;
4704         unsigned long nr = 0;
4705         u64 index = 0;
4706
4707         if (!new_valid_dev(rdev))
4708                 return -EINVAL;
4709
4710         err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
4711         if (err)
4712                 return err;
4713
4714         /*
4715          * 2 for inode item and ref
4716          * 2 for dir items
4717          * 1 for xattr if selinux is on
4718          */
4719         trans = btrfs_start_transaction(root, 5);
4720         if (IS_ERR(trans))
4721                 return PTR_ERR(trans);
4722
4723         btrfs_set_trans_block_group(trans, dir);
4724
4725         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4726                                 dentry->d_name.len, dir->i_ino, objectid,
4727                                 BTRFS_I(dir)->block_group, mode, &index);
4728         err = PTR_ERR(inode);
4729         if (IS_ERR(inode))
4730                 goto out_unlock;
4731
4732         err = btrfs_init_inode_security(trans, inode, dir);
4733         if (err) {
4734                 drop_inode = 1;
4735                 goto out_unlock;
4736         }
4737
4738         btrfs_set_trans_block_group(trans, inode);
4739         err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
4740         if (err)
4741                 drop_inode = 1;
4742         else {
4743                 inode->i_op = &btrfs_special_inode_operations;
4744                 init_special_inode(inode, inode->i_mode, rdev);
4745                 btrfs_update_inode(trans, root, inode);
4746         }
4747         btrfs_update_inode_block_group(trans, inode);
4748         btrfs_update_inode_block_group(trans, dir);
4749 out_unlock:
4750         nr = trans->blocks_used;
4751         btrfs_end_transaction_throttle(trans, root);
4752         btrfs_btree_balance_dirty(root, nr);
4753         if (drop_inode) {
4754                 inode_dec_link_count(inode);
4755                 iput(inode);
4756         }
4757         return err;
4758 }
4759
4760 static int btrfs_create(struct inode *dir, struct dentry *dentry,
4761                         int mode, struct nameidata *nd)
4762 {
4763         struct btrfs_trans_handle *trans;
4764         struct btrfs_root *root = BTRFS_I(dir)->root;
4765         struct inode *inode = NULL;
4766         int drop_inode = 0;
4767         int err;
4768         unsigned long nr = 0;
4769         u64 objectid;
4770         u64 index = 0;
4771
4772         err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
4773         if (err)
4774                 return err;
4775         /*
4776          * 2 for inode item and ref
4777          * 2 for dir items
4778          * 1 for xattr if selinux is on
4779          */
4780         trans = btrfs_start_transaction(root, 5);
4781         if (IS_ERR(trans))
4782                 return PTR_ERR(trans);
4783
4784         btrfs_set_trans_block_group(trans, dir);
4785
4786         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4787                                 dentry->d_name.len, dir->i_ino, objectid,
4788                                 BTRFS_I(dir)->block_group, mode, &index);
4789         err = PTR_ERR(inode);
4790         if (IS_ERR(inode))
4791                 goto out_unlock;
4792
4793         err = btrfs_init_inode_security(trans, inode, dir);
4794         if (err) {
4795                 drop_inode = 1;
4796                 goto out_unlock;
4797         }
4798
4799         btrfs_set_trans_block_group(trans, inode);
4800         err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
4801         if (err)
4802                 drop_inode = 1;
4803         else {
4804                 inode->i_mapping->a_ops = &btrfs_aops;
4805                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
4806                 inode->i_fop = &btrfs_file_operations;
4807                 inode->i_op = &btrfs_file_inode_operations;
4808                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
4809         }
4810         btrfs_update_inode_block_group(trans, inode);
4811         btrfs_update_inode_block_group(trans, dir);
4812 out_unlock:
4813         nr = trans->blocks_used;
4814         btrfs_end_transaction_throttle(trans, root);
4815         if (drop_inode) {
4816                 inode_dec_link_count(inode);
4817                 iput(inode);
4818         }
4819         btrfs_btree_balance_dirty(root, nr);
4820         return err;
4821 }
4822
4823 static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
4824                       struct dentry *dentry)
4825 {
4826         struct btrfs_trans_handle *trans;
4827         struct btrfs_root *root = BTRFS_I(dir)->root;
4828         struct inode *inode = old_dentry->d_inode;
4829         u64 index;
4830         unsigned long nr = 0;
4831         int err;
4832         int drop_inode = 0;
4833
4834         if (inode->i_nlink == 0)
4835                 return -ENOENT;
4836
4837         /* do not allow sys_link's with other subvols of the same device */
4838         if (root->objectid != BTRFS_I(inode)->root->objectid)
4839                 return -EPERM;
4840
4841         btrfs_inc_nlink(inode);
4842         inode->i_ctime = CURRENT_TIME;
4843
4844         err = btrfs_set_inode_index(dir, &index);
4845         if (err)
4846                 goto fail;
4847
4848         /*
4849          * 2 items for inode and inode ref
4850          * 2 items for dir items
4851          * 1 item for parent inode
4852          */
4853         trans = btrfs_start_transaction(root, 5);
4854         if (IS_ERR(trans)) {
4855                 err = PTR_ERR(trans);
4856                 goto fail;
4857         }
4858
4859         btrfs_set_trans_block_group(trans, dir);
4860         ihold(inode);
4861
4862         err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
4863
4864         if (err) {
4865                 drop_inode = 1;
4866         } else {
4867                 struct dentry *parent = dget_parent(dentry);
4868                 btrfs_update_inode_block_group(trans, dir);
4869                 err = btrfs_update_inode(trans, root, inode);
4870                 BUG_ON(err);
4871                 btrfs_log_new_name(trans, inode, NULL, parent);
4872                 dput(parent);
4873         }
4874
4875         nr = trans->blocks_used;
4876         btrfs_end_transaction_throttle(trans, root);
4877 fail:
4878         if (drop_inode) {
4879                 inode_dec_link_count(inode);
4880                 iput(inode);
4881         }
4882         btrfs_btree_balance_dirty(root, nr);
4883         return err;
4884 }
4885
4886 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
4887 {
4888         struct inode *inode = NULL;
4889         struct btrfs_trans_handle *trans;
4890         struct btrfs_root *root = BTRFS_I(dir)->root;
4891         int err = 0;
4892         int drop_on_err = 0;
4893         u64 objectid = 0;
4894         u64 index = 0;
4895         unsigned long nr = 1;
4896
4897         err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
4898         if (err)
4899                 return err;
4900
4901         /*
4902          * 2 items for inode and ref
4903          * 2 items for dir items
4904          * 1 for xattr if selinux is on
4905          */
4906         trans = btrfs_start_transaction(root, 5);
4907         if (IS_ERR(trans))
4908                 return PTR_ERR(trans);
4909         btrfs_set_trans_block_group(trans, dir);
4910
4911         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4912                                 dentry->d_name.len, dir->i_ino, objectid,
4913                                 BTRFS_I(dir)->block_group, S_IFDIR | mode,
4914                                 &index);
4915         if (IS_ERR(inode)) {
4916                 err = PTR_ERR(inode);
4917                 goto out_fail;
4918         }
4919
4920         drop_on_err = 1;
4921
4922         err = btrfs_init_inode_security(trans, inode, dir);
4923         if (err)
4924                 goto out_fail;
4925
4926         inode->i_op = &btrfs_dir_inode_operations;
4927         inode->i_fop = &btrfs_dir_file_operations;
4928         btrfs_set_trans_block_group(trans, inode);
4929
4930         btrfs_i_size_write(inode, 0);
4931         err = btrfs_update_inode(trans, root, inode);
4932         if (err)
4933                 goto out_fail;
4934
4935         err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
4936                              dentry->d_name.len, 0, index);
4937         if (err)
4938                 goto out_fail;
4939
4940         d_instantiate(dentry, inode);
4941         drop_on_err = 0;
4942         btrfs_update_inode_block_group(trans, inode);
4943         btrfs_update_inode_block_group(trans, dir);
4944
4945 out_fail:
4946         nr = trans->blocks_used;
4947         btrfs_end_transaction_throttle(trans, root);
4948         if (drop_on_err)
4949                 iput(inode);
4950         btrfs_btree_balance_dirty(root, nr);
4951         return err;
4952 }
4953
4954 /* helper for btfs_get_extent.  Given an existing extent in the tree,
4955  * and an extent that you want to insert, deal with overlap and insert
4956  * the new extent into the tree.
4957  */
4958 static int merge_extent_mapping(struct extent_map_tree *em_tree,
4959                                 struct extent_map *existing,
4960                                 struct extent_map *em,
4961                                 u64 map_start, u64 map_len)
4962 {
4963         u64 start_diff;
4964
4965         BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
4966         start_diff = map_start - em->start;
4967         em->start = map_start;
4968         em->len = map_len;
4969         if (em->block_start < EXTENT_MAP_LAST_BYTE &&
4970             !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
4971                 em->block_start += start_diff;
4972                 em->block_len -= start_diff;
4973         }
4974         return add_extent_mapping(em_tree, em);
4975 }
4976
4977 static noinline int uncompress_inline(struct btrfs_path *path,
4978                                       struct inode *inode, struct page *page,
4979                                       size_t pg_offset, u64 extent_offset,
4980                                       struct btrfs_file_extent_item *item)
4981 {
4982         int ret;
4983         struct extent_buffer *leaf = path->nodes[0];
4984         char *tmp;
4985         size_t max_size;
4986         unsigned long inline_size;
4987         unsigned long ptr;
4988         int compress_type;
4989
4990         WARN_ON(pg_offset != 0);
4991         compress_type = btrfs_file_extent_compression(leaf, item);
4992         max_size = btrfs_file_extent_ram_bytes(leaf, item);
4993         inline_size = btrfs_file_extent_inline_item_len(leaf,
4994                                         btrfs_item_nr(leaf, path->slots[0]));
4995         tmp = kmalloc(inline_size, GFP_NOFS);
4996         ptr = btrfs_file_extent_inline_start(item);
4997
4998         read_extent_buffer(leaf, tmp, ptr, inline_size);
4999
5000         max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
5001         ret = btrfs_decompress(compress_type, tmp, page,
5002                                extent_offset, inline_size, max_size);
5003         if (ret) {
5004                 char *kaddr = kmap_atomic(page, KM_USER0);
5005                 unsigned long copy_size = min_t(u64,
5006                                   PAGE_CACHE_SIZE - pg_offset,
5007                                   max_size - extent_offset);
5008                 memset(kaddr + pg_offset, 0, copy_size);
5009                 kunmap_atomic(kaddr, KM_USER0);
5010         }
5011         kfree(tmp);
5012         return 0;
5013 }
5014
5015 /*
5016  * a bit scary, this does extent mapping from logical file offset to the disk.
5017  * the ugly parts come from merging extents from the disk with the in-ram
5018  * representation.  This gets more complex because of the data=ordered code,
5019  * where the in-ram extents might be locked pending data=ordered completion.
5020  *
5021  * This also copies inline extents directly into the page.
5022  */
5023
5024 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
5025                                     size_t pg_offset, u64 start, u64 len,
5026                                     int create)
5027 {
5028         int ret;
5029         int err = 0;
5030         u64 bytenr;
5031         u64 extent_start = 0;
5032         u64 extent_end = 0;
5033         u64 objectid = inode->i_ino;
5034         u32 found_type;
5035         struct btrfs_path *path = NULL;
5036         struct btrfs_root *root = BTRFS_I(inode)->root;
5037         struct btrfs_file_extent_item *item;
5038         struct extent_buffer *leaf;
5039         struct btrfs_key found_key;
5040         struct extent_map *em = NULL;
5041         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5042         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
5043         struct btrfs_trans_handle *trans = NULL;
5044         int compress_type;
5045
5046 again:
5047         read_lock(&em_tree->lock);
5048         em = lookup_extent_mapping(em_tree, start, len);
5049         if (em)
5050                 em->bdev = root->fs_info->fs_devices->latest_bdev;
5051         read_unlock(&em_tree->lock);
5052
5053         if (em) {
5054                 if (em->start > start || em->start + em->len <= start)
5055                         free_extent_map(em);
5056                 else if (em->block_start == EXTENT_MAP_INLINE && page)
5057                         free_extent_map(em);
5058                 else
5059                         goto out;
5060         }
5061         em = alloc_extent_map(GFP_NOFS);
5062         if (!em) {
5063                 err = -ENOMEM;
5064                 goto out;
5065         }
5066         em->bdev = root->fs_info->fs_devices->latest_bdev;
5067         em->start = EXTENT_MAP_HOLE;
5068         em->orig_start = EXTENT_MAP_HOLE;
5069         em->len = (u64)-1;
5070         em->block_len = (u64)-1;
5071
5072         if (!path) {
5073                 path = btrfs_alloc_path();
5074                 BUG_ON(!path);
5075         }
5076
5077         ret = btrfs_lookup_file_extent(trans, root, path,
5078                                        objectid, start, trans != NULL);
5079         if (ret < 0) {
5080                 err = ret;
5081                 goto out;
5082         }
5083
5084         if (ret != 0) {
5085                 if (path->slots[0] == 0)
5086                         goto not_found;
5087                 path->slots[0]--;
5088         }
5089
5090         leaf = path->nodes[0];
5091         item = btrfs_item_ptr(leaf, path->slots[0],
5092                               struct btrfs_file_extent_item);
5093         /* are we inside the extent that was found? */
5094         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
5095         found_type = btrfs_key_type(&found_key);
5096         if (found_key.objectid != objectid ||
5097             found_type != BTRFS_EXTENT_DATA_KEY) {
5098                 goto not_found;
5099         }
5100
5101         found_type = btrfs_file_extent_type(leaf, item);
5102         extent_start = found_key.offset;
5103         compress_type = btrfs_file_extent_compression(leaf, item);
5104         if (found_type == BTRFS_FILE_EXTENT_REG ||
5105             found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5106                 extent_end = extent_start +
5107                        btrfs_file_extent_num_bytes(leaf, item);
5108         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
5109                 size_t size;
5110                 size = btrfs_file_extent_inline_len(leaf, item);
5111                 extent_end = (extent_start + size + root->sectorsize - 1) &
5112                         ~((u64)root->sectorsize - 1);
5113         }
5114
5115         if (start >= extent_end) {
5116                 path->slots[0]++;
5117                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
5118                         ret = btrfs_next_leaf(root, path);
5119                         if (ret < 0) {
5120                                 err = ret;
5121                                 goto out;
5122                         }
5123                         if (ret > 0)
5124                                 goto not_found;
5125                         leaf = path->nodes[0];
5126                 }
5127                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
5128                 if (found_key.objectid != objectid ||
5129                     found_key.type != BTRFS_EXTENT_DATA_KEY)
5130                         goto not_found;
5131                 if (start + len <= found_key.offset)
5132                         goto not_found;
5133                 em->start = start;
5134                 em->len = found_key.offset - start;
5135                 goto not_found_em;
5136         }
5137
5138         if (found_type == BTRFS_FILE_EXTENT_REG ||
5139             found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5140                 em->start = extent_start;
5141                 em->len = extent_end - extent_start;
5142                 em->orig_start = extent_start -
5143                                  btrfs_file_extent_offset(leaf, item);
5144                 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
5145                 if (bytenr == 0) {
5146                         em->block_start = EXTENT_MAP_HOLE;
5147                         goto insert;
5148                 }
5149                 if (compress_type != BTRFS_COMPRESS_NONE) {
5150                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5151                         em->compress_type = compress_type;
5152                         em->block_start = bytenr;
5153                         em->block_len = btrfs_file_extent_disk_num_bytes(leaf,
5154                                                                          item);
5155                 } else {
5156                         bytenr += btrfs_file_extent_offset(leaf, item);
5157                         em->block_start = bytenr;
5158                         em->block_len = em->len;
5159                         if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
5160                                 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
5161                 }
5162                 goto insert;
5163         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
5164                 unsigned long ptr;
5165                 char *map;
5166                 size_t size;
5167                 size_t extent_offset;
5168                 size_t copy_size;
5169
5170                 em->block_start = EXTENT_MAP_INLINE;
5171                 if (!page || create) {
5172                         em->start = extent_start;
5173                         em->len = extent_end - extent_start;
5174                         goto out;
5175                 }
5176
5177                 size = btrfs_file_extent_inline_len(leaf, item);
5178                 extent_offset = page_offset(page) + pg_offset - extent_start;
5179                 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
5180                                 size - extent_offset);
5181                 em->start = extent_start + extent_offset;
5182                 em->len = (copy_size + root->sectorsize - 1) &
5183                         ~((u64)root->sectorsize - 1);
5184                 em->orig_start = EXTENT_MAP_INLINE;
5185                 if (compress_type) {
5186                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5187                         em->compress_type = compress_type;
5188                 }
5189                 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
5190                 if (create == 0 && !PageUptodate(page)) {
5191                         if (btrfs_file_extent_compression(leaf, item) !=
5192                             BTRFS_COMPRESS_NONE) {
5193                                 ret = uncompress_inline(path, inode, page,
5194                                                         pg_offset,
5195                                                         extent_offset, item);
5196                                 BUG_ON(ret);
5197                         } else {
5198                                 map = kmap(page);
5199                                 read_extent_buffer(leaf, map + pg_offset, ptr,
5200                                                    copy_size);
5201                                 if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
5202                                         memset(map + pg_offset + copy_size, 0,
5203                                                PAGE_CACHE_SIZE - pg_offset -
5204                                                copy_size);
5205                                 }
5206                                 kunmap(page);
5207                         }
5208                         flush_dcache_page(page);
5209                 } else if (create && PageUptodate(page)) {
5210                         WARN_ON(1);
5211                         if (!trans) {
5212                                 kunmap(page);
5213                                 free_extent_map(em);
5214                                 em = NULL;
5215                                 btrfs_release_path(root, path);
5216                                 trans = btrfs_join_transaction(root, 1);
5217                                 if (IS_ERR(trans))
5218                                         return ERR_CAST(trans);
5219                                 goto again;
5220                         }
5221                         map = kmap(page);
5222                         write_extent_buffer(leaf, map + pg_offset, ptr,
5223                                             copy_size);
5224                         kunmap(page);
5225                         btrfs_mark_buffer_dirty(leaf);
5226                 }
5227                 set_extent_uptodate(io_tree, em->start,
5228                                     extent_map_end(em) - 1, GFP_NOFS);
5229                 goto insert;
5230         } else {
5231                 printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
5232                 WARN_ON(1);
5233         }
5234 not_found:
5235         em->start = start;
5236         em->len = len;
5237 not_found_em:
5238         em->block_start = EXTENT_MAP_HOLE;
5239         set_bit(EXTENT_FLAG_VACANCY, &em->flags);
5240 insert:
5241         btrfs_release_path(root, path);
5242         if (em->start > start || extent_map_end(em) <= start) {
5243                 printk(KERN_ERR "Btrfs: bad extent! em: [%llu %llu] passed "
5244                        "[%llu %llu]\n", (unsigned long long)em->start,
5245                        (unsigned long long)em->len,
5246                        (unsigned long long)start,
5247                        (unsigned long long)len);
5248                 err = -EIO;
5249                 goto out;
5250         }
5251
5252         err = 0;
5253         write_lock(&em_tree->lock);
5254         ret = add_extent_mapping(em_tree, em);
5255         /* it is possible that someone inserted the extent into the tree
5256          * while we had the lock dropped.  It is also possible that
5257          * an overlapping map exists in the tree
5258          */
5259         if (ret == -EEXIST) {
5260                 struct extent_map *existing;
5261
5262                 ret = 0;
5263
5264                 existing = lookup_extent_mapping(em_tree, start, len);
5265                 if (existing && (existing->start > start ||
5266                     existing->start + existing->len <= start)) {
5267                         free_extent_map(existing);
5268                         existing = NULL;
5269                 }
5270                 if (!existing) {
5271                         existing = lookup_extent_mapping(em_tree, em->start,
5272                                                          em->len);
5273                         if (existing) {
5274                                 err = merge_extent_mapping(em_tree, existing,
5275                                                            em, start,
5276                                                            root->sectorsize);
5277                                 free_extent_map(existing);
5278                                 if (err) {
5279                                         free_extent_map(em);
5280                                         em = NULL;
5281                                 }
5282                         } else {
5283                                 err = -EIO;
5284                                 free_extent_map(em);
5285                                 em = NULL;
5286                         }
5287                 } else {
5288                         free_extent_map(em);
5289                         em = existing;
5290                         err = 0;
5291                 }
5292         }
5293         write_unlock(&em_tree->lock);
5294 out:
5295         if (path)
5296                 btrfs_free_path(path);
5297         if (trans) {
5298                 ret = btrfs_end_transaction(trans, root);
5299                 if (!err)
5300                         err = ret;
5301         }
5302         if (err) {
5303                 free_extent_map(em);
5304                 return ERR_PTR(err);
5305         }
5306         return em;
5307 }
5308
5309 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
5310                                            size_t pg_offset, u64 start, u64 len,
5311                                            int create)
5312 {
5313         struct extent_map *em;
5314         struct extent_map *hole_em = NULL;
5315         u64 range_start = start;
5316         u64 end;
5317         u64 found;
5318         u64 found_end;
5319         int err = 0;
5320
5321         em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
5322         if (IS_ERR(em))
5323                 return em;
5324         if (em) {
5325                 /*
5326                  * if our em maps to a hole, there might
5327                  * actually be delalloc bytes behind it
5328                  */
5329                 if (em->block_start != EXTENT_MAP_HOLE)
5330                         return em;
5331                 else
5332                         hole_em = em;
5333         }
5334
5335         /* check to see if we've wrapped (len == -1 or similar) */
5336         end = start + len;
5337         if (end < start)
5338                 end = (u64)-1;
5339         else
5340                 end -= 1;
5341
5342         em = NULL;
5343
5344         /* ok, we didn't find anything, lets look for delalloc */
5345         found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
5346                                  end, len, EXTENT_DELALLOC, 1);
5347         found_end = range_start + found;
5348         if (found_end < range_start)
5349                 found_end = (u64)-1;
5350
5351         /*
5352          * we didn't find anything useful, return
5353          * the original results from get_extent()
5354          */
5355         if (range_start > end || found_end <= start) {
5356                 em = hole_em;
5357                 hole_em = NULL;
5358                 goto out;
5359         }
5360
5361         /* adjust the range_start to make sure it doesn't
5362          * go backwards from the start they passed in
5363          */
5364         range_start = max(start,range_start);
5365         found = found_end - range_start;
5366
5367         if (found > 0) {
5368                 u64 hole_start = start;
5369                 u64 hole_len = len;
5370
5371                 em = alloc_extent_map(GFP_NOFS);
5372                 if (!em) {
5373                         err = -ENOMEM;
5374                         goto out;
5375                 }
5376                 /*
5377                  * when btrfs_get_extent can't find anything it
5378                  * returns one huge hole
5379                  *
5380                  * make sure what it found really fits our range, and
5381                  * adjust to make sure it is based on the start from
5382                  * the caller
5383                  */
5384                 if (hole_em) {
5385                         u64 calc_end = extent_map_end(hole_em);
5386
5387                         if (calc_end <= start || (hole_em->start > end)) {
5388                                 free_extent_map(hole_em);
5389                                 hole_em = NULL;
5390                         } else {
5391                                 hole_start = max(hole_em->start, start);
5392                                 hole_len = calc_end - hole_start;
5393                         }
5394                 }
5395                 em->bdev = NULL;
5396                 if (hole_em && range_start > hole_start) {
5397                         /* our hole starts before our delalloc, so we
5398                          * have to return just the parts of the hole
5399                          * that go until  the delalloc starts
5400                          */
5401                         em->len = min(hole_len,
5402                                       range_start - hole_start);
5403                         em->start = hole_start;
5404                         em->orig_start = hole_start;
5405                         /*
5406                          * don't adjust block start at all,
5407                          * it is fixed at EXTENT_MAP_HOLE
5408                          */
5409                         em->block_start = hole_em->block_start;
5410                         em->block_len = hole_len;
5411                 } else {
5412                         em->start = range_start;
5413                         em->len = found;
5414                         em->orig_start = range_start;
5415                         em->block_start = EXTENT_MAP_DELALLOC;
5416                         em->block_len = found;
5417                 }
5418         } else if (hole_em) {
5419                 return hole_em;
5420         }
5421 out:
5422
5423         free_extent_map(hole_em);
5424         if (err) {
5425                 free_extent_map(em);
5426                 return ERR_PTR(err);
5427         }
5428         return em;
5429 }
5430
5431 static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5432                                                   u64 start, u64 len)
5433 {
5434         struct btrfs_root *root = BTRFS_I(inode)->root;
5435         struct btrfs_trans_handle *trans;
5436         struct extent_map *em;
5437         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5438         struct btrfs_key ins;
5439         u64 alloc_hint;
5440         int ret;
5441
5442         btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
5443
5444         trans = btrfs_join_transaction(root, 0);
5445         if (IS_ERR(trans))
5446                 return ERR_CAST(trans);
5447
5448         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
5449
5450         alloc_hint = get_extent_allocation_hint(inode, start, len);
5451         ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
5452                                    alloc_hint, (u64)-1, &ins, 1);
5453         if (ret) {
5454                 em = ERR_PTR(ret);
5455                 goto out;
5456         }
5457
5458         em = alloc_extent_map(GFP_NOFS);
5459         if (!em) {
5460                 em = ERR_PTR(-ENOMEM);
5461                 goto out;
5462         }
5463
5464         em->start = start;
5465         em->orig_start = em->start;
5466         em->len = ins.offset;
5467
5468         em->block_start = ins.objectid;
5469         em->block_len = ins.offset;
5470         em->bdev = root->fs_info->fs_devices->latest_bdev;
5471         set_bit(EXTENT_FLAG_PINNED, &em->flags);
5472
5473         while (1) {
5474                 write_lock(&em_tree->lock);
5475                 ret = add_extent_mapping(em_tree, em);
5476                 write_unlock(&em_tree->lock);
5477                 if (ret != -EEXIST)
5478                         break;
5479                 btrfs_drop_extent_cache(inode, start, start + em->len - 1, 0);
5480         }
5481
5482         ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
5483                                            ins.offset, ins.offset, 0);
5484         if (ret) {
5485                 btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
5486                 em = ERR_PTR(ret);
5487         }
5488 out:
5489         btrfs_end_transaction(trans, root);
5490         return em;
5491 }
5492
5493 /*
5494  * returns 1 when the nocow is safe, < 1 on error, 0 if the
5495  * block must be cow'd
5496  */
5497 static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
5498                                       struct inode *inode, u64 offset, u64 len)
5499 {
5500         struct btrfs_path *path;
5501         int ret;
5502         struct extent_buffer *leaf;
5503         struct btrfs_root *root = BTRFS_I(inode)->root;
5504         struct btrfs_file_extent_item *fi;
5505         struct btrfs_key key;
5506         u64 disk_bytenr;
5507         u64 backref_offset;
5508         u64 extent_end;
5509         u64 num_bytes;
5510         int slot;
5511         int found_type;
5512
5513         path = btrfs_alloc_path();
5514         if (!path)
5515                 return -ENOMEM;
5516
5517         ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
5518                                        offset, 0);
5519         if (ret < 0)
5520                 goto out;
5521
5522         slot = path->slots[0];
5523         if (ret == 1) {
5524                 if (slot == 0) {
5525                         /* can't find the item, must cow */
5526                         ret = 0;
5527                         goto out;
5528                 }
5529                 slot--;
5530         }
5531         ret = 0;
5532         leaf = path->nodes[0];
5533         btrfs_item_key_to_cpu(leaf, &key, slot);
5534         if (key.objectid != inode->i_ino ||
5535             key.type != BTRFS_EXTENT_DATA_KEY) {
5536                 /* not our file or wrong item type, must cow */
5537                 goto out;
5538         }
5539
5540         if (key.offset > offset) {
5541                 /* Wrong offset, must cow */
5542                 goto out;
5543         }
5544
5545         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
5546         found_type = btrfs_file_extent_type(leaf, fi);
5547         if (found_type != BTRFS_FILE_EXTENT_REG &&
5548             found_type != BTRFS_FILE_EXTENT_PREALLOC) {
5549                 /* not a regular extent, must cow */
5550                 goto out;
5551         }
5552         disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
5553         backref_offset = btrfs_file_extent_offset(leaf, fi);
5554
5555         extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
5556         if (extent_end < offset + len) {
5557                 /* extent doesn't include our full range, must cow */
5558                 goto out;
5559         }
5560
5561         if (btrfs_extent_readonly(root, disk_bytenr))
5562                 goto out;
5563
5564         /*
5565          * look for other files referencing this extent, if we
5566          * find any we must cow
5567          */
5568         if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
5569                                   key.offset - backref_offset, disk_bytenr))
5570                 goto out;
5571
5572         /*
5573          * adjust disk_bytenr and num_bytes to cover just the bytes
5574          * in this extent we are about to write.  If there
5575          * are any csums in that range we have to cow in order
5576          * to keep the csums correct
5577          */
5578         disk_bytenr += backref_offset;
5579         disk_bytenr += offset - key.offset;
5580         num_bytes = min(offset + len, extent_end) - offset;
5581         if (csum_exist_in_range(root, disk_bytenr, num_bytes))
5582                                 goto out;
5583         /*
5584          * all of the above have passed, it is safe to overwrite this extent
5585          * without cow
5586          */
5587         ret = 1;
5588 out:
5589         btrfs_free_path(path);
5590         return ret;
5591 }
5592
5593 static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
5594                                    struct buffer_head *bh_result, int create)
5595 {
5596         struct extent_map *em;
5597         struct btrfs_root *root = BTRFS_I(inode)->root;
5598         u64 start = iblock << inode->i_blkbits;
5599         u64 len = bh_result->b_size;
5600         struct btrfs_trans_handle *trans;
5601
5602         em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
5603         if (IS_ERR(em))
5604                 return PTR_ERR(em);
5605
5606         /*
5607          * Ok for INLINE and COMPRESSED extents we need to fallback on buffered
5608          * io.  INLINE is special, and we could probably kludge it in here, but
5609          * it's still buffered so for safety lets just fall back to the generic
5610          * buffered path.
5611          *
5612          * For COMPRESSED we _have_ to read the entire extent in so we can
5613          * decompress it, so there will be buffering required no matter what we
5614          * do, so go ahead and fallback to buffered.
5615          *
5616          * We return -ENOTBLK because thats what makes DIO go ahead and go back
5617          * to buffered IO.  Don't blame me, this is the price we pay for using
5618          * the generic code.
5619          */
5620         if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||
5621             em->block_start == EXTENT_MAP_INLINE) {
5622                 free_extent_map(em);
5623                 return -ENOTBLK;
5624         }
5625
5626         /* Just a good old fashioned hole, return */
5627         if (!create && (em->block_start == EXTENT_MAP_HOLE ||
5628                         test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
5629                 free_extent_map(em);
5630                 /* DIO will do one hole at a time, so just unlock a sector */
5631                 unlock_extent(&BTRFS_I(inode)->io_tree, start,
5632                               start + root->sectorsize - 1, GFP_NOFS);
5633                 return 0;
5634         }
5635
5636         /*
5637          * We don't allocate a new extent in the following cases
5638          *
5639          * 1) The inode is marked as NODATACOW.  In this case we'll just use the
5640          * existing extent.
5641          * 2) The extent is marked as PREALLOC.  We're good to go here and can
5642          * just use the extent.
5643          *
5644          */
5645         if (!create) {
5646                 len = em->len - (start - em->start);
5647                 goto map;
5648         }
5649
5650         if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
5651             ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
5652              em->block_start != EXTENT_MAP_HOLE)) {
5653                 int type;
5654                 int ret;
5655                 u64 block_start;
5656
5657                 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
5658                         type = BTRFS_ORDERED_PREALLOC;
5659                 else
5660                         type = BTRFS_ORDERED_NOCOW;
5661                 len = min(len, em->len - (start - em->start));
5662                 block_start = em->block_start + (start - em->start);
5663
5664                 /*
5665                  * we're not going to log anything, but we do need
5666                  * to make sure the current transaction stays open
5667                  * while we look for nocow cross refs
5668                  */
5669                 trans = btrfs_join_transaction(root, 0);
5670                 if (IS_ERR(trans))
5671                         goto must_cow;
5672
5673                 if (can_nocow_odirect(trans, inode, start, len) == 1) {
5674                         ret = btrfs_add_ordered_extent_dio(inode, start,
5675                                            block_start, len, len, type);
5676                         btrfs_end_transaction(trans, root);
5677                         if (ret) {
5678                                 free_extent_map(em);
5679                                 return ret;
5680                         }
5681                         goto unlock;
5682                 }
5683                 btrfs_end_transaction(trans, root);
5684         }
5685 must_cow:
5686         /*
5687          * this will cow the extent, reset the len in case we changed
5688          * it above
5689          */
5690         len = bh_result->b_size;
5691         free_extent_map(em);
5692         em = btrfs_new_extent_direct(inode, start, len);
5693         if (IS_ERR(em))
5694                 return PTR_ERR(em);
5695         len = min(len, em->len - (start - em->start));
5696 unlock:
5697         clear_extent_bit(&BTRFS_I(inode)->io_tree, start, start + len - 1,
5698                           EXTENT_LOCKED | EXTENT_DELALLOC | EXTENT_DIRTY, 1,
5699                           0, NULL, GFP_NOFS);
5700 map:
5701         bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
5702                 inode->i_blkbits;
5703         bh_result->b_size = len;
5704         bh_result->b_bdev = em->bdev;
5705         set_buffer_mapped(bh_result);
5706         if (create && !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
5707                 set_buffer_new(bh_result);
5708
5709         free_extent_map(em);
5710
5711         return 0;
5712 }
5713
5714 struct btrfs_dio_private {
5715         struct inode *inode;
5716         u64 logical_offset;
5717         u64 disk_bytenr;
5718         u64 bytes;
5719         u32 *csums;
5720         void *private;
5721
5722         /* number of bios pending for this dio */
5723         atomic_t pending_bios;
5724
5725         /* IO errors */
5726         int errors;
5727
5728         struct bio *orig_bio;
5729 };
5730
5731 static void btrfs_endio_direct_read(struct bio *bio, int err)
5732 {
5733         struct btrfs_dio_private *dip = bio->bi_private;
5734         struct bio_vec *bvec_end = bio->bi_io_vec + bio->bi_vcnt - 1;
5735         struct bio_vec *bvec = bio->bi_io_vec;
5736         struct inode *inode = dip->inode;
5737         struct btrfs_root *root = BTRFS_I(inode)->root;
5738         u64 start;
5739         u32 *private = dip->csums;
5740
5741         start = dip->logical_offset;
5742         do {
5743                 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
5744                         struct page *page = bvec->bv_page;
5745                         char *kaddr;
5746                         u32 csum = ~(u32)0;
5747                         unsigned long flags;
5748
5749                         local_irq_save(flags);
5750                         kaddr = kmap_atomic(page, KM_IRQ0);
5751                         csum = btrfs_csum_data(root, kaddr + bvec->bv_offset,
5752                                                csum, bvec->bv_len);
5753                         btrfs_csum_final(csum, (char *)&csum);
5754                         kunmap_atomic(kaddr, KM_IRQ0);
5755                         local_irq_restore(flags);
5756
5757                         flush_dcache_page(bvec->bv_page);
5758                         if (csum != *private) {
5759                                 printk(KERN_ERR "btrfs csum failed ino %lu off"
5760                                       " %llu csum %u private %u\n",
5761                                       inode->i_ino, (unsigned long long)start,
5762                                       csum, *private);
5763                                 err = -EIO;
5764                         }
5765                 }
5766
5767                 start += bvec->bv_len;
5768                 private++;
5769                 bvec++;
5770         } while (bvec <= bvec_end);
5771
5772         unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
5773                       dip->logical_offset + dip->bytes - 1, GFP_NOFS);
5774         bio->bi_private = dip->private;
5775
5776         kfree(dip->csums);
5777         kfree(dip);
5778         dio_end_io(bio, err);
5779 }
5780
5781 static void btrfs_endio_direct_write(struct bio *bio, int err)
5782 {
5783         struct btrfs_dio_private *dip = bio->bi_private;
5784         struct inode *inode = dip->inode;
5785         struct btrfs_root *root = BTRFS_I(inode)->root;
5786         struct btrfs_trans_handle *trans;
5787         struct btrfs_ordered_extent *ordered = NULL;
5788         struct extent_state *cached_state = NULL;
5789         u64 ordered_offset = dip->logical_offset;
5790         u64 ordered_bytes = dip->bytes;
5791         int ret;
5792
5793         if (err)
5794                 goto out_done;
5795 again:
5796         ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
5797                                                    &ordered_offset,
5798                                                    ordered_bytes);
5799         if (!ret)
5800                 goto out_test;
5801
5802         BUG_ON(!ordered);
5803
5804         trans = btrfs_join_transaction(root, 1);
5805         if (IS_ERR(trans)) {
5806                 err = -ENOMEM;
5807                 goto out;
5808         }
5809         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
5810
5811         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
5812                 ret = btrfs_ordered_update_i_size(inode, 0, ordered);
5813                 if (!ret)
5814                         ret = btrfs_update_inode(trans, root, inode);
5815                 err = ret;
5816                 goto out;
5817         }
5818
5819         lock_extent_bits(&BTRFS_I(inode)->io_tree, ordered->file_offset,
5820                          ordered->file_offset + ordered->len - 1, 0,
5821                          &cached_state, GFP_NOFS);
5822
5823         if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
5824                 ret = btrfs_mark_extent_written(trans, inode,
5825                                                 ordered->file_offset,
5826                                                 ordered->file_offset +
5827                                                 ordered->len);
5828                 if (ret) {
5829                         err = ret;
5830                         goto out_unlock;
5831                 }
5832         } else {
5833                 ret = insert_reserved_file_extent(trans, inode,
5834                                                   ordered->file_offset,
5835                                                   ordered->start,
5836                                                   ordered->disk_len,
5837                                                   ordered->len,
5838                                                   ordered->len,
5839                                                   0, 0, 0,
5840                                                   BTRFS_FILE_EXTENT_REG);
5841                 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
5842                                    ordered->file_offset, ordered->len);
5843                 if (ret) {
5844                         err = ret;
5845                         WARN_ON(1);
5846                         goto out_unlock;
5847                 }
5848         }
5849
5850         add_pending_csums(trans, inode, ordered->file_offset, &ordered->list);
5851         btrfs_ordered_update_i_size(inode, 0, ordered);
5852         btrfs_update_inode(trans, root, inode);
5853 out_unlock:
5854         unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset,
5855                              ordered->file_offset + ordered->len - 1,
5856                              &cached_state, GFP_NOFS);
5857 out:
5858         btrfs_delalloc_release_metadata(inode, ordered->len);
5859         btrfs_end_transaction(trans, root);
5860         ordered_offset = ordered->file_offset + ordered->len;
5861         btrfs_put_ordered_extent(ordered);
5862         btrfs_put_ordered_extent(ordered);
5863
5864 out_test:
5865         /*
5866          * our bio might span multiple ordered extents.  If we haven't
5867          * completed the accounting for the whole dio, go back and try again
5868          */
5869         if (ordered_offset < dip->logical_offset + dip->bytes) {
5870                 ordered_bytes = dip->logical_offset + dip->bytes -
5871                         ordered_offset;
5872                 goto again;
5873         }
5874 out_done:
5875         bio->bi_private = dip->private;
5876
5877         kfree(dip->csums);
5878         kfree(dip);
5879         dio_end_io(bio, err);
5880 }
5881
5882 static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
5883                                     struct bio *bio, int mirror_num,
5884                                     unsigned long bio_flags, u64 offset)
5885 {
5886         int ret;
5887         struct btrfs_root *root = BTRFS_I(inode)->root;
5888         ret = btrfs_csum_one_bio(root, inode, bio, offset, 1);
5889         BUG_ON(ret);
5890         return 0;
5891 }
5892
5893 static void btrfs_end_dio_bio(struct bio *bio, int err)
5894 {
5895         struct btrfs_dio_private *dip = bio->bi_private;
5896
5897         if (err) {
5898                 printk(KERN_ERR "btrfs direct IO failed ino %lu rw %lu "
5899                       "sector %#Lx len %u err no %d\n",
5900                       dip->inode->i_ino, bio->bi_rw,
5901                       (unsigned long long)bio->bi_sector, bio->bi_size, err);
5902                 dip->errors = 1;
5903
5904                 /*
5905                  * before atomic variable goto zero, we must make sure
5906                  * dip->errors is perceived to be set.
5907                  */
5908                 smp_mb__before_atomic_dec();
5909         }
5910
5911         /* if there are more bios still pending for this dio, just exit */
5912         if (!atomic_dec_and_test(&dip->pending_bios))
5913                 goto out;
5914
5915         if (dip->errors)
5916                 bio_io_error(dip->orig_bio);
5917         else {
5918                 set_bit(BIO_UPTODATE, &dip->orig_bio->bi_flags);
5919                 bio_endio(dip->orig_bio, 0);
5920         }
5921 out:
5922         bio_put(bio);
5923 }
5924
5925 static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
5926                                        u64 first_sector, gfp_t gfp_flags)
5927 {
5928         int nr_vecs = bio_get_nr_vecs(bdev);
5929         return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags);
5930 }
5931
5932 static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
5933                                          int rw, u64 file_offset, int skip_sum,
5934                                          u32 *csums)
5935 {
5936         int write = rw & REQ_WRITE;
5937         struct btrfs_root *root = BTRFS_I(inode)->root;
5938         int ret;
5939
5940         bio_get(bio);
5941         ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
5942         if (ret)
5943                 goto err;
5944
5945         if (write && !skip_sum) {
5946                 ret = btrfs_wq_submit_bio(root->fs_info,
5947                                    inode, rw, bio, 0, 0,
5948                                    file_offset,
5949                                    __btrfs_submit_bio_start_direct_io,
5950                                    __btrfs_submit_bio_done);
5951                 goto err;
5952         } else if (!skip_sum)
5953                 btrfs_lookup_bio_sums_dio(root, inode, bio,
5954                                           file_offset, csums);
5955
5956         ret = btrfs_map_bio(root, rw, bio, 0, 1);
5957 err:
5958         bio_put(bio);
5959         return ret;
5960 }
5961
5962 static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
5963                                     int skip_sum)
5964 {
5965         struct inode *inode = dip->inode;
5966         struct btrfs_root *root = BTRFS_I(inode)->root;
5967         struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
5968         struct bio *bio;
5969         struct bio *orig_bio = dip->orig_bio;
5970         struct bio_vec *bvec = orig_bio->bi_io_vec;
5971         u64 start_sector = orig_bio->bi_sector;
5972         u64 file_offset = dip->logical_offset;
5973         u64 submit_len = 0;
5974         u64 map_length;
5975         int nr_pages = 0;
5976         u32 *csums = dip->csums;
5977         int ret = 0;
5978
5979         bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
5980         if (!bio)
5981                 return -ENOMEM;
5982         bio->bi_private = dip;
5983         bio->bi_end_io = btrfs_end_dio_bio;
5984         atomic_inc(&dip->pending_bios);
5985
5986         map_length = orig_bio->bi_size;
5987         ret = btrfs_map_block(map_tree, READ, start_sector << 9,
5988                               &map_length, NULL, 0);
5989         if (ret) {
5990                 bio_put(bio);
5991                 return -EIO;
5992         }
5993
5994         while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
5995                 if (unlikely(map_length < submit_len + bvec->bv_len ||
5996                     bio_add_page(bio, bvec->bv_page, bvec->bv_len,
5997                                  bvec->bv_offset) < bvec->bv_len)) {
5998                         /*
5999                          * inc the count before we submit the bio so
6000                          * we know the end IO handler won't happen before
6001                          * we inc the count. Otherwise, the dip might get freed
6002                          * before we're done setting it up
6003                          */
6004                         atomic_inc(&dip->pending_bios);
6005                         ret = __btrfs_submit_dio_bio(bio, inode, rw,
6006                                                      file_offset, skip_sum,
6007                                                      csums);
6008                         if (ret) {
6009                                 bio_put(bio);
6010                                 atomic_dec(&dip->pending_bios);
6011                                 goto out_err;
6012                         }
6013
6014                         if (!skip_sum)
6015                                 csums = csums + nr_pages;
6016                         start_sector += submit_len >> 9;
6017                         file_offset += submit_len;
6018
6019                         submit_len = 0;
6020                         nr_pages = 0;
6021
6022                         bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
6023                                                   start_sector, GFP_NOFS);
6024                         if (!bio)
6025                                 goto out_err;
6026                         bio->bi_private = dip;
6027                         bio->bi_end_io = btrfs_end_dio_bio;
6028
6029                         map_length = orig_bio->bi_size;
6030                         ret = btrfs_map_block(map_tree, READ, start_sector << 9,
6031                                               &map_length, NULL, 0);
6032                         if (ret) {
6033                                 bio_put(bio);
6034                                 goto out_err;
6035                         }
6036                 } else {
6037                         submit_len += bvec->bv_len;
6038                         nr_pages ++;
6039                         bvec++;
6040                 }
6041         }
6042
6043         ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
6044                                      csums);
6045         if (!ret)
6046                 return 0;
6047
6048         bio_put(bio);
6049 out_err:
6050         dip->errors = 1;
6051         /*
6052          * before atomic variable goto zero, we must
6053          * make sure dip->errors is perceived to be set.
6054          */
6055         smp_mb__before_atomic_dec();
6056         if (atomic_dec_and_test(&dip->pending_bios))
6057                 bio_io_error(dip->orig_bio);
6058
6059         /* bio_end_io() will handle error, so we needn't return it */
6060         return 0;
6061 }
6062
6063 static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
6064                                 loff_t file_offset)
6065 {
6066         struct btrfs_root *root = BTRFS_I(inode)->root;
6067         struct btrfs_dio_private *dip;
6068         struct bio_vec *bvec = bio->bi_io_vec;
6069         int skip_sum;
6070         int write = rw & REQ_WRITE;
6071         int ret = 0;
6072
6073         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
6074
6075         dip = kmalloc(sizeof(*dip), GFP_NOFS);
6076         if (!dip) {
6077                 ret = -ENOMEM;
6078                 goto free_ordered;
6079         }
6080         dip->csums = NULL;
6081
6082         if (!skip_sum) {
6083                 dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS);
6084                 if (!dip->csums) {
6085                         kfree(dip);
6086                         ret = -ENOMEM;
6087                         goto free_ordered;
6088                 }
6089         }
6090
6091         dip->private = bio->bi_private;
6092         dip->inode = inode;
6093         dip->logical_offset = file_offset;
6094
6095         dip->bytes = 0;
6096         do {
6097                 dip->bytes += bvec->bv_len;
6098                 bvec++;
6099         } while (bvec <= (bio->bi_io_vec + bio->bi_vcnt - 1));
6100
6101         dip->disk_bytenr = (u64)bio->bi_sector << 9;
6102         bio->bi_private = dip;
6103         dip->errors = 0;
6104         dip->orig_bio = bio;
6105         atomic_set(&dip->pending_bios, 0);
6106
6107         if (write)
6108                 bio->bi_end_io = btrfs_endio_direct_write;
6109         else
6110                 bio->bi_end_io = btrfs_endio_direct_read;
6111
6112         ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
6113         if (!ret)
6114                 return;
6115 free_ordered:
6116         /*
6117          * If this is a write, we need to clean up the reserved space and kill
6118          * the ordered extent.
6119          */
6120         if (write) {
6121                 struct btrfs_ordered_extent *ordered;
6122                 ordered = btrfs_lookup_ordered_extent(inode, file_offset);
6123                 if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
6124                     !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
6125                         btrfs_free_reserved_extent(root, ordered->start,
6126                                                    ordered->disk_len);
6127                 btrfs_put_ordered_extent(ordered);
6128                 btrfs_put_ordered_extent(ordered);
6129         }
6130         bio_endio(bio, ret);
6131 }
6132
6133 static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
6134                         const struct iovec *iov, loff_t offset,
6135                         unsigned long nr_segs)
6136 {
6137         int seg;
6138         size_t size;
6139         unsigned long addr;
6140         unsigned blocksize_mask = root->sectorsize - 1;
6141         ssize_t retval = -EINVAL;
6142         loff_t end = offset;
6143
6144         if (offset & blocksize_mask)
6145                 goto out;
6146
6147         /* Check the memory alignment.  Blocks cannot straddle pages */
6148         for (seg = 0; seg < nr_segs; seg++) {
6149                 addr = (unsigned long)iov[seg].iov_base;
6150                 size = iov[seg].iov_len;
6151                 end += size;
6152                 if ((addr & blocksize_mask) || (size & blocksize_mask))
6153                         goto out;
6154         }
6155         retval = 0;
6156 out:
6157         return retval;
6158 }
6159 static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
6160                         const struct iovec *iov, loff_t offset,
6161                         unsigned long nr_segs)
6162 {
6163         struct file *file = iocb->ki_filp;
6164         struct inode *inode = file->f_mapping->host;
6165         struct btrfs_ordered_extent *ordered;
6166         struct extent_state *cached_state = NULL;
6167         u64 lockstart, lockend;
6168         ssize_t ret;
6169         int writing = rw & WRITE;
6170         int write_bits = 0;
6171         size_t count = iov_length(iov, nr_segs);
6172
6173         if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
6174                             offset, nr_segs)) {
6175                 return 0;
6176         }
6177
6178         lockstart = offset;
6179         lockend = offset + count - 1;
6180
6181         if (writing) {
6182                 ret = btrfs_delalloc_reserve_space(inode, count);
6183                 if (ret)
6184                         goto out;
6185         }
6186
6187         while (1) {
6188                 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6189                                  0, &cached_state, GFP_NOFS);
6190                 /*
6191                  * We're concerned with the entire range that we're going to be
6192                  * doing DIO to, so we need to make sure theres no ordered
6193                  * extents in this range.
6194                  */
6195                 ordered = btrfs_lookup_ordered_range(inode, lockstart,
6196                                                      lockend - lockstart + 1);
6197                 if (!ordered)
6198                         break;
6199                 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6200                                      &cached_state, GFP_NOFS);
6201                 btrfs_start_ordered_extent(inode, ordered, 1);
6202                 btrfs_put_ordered_extent(ordered);
6203                 cond_resched();
6204         }
6205
6206         /*
6207          * we don't use btrfs_set_extent_delalloc because we don't want
6208          * the dirty or uptodate bits
6209          */
6210         if (writing) {
6211                 write_bits = EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING;
6212                 ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6213                                      EXTENT_DELALLOC, 0, NULL, &cached_state,
6214                                      GFP_NOFS);
6215                 if (ret) {
6216                         clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
6217                                          lockend, EXTENT_LOCKED | write_bits,
6218                                          1, 0, &cached_state, GFP_NOFS);
6219                         goto out;
6220                 }
6221         }
6222
6223         free_extent_state(cached_state);
6224         cached_state = NULL;
6225
6226         ret = __blockdev_direct_IO(rw, iocb, inode,
6227                    BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
6228                    iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
6229                    btrfs_submit_direct, 0);
6230
6231         if (ret < 0 && ret != -EIOCBQUEUED) {
6232                 clear_extent_bit(&BTRFS_I(inode)->io_tree, offset,
6233                               offset + iov_length(iov, nr_segs) - 1,
6234                               EXTENT_LOCKED | write_bits, 1, 0,
6235                               &cached_state, GFP_NOFS);
6236         } else if (ret >= 0 && ret < iov_length(iov, nr_segs)) {
6237                 /*
6238                  * We're falling back to buffered, unlock the section we didn't
6239                  * do IO on.
6240                  */
6241                 clear_extent_bit(&BTRFS_I(inode)->io_tree, offset + ret,
6242                               offset + iov_length(iov, nr_segs) - 1,
6243                               EXTENT_LOCKED | write_bits, 1, 0,
6244                               &cached_state, GFP_NOFS);
6245         }
6246 out:
6247         free_extent_state(cached_state);
6248         return ret;
6249 }
6250
6251 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
6252                 __u64 start, __u64 len)
6253 {
6254         return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
6255 }
6256
6257 int btrfs_readpage(struct file *file, struct page *page)
6258 {
6259         struct extent_io_tree *tree;
6260         tree = &BTRFS_I(page->mapping->host)->io_tree;
6261         return extent_read_full_page(tree, page, btrfs_get_extent);
6262 }
6263
6264 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
6265 {
6266         struct extent_io_tree *tree;
6267
6268
6269         if (current->flags & PF_MEMALLOC) {
6270                 redirty_page_for_writepage(wbc, page);
6271                 unlock_page(page);
6272                 return 0;
6273         }
6274         tree = &BTRFS_I(page->mapping->host)->io_tree;
6275         return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
6276 }
6277
6278 int btrfs_writepages(struct address_space *mapping,
6279                      struct writeback_control *wbc)
6280 {
6281         struct extent_io_tree *tree;
6282
6283         tree = &BTRFS_I(mapping->host)->io_tree;
6284         return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
6285 }
6286
6287 static int
6288 btrfs_readpages(struct file *file, struct address_space *mapping,
6289                 struct list_head *pages, unsigned nr_pages)
6290 {
6291         struct extent_io_tree *tree;
6292         tree = &BTRFS_I(mapping->host)->io_tree;
6293         return extent_readpages(tree, mapping, pages, nr_pages,
6294                                 btrfs_get_extent);
6295 }
6296 static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
6297 {
6298         struct extent_io_tree *tree;
6299         struct extent_map_tree *map;
6300         int ret;
6301
6302         tree = &BTRFS_I(page->mapping->host)->io_tree;
6303         map = &BTRFS_I(page->mapping->host)->extent_tree;
6304         ret = try_release_extent_mapping(map, tree, page, gfp_flags);
6305         if (ret == 1) {
6306                 ClearPagePrivate(page);
6307                 set_page_private(page, 0);
6308                 page_cache_release(page);
6309         }
6310         return ret;
6311 }
6312
6313 static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
6314 {
6315         if (PageWriteback(page) || PageDirty(page))
6316                 return 0;
6317         return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
6318 }
6319
6320 static void btrfs_invalidatepage(struct page *page, unsigned long offset)
6321 {
6322         struct extent_io_tree *tree;
6323         struct btrfs_ordered_extent *ordered;
6324         struct extent_state *cached_state = NULL;
6325         u64 page_start = page_offset(page);
6326         u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
6327
6328
6329         /*
6330          * we have the page locked, so new writeback can't start,
6331          * and the dirty bit won't be cleared while we are here.
6332          *
6333          * Wait for IO on this page so that we can safely clear
6334          * the PagePrivate2 bit and do ordered accounting
6335          */
6336         wait_on_page_writeback(page);
6337
6338         tree = &BTRFS_I(page->mapping->host)->io_tree;
6339         if (offset) {
6340                 btrfs_releasepage(page, GFP_NOFS);
6341                 return;
6342         }
6343         lock_extent_bits(tree, page_start, page_end, 0, &cached_state,
6344                          GFP_NOFS);
6345         ordered = btrfs_lookup_ordered_extent(page->mapping->host,
6346                                            page_offset(page));
6347         if (ordered) {
6348                 /*
6349                  * IO on this page will never be started, so we need
6350                  * to account for any ordered extents now
6351                  */
6352                 clear_extent_bit(tree, page_start, page_end,
6353                                  EXTENT_DIRTY | EXTENT_DELALLOC |
6354                                  EXTENT_LOCKED | EXTENT_DO_ACCOUNTING, 1, 0,
6355                                  &cached_state, GFP_NOFS);
6356                 /*
6357                  * whoever cleared the private bit is responsible
6358                  * for the finish_ordered_io
6359                  */
6360                 if (TestClearPagePrivate2(page)) {
6361                         btrfs_finish_ordered_io(page->mapping->host,
6362                                                 page_start, page_end);
6363                 }
6364                 btrfs_put_ordered_extent(ordered);
6365                 cached_state = NULL;
6366                 lock_extent_bits(tree, page_start, page_end, 0, &cached_state,
6367                                  GFP_NOFS);
6368         }
6369         clear_extent_bit(tree, page_start, page_end,
6370                  EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
6371                  EXTENT_DO_ACCOUNTING, 1, 1, &cached_state, GFP_NOFS);
6372         __btrfs_releasepage(page, GFP_NOFS);
6373
6374         ClearPageChecked(page);
6375         if (PagePrivate(page)) {
6376                 ClearPagePrivate(page);
6377                 set_page_private(page, 0);
6378                 page_cache_release(page);
6379         }
6380 }
6381
6382 /*
6383  * btrfs_page_mkwrite() is not allowed to change the file size as it gets
6384  * called from a page fault handler when a page is first dirtied. Hence we must
6385  * be careful to check for EOF conditions here. We set the page up correctly
6386  * for a written page which means we get ENOSPC checking when writing into
6387  * holes and correct delalloc and unwritten extent mapping on filesystems that
6388  * support these features.
6389  *
6390  * We are not allowed to take the i_mutex here so we have to play games to
6391  * protect against truncate races as the page could now be beyond EOF.  Because
6392  * vmtruncate() writes the inode size before removing pages, once we have the
6393  * page lock we can determine safely if the page is beyond EOF. If it is not
6394  * beyond EOF, then the page is guaranteed safe against truncation until we
6395  * unlock the page.
6396  */
6397 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
6398 {
6399         struct page *page = vmf->page;
6400         struct inode *inode = fdentry(vma->vm_file)->d_inode;
6401         struct btrfs_root *root = BTRFS_I(inode)->root;
6402         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
6403         struct btrfs_ordered_extent *ordered;
6404         struct extent_state *cached_state = NULL;
6405         char *kaddr;
6406         unsigned long zero_start;
6407         loff_t size;
6408         int ret;
6409         u64 page_start;
6410         u64 page_end;
6411
6412         ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
6413         if (ret) {
6414                 if (ret == -ENOMEM)
6415                         ret = VM_FAULT_OOM;
6416                 else /* -ENOSPC, -EIO, etc */
6417                         ret = VM_FAULT_SIGBUS;
6418                 goto out;
6419         }
6420
6421         ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
6422 again:
6423         lock_page(page);
6424         size = i_size_read(inode);
6425         page_start = page_offset(page);
6426         page_end = page_start + PAGE_CACHE_SIZE - 1;
6427
6428         if ((page->mapping != inode->i_mapping) ||
6429             (page_start >= size)) {
6430                 /* page got truncated out from underneath us */
6431                 goto out_unlock;
6432         }
6433         wait_on_page_writeback(page);
6434
6435         lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state,
6436                          GFP_NOFS);
6437         set_page_extent_mapped(page);
6438
6439         /*
6440          * we can't set the delalloc bits if there are pending ordered
6441          * extents.  Drop our locks and wait for them to finish
6442          */
6443         ordered = btrfs_lookup_ordered_extent(inode, page_start);
6444         if (ordered) {
6445                 unlock_extent_cached(io_tree, page_start, page_end,
6446                                      &cached_state, GFP_NOFS);
6447                 unlock_page(page);
6448                 btrfs_start_ordered_extent(inode, ordered, 1);
6449                 btrfs_put_ordered_extent(ordered);
6450                 goto again;
6451         }
6452
6453         /*
6454          * XXX - page_mkwrite gets called every time the page is dirtied, even
6455          * if it was already dirty, so for space accounting reasons we need to
6456          * clear any delalloc bits for the range we are fixing to save.  There
6457          * is probably a better way to do this, but for now keep consistent with
6458          * prepare_pages in the normal write path.
6459          */
6460         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
6461                           EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
6462                           0, 0, &cached_state, GFP_NOFS);
6463
6464         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
6465                                         &cached_state);
6466         if (ret) {
6467                 unlock_extent_cached(io_tree, page_start, page_end,
6468                                      &cached_state, GFP_NOFS);
6469                 ret = VM_FAULT_SIGBUS;
6470                 goto out_unlock;
6471         }
6472         ret = 0;
6473
6474         /* page is wholly or partially inside EOF */
6475         if (page_start + PAGE_CACHE_SIZE > size)
6476                 zero_start = size & ~PAGE_CACHE_MASK;
6477         else
6478                 zero_start = PAGE_CACHE_SIZE;
6479
6480         if (zero_start != PAGE_CACHE_SIZE) {
6481                 kaddr = kmap(page);
6482                 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
6483                 flush_dcache_page(page);
6484                 kunmap(page);
6485         }
6486         ClearPageChecked(page);
6487         set_page_dirty(page);
6488         SetPageUptodate(page);
6489
6490         BTRFS_I(inode)->last_trans = root->fs_info->generation;
6491         BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
6492
6493         unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
6494
6495 out_unlock:
6496         if (!ret)
6497                 return VM_FAULT_LOCKED;
6498         unlock_page(page);
6499         btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
6500 out:
6501         return ret;
6502 }
6503
6504 static int btrfs_truncate(struct inode *inode)
6505 {
6506         struct btrfs_root *root = BTRFS_I(inode)->root;
6507         int ret;
6508         int err = 0;
6509         struct btrfs_trans_handle *trans;
6510         unsigned long nr;
6511         u64 mask = root->sectorsize - 1;
6512
6513         ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
6514         if (ret)
6515                 return ret;
6516
6517         btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
6518         btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
6519
6520         trans = btrfs_start_transaction(root, 0);
6521         if (IS_ERR(trans))
6522                 return PTR_ERR(trans);
6523         btrfs_set_trans_block_group(trans, inode);
6524         trans->block_rsv = root->orphan_block_rsv;
6525
6526         /*
6527          * setattr is responsible for setting the ordered_data_close flag,
6528          * but that is only tested during the last file release.  That
6529          * could happen well after the next commit, leaving a great big
6530          * window where new writes may get lost if someone chooses to write
6531          * to this file after truncating to zero
6532          *
6533          * The inode doesn't have any dirty data here, and so if we commit
6534          * this is a noop.  If someone immediately starts writing to the inode
6535          * it is very likely we'll catch some of their writes in this
6536          * transaction, and the commit will find this file on the ordered
6537          * data list with good things to send down.
6538          *
6539          * This is a best effort solution, there is still a window where
6540          * using truncate to replace the contents of the file will
6541          * end up with a zero length file after a crash.
6542          */
6543         if (inode->i_size == 0 && BTRFS_I(inode)->ordered_data_close)
6544                 btrfs_add_ordered_operation(trans, root, inode);
6545
6546         while (1) {
6547                 if (!trans) {
6548                         trans = btrfs_start_transaction(root, 0);
6549                         if (IS_ERR(trans))
6550                                 return PTR_ERR(trans);
6551                         btrfs_set_trans_block_group(trans, inode);
6552                         trans->block_rsv = root->orphan_block_rsv;
6553                 }
6554
6555                 ret = btrfs_block_rsv_check(trans, root,
6556                                             root->orphan_block_rsv, 0, 5);
6557                 if (ret == -EAGAIN) {
6558                         ret = btrfs_commit_transaction(trans, root);
6559                         if (ret)
6560                                 return ret;
6561                         trans = NULL;
6562                         continue;
6563                 } else if (ret) {
6564                         err = ret;
6565                         break;
6566                 }
6567
6568                 ret = btrfs_truncate_inode_items(trans, root, inode,
6569                                                  inode->i_size,
6570                                                  BTRFS_EXTENT_DATA_KEY);
6571                 if (ret != -EAGAIN) {
6572                         err = ret;
6573                         break;
6574                 }
6575
6576                 ret = btrfs_update_inode(trans, root, inode);
6577                 if (ret) {
6578                         err = ret;
6579                         break;
6580                 }
6581
6582                 nr = trans->blocks_used;
6583                 btrfs_end_transaction(trans, root);
6584                 trans = NULL;
6585                 btrfs_btree_balance_dirty(root, nr);
6586         }
6587
6588         if (ret == 0 && inode->i_nlink > 0) {
6589                 ret = btrfs_orphan_del(trans, inode);
6590                 if (ret)
6591                         err = ret;
6592         } else if (ret && inode->i_nlink > 0) {
6593                 /*
6594                  * Failed to do the truncate, remove us from the in memory
6595                  * orphan list.
6596                  */
6597                 ret = btrfs_orphan_del(NULL, inode);
6598         }
6599
6600         ret = btrfs_update_inode(trans, root, inode);
6601         if (ret && !err)
6602                 err = ret;
6603
6604         nr = trans->blocks_used;
6605         ret = btrfs_end_transaction_throttle(trans, root);
6606         if (ret && !err)
6607                 err = ret;
6608         btrfs_btree_balance_dirty(root, nr);
6609
6610         return err;
6611 }
6612
6613 /*
6614  * create a new subvolume directory/inode (helper for the ioctl).
6615  */
6616 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
6617                              struct btrfs_root *new_root,
6618                              u64 new_dirid, u64 alloc_hint)
6619 {
6620         struct inode *inode;
6621         int err;
6622         u64 index = 0;
6623
6624         inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid,
6625                                 new_dirid, alloc_hint, S_IFDIR | 0700, &index);
6626         if (IS_ERR(inode))
6627                 return PTR_ERR(inode);
6628         inode->i_op = &btrfs_dir_inode_operations;
6629         inode->i_fop = &btrfs_dir_file_operations;
6630
6631         inode->i_nlink = 1;
6632         btrfs_i_size_write(inode, 0);
6633
6634         err = btrfs_update_inode(trans, new_root, inode);
6635         BUG_ON(err);
6636
6637         iput(inode);
6638         return 0;
6639 }
6640
6641 /* helper function for file defrag and space balancing.  This
6642  * forces readahead on a given range of bytes in an inode
6643  */
6644 unsigned long btrfs_force_ra(struct address_space *mapping,
6645                               struct file_ra_state *ra, struct file *file,
6646                               pgoff_t offset, pgoff_t last_index)
6647 {
6648         pgoff_t req_size = last_index - offset + 1;
6649
6650         page_cache_sync_readahead(mapping, ra, file, offset, req_size);
6651         return offset + req_size;
6652 }
6653
6654 struct inode *btrfs_alloc_inode(struct super_block *sb)
6655 {
6656         struct btrfs_inode *ei;
6657         struct inode *inode;
6658
6659         ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
6660         if (!ei)
6661                 return NULL;
6662
6663         ei->root = NULL;
6664         ei->space_info = NULL;
6665         ei->generation = 0;
6666         ei->sequence = 0;
6667         ei->last_trans = 0;
6668         ei->last_sub_trans = 0;
6669         ei->logged_trans = 0;
6670         ei->delalloc_bytes = 0;
6671         ei->reserved_bytes = 0;
6672         ei->disk_i_size = 0;
6673         ei->flags = 0;
6674         ei->index_cnt = (u64)-1;
6675         ei->last_unlink_trans = 0;
6676
6677         atomic_set(&ei->outstanding_extents, 0);
6678         atomic_set(&ei->reserved_extents, 0);
6679
6680         ei->ordered_data_close = 0;
6681         ei->orphan_meta_reserved = 0;
6682         ei->dummy_inode = 0;
6683         ei->force_compress = BTRFS_COMPRESS_NONE;
6684
6685         inode = &ei->vfs_inode;
6686         extent_map_tree_init(&ei->extent_tree, GFP_NOFS);
6687         extent_io_tree_init(&ei->io_tree, &inode->i_data, GFP_NOFS);
6688         extent_io_tree_init(&ei->io_failure_tree, &inode->i_data, GFP_NOFS);
6689         mutex_init(&ei->log_mutex);
6690         btrfs_ordered_inode_tree_init(&ei->ordered_tree);
6691         INIT_LIST_HEAD(&ei->i_orphan);
6692         INIT_LIST_HEAD(&ei->delalloc_inodes);
6693         INIT_LIST_HEAD(&ei->ordered_operations);
6694         RB_CLEAR_NODE(&ei->rb_node);
6695
6696         return inode;
6697 }
6698
6699 static void btrfs_i_callback(struct rcu_head *head)
6700 {
6701         struct inode *inode = container_of(head, struct inode, i_rcu);
6702         INIT_LIST_HEAD(&inode->i_dentry);
6703         kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
6704 }
6705
6706 void btrfs_destroy_inode(struct inode *inode)
6707 {
6708         struct btrfs_ordered_extent *ordered;
6709         struct btrfs_root *root = BTRFS_I(inode)->root;
6710
6711         WARN_ON(!list_empty(&inode->i_dentry));
6712         WARN_ON(inode->i_data.nrpages);
6713         WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents));
6714         WARN_ON(atomic_read(&BTRFS_I(inode)->reserved_extents));
6715
6716         /*
6717          * This can happen where we create an inode, but somebody else also
6718          * created the same inode and we need to destroy the one we already
6719          * created.
6720          */
6721         if (!root)
6722                 goto free;
6723
6724         /*
6725          * Make sure we're properly removed from the ordered operation
6726          * lists.
6727          */
6728         smp_mb();
6729         if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
6730                 spin_lock(&root->fs_info->ordered_extent_lock);
6731                 list_del_init(&BTRFS_I(inode)->ordered_operations);
6732                 spin_unlock(&root->fs_info->ordered_extent_lock);
6733         }
6734
6735         if (root == root->fs_info->tree_root) {
6736                 struct btrfs_block_group_cache *block_group;
6737
6738                 block_group = btrfs_lookup_block_group(root->fs_info,
6739                                                 BTRFS_I(inode)->block_group);
6740                 if (block_group && block_group->inode == inode) {
6741                         spin_lock(&block_group->lock);
6742                         block_group->inode = NULL;
6743                         spin_unlock(&block_group->lock);
6744                         btrfs_put_block_group(block_group);
6745                 } else if (block_group) {
6746                         btrfs_put_block_group(block_group);
6747                 }
6748         }
6749
6750         spin_lock(&root->orphan_lock);
6751         if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
6752                 printk(KERN_INFO "BTRFS: inode %lu still on the orphan list\n",
6753                        inode->i_ino);
6754                 list_del_init(&BTRFS_I(inode)->i_orphan);
6755         }
6756         spin_unlock(&root->orphan_lock);
6757
6758         while (1) {
6759                 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
6760                 if (!ordered)
6761                         break;
6762                 else {
6763                         printk(KERN_ERR "btrfs found ordered "
6764                                "extent %llu %llu on inode cleanup\n",
6765                                (unsigned long long)ordered->file_offset,
6766                                (unsigned long long)ordered->len);
6767                         btrfs_remove_ordered_extent(inode, ordered);
6768                         btrfs_put_ordered_extent(ordered);
6769                         btrfs_put_ordered_extent(ordered);
6770                 }
6771         }
6772         inode_tree_del(inode);
6773         btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
6774 free:
6775         call_rcu(&inode->i_rcu, btrfs_i_callback);
6776 }
6777
6778 int btrfs_drop_inode(struct inode *inode)
6779 {
6780         struct btrfs_root *root = BTRFS_I(inode)->root;
6781
6782         if (btrfs_root_refs(&root->root_item) == 0 &&
6783             root != root->fs_info->tree_root)
6784                 return 1;
6785         else
6786                 return generic_drop_inode(inode);
6787 }
6788
6789 static void init_once(void *foo)
6790 {
6791         struct btrfs_inode *ei = (struct btrfs_inode *) foo;
6792
6793         inode_init_once(&ei->vfs_inode);
6794 }
6795
6796 void btrfs_destroy_cachep(void)
6797 {
6798         if (btrfs_inode_cachep)
6799                 kmem_cache_destroy(btrfs_inode_cachep);
6800         if (btrfs_trans_handle_cachep)
6801                 kmem_cache_destroy(btrfs_trans_handle_cachep);
6802         if (btrfs_transaction_cachep)
6803                 kmem_cache_destroy(btrfs_transaction_cachep);
6804         if (btrfs_path_cachep)
6805                 kmem_cache_destroy(btrfs_path_cachep);
6806         if (btrfs_free_space_cachep)
6807                 kmem_cache_destroy(btrfs_free_space_cachep);
6808 }
6809
6810 int btrfs_init_cachep(void)
6811 {
6812         btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
6813                         sizeof(struct btrfs_inode), 0,
6814                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
6815         if (!btrfs_inode_cachep)
6816                 goto fail;
6817
6818         btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
6819                         sizeof(struct btrfs_trans_handle), 0,
6820                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
6821         if (!btrfs_trans_handle_cachep)
6822                 goto fail;
6823
6824         btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
6825                         sizeof(struct btrfs_transaction), 0,
6826                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
6827         if (!btrfs_transaction_cachep)
6828                 goto fail;
6829
6830         btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
6831                         sizeof(struct btrfs_path), 0,
6832                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
6833         if (!btrfs_path_cachep)
6834                 goto fail;
6835
6836         btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
6837                         sizeof(struct btrfs_free_space), 0,
6838                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
6839         if (!btrfs_free_space_cachep)
6840                 goto fail;
6841
6842         return 0;
6843 fail:
6844         btrfs_destroy_cachep();
6845         return -ENOMEM;
6846 }
6847
6848 static int btrfs_getattr(struct vfsmount *mnt,
6849                          struct dentry *dentry, struct kstat *stat)
6850 {
6851         struct inode *inode = dentry->d_inode;
6852         generic_fillattr(inode, stat);
6853         stat->dev = BTRFS_I(inode)->root->anon_super.s_dev;
6854         stat->blksize = PAGE_CACHE_SIZE;
6855         stat->blocks = (inode_get_bytes(inode) +
6856                         BTRFS_I(inode)->delalloc_bytes) >> 9;
6857         return 0;
6858 }
6859
6860 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
6861                            struct inode *new_dir, struct dentry *new_dentry)
6862 {
6863         struct btrfs_trans_handle *trans;
6864         struct btrfs_root *root = BTRFS_I(old_dir)->root;
6865         struct btrfs_root *dest = BTRFS_I(new_dir)->root;
6866         struct inode *new_inode = new_dentry->d_inode;
6867         struct inode *old_inode = old_dentry->d_inode;
6868         struct timespec ctime = CURRENT_TIME;
6869         u64 index = 0;
6870         u64 root_objectid;
6871         int ret;
6872
6873         if (new_dir->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
6874                 return -EPERM;
6875
6876         /* we only allow rename subvolume link between subvolumes */
6877         if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
6878                 return -EXDEV;
6879
6880         if (old_inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
6881             (new_inode && new_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID))
6882                 return -ENOTEMPTY;
6883
6884         if (S_ISDIR(old_inode->i_mode) && new_inode &&
6885             new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
6886                 return -ENOTEMPTY;
6887         /*
6888          * we're using rename to replace one file with another.
6889          * and the replacement file is large.  Start IO on it now so
6890          * we don't add too much work to the end of the transaction
6891          */
6892         if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
6893             old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
6894                 filemap_flush(old_inode->i_mapping);
6895
6896         /* close the racy window with snapshot create/destroy ioctl */
6897         if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
6898                 down_read(&root->fs_info->subvol_sem);
6899         /*
6900          * We want to reserve the absolute worst case amount of items.  So if
6901          * both inodes are subvols and we need to unlink them then that would
6902          * require 4 item modifications, but if they are both normal inodes it
6903          * would require 5 item modifications, so we'll assume their normal
6904          * inodes.  So 5 * 2 is 10, plus 1 for the new link, so 11 total items
6905          * should cover the worst case number of items we'll modify.
6906          */
6907         trans = btrfs_start_transaction(root, 20);
6908         if (IS_ERR(trans))
6909                 return PTR_ERR(trans);
6910
6911         btrfs_set_trans_block_group(trans, new_dir);
6912
6913         if (dest != root)
6914                 btrfs_record_root_in_trans(trans, dest);
6915
6916         ret = btrfs_set_inode_index(new_dir, &index);
6917         if (ret)
6918                 goto out_fail;
6919
6920         if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
6921                 /* force full log commit if subvolume involved. */
6922                 root->fs_info->last_trans_log_full_commit = trans->transid;
6923         } else {
6924                 ret = btrfs_insert_inode_ref(trans, dest,
6925                                              new_dentry->d_name.name,
6926                                              new_dentry->d_name.len,
6927                                              old_inode->i_ino,
6928                                              new_dir->i_ino, index);
6929                 if (ret)
6930                         goto out_fail;
6931                 /*
6932                  * this is an ugly little race, but the rename is required
6933                  * to make sure that if we crash, the inode is either at the
6934                  * old name or the new one.  pinning the log transaction lets
6935                  * us make sure we don't allow a log commit to come in after
6936                  * we unlink the name but before we add the new name back in.
6937                  */
6938                 btrfs_pin_log_trans(root);
6939         }
6940         /*
6941          * make sure the inode gets flushed if it is replacing
6942          * something.
6943          */
6944         if (new_inode && new_inode->i_size &&
6945             old_inode && S_ISREG(old_inode->i_mode)) {
6946                 btrfs_add_ordered_operation(trans, root, old_inode);
6947         }
6948
6949         old_dir->i_ctime = old_dir->i_mtime = ctime;
6950         new_dir->i_ctime = new_dir->i_mtime = ctime;
6951         old_inode->i_ctime = ctime;
6952
6953         if (old_dentry->d_parent != new_dentry->d_parent)
6954                 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
6955
6956         if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
6957                 root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
6958                 ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
6959                                         old_dentry->d_name.name,
6960                                         old_dentry->d_name.len);
6961         } else {
6962                 btrfs_inc_nlink(old_dentry->d_inode);
6963                 ret = btrfs_unlink_inode(trans, root, old_dir,
6964                                          old_dentry->d_inode,
6965                                          old_dentry->d_name.name,
6966                                          old_dentry->d_name.len);
6967         }
6968         BUG_ON(ret);
6969
6970         if (new_inode) {
6971                 new_inode->i_ctime = CURRENT_TIME;
6972                 if (unlikely(new_inode->i_ino ==
6973                              BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
6974                         root_objectid = BTRFS_I(new_inode)->location.objectid;
6975                         ret = btrfs_unlink_subvol(trans, dest, new_dir,
6976                                                 root_objectid,
6977                                                 new_dentry->d_name.name,
6978                                                 new_dentry->d_name.len);
6979                         BUG_ON(new_inode->i_nlink == 0);
6980                 } else {
6981                         ret = btrfs_unlink_inode(trans, dest, new_dir,
6982                                                  new_dentry->d_inode,
6983                                                  new_dentry->d_name.name,
6984                                                  new_dentry->d_name.len);
6985                 }
6986                 BUG_ON(ret);
6987                 if (new_inode->i_nlink == 0) {
6988                         ret = btrfs_orphan_add(trans, new_dentry->d_inode);
6989                         BUG_ON(ret);
6990                 }
6991         }
6992
6993         ret = btrfs_add_link(trans, new_dir, old_inode,
6994                              new_dentry->d_name.name,
6995                              new_dentry->d_name.len, 0, index);
6996         BUG_ON(ret);
6997
6998         if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) {
6999                 struct dentry *parent = dget_parent(new_dentry);
7000                 btrfs_log_new_name(trans, old_inode, old_dir, parent);
7001                 dput(parent);
7002                 btrfs_end_log_trans(root);
7003         }
7004 out_fail:
7005         btrfs_end_transaction_throttle(trans, root);
7006
7007         if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
7008                 up_read(&root->fs_info->subvol_sem);
7009
7010         return ret;
7011 }
7012
7013 /*
7014  * some fairly slow code that needs optimization. This walks the list
7015  * of all the inodes with pending delalloc and forces them to disk.
7016  */
7017 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7018 {
7019         struct list_head *head = &root->fs_info->delalloc_inodes;
7020         struct btrfs_inode *binode;
7021         struct inode *inode;
7022
7023         if (root->fs_info->sb->s_flags & MS_RDONLY)
7024                 return -EROFS;
7025
7026         spin_lock(&root->fs_info->delalloc_lock);
7027         while (!list_empty(head)) {
7028                 binode = list_entry(head->next, struct btrfs_inode,
7029                                     delalloc_inodes);
7030                 inode = igrab(&binode->vfs_inode);
7031                 if (!inode)
7032                         list_del_init(&binode->delalloc_inodes);
7033                 spin_unlock(&root->fs_info->delalloc_lock);
7034                 if (inode) {
7035                         filemap_flush(inode->i_mapping);
7036                         if (delay_iput)
7037                                 btrfs_add_delayed_iput(inode);
7038                         else
7039                                 iput(inode);
7040                 }
7041                 cond_resched();
7042                 spin_lock(&root->fs_info->delalloc_lock);
7043         }
7044         spin_unlock(&root->fs_info->delalloc_lock);
7045
7046         /* the filemap_flush will queue IO into the worker threads, but
7047          * we have to make sure the IO is actually started and that
7048          * ordered extents get created before we return
7049          */
7050         atomic_inc(&root->fs_info->async_submit_draining);
7051         while (atomic_read(&root->fs_info->nr_async_submits) ||
7052               atomic_read(&root->fs_info->async_delalloc_pages)) {
7053                 wait_event(root->fs_info->async_submit_wait,
7054                    (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
7055                     atomic_read(&root->fs_info->async_delalloc_pages) == 0));
7056         }
7057         atomic_dec(&root->fs_info->async_submit_draining);
7058         return 0;
7059 }
7060
7061 int btrfs_start_one_delalloc_inode(struct btrfs_root *root, int delay_iput,
7062                                    int sync)
7063 {
7064         struct btrfs_inode *binode;
7065         struct inode *inode = NULL;
7066
7067         spin_lock(&root->fs_info->delalloc_lock);
7068         while (!list_empty(&root->fs_info->delalloc_inodes)) {
7069                 binode = list_entry(root->fs_info->delalloc_inodes.next,
7070                                     struct btrfs_inode, delalloc_inodes);
7071                 inode = igrab(&binode->vfs_inode);
7072                 if (inode) {
7073                         list_move_tail(&binode->delalloc_inodes,
7074                                        &root->fs_info->delalloc_inodes);
7075                         break;
7076                 }
7077
7078                 list_del_init(&binode->delalloc_inodes);
7079                 cond_resched_lock(&root->fs_info->delalloc_lock);
7080         }
7081         spin_unlock(&root->fs_info->delalloc_lock);
7082
7083         if (inode) {
7084                 if (sync) {
7085                         filemap_write_and_wait(inode->i_mapping);
7086                         /*
7087                          * We have to do this because compression doesn't
7088                          * actually set PG_writeback until it submits the pages
7089                          * for IO, which happens in an async thread, so we could
7090                          * race and not actually wait for any writeback pages
7091                          * because they've not been submitted yet.  Technically
7092                          * this could still be the case for the ordered stuff
7093                          * since the async thread may not have started to do its
7094                          * work yet.  If this becomes the case then we need to
7095                          * figure out a way to make sure that in writepage we
7096                          * wait for any async pages to be submitted before
7097                          * returning so that fdatawait does what its supposed to
7098                          * do.
7099                          */
7100                         btrfs_wait_ordered_range(inode, 0, (u64)-1);
7101                 } else {
7102                         filemap_flush(inode->i_mapping);
7103                 }
7104                 if (delay_iput)
7105                         btrfs_add_delayed_iput(inode);
7106                 else
7107                         iput(inode);
7108                 return 1;
7109         }
7110         return 0;
7111 }
7112
7113 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
7114                          const char *symname)
7115 {
7116         struct btrfs_trans_handle *trans;
7117         struct btrfs_root *root = BTRFS_I(dir)->root;
7118         struct btrfs_path *path;
7119         struct btrfs_key key;
7120         struct inode *inode = NULL;
7121         int err;
7122         int drop_inode = 0;
7123         u64 objectid;
7124         u64 index = 0 ;
7125         int name_len;
7126         int datasize;
7127         unsigned long ptr;
7128         struct btrfs_file_extent_item *ei;
7129         struct extent_buffer *leaf;
7130         unsigned long nr = 0;
7131
7132         name_len = strlen(symname) + 1;
7133         if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
7134                 return -ENAMETOOLONG;
7135
7136         err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
7137         if (err)
7138                 return err;
7139         /*
7140          * 2 items for inode item and ref
7141          * 2 items for dir items
7142          * 1 item for xattr if selinux is on
7143          */
7144         trans = btrfs_start_transaction(root, 5);
7145         if (IS_ERR(trans))
7146                 return PTR_ERR(trans);
7147
7148         btrfs_set_trans_block_group(trans, dir);
7149
7150         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
7151                                 dentry->d_name.len, dir->i_ino, objectid,
7152                                 BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
7153                                 &index);
7154         err = PTR_ERR(inode);
7155         if (IS_ERR(inode))
7156                 goto out_unlock;
7157
7158         err = btrfs_init_inode_security(trans, inode, dir);
7159         if (err) {
7160                 drop_inode = 1;
7161                 goto out_unlock;
7162         }
7163
7164         btrfs_set_trans_block_group(trans, inode);
7165         err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
7166         if (err)
7167                 drop_inode = 1;
7168         else {
7169                 inode->i_mapping->a_ops = &btrfs_aops;
7170                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7171                 inode->i_fop = &btrfs_file_operations;
7172                 inode->i_op = &btrfs_file_inode_operations;
7173                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
7174         }
7175         btrfs_update_inode_block_group(trans, inode);
7176         btrfs_update_inode_block_group(trans, dir);
7177         if (drop_inode)
7178                 goto out_unlock;
7179
7180         path = btrfs_alloc_path();
7181         BUG_ON(!path);
7182         key.objectid = inode->i_ino;
7183         key.offset = 0;
7184         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
7185         datasize = btrfs_file_extent_calc_inline_size(name_len);
7186         err = btrfs_insert_empty_item(trans, root, path, &key,
7187                                       datasize);
7188         if (err) {
7189                 drop_inode = 1;
7190                 goto out_unlock;
7191         }
7192         leaf = path->nodes[0];
7193         ei = btrfs_item_ptr(leaf, path->slots[0],
7194                             struct btrfs_file_extent_item);
7195         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
7196         btrfs_set_file_extent_type(leaf, ei,
7197                                    BTRFS_FILE_EXTENT_INLINE);
7198         btrfs_set_file_extent_encryption(leaf, ei, 0);
7199         btrfs_set_file_extent_compression(leaf, ei, 0);
7200         btrfs_set_file_extent_other_encoding(leaf, ei, 0);
7201         btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
7202
7203         ptr = btrfs_file_extent_inline_start(ei);
7204         write_extent_buffer(leaf, symname, ptr, name_len);
7205         btrfs_mark_buffer_dirty(leaf);
7206         btrfs_free_path(path);
7207
7208         inode->i_op = &btrfs_symlink_inode_operations;
7209         inode->i_mapping->a_ops = &btrfs_symlink_aops;
7210         inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7211         inode_set_bytes(inode, name_len);
7212         btrfs_i_size_write(inode, name_len - 1);
7213         err = btrfs_update_inode(trans, root, inode);
7214         if (err)
7215                 drop_inode = 1;
7216
7217 out_unlock:
7218         nr = trans->blocks_used;
7219         btrfs_end_transaction_throttle(trans, root);
7220         if (drop_inode) {
7221                 inode_dec_link_count(inode);
7222                 iput(inode);
7223         }
7224         btrfs_btree_balance_dirty(root, nr);
7225         return err;
7226 }
7227
7228 static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
7229                                        u64 start, u64 num_bytes, u64 min_size,
7230                                        loff_t actual_len, u64 *alloc_hint,
7231                                        struct btrfs_trans_handle *trans)
7232 {
7233         struct btrfs_root *root = BTRFS_I(inode)->root;
7234         struct btrfs_key ins;
7235         u64 cur_offset = start;
7236         u64 i_size;
7237         int ret = 0;
7238         bool own_trans = true;
7239
7240         if (trans)
7241                 own_trans = false;
7242         while (num_bytes > 0) {
7243                 if (own_trans) {
7244                         trans = btrfs_start_transaction(root, 3);
7245                         if (IS_ERR(trans)) {
7246                                 ret = PTR_ERR(trans);
7247                                 break;
7248                         }
7249                 }
7250
7251                 ret = btrfs_reserve_extent(trans, root, num_bytes, min_size,
7252                                            0, *alloc_hint, (u64)-1, &ins, 1);
7253                 if (ret) {
7254                         if (own_trans)
7255                                 btrfs_end_transaction(trans, root);
7256                         break;
7257                 }
7258
7259                 ret = insert_reserved_file_extent(trans, inode,
7260                                                   cur_offset, ins.objectid,
7261                                                   ins.offset, ins.offset,
7262                                                   ins.offset, 0, 0, 0,
7263                                                   BTRFS_FILE_EXTENT_PREALLOC);
7264                 BUG_ON(ret);
7265                 btrfs_drop_extent_cache(inode, cur_offset,
7266                                         cur_offset + ins.offset -1, 0);
7267
7268                 num_bytes -= ins.offset;
7269                 cur_offset += ins.offset;
7270                 *alloc_hint = ins.objectid + ins.offset;
7271
7272                 inode->i_ctime = CURRENT_TIME;
7273                 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
7274                 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
7275                     (actual_len > inode->i_size) &&
7276                     (cur_offset > inode->i_size)) {
7277                         if (cur_offset > actual_len)
7278                                 i_size = actual_len;
7279                         else
7280                                 i_size = cur_offset;
7281                         i_size_write(inode, i_size);
7282                         btrfs_ordered_update_i_size(inode, i_size, NULL);
7283                 }
7284
7285                 ret = btrfs_update_inode(trans, root, inode);
7286                 BUG_ON(ret);
7287
7288                 if (own_trans)
7289                         btrfs_end_transaction(trans, root);
7290         }
7291         return ret;
7292 }
7293
7294 int btrfs_prealloc_file_range(struct inode *inode, int mode,
7295                               u64 start, u64 num_bytes, u64 min_size,
7296                               loff_t actual_len, u64 *alloc_hint)
7297 {
7298         return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
7299                                            min_size, actual_len, alloc_hint,
7300                                            NULL);
7301 }
7302
7303 int btrfs_prealloc_file_range_trans(struct inode *inode,
7304                                     struct btrfs_trans_handle *trans, int mode,
7305                                     u64 start, u64 num_bytes, u64 min_size,
7306                                     loff_t actual_len, u64 *alloc_hint)
7307 {
7308         return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
7309                                            min_size, actual_len, alloc_hint, trans);
7310 }
7311
7312 static int btrfs_set_page_dirty(struct page *page)
7313 {
7314         return __set_page_dirty_nobuffers(page);
7315 }
7316
7317 static int btrfs_permission(struct inode *inode, int mask, unsigned int flags)
7318 {
7319         struct btrfs_root *root = BTRFS_I(inode)->root;
7320
7321         if (btrfs_root_readonly(root) && (mask & MAY_WRITE))
7322                 return -EROFS;
7323         if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE))
7324                 return -EACCES;
7325         return generic_permission(inode, mask, flags, btrfs_check_acl);
7326 }
7327
7328 static const struct inode_operations btrfs_dir_inode_operations = {
7329         .getattr        = btrfs_getattr,
7330         .lookup         = btrfs_lookup,
7331         .create         = btrfs_create,
7332         .unlink         = btrfs_unlink,
7333         .link           = btrfs_link,
7334         .mkdir          = btrfs_mkdir,
7335         .rmdir          = btrfs_rmdir,
7336         .rename         = btrfs_rename,
7337         .symlink        = btrfs_symlink,
7338         .setattr        = btrfs_setattr,
7339         .mknod          = btrfs_mknod,
7340         .setxattr       = btrfs_setxattr,
7341         .getxattr       = btrfs_getxattr,
7342         .listxattr      = btrfs_listxattr,
7343         .removexattr    = btrfs_removexattr,
7344         .permission     = btrfs_permission,
7345 };
7346 static const struct inode_operations btrfs_dir_ro_inode_operations = {
7347         .lookup         = btrfs_lookup,
7348         .permission     = btrfs_permission,
7349 };
7350
7351 static const struct file_operations btrfs_dir_file_operations = {
7352         .llseek         = generic_file_llseek,
7353         .read           = generic_read_dir,
7354         .readdir        = btrfs_real_readdir,
7355         .unlocked_ioctl = btrfs_ioctl,
7356 #ifdef CONFIG_COMPAT
7357         .compat_ioctl   = btrfs_ioctl,
7358 #endif
7359         .release        = btrfs_release_file,
7360         .fsync          = btrfs_sync_file,
7361 };
7362
7363 static struct extent_io_ops btrfs_extent_io_ops = {
7364         .fill_delalloc = run_delalloc_range,
7365         .submit_bio_hook = btrfs_submit_bio_hook,
7366         .merge_bio_hook = btrfs_merge_bio_hook,
7367         .readpage_end_io_hook = btrfs_readpage_end_io_hook,
7368         .writepage_end_io_hook = btrfs_writepage_end_io_hook,
7369         .writepage_start_hook = btrfs_writepage_start_hook,
7370         .readpage_io_failed_hook = btrfs_io_failed_hook,
7371         .set_bit_hook = btrfs_set_bit_hook,
7372         .clear_bit_hook = btrfs_clear_bit_hook,
7373         .merge_extent_hook = btrfs_merge_extent_hook,
7374         .split_extent_hook = btrfs_split_extent_hook,
7375 };
7376
7377 /*
7378  * btrfs doesn't support the bmap operation because swapfiles
7379  * use bmap to make a mapping of extents in the file.  They assume
7380  * these extents won't change over the life of the file and they
7381  * use the bmap result to do IO directly to the drive.
7382  *
7383  * the btrfs bmap call would return logical addresses that aren't
7384  * suitable for IO and they also will change frequently as COW
7385  * operations happen.  So, swapfile + btrfs == corruption.
7386  *
7387  * For now we're avoiding this by dropping bmap.
7388  */
7389 static const struct address_space_operations btrfs_aops = {
7390         .readpage       = btrfs_readpage,
7391         .writepage      = btrfs_writepage,
7392         .writepages     = btrfs_writepages,
7393         .readpages      = btrfs_readpages,
7394         .sync_page      = block_sync_page,
7395         .direct_IO      = btrfs_direct_IO,
7396         .invalidatepage = btrfs_invalidatepage,
7397         .releasepage    = btrfs_releasepage,
7398         .set_page_dirty = btrfs_set_page_dirty,
7399         .error_remove_page = generic_error_remove_page,
7400 };
7401
7402 static const struct address_space_operations btrfs_symlink_aops = {
7403         .readpage       = btrfs_readpage,
7404         .writepage      = btrfs_writepage,
7405         .invalidatepage = btrfs_invalidatepage,
7406         .releasepage    = btrfs_releasepage,
7407 };
7408
7409 static const struct inode_operations btrfs_file_inode_operations = {
7410         .getattr        = btrfs_getattr,
7411         .setattr        = btrfs_setattr,
7412         .setxattr       = btrfs_setxattr,
7413         .getxattr       = btrfs_getxattr,
7414         .listxattr      = btrfs_listxattr,
7415         .removexattr    = btrfs_removexattr,
7416         .permission     = btrfs_permission,
7417         .fiemap         = btrfs_fiemap,
7418 };
7419 static const struct inode_operations btrfs_special_inode_operations = {
7420         .getattr        = btrfs_getattr,
7421         .setattr        = btrfs_setattr,
7422         .permission     = btrfs_permission,
7423         .setxattr       = btrfs_setxattr,
7424         .getxattr       = btrfs_getxattr,
7425         .listxattr      = btrfs_listxattr,
7426         .removexattr    = btrfs_removexattr,
7427 };
7428 static const struct inode_operations btrfs_symlink_inode_operations = {
7429         .readlink       = generic_readlink,
7430         .follow_link    = page_follow_link_light,
7431         .put_link       = page_put_link,
7432         .getattr        = btrfs_getattr,
7433         .permission     = btrfs_permission,
7434         .setxattr       = btrfs_setxattr,
7435         .getxattr       = btrfs_getxattr,
7436         .listxattr      = btrfs_listxattr,
7437         .removexattr    = btrfs_removexattr,
7438 };
7439
7440 const struct dentry_operations btrfs_dentry_operations = {
7441         .d_delete       = btrfs_dentry_delete,
7442 };