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/smp_lock.h>
  30 #include <linux/backing-dev.h>
  31 #include <linux/mpage.h>
  32 #include <linux/swap.h>
  33 #include <linux/writeback.h>
  34 #include <linux/statfs.h>
  35 #include <linux/compat.h>
  36 #include <linux/bit_spinlock.h>
  37 #include <linux/version.h>
  38 #include <linux/xattr.h>
  39 #include "ctree.h"
  40 #include "disk-io.h"
  41 #include "transaction.h"
  42 #include "btrfs_inode.h"
  43 #include "ioctl.h"
  44 #include "print-tree.h"
  45 #include "volumes.h"
  46
  47 struct btrfs_iget_args {
  48         u64 ino;
  49         struct btrfs_root *root;
  50 };
  51
  52 static struct inode_operations btrfs_dir_inode_operations;
  53 static struct inode_operations btrfs_symlink_inode_operations;
  54 static struct inode_operations btrfs_dir_ro_inode_operations;
  55 static struct inode_operations btrfs_special_inode_operations;
  56 static struct inode_operations btrfs_file_inode_operations;
  57 static struct address_space_operations btrfs_aops;
  58 static struct address_space_operations btrfs_symlink_aops;
  59 static struct file_operations btrfs_dir_file_operations;
  60 static struct extent_io_ops btrfs_extent_io_ops;
  61
  62 static struct kmem_cache *btrfs_inode_cachep;
  63 struct kmem_cache *btrfs_trans_handle_cachep;
  64 struct kmem_cache *btrfs_transaction_cachep;
  65 struct kmem_cache *btrfs_bit_radix_cachep;
  66 struct kmem_cache *btrfs_path_cachep;
  67
  68 #define S_SHIFT 12
  69 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  70         [S_IFREG >> S_SHIFT]    = BTRFS_FT_REG_FILE,
  71         [S_IFDIR >> S_SHIFT]    = BTRFS_FT_DIR,
  72         [S_IFCHR >> S_SHIFT]    = BTRFS_FT_CHRDEV,
  73         [S_IFBLK >> S_SHIFT]    = BTRFS_FT_BLKDEV,
  74         [S_IFIFO >> S_SHIFT]    = BTRFS_FT_FIFO,
  75         [S_IFSOCK >> S_SHIFT]   = BTRFS_FT_SOCK,
  76         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
  77 };
  78
  79 int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
  80                            int for_del)
  81 {
  82         u64 total;
  83         u64 used;
  84         u64 thresh;
  85         unsigned long flags;
  86         int ret = 0;
  87
  88         spin_lock_irqsave(&root->fs_info->delalloc_lock, flags);
  89         total = btrfs_super_total_bytes(&root->fs_info->super_copy);
  90         used = btrfs_super_bytes_used(&root->fs_info->super_copy);
  91         if (for_del)
  92                 thresh = total * 90;
  93         else
  94                 thresh = total * 85;
  95
  96         do_div(thresh, 100);
  97
  98         if (used + root->fs_info->delalloc_bytes + num_required > thresh)
  99                 ret = -ENOSPC;
 100         spin_unlock_irqrestore(&root->fs_info->delalloc_lock, flags);
 101         return ret;
 102 }
 103
 104 static int cow_file_range(struct inode *inode, u64 start, u64 end)
 105 {
 106         struct btrfs_root *root = BTRFS_I(inode)->root;
 107         struct btrfs_trans_handle *trans;
 108         u64 alloc_hint = 0;
 109         u64 num_bytes;
 110         u64 cur_alloc_size;
 111         u64 blocksize = root->sectorsize;
 112         u64 orig_start = start;
 113         u64 orig_num_bytes;
 114         struct btrfs_key ins;
 115         int ret;
 116
 117         trans = btrfs_start_transaction(root, 1);
 118         BUG_ON(!trans);
 119         btrfs_set_trans_block_group(trans, inode);
 120
 121         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
 122         num_bytes = max(blocksize,  num_bytes);
 123         ret = btrfs_drop_extents(trans, root, inode,
 124                                  start, start + num_bytes, start, &alloc_hint);
 125         orig_num_bytes = num_bytes;
 126
 127         if (alloc_hint == EXTENT_MAP_INLINE)
 128                 goto out;
 129
 130         BUG_ON(num_bytes > btrfs_super_total_bytes(&root->fs_info->super_copy));
 131
 132         while(num_bytes > 0) {
 133                 cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
 134                 ret = btrfs_alloc_extent(trans, root, cur_alloc_size,
 135                                          root->sectorsize,
 136                                          root->root_key.objectid,
 137                                          trans->transid,
 138                                          inode->i_ino, start, 0,
 139                                          alloc_hint, (u64)-1, &ins, 1);
 140                 if (ret) {
 141                         WARN_ON(1);
 142                         goto out;
 143                 }
 144                 cur_alloc_size = ins.offset;
 145                 ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
 146                                                start, ins.objectid, ins.offset,
 147                                                ins.offset, 0);
 148                 inode->i_blocks += ins.offset >> 9;
 149                 btrfs_check_file(root, inode);
 150                 if (num_bytes < cur_alloc_size) {
 151                         printk("num_bytes %Lu cur_alloc %Lu\n", num_bytes,
 152                                cur_alloc_size);
 153                         break;
 154                 }
 155                 num_bytes -= cur_alloc_size;
 156                 alloc_hint = ins.objectid + ins.offset;
 157                 start += cur_alloc_size;
 158         }
 159         btrfs_drop_extent_cache(inode, orig_start,
 160                                 orig_start + orig_num_bytes - 1);
 161         btrfs_add_ordered_inode(inode);
 162         btrfs_update_inode(trans, root, inode);
 163 out:
 164         btrfs_end_transaction(trans, root);
 165         return ret;
 166 }
 167
 168 static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
 169 {
 170         u64 extent_start;
 171         u64 extent_end;
 172         u64 bytenr;
 173         u64 cow_end;
 174         u64 loops = 0;
 175         u64 total_fs_bytes;
 176         struct btrfs_root *root = BTRFS_I(inode)->root;
 177         struct btrfs_block_group_cache *block_group;
 178         struct extent_buffer *leaf;
 179         int found_type;
 180         struct btrfs_path *path;
 181         struct btrfs_file_extent_item *item;
 182         int ret;
 183         int err;
 184         struct btrfs_key found_key;
 185
 186         total_fs_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
 187         path = btrfs_alloc_path();
 188         BUG_ON(!path);
 189 again:
 190         ret = btrfs_lookup_file_extent(NULL, root, path,
 191                                        inode->i_ino, start, 0);
 192         if (ret < 0) {
 193                 btrfs_free_path(path);
 194                 return ret;
 195         }
 196
 197         cow_end = end;
 198         if (ret != 0) {
 199                 if (path->slots[0] == 0)
 200                         goto not_found;
 201                 path->slots[0]--;
 202         }
 203
 204         leaf = path->nodes[0];
 205         item = btrfs_item_ptr(leaf, path->slots[0],
 206                               struct btrfs_file_extent_item);
 207
 208         /* are we inside the extent that was found? */
 209         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 210         found_type = btrfs_key_type(&found_key);
 211         if (found_key.objectid != inode->i_ino ||
 212             found_type != BTRFS_EXTENT_DATA_KEY)
 213                 goto not_found;
 214
 215         found_type = btrfs_file_extent_type(leaf, item);
 216         extent_start = found_key.offset;
 217         if (found_type == BTRFS_FILE_EXTENT_REG) {
 218                 u64 extent_num_bytes;
 219
 220                 extent_num_bytes = btrfs_file_extent_num_bytes(leaf, item);
 221                 extent_end = extent_start + extent_num_bytes;
 222                 err = 0;
 223
 224                 if (loops && start != extent_start)
 225                         goto not_found;
 226
 227                 if (start < extent_start || start >= extent_end)
 228                         goto not_found;
 229
 230                 cow_end = min(end, extent_end - 1);
 231                 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
 232                 if (bytenr == 0)
 233                         goto not_found;
 234
 235                 if (btrfs_count_snapshots_in_path(root, path, inode->i_ino,
 236                                                   bytenr) != 1) {
 237                         goto not_found;
 238                 }
 239
 240                 /*
 241                  * we may be called by the resizer, make sure we're inside
 242                  * the limits of the FS
 243                  */
 244                 block_group = btrfs_lookup_block_group(root->fs_info,
 245                                                        bytenr);
 246                 if (!block_group || block_group->ro)
 247                         goto not_found;
 248
 249                 start = extent_end;
 250         } else {
 251                 goto not_found;
 252         }
 253 loop:
 254         if (start > end) {
 255                 btrfs_free_path(path);
 256                 return 0;
 257         }
 258         btrfs_release_path(root, path);
 259         loops++;
 260         goto again;
 261
 262 not_found:
 263         cow_file_range(inode, start, end);
 264         start = end + 1;
 265         goto loop;
 266 }
 267
 268 static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
 269 {
 270         struct btrfs_root *root = BTRFS_I(inode)->root;
 271         int ret;
 272
 273         if (btrfs_test_opt(root, NODATACOW) ||
 274             btrfs_test_flag(inode, NODATACOW))
 275                 ret = run_delalloc_nocow(inode, start, end);
 276         else
 277                 ret = cow_file_range(inode, start, end);
 278
 279         return ret;
 280 }
 281
 282 int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
 283                        unsigned long old, unsigned long bits)
 284 {
 285         unsigned long flags;
 286         if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
 287                 struct btrfs_root *root = BTRFS_I(inode)->root;
 288                 spin_lock_irqsave(&root->fs_info->delalloc_lock, flags);
 289                 BTRFS_I(inode)->delalloc_bytes += end - start + 1;
 290                 root->fs_info->delalloc_bytes += end - start + 1;
 291                 spin_unlock_irqrestore(&root->fs_info->delalloc_lock, flags);
 292         }
 293         return 0;
 294 }
 295
 296 int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
 297                          unsigned long old, unsigned long bits)
 298 {
 299         if ((old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
 300                 struct btrfs_root *root = BTRFS_I(inode)->root;
 301                 unsigned long flags;
 302
 303                 spin_lock_irqsave(&root->fs_info->delalloc_lock, flags);
 304                 if (end - start + 1 > root->fs_info->delalloc_bytes) {
 305                         printk("warning: delalloc account %Lu %Lu\n",
 306                                end - start + 1, root->fs_info->delalloc_bytes);
 307                         root->fs_info->delalloc_bytes = 0;
 308                         BTRFS_I(inode)->delalloc_bytes = 0;
 309                 } else {
 310                         root->fs_info->delalloc_bytes -= end - start + 1;
 311                         BTRFS_I(inode)->delalloc_bytes -= end - start + 1;
 312                 }
 313                 spin_unlock_irqrestore(&root->fs_info->delalloc_lock, flags);
 314         }
 315         return 0;
 316 }
 317
 318 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
 319                          size_t size, struct bio *bio)
 320 {
 321         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 322         struct btrfs_mapping_tree *map_tree;
 323         u64 logical = bio->bi_sector << 9;
 324         u64 length = 0;
 325         u64 map_length;
 326         int ret;
 327
 328         length = bio->bi_size;
 329         map_tree = &root->fs_info->mapping_tree;
 330         map_length = length;
 331         ret = btrfs_map_block(map_tree, READ, logical,
 332                               &map_length, NULL, 0);
 333
 334         if (map_length < length + size) {
 335                 return 1;
 336         }
 337         return 0;
 338 }
 339
 340 int __btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 341                           int mirror_num)
 342 {
 343         struct btrfs_root *root = BTRFS_I(inode)->root;
 344         struct btrfs_trans_handle *trans;
 345         int ret = 0;
 346         char *sums = NULL;
 347
 348         ret = btrfs_csum_one_bio(root, bio, &sums);
 349         BUG_ON(ret);
 350
 351         trans = btrfs_start_transaction(root, 1);
 352
 353         btrfs_set_trans_block_group(trans, inode);
 354         btrfs_csum_file_blocks(trans, root, inode, bio, sums);
 355
 356         ret = btrfs_end_transaction(trans, root);
 357         BUG_ON(ret);
 358
 359         kfree(sums);
 360
 361         return btrfs_map_bio(root, rw, bio, mirror_num, 1);
 362 }
 363
 364 int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 365                           int mirror_num)
 366 {
 367         struct btrfs_root *root = BTRFS_I(inode)->root;
 368         int ret = 0;
 369
 370         if (!(rw & (1 << BIO_RW))) {
 371                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
 372                 BUG_ON(ret);
 373                 goto mapit;
 374         }
 375
 376         if (btrfs_test_opt(root, NODATASUM) ||
 377             btrfs_test_flag(inode, NODATASUM)) {
 378                 goto mapit;
 379         }
 380
 381         return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
 382                                    inode, rw, bio, mirror_num,
 383                                    __btrfs_submit_bio_hook);
 384 mapit:
 385         return btrfs_map_bio(root, rw, bio, mirror_num, 0);
 386 }
 387
 388 int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
 389 {
 390         int ret = 0;
 391         struct inode *inode = page->mapping->host;
 392         struct btrfs_root *root = BTRFS_I(inode)->root;
 393         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 394         struct btrfs_csum_item *item;
 395         struct btrfs_path *path = NULL;
 396         u32 csum;
 397
 398         if (btrfs_test_opt(root, NODATASUM) ||
 399             btrfs_test_flag(inode, NODATASUM))
 400                 return 0;
 401
 402         path = btrfs_alloc_path();
 403         item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
 404         if (IS_ERR(item)) {
 405                 ret = PTR_ERR(item);
 406                 /* a csum that isn't present is a preallocated region. */
 407                 if (ret == -ENOENT || ret == -EFBIG)
 408                         ret = 0;
 409                 csum = 0;
 410                 printk("no csum found for inode %lu start %Lu\n", inode->i_ino, start);
 411                 goto out;
 412         }
 413         read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
 414                            BTRFS_CRC32_SIZE);
 415         set_state_private(io_tree, start, csum);
 416 out:
 417         if (path)
 418                 btrfs_free_path(path);
 419         return ret;
 420 }
 421
 422 struct io_failure_record {
 423         struct page *page;
 424         u64 start;
 425         u64 len;
 426         u64 logical;
 427         int last_mirror;
 428 };
 429
 430 int btrfs_io_failed_hook(struct bio *failed_bio,
 431                          struct page *page, u64 start, u64 end,
 432                          struct extent_state *state)
 433 {
 434         struct io_failure_record *failrec = NULL;
 435         u64 private;
 436         struct extent_map *em;
 437         struct inode *inode = page->mapping->host;
 438         struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
 439         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 440         struct bio *bio;
 441         int num_copies;
 442         int ret;
 443         int rw;
 444         u64 logical;
 445
 446         ret = get_state_private(failure_tree, start, &private);
 447         if (ret) {
 448                 failrec = kmalloc(sizeof(*failrec), GFP_NOFS);
 449                 if (!failrec)
 450                         return -ENOMEM;
 451                 failrec->start = start;
 452                 failrec->len = end - start + 1;
 453                 failrec->last_mirror = 0;
 454
 455                 spin_lock(&em_tree->lock);
 456                 em = lookup_extent_mapping(em_tree, start, failrec->len);
 457                 if (em->start > start || em->start + em->len < start) {
 458                         free_extent_map(em);
 459                         em = NULL;
 460                 }
 461                 spin_unlock(&em_tree->lock);
 462
 463                 if (!em || IS_ERR(em)) {
 464                         kfree(failrec);
 465                         return -EIO;
 466                 }
 467                 logical = start - em->start;
 468                 logical = em->block_start + logical;
 469                 failrec->logical = logical;
 470                 free_extent_map(em);
 471                 set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
 472                                 EXTENT_DIRTY, GFP_NOFS);
 473                 set_state_private(failure_tree, start,
 474                                  (u64)(unsigned long)failrec);
 475         } else {
 476                 failrec = (struct io_failure_record *)(unsigned long)private;
 477         }
 478         num_copies = btrfs_num_copies(
 479                               &BTRFS_I(inode)->root->fs_info->mapping_tree,
 480                               failrec->logical, failrec->len);
 481         failrec->last_mirror++;
 482         if (!state) {
 483                 spin_lock_irq(&BTRFS_I(inode)->io_tree.lock);
 484                 state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
 485                                                     failrec->start,
 486                                                     EXTENT_LOCKED);
 487                 if (state && state->start != failrec->start)
 488                         state = NULL;
 489                 spin_unlock_irq(&BTRFS_I(inode)->io_tree.lock);
 490         }
 491         if (!state || failrec->last_mirror > num_copies) {
 492                 set_state_private(failure_tree, failrec->start, 0);
 493                 clear_extent_bits(failure_tree, failrec->start,
 494                                   failrec->start + failrec->len - 1,
 495                                   EXTENT_LOCKED | EXTENT_DIRTY, GFP_NOFS);
 496                 kfree(failrec);
 497                 return -EIO;
 498         }
 499         bio = bio_alloc(GFP_NOFS, 1);
 500         bio->bi_private = state;
 501         bio->bi_end_io = failed_bio->bi_end_io;
 502         bio->bi_sector = failrec->logical >> 9;
 503         bio->bi_bdev = failed_bio->bi_bdev;
 504         bio->bi_size = 0;
 505         bio_add_page(bio, page, failrec->len, start - page_offset(page));
 506         if (failed_bio->bi_rw & (1 << BIO_RW))
 507                 rw = WRITE;
 508         else
 509                 rw = READ;
 510
 511         BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
 512                                                       failrec->last_mirror);
 513         return 0;
 514 }
 515
 516 int btrfs_clean_io_failures(struct inode *inode, u64 start)
 517 {
 518         u64 private;
 519         u64 private_failure;
 520         struct io_failure_record *failure;
 521         int ret;
 522
 523         private = 0;
 524         if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
 525                              (u64)-1, 1, EXTENT_DIRTY)) {
 526                 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
 527                                         start, &private_failure);
 528                 if (ret == 0) {
 529                         failure = (struct io_failure_record *)(unsigned long)
 530                                    private_failure;
 531                         set_state_private(&BTRFS_I(inode)->io_failure_tree,
 532                                           failure->start, 0);
 533                         clear_extent_bits(&BTRFS_I(inode)->io_failure_tree,
 534                                           failure->start,
 535                                           failure->start + failure->len - 1,
 536                                           EXTENT_DIRTY | EXTENT_LOCKED,
 537                                           GFP_NOFS);
 538                         kfree(failure);
 539                 }
 540         }
 541         return 0;
 542 }
 543
 544 int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
 545                                struct extent_state *state)
 546 {
 547         size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
 548         struct inode *inode = page->mapping->host;
 549         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 550         char *kaddr;
 551         u64 private = ~(u32)0;
 552         int ret;
 553         struct btrfs_root *root = BTRFS_I(inode)->root;
 554         u32 csum = ~(u32)0;
 555         unsigned long flags;
 556
 557         if (btrfs_test_opt(root, NODATASUM) ||
 558             btrfs_test_flag(inode, NODATASUM))
 559                 return 0;
 560         if (state && state->start == start) {
 561                 private = state->private;
 562                 ret = 0;
 563         } else {
 564                 ret = get_state_private(io_tree, start, &private);
 565         }
 566         local_irq_save(flags);
 567         kaddr = kmap_atomic(page, KM_IRQ0);
 568         if (ret) {
 569                 goto zeroit;
 570         }
 571         csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
 572         btrfs_csum_final(csum, (char *)&csum);
 573         if (csum != private) {
 574                 goto zeroit;
 575         }
 576         kunmap_atomic(kaddr, KM_IRQ0);
 577         local_irq_restore(flags);
 578
 579         /* if the io failure tree for this inode is non-empty,
 580          * check to see if we've recovered from a failed IO
 581          */
 582         btrfs_clean_io_failures(inode, start);
 583         return 0;
 584
 585 zeroit:
 586         printk("btrfs csum failed ino %lu off %llu csum %u private %Lu\n",
 587                page->mapping->host->i_ino, (unsigned long long)start, csum,
 588                private);
 589         memset(kaddr + offset, 1, end - start + 1);
 590         flush_dcache_page(page);
 591         kunmap_atomic(kaddr, KM_IRQ0);
 592         local_irq_restore(flags);
 593         if (private == 0)
 594                 return 0;
 595         return -EIO;
 596 }
 597
 598 void btrfs_read_locked_inode(struct inode *inode)
 599 {
 600         struct btrfs_path *path;
 601         struct extent_buffer *leaf;
 602         struct btrfs_inode_item *inode_item;
 603         struct btrfs_timespec *tspec;
 604         struct btrfs_root *root = BTRFS_I(inode)->root;
 605         struct btrfs_key location;
 606         u64 alloc_group_block;
 607         u32 rdev;
 608         int ret;
 609
 610         path = btrfs_alloc_path();
 611         BUG_ON(!path);
 612         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
 613
 614         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
 615         if (ret)
 616                 goto make_bad;
 617
 618         leaf = path->nodes[0];
 619         inode_item = btrfs_item_ptr(leaf, path->slots[0],
 620                                     struct btrfs_inode_item);
 621
 622         inode->i_mode = btrfs_inode_mode(leaf, inode_item);
 623         inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
 624         inode->i_uid = btrfs_inode_uid(leaf, inode_item);
 625         inode->i_gid = btrfs_inode_gid(leaf, inode_item);
 626         inode->i_size = btrfs_inode_size(leaf, inode_item);
 627
 628         tspec = btrfs_inode_atime(inode_item);
 629         inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
 630         inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
 631
 632         tspec = btrfs_inode_mtime(inode_item);
 633         inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
 634         inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
 635
 636         tspec = btrfs_inode_ctime(inode_item);
 637         inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
 638         inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
 639
 640         inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
 641         inode->i_generation = btrfs_inode_generation(leaf, inode_item);
 642         inode->i_rdev = 0;
 643         rdev = btrfs_inode_rdev(leaf, inode_item);
 644
 645         alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
 646         BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
 647                                                        alloc_group_block);
 648         BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
 649         if (!BTRFS_I(inode)->block_group) {
 650                 BTRFS_I(inode)->block_group = btrfs_find_block_group(root,
 651                                                  NULL, 0,
 652                                                  BTRFS_BLOCK_GROUP_METADATA, 0);
 653         }
 654         btrfs_free_path(path);
 655         inode_item = NULL;
 656
 657         switch (inode->i_mode & S_IFMT) {
 658         case S_IFREG:
 659                 inode->i_mapping->a_ops = &btrfs_aops;
 660                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
 661                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
 662                 inode->i_fop = &btrfs_file_operations;
 663                 inode->i_op = &btrfs_file_inode_operations;
 664                 break;
 665         case S_IFDIR:
 666                 inode->i_fop = &btrfs_dir_file_operations;
 667                 if (root == root->fs_info->tree_root)
 668                         inode->i_op = &btrfs_dir_ro_inode_operations;
 669                 else
 670                         inode->i_op = &btrfs_dir_inode_operations;
 671                 break;
 672         case S_IFLNK:
 673                 inode->i_op = &btrfs_symlink_inode_operations;
 674                 inode->i_mapping->a_ops = &btrfs_symlink_aops;
 675                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
 676                 break;
 677         default:
 678                 init_special_inode(inode, inode->i_mode, rdev);
 679                 break;
 680         }
 681         return;
 682
 683 make_bad:
 684         btrfs_free_path(path);
 685         make_bad_inode(inode);
 686 }
 687
 688 static void fill_inode_item(struct extent_buffer *leaf,
 689                             struct btrfs_inode_item *item,
 690                             struct inode *inode)
 691 {
 692         btrfs_set_inode_uid(leaf, item, inode->i_uid);
 693         btrfs_set_inode_gid(leaf, item, inode->i_gid);
 694         btrfs_set_inode_size(leaf, item, inode->i_size);
 695         btrfs_set_inode_mode(leaf, item, inode->i_mode);
 696         btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
 697
 698         btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
 699                                inode->i_atime.tv_sec);
 700         btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
 701                                 inode->i_atime.tv_nsec);
 702
 703         btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
 704                                inode->i_mtime.tv_sec);
 705         btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
 706                                 inode->i_mtime.tv_nsec);
 707
 708         btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
 709                                inode->i_ctime.tv_sec);
 710         btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
 711                                 inode->i_ctime.tv_nsec);
 712
 713         btrfs_set_inode_nblocks(leaf, item, inode->i_blocks);
 714         btrfs_set_inode_generation(leaf, item, inode->i_generation);
 715         btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
 716         btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
 717         btrfs_set_inode_block_group(leaf, item,
 718                                     BTRFS_I(inode)->block_group->key.objectid);
 719 }
 720
 721 int btrfs_update_inode(struct btrfs_trans_handle *trans,
 722                               struct btrfs_root *root,
 723                               struct inode *inode)
 724 {
 725         struct btrfs_inode_item *inode_item;
 726         struct btrfs_path *path;
 727         struct extent_buffer *leaf;
 728         int ret;
 729
 730         path = btrfs_alloc_path();
 731         BUG_ON(!path);
 732         ret = btrfs_lookup_inode(trans, root, path,
 733                                  &BTRFS_I(inode)->location, 1);
 734         if (ret) {
 735                 if (ret > 0)
 736                         ret = -ENOENT;
 737                 goto failed;
 738         }
 739
 740         leaf = path->nodes[0];
 741         inode_item = btrfs_item_ptr(leaf, path->slots[0],
 742                                   struct btrfs_inode_item);
 743
 744         fill_inode_item(leaf, inode_item, inode);
 745         btrfs_mark_buffer_dirty(leaf);
 746         btrfs_set_inode_last_trans(trans, inode);
 747         ret = 0;
 748 failed:
 749         btrfs_free_path(path);
 750         return ret;
 751 }
 752
 753
 754 static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
 755                               struct btrfs_root *root,
 756                               struct inode *dir,
 757                               struct dentry *dentry)
 758 {
 759         struct btrfs_path *path;
 760         const char *name = dentry->d_name.name;
 761         int name_len = dentry->d_name.len;
 762         int ret = 0;
 763         struct extent_buffer *leaf;
 764         struct btrfs_dir_item *di;
 765         struct btrfs_key key;
 766
 767         path = btrfs_alloc_path();
 768         if (!path) {
 769                 ret = -ENOMEM;
 770                 goto err;
 771         }
 772
 773         di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
 774                                     name, name_len, -1);
 775         if (IS_ERR(di)) {
 776                 ret = PTR_ERR(di);
 777                 goto err;
 778         }
 779         if (!di) {
 780                 ret = -ENOENT;
 781                 goto err;
 782         }
 783         leaf = path->nodes[0];
 784         btrfs_dir_item_key_to_cpu(leaf, di, &key);
 785         ret = btrfs_delete_one_dir_name(trans, root, path, di);
 786         if (ret)
 787                 goto err;
 788         btrfs_release_path(root, path);
 789
 790         di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
 791                                          key.objectid, name, name_len, -1);
 792         if (IS_ERR(di)) {
 793                 ret = PTR_ERR(di);
 794                 goto err;
 795         }
 796         if (!di) {
 797                 ret = -ENOENT;
 798                 goto err;
 799         }
 800         ret = btrfs_delete_one_dir_name(trans, root, path, di);
 801         btrfs_release_path(root, path);
 802
 803         dentry->d_inode->i_ctime = dir->i_ctime;
 804         ret = btrfs_del_inode_ref(trans, root, name, name_len,
 805                                   dentry->d_inode->i_ino,
 806                                   dentry->d_parent->d_inode->i_ino);
 807         if (ret) {
 808                 printk("failed to delete reference to %.*s, "
 809                        "inode %lu parent %lu\n", name_len, name,
 810                        dentry->d_inode->i_ino,
 811                        dentry->d_parent->d_inode->i_ino);
 812         }
 813 err:
 814         btrfs_free_path(path);
 815         if (!ret) {
 816                 dir->i_size -= name_len * 2;
 817                 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 818                 btrfs_update_inode(trans, root, dir);
 819 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
 820                 dentry->d_inode->i_nlink--;
 821 #else
 822                 drop_nlink(dentry->d_inode);
 823 #endif
 824                 ret = btrfs_update_inode(trans, root, dentry->d_inode);
 825                 dir->i_sb->s_dirt = 1;
 826         }
 827         return ret;
 828 }
 829
 830 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 831 {
 832         struct btrfs_root *root;
 833         struct btrfs_trans_handle *trans;
 834         struct inode *inode = dentry->d_inode;
 835         int ret;
 836         unsigned long nr = 0;
 837
 838         root = BTRFS_I(dir)->root;
 839
 840         ret = btrfs_check_free_space(root, 1, 1);
 841         if (ret)
 842                 goto fail;
 843
 844         trans = btrfs_start_transaction(root, 1);
 845
 846         btrfs_set_trans_block_group(trans, dir);
 847         ret = btrfs_unlink_trans(trans, root, dir, dentry);
 848         nr = trans->blocks_used;
 849
 850         if (inode->i_nlink == 0) {
 851                 /* if the inode isn't linked anywhere,
 852                  * we don't need to worry about
 853                  * data=ordered
 854                  */
 855                 btrfs_del_ordered_inode(inode, 1);
 856         }
 857
 858         btrfs_end_transaction_throttle(trans, root);
 859 fail:
 860         btrfs_btree_balance_dirty(root, nr);
 861         return ret;
 862 }
 863
 864 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 865 {
 866         struct inode *inode = dentry->d_inode;
 867         int err = 0;
 868         int ret;
 869         struct btrfs_root *root = BTRFS_I(dir)->root;
 870         struct btrfs_trans_handle *trans;
 871         unsigned long nr = 0;
 872
 873         if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
 874                 return -ENOTEMPTY;
 875         }
 876
 877         ret = btrfs_check_free_space(root, 1, 1);
 878         if (ret)
 879                 goto fail;
 880
 881         trans = btrfs_start_transaction(root, 1);
 882         btrfs_set_trans_block_group(trans, dir);
 883
 884         /* now the directory is empty */
 885         err = btrfs_unlink_trans(trans, root, dir, dentry);
 886         if (!err) {
 887                 inode->i_size = 0;
 888         }
 889
 890         nr = trans->blocks_used;
 891         ret = btrfs_end_transaction_throttle(trans, root);
 892 fail:
 893         btrfs_btree_balance_dirty(root, nr);
 894
 895         if (ret && !err)
 896                 err = ret;
 897         return err;
 898 }
 899
 900 /*
 901  * this can truncate away extent items, csum items and directory items.
 902  * It starts at a high offset and removes keys until it can't find
 903  * any higher than i_size.
 904  *
 905  * csum items that cross the new i_size are truncated to the new size
 906  * as well.
 907  */
 908 static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
 909                                    struct btrfs_root *root,
 910                                    struct inode *inode,
 911                                    u32 min_type)
 912 {
 913         int ret;
 914         struct btrfs_path *path;
 915         struct btrfs_key key;
 916         struct btrfs_key found_key;
 917         u32 found_type;
 918         struct extent_buffer *leaf;
 919         struct btrfs_file_extent_item *fi;
 920         u64 extent_start = 0;
 921         u64 extent_num_bytes = 0;
 922         u64 item_end = 0;
 923         u64 root_gen = 0;
 924         u64 root_owner = 0;
 925         int found_extent;
 926         int del_item;
 927         int pending_del_nr = 0;
 928         int pending_del_slot = 0;
 929         int extent_type = -1;
 930         u64 mask = root->sectorsize - 1;
 931
 932         btrfs_drop_extent_cache(inode, inode->i_size & (~mask), (u64)-1);
 933         path = btrfs_alloc_path();
 934         path->reada = -1;
 935         BUG_ON(!path);
 936
 937         /* FIXME, add redo link to tree so we don't leak on crash */
 938         key.objectid = inode->i_ino;
 939         key.offset = (u64)-1;
 940         key.type = (u8)-1;
 941
 942         btrfs_init_path(path);
 943 search_again:
 944         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 945         if (ret < 0) {
 946                 goto error;
 947         }
 948         if (ret > 0) {
 949                 BUG_ON(path->slots[0] == 0);
 950                 path->slots[0]--;
 951         }
 952
 953         while(1) {
 954                 fi = NULL;
 955                 leaf = path->nodes[0];
 956                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 957                 found_type = btrfs_key_type(&found_key);
 958
 959                 if (found_key.objectid != inode->i_ino)
 960                         break;
 961
 962                 if (found_type < min_type)
 963                         break;
 964
 965                 item_end = found_key.offset;
 966                 if (found_type == BTRFS_EXTENT_DATA_KEY) {
 967                         fi = btrfs_item_ptr(leaf, path->slots[0],
 968                                             struct btrfs_file_extent_item);
 969                         extent_type = btrfs_file_extent_type(leaf, fi);
 970                         if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
 971                                 item_end +=
 972                                     btrfs_file_extent_num_bytes(leaf, fi);
 973                         } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
 974                                 struct btrfs_item *item = btrfs_item_nr(leaf,
 975                                                                 path->slots[0]);
 976                                 item_end += btrfs_file_extent_inline_len(leaf,
 977                                                                          item);
 978                         }
 979                         item_end--;
 980                 }
 981                 if (found_type == BTRFS_CSUM_ITEM_KEY) {
 982                         ret = btrfs_csum_truncate(trans, root, path,
 983                                                   inode->i_size);
 984                         BUG_ON(ret);
 985                 }
 986                 if (item_end < inode->i_size) {
 987                         if (found_type == BTRFS_DIR_ITEM_KEY) {
 988                                 found_type = BTRFS_INODE_ITEM_KEY;
 989                         } else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
 990                                 found_type = BTRFS_CSUM_ITEM_KEY;
 991                         } else if (found_type == BTRFS_EXTENT_DATA_KEY) {
 992                                 found_type = BTRFS_XATTR_ITEM_KEY;
 993                         } else if (found_type == BTRFS_XATTR_ITEM_KEY) {
 994                                 found_type = BTRFS_INODE_REF_KEY;
 995                         } else if (found_type) {
 996                                 found_type--;
 997                         } else {
 998                                 break;
 999                         }
1000                         btrfs_set_key_type(&key, found_type);
1001                         goto next;
1002                 }
1003                 if (found_key.offset >= inode->i_size)
1004                         del_item = 1;
1005                 else
1006                         del_item = 0;
1007                 found_extent = 0;
1008
1009                 /* FIXME, shrink the extent if the ref count is only 1 */
1010                 if (found_type != BTRFS_EXTENT_DATA_KEY)
1011                         goto delete;
1012
1013                 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
1014                         u64 num_dec;
1015                         extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
1016                         if (!del_item) {
1017                                 u64 orig_num_bytes =
1018                                         btrfs_file_extent_num_bytes(leaf, fi);
1019                                 extent_num_bytes = inode->i_size -
1020                                         found_key.offset + root->sectorsize - 1;
1021                                 extent_num_bytes = extent_num_bytes &
1022                                         ~((u64)root->sectorsize - 1);
1023                                 btrfs_set_file_extent_num_bytes(leaf, fi,
1024                                                          extent_num_bytes);
1025                                 num_dec = (orig_num_bytes -
1026                                            extent_num_bytes);
1027                                 if (extent_start != 0)
1028                                         dec_i_blocks(inode, num_dec);
1029                                 btrfs_mark_buffer_dirty(leaf);
1030                         } else {
1031                                 extent_num_bytes =
1032                                         btrfs_file_extent_disk_num_bytes(leaf,
1033                                                                          fi);
1034                                 /* FIXME blocksize != 4096 */
1035                                 num_dec = btrfs_file_extent_num_bytes(leaf, fi);
1036                                 if (extent_start != 0) {
1037                                         found_extent = 1;
1038                                         dec_i_blocks(inode, num_dec);
1039                                 }
1040                                 root_gen = btrfs_header_generation(leaf);
1041                                 root_owner = btrfs_header_owner(leaf);
1042                         }
1043                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1044                         if (!del_item) {
1045                                 u32 newsize = inode->i_size - found_key.offset;
1046                                 dec_i_blocks(inode, item_end + 1 -
1047                                             found_key.offset - newsize);
1048                                 newsize =
1049                                     btrfs_file_extent_calc_inline_size(newsize);
1050                                 ret = btrfs_truncate_item(trans, root, path,
1051                                                           newsize, 1);
1052                                 BUG_ON(ret);
1053                         } else {
1054                                 dec_i_blocks(inode, item_end + 1 -
1055                                              found_key.offset);
1056                         }
1057                 }
1058 delete:
1059                 if (del_item) {
1060                         if (!pending_del_nr) {
1061                                 /* no pending yet, add ourselves */
1062                                 pending_del_slot = path->slots[0];
1063                                 pending_del_nr = 1;
1064                         } else if (pending_del_nr &&
1065                                    path->slots[0] + 1 == pending_del_slot) {
1066                                 /* hop on the pending chunk */
1067                                 pending_del_nr++;
1068                                 pending_del_slot = path->slots[0];
1069                         } else {
1070                                 printk("bad pending slot %d pending_del_nr %d pending_del_slot %d\n", path->slots[0], pending_del_nr, pending_del_slot);
1071                         }
1072                 } else {
1073                         break;
1074                 }
1075                 if (found_extent) {
1076                         ret = btrfs_free_extent(trans, root, extent_start,
1077                                                 extent_num_bytes,
1078                                                 root_owner,
1079                                                 root_gen, inode->i_ino,
1080                                                 found_key.offset, 0);
1081                         BUG_ON(ret);
1082                 }
1083 next:
1084                 if (path->slots[0] == 0) {
1085                         if (pending_del_nr)
1086                                 goto del_pending;
1087                         btrfs_release_path(root, path);
1088                         goto search_again;
1089                 }
1090
1091                 path->slots[0]--;
1092                 if (pending_del_nr &&
1093                     path->slots[0] + 1 != pending_del_slot) {
1094                         struct btrfs_key debug;
1095 del_pending:
1096                         btrfs_item_key_to_cpu(path->nodes[0], &debug,
1097                                               pending_del_slot);
1098                         ret = btrfs_del_items(trans, root, path,
1099                                               pending_del_slot,
1100                                               pending_del_nr);
1101                         BUG_ON(ret);
1102                         pending_del_nr = 0;
1103                         btrfs_release_path(root, path);
1104                         goto search_again;
1105                 }
1106         }
1107         ret = 0;
1108 error:
1109         if (pending_del_nr) {
1110                 ret = btrfs_del_items(trans, root, path, pending_del_slot,
1111                                       pending_del_nr);
1112         }
1113         btrfs_free_path(path);
1114         inode->i_sb->s_dirt = 1;
1115         return ret;
1116 }
1117
1118 static int btrfs_cow_one_page(struct inode *inode, struct page *page,
1119                               size_t zero_start)
1120 {
1121         char *kaddr;
1122         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1123         u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
1124         u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
1125         int ret = 0;
1126
1127         WARN_ON(!PageLocked(page));
1128         set_page_extent_mapped(page);
1129
1130         lock_extent(io_tree, page_start, page_end, GFP_NOFS);
1131         set_extent_delalloc(&BTRFS_I(inode)->io_tree, page_start,
1132                             page_end, GFP_NOFS);
1133
1134         if (zero_start != PAGE_CACHE_SIZE) {
1135                 kaddr = kmap(page);
1136                 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
1137                 flush_dcache_page(page);
1138                 kunmap(page);
1139         }
1140         set_page_dirty(page);
1141         unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
1142
1143         return ret;
1144 }
1145
1146 /*
1147  * taken from block_truncate_page, but does cow as it zeros out
1148  * any bytes left in the last page in the file.
1149  */
1150 static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
1151 {
1152         struct inode *inode = mapping->host;
1153         struct btrfs_root *root = BTRFS_I(inode)->root;
1154         u32 blocksize = root->sectorsize;
1155         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1156         unsigned offset = from & (PAGE_CACHE_SIZE-1);
1157         struct page *page;
1158         int ret = 0;
1159         u64 page_start;
1160
1161         if ((offset & (blocksize - 1)) == 0)
1162                 goto out;
1163
1164         ret = -ENOMEM;
1165 again:
1166         page = grab_cache_page(mapping, index);
1167         if (!page)
1168                 goto out;
1169         if (!PageUptodate(page)) {
1170                 ret = btrfs_readpage(NULL, page);
1171                 lock_page(page);
1172                 if (page->mapping != mapping) {
1173                         unlock_page(page);
1174                         page_cache_release(page);
1175                         goto again;
1176                 }
1177                 if (!PageUptodate(page)) {
1178                         ret = -EIO;
1179                         goto out;
1180                 }
1181         }
1182
1183         page_start = (u64)page->index << PAGE_CACHE_SHIFT;
1184         wait_on_page_writeback(page);
1185         ret = btrfs_cow_one_page(inode, page, offset);
1186
1187         unlock_page(page);
1188         page_cache_release(page);
1189 out:
1190         return ret;
1191 }
1192
1193 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
1194 {
1195         struct inode *inode = dentry->d_inode;
1196         int err;
1197
1198         err = inode_change_ok(inode, attr);
1199         if (err)
1200                 return err;
1201
1202         if (S_ISREG(inode->i_mode) &&
1203             attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
1204                 struct btrfs_trans_handle *trans;
1205                 struct btrfs_root *root = BTRFS_I(inode)->root;
1206                 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1207
1208                 u64 mask = root->sectorsize - 1;
1209                 u64 hole_start = (inode->i_size + mask) & ~mask;
1210                 u64 block_end = (attr->ia_size + mask) & ~mask;
1211                 u64 hole_size;
1212                 u64 alloc_hint = 0;
1213
1214                 if (attr->ia_size <= hole_start)
1215                         goto out;
1216
1217                 err = btrfs_check_free_space(root, 1, 0);
1218                 if (err)
1219                         goto fail;
1220
1221                 btrfs_truncate_page(inode->i_mapping, inode->i_size);
1222
1223                 lock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
1224                 hole_size = block_end - hole_start;
1225
1226                 trans = btrfs_start_transaction(root, 1);
1227                 btrfs_set_trans_block_group(trans, inode);
1228                 err = btrfs_drop_extents(trans, root, inode,
1229                                          hole_start, block_end, hole_start,
1230                                          &alloc_hint);
1231
1232                 if (alloc_hint != EXTENT_MAP_INLINE) {
1233                         err = btrfs_insert_file_extent(trans, root,
1234                                                        inode->i_ino,
1235                                                        hole_start, 0, 0,
1236                                                        hole_size, 0);
1237                         btrfs_drop_extent_cache(inode, hole_start,
1238                                                 (u64)-1);
1239                         btrfs_check_file(root, inode);
1240                 }
1241                 btrfs_end_transaction(trans, root);
1242                 unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
1243                 if (err)
1244                         return err;
1245         }
1246 out:
1247         err = inode_setattr(inode, attr);
1248 fail:
1249         return err;
1250 }
1251
1252 void btrfs_delete_inode(struct inode *inode)
1253 {
1254         struct btrfs_trans_handle *trans;
1255         struct btrfs_root *root = BTRFS_I(inode)->root;
1256         unsigned long nr;
1257         int ret;
1258
1259         truncate_inode_pages(&inode->i_data, 0);
1260         if (is_bad_inode(inode)) {
1261                 goto no_delete;
1262         }
1263
1264         inode->i_size = 0;
1265         trans = btrfs_start_transaction(root, 1);
1266
1267         btrfs_set_trans_block_group(trans, inode);
1268         ret = btrfs_truncate_in_trans(trans, root, inode, 0);
1269         if (ret)
1270                 goto no_delete_lock;
1271
1272         nr = trans->blocks_used;
1273         clear_inode(inode);
1274
1275         btrfs_end_transaction(trans, root);
1276         btrfs_btree_balance_dirty(root, nr);
1277         return;
1278
1279 no_delete_lock:
1280         nr = trans->blocks_used;
1281         btrfs_end_transaction(trans, root);
1282         btrfs_btree_balance_dirty(root, nr);
1283 no_delete:
1284         clear_inode(inode);
1285 }
1286
1287 /*
1288  * this returns the key found in the dir entry in the location pointer.
1289  * If no dir entries were found, location->objectid is 0.
1290  */
1291 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
1292                                struct btrfs_key *location)
1293 {
1294         const char *name = dentry->d_name.name;
1295         int namelen = dentry->d_name.len;
1296         struct btrfs_dir_item *di;
1297         struct btrfs_path *path;
1298         struct btrfs_root *root = BTRFS_I(dir)->root;
1299         int ret = 0;
1300
1301         if (namelen == 1 && strcmp(name, ".") == 0) {
1302                 location->objectid = dir->i_ino;
1303                 location->type = BTRFS_INODE_ITEM_KEY;
1304                 location->offset = 0;
1305                 return 0;
1306         }
1307         path = btrfs_alloc_path();
1308         BUG_ON(!path);
1309
1310         if (namelen == 2 && strcmp(name, "..") == 0) {
1311                 struct btrfs_key key;
1312                 struct extent_buffer *leaf;
1313                 u32 nritems;
1314                 int slot;
1315
1316                 key.objectid = dir->i_ino;
1317                 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
1318                 key.offset = 0;
1319                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1320                 BUG_ON(ret == 0);
1321                 ret = 0;
1322
1323                 leaf = path->nodes[0];
1324                 slot = path->slots[0];
1325                 nritems = btrfs_header_nritems(leaf);
1326                 if (slot >= nritems)
1327                         goto out_err;
1328
1329                 btrfs_item_key_to_cpu(leaf, &key, slot);
1330                 if (key.objectid != dir->i_ino ||
1331                     key.type != BTRFS_INODE_REF_KEY) {
1332                         goto out_err;
1333                 }
1334                 location->objectid = key.offset;
1335                 location->type = BTRFS_INODE_ITEM_KEY;
1336                 location->offset = 0;
1337                 goto out;
1338         }
1339
1340         di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
1341                                     namelen, 0);
1342         if (IS_ERR(di))
1343                 ret = PTR_ERR(di);
1344         if (!di || IS_ERR(di)) {
1345                 goto out_err;
1346         }
1347         btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
1348 out:
1349         btrfs_free_path(path);
1350         return ret;
1351 out_err:
1352         location->objectid = 0;
1353         goto out;
1354 }
1355
1356 /*
1357  * when we hit a tree root in a directory, the btrfs part of the inode
1358  * needs to be changed to reflect the root directory of the tree root.  This
1359  * is kind of like crossing a mount point.
1360  */
1361 static int fixup_tree_root_location(struct btrfs_root *root,
1362                              struct btrfs_key *location,
1363                              struct btrfs_root **sub_root,
1364                              struct dentry *dentry)
1365 {
1366         struct btrfs_path *path;
1367         struct btrfs_root_item *ri;
1368
1369         if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
1370                 return 0;
1371         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1372                 return 0;
1373
1374         path = btrfs_alloc_path();
1375         BUG_ON(!path);
1376
1377         *sub_root = btrfs_read_fs_root(root->fs_info, location,
1378                                         dentry->d_name.name,
1379                                         dentry->d_name.len);
1380         if (IS_ERR(*sub_root))
1381                 return PTR_ERR(*sub_root);
1382
1383         ri = &(*sub_root)->root_item;
1384         location->objectid = btrfs_root_dirid(ri);
1385         btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
1386         location->offset = 0;
1387
1388         btrfs_free_path(path);
1389         return 0;
1390 }
1391
1392 static int btrfs_init_locked_inode(struct inode *inode, void *p)
1393 {
1394         struct btrfs_iget_args *args = p;
1395         inode->i_ino = args->ino;
1396         BTRFS_I(inode)->root = args->root;
1397         BTRFS_I(inode)->delalloc_bytes = 0;
1398         extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1399         extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1400                              inode->i_mapping, GFP_NOFS);
1401         extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1402                              inode->i_mapping, GFP_NOFS);
1403         atomic_set(&BTRFS_I(inode)->ordered_writeback, 0);
1404         return 0;
1405 }
1406
1407 static int btrfs_find_actor(struct inode *inode, void *opaque)
1408 {
1409         struct btrfs_iget_args *args = opaque;
1410         return (args->ino == inode->i_ino &&
1411                 args->root == BTRFS_I(inode)->root);
1412 }
1413
1414 struct inode *btrfs_ilookup(struct super_block *s, u64 objectid,
1415                             u64 root_objectid)
1416 {
1417         struct btrfs_iget_args args;
1418         args.ino = objectid;
1419         args.root = btrfs_lookup_fs_root(btrfs_sb(s)->fs_info, root_objectid);
1420
1421         if (!args.root)
1422                 return NULL;
1423
1424         return ilookup5(s, objectid, btrfs_find_actor, (void *)&args);
1425 }
1426
1427 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
1428                                 struct btrfs_root *root)
1429 {
1430         struct inode *inode;
1431         struct btrfs_iget_args args;
1432         args.ino = objectid;
1433         args.root = root;
1434
1435         inode = iget5_locked(s, objectid, btrfs_find_actor,
1436                              btrfs_init_locked_inode,
1437                              (void *)&args);
1438         return inode;
1439 }
1440
1441 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
1442                                    struct nameidata *nd)
1443 {
1444         struct inode * inode;
1445         struct btrfs_inode *bi = BTRFS_I(dir);
1446         struct btrfs_root *root = bi->root;
1447         struct btrfs_root *sub_root = root;
1448         struct btrfs_key location;
1449         int ret;
1450
1451         if (dentry->d_name.len > BTRFS_NAME_LEN)
1452                 return ERR_PTR(-ENAMETOOLONG);
1453
1454         ret = btrfs_inode_by_name(dir, dentry, &location);
1455
1456         if (ret < 0)
1457                 return ERR_PTR(ret);
1458
1459         inode = NULL;
1460         if (location.objectid) {
1461                 ret = fixup_tree_root_location(root, &location, &sub_root,
1462                                                 dentry);
1463                 if (ret < 0)
1464                         return ERR_PTR(ret);
1465                 if (ret > 0)
1466                         return ERR_PTR(-ENOENT);
1467                 inode = btrfs_iget_locked(dir->i_sb, location.objectid,
1468                                           sub_root);
1469                 if (!inode)
1470                         return ERR_PTR(-EACCES);
1471                 if (inode->i_state & I_NEW) {
1472                         /* the inode and parent dir are two different roots */
1473                         if (sub_root != root) {
1474                                 igrab(inode);
1475                                 sub_root->inode = inode;
1476                         }
1477                         BTRFS_I(inode)->root = sub_root;
1478                         memcpy(&BTRFS_I(inode)->location, &location,
1479                                sizeof(location));
1480                         btrfs_read_locked_inode(inode);
1481                         unlock_new_inode(inode);
1482                 }
1483         }
1484         return d_splice_alias(inode, dentry);
1485 }
1486
1487 static unsigned char btrfs_filetype_table[] = {
1488         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
1489 };
1490
1491 static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
1492 {
1493         struct inode *inode = filp->f_dentry->d_inode;
1494         struct btrfs_root *root = BTRFS_I(inode)->root;
1495         struct btrfs_item *item;
1496         struct btrfs_dir_item *di;
1497         struct btrfs_key key;
1498         struct btrfs_key found_key;
1499         struct btrfs_path *path;
1500         int ret;
1501         u32 nritems;
1502         struct extent_buffer *leaf;
1503         int slot;
1504         int advance;
1505         unsigned char d_type;
1506         int over = 0;
1507         u32 di_cur;
1508         u32 di_total;
1509         u32 di_len;
1510         int key_type = BTRFS_DIR_INDEX_KEY;
1511         char tmp_name[32];
1512         char *name_ptr;
1513         int name_len;
1514
1515         /* FIXME, use a real flag for deciding about the key type */
1516         if (root->fs_info->tree_root == root)
1517                 key_type = BTRFS_DIR_ITEM_KEY;
1518
1519         /* special case for "." */
1520         if (filp->f_pos == 0) {
1521                 over = filldir(dirent, ".", 1,
1522                                1, inode->i_ino,
1523                                DT_DIR);
1524                 if (over)
1525                         return 0;
1526                 filp->f_pos = 1;
1527         }
1528
1529         key.objectid = inode->i_ino;
1530         path = btrfs_alloc_path();
1531         path->reada = 2;
1532
1533         /* special case for .., just use the back ref */
1534         if (filp->f_pos == 1) {
1535                 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
1536                 key.offset = 0;
1537                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1538                 BUG_ON(ret == 0);
1539                 leaf = path->nodes[0];
1540                 slot = path->slots[0];
1541                 nritems = btrfs_header_nritems(leaf);
1542                 if (slot >= nritems) {
1543                         btrfs_release_path(root, path);
1544                         goto read_dir_items;
1545                 }
1546                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
1547                 btrfs_release_path(root, path);
1548                 if (found_key.objectid != key.objectid ||
1549                     found_key.type != BTRFS_INODE_REF_KEY)
1550                         goto read_dir_items;
1551                 over = filldir(dirent, "..", 2,
1552                                2, found_key.offset, DT_DIR);
1553                 if (over)
1554                         goto nopos;
1555                 filp->f_pos = 2;
1556         }
1557
1558 read_dir_items:
1559         btrfs_set_key_type(&key, key_type);
1560         key.offset = filp->f_pos;
1561
1562         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1563         if (ret < 0)
1564                 goto err;
1565         advance = 0;
1566         while(1) {
1567                 leaf = path->nodes[0];
1568                 nritems = btrfs_header_nritems(leaf);
1569                 slot = path->slots[0];
1570                 if (advance || slot >= nritems) {
1571                         if (slot >= nritems -1) {
1572                                 ret = btrfs_next_leaf(root, path);
1573                                 if (ret)
1574                                         break;
1575                                 leaf = path->nodes[0];
1576                                 nritems = btrfs_header_nritems(leaf);
1577                                 slot = path->slots[0];
1578                         } else {
1579                                 slot++;
1580                                 path->slots[0]++;
1581                         }
1582                 }
1583                 advance = 1;
1584                 item = btrfs_item_nr(leaf, slot);
1585                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
1586
1587                 if (found_key.objectid != key.objectid)
1588                         break;
1589                 if (btrfs_key_type(&found_key) != key_type)
1590                         break;
1591                 if (found_key.offset < filp->f_pos)
1592                         continue;
1593
1594                 filp->f_pos = found_key.offset;
1595                 advance = 1;
1596                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
1597                 di_cur = 0;
1598                 di_total = btrfs_item_size(leaf, item);
1599                 while(di_cur < di_total) {
1600                         struct btrfs_key location;
1601
1602                         name_len = btrfs_dir_name_len(leaf, di);
1603                         if (name_len < 32) {
1604                                 name_ptr = tmp_name;
1605                         } else {
1606                                 name_ptr = kmalloc(name_len, GFP_NOFS);
1607                                 BUG_ON(!name_ptr);
1608                         }
1609                         read_extent_buffer(leaf, name_ptr,
1610                                            (unsigned long)(di + 1), name_len);
1611
1612                         d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
1613                         btrfs_dir_item_key_to_cpu(leaf, di, &location);
1614                         over = filldir(dirent, name_ptr, name_len,
1615                                        found_key.offset,
1616                                        location.objectid,
1617                                        d_type);
1618
1619                         if (name_ptr != tmp_name)
1620                                 kfree(name_ptr);
1621
1622                         if (over)
1623                                 goto nopos;
1624                         di_len = btrfs_dir_name_len(leaf, di) +
1625                                 btrfs_dir_data_len(leaf, di) +sizeof(*di);
1626                         di_cur += di_len;
1627                         di = (struct btrfs_dir_item *)((char *)di + di_len);
1628                 }
1629         }
1630         if (key_type == BTRFS_DIR_INDEX_KEY)
1631                 filp->f_pos = INT_LIMIT(typeof(filp->f_pos));
1632         else
1633                 filp->f_pos++;
1634 nopos:
1635         ret = 0;
1636 err:
1637         btrfs_free_path(path);
1638         return ret;
1639 }
1640
1641 int btrfs_write_inode(struct inode *inode, int wait)
1642 {
1643         struct btrfs_root *root = BTRFS_I(inode)->root;
1644         struct btrfs_trans_handle *trans;
1645         int ret = 0;
1646
1647         if (wait) {
1648                 trans = btrfs_start_transaction(root, 1);
1649                 btrfs_set_trans_block_group(trans, inode);
1650                 ret = btrfs_commit_transaction(trans, root);
1651         }
1652         return ret;
1653 }
1654
1655 /*
1656  * This is somewhat expensive, updating the tree every time the
1657  * inode changes.  But, it is most likely to find the inode in cache.
1658  * FIXME, needs more benchmarking...there are no reasons other than performance
1659  * to keep or drop this code.
1660  */
1661 void btrfs_dirty_inode(struct inode *inode)
1662 {
1663         struct btrfs_root *root = BTRFS_I(inode)->root;
1664         struct btrfs_trans_handle *trans;
1665
1666         trans = btrfs_start_transaction(root, 1);
1667         btrfs_set_trans_block_group(trans, inode);
1668         btrfs_update_inode(trans, root, inode);
1669         btrfs_end_transaction(trans, root);
1670 }
1671
1672 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
1673                                      struct btrfs_root *root,
1674                                      const char *name, int name_len,
1675                                      u64 ref_objectid,
1676                                      u64 objectid,
1677                                      struct btrfs_block_group_cache *group,
1678                                      int mode)
1679 {
1680         struct inode *inode;
1681         struct btrfs_inode_item *inode_item;
1682         struct btrfs_block_group_cache *new_inode_group;
1683         struct btrfs_key *location;
1684         struct btrfs_path *path;
1685         struct btrfs_inode_ref *ref;
1686         struct btrfs_key key[2];
1687         u32 sizes[2];
1688         unsigned long ptr;
1689         int ret;
1690         int owner;
1691
1692         path = btrfs_alloc_path();
1693         BUG_ON(!path);
1694
1695         inode = new_inode(root->fs_info->sb);
1696         if (!inode)
1697                 return ERR_PTR(-ENOMEM);
1698
1699         extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1700         extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1701                              inode->i_mapping, GFP_NOFS);
1702         extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1703                              inode->i_mapping, GFP_NOFS);
1704         atomic_set(&BTRFS_I(inode)->ordered_writeback, 0);
1705         BTRFS_I(inode)->delalloc_bytes = 0;
1706         BTRFS_I(inode)->root = root;
1707
1708         if (mode & S_IFDIR)
1709                 owner = 0;
1710         else
1711                 owner = 1;
1712         new_inode_group = btrfs_find_block_group(root, group, 0,
1713                                        BTRFS_BLOCK_GROUP_METADATA, owner);
1714         if (!new_inode_group) {
1715                 printk("find_block group failed\n");
1716                 new_inode_group = group;
1717         }
1718         BTRFS_I(inode)->block_group = new_inode_group;
1719         BTRFS_I(inode)->flags = 0;
1720
1721         key[0].objectid = objectid;
1722         btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
1723         key[0].offset = 0;
1724
1725         key[1].objectid = objectid;
1726         btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
1727         key[1].offset = ref_objectid;
1728
1729         sizes[0] = sizeof(struct btrfs_inode_item);
1730         sizes[1] = name_len + sizeof(*ref);
1731
1732         ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
1733         if (ret != 0)
1734                 goto fail;
1735
1736         if (objectid > root->highest_inode)
1737                 root->highest_inode = objectid;
1738
1739         inode->i_uid = current->fsuid;
1740         inode->i_gid = current->fsgid;
1741         inode->i_mode = mode;
1742         inode->i_ino = objectid;
1743         inode->i_blocks = 0;
1744         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1745         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1746                                   struct btrfs_inode_item);
1747         fill_inode_item(path->nodes[0], inode_item, inode);
1748
1749         ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
1750                              struct btrfs_inode_ref);
1751         btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
1752         ptr = (unsigned long)(ref + 1);
1753         write_extent_buffer(path->nodes[0], name, ptr, name_len);
1754
1755         btrfs_mark_buffer_dirty(path->nodes[0]);
1756         btrfs_free_path(path);
1757
1758         location = &BTRFS_I(inode)->location;
1759         location->objectid = objectid;
1760         location->offset = 0;
1761         btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
1762
1763         insert_inode_hash(inode);
1764         return inode;
1765 fail:
1766         btrfs_free_path(path);
1767         return ERR_PTR(ret);
1768 }
1769
1770 static inline u8 btrfs_inode_type(struct inode *inode)
1771 {
1772         return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
1773 }
1774
1775 static int btrfs_add_link(struct btrfs_trans_handle *trans,
1776                             struct dentry *dentry, struct inode *inode,
1777                             int add_backref)
1778 {
1779         int ret;
1780         struct btrfs_key key;
1781         struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
1782         struct inode *parent_inode;
1783
1784         key.objectid = inode->i_ino;
1785         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
1786         key.offset = 0;
1787
1788         ret = btrfs_insert_dir_item(trans, root,
1789                                     dentry->d_name.name, dentry->d_name.len,
1790                                     dentry->d_parent->d_inode->i_ino,
1791                                     &key, btrfs_inode_type(inode));
1792         if (ret == 0) {
1793                 if (add_backref) {
1794                         ret = btrfs_insert_inode_ref(trans, root,
1795                                              dentry->d_name.name,
1796                                              dentry->d_name.len,
1797                                              inode->i_ino,
1798                                              dentry->d_parent->d_inode->i_ino);
1799                 }
1800                 parent_inode = dentry->d_parent->d_inode;
1801                 parent_inode->i_size += dentry->d_name.len * 2;
1802                 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
1803                 ret = btrfs_update_inode(trans, root,
1804                                          dentry->d_parent->d_inode);
1805         }
1806         return ret;
1807 }
1808
1809 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
1810                             struct dentry *dentry, struct inode *inode,
1811                             int backref)
1812 {
1813         int err = btrfs_add_link(trans, dentry, inode, backref);
1814         if (!err) {
1815                 d_instantiate(dentry, inode);
1816                 return 0;
1817         }
1818         if (err > 0)
1819                 err = -EEXIST;
1820         return err;
1821 }
1822
1823 static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
1824                         int mode, dev_t rdev)
1825 {
1826         struct btrfs_trans_handle *trans;
1827         struct btrfs_root *root = BTRFS_I(dir)->root;
1828         struct inode *inode = NULL;
1829         int err;
1830         int drop_inode = 0;
1831         u64 objectid;
1832         unsigned long nr = 0;
1833
1834         if (!new_valid_dev(rdev))
1835                 return -EINVAL;
1836
1837         err = btrfs_check_free_space(root, 1, 0);
1838         if (err)
1839                 goto fail;
1840
1841         trans = btrfs_start_transaction(root, 1);
1842         btrfs_set_trans_block_group(trans, dir);
1843
1844         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
1845         if (err) {
1846                 err = -ENOSPC;
1847                 goto out_unlock;
1848         }
1849
1850         inode = btrfs_new_inode(trans, root, dentry->d_name.name,
1851                                 dentry->d_name.len,
1852                                 dentry->d_parent->d_inode->i_ino, objectid,
1853                                 BTRFS_I(dir)->block_group, mode);
1854         err = PTR_ERR(inode);
1855         if (IS_ERR(inode))
1856                 goto out_unlock;
1857
1858         btrfs_set_trans_block_group(trans, inode);
1859         err = btrfs_add_nondir(trans, dentry, inode, 0);
1860         if (err)
1861                 drop_inode = 1;
1862         else {
1863                 inode->i_op = &btrfs_special_inode_operations;
1864                 init_special_inode(inode, inode->i_mode, rdev);
1865                 btrfs_update_inode(trans, root, inode);
1866         }
1867         dir->i_sb->s_dirt = 1;
1868         btrfs_update_inode_block_group(trans, inode);
1869         btrfs_update_inode_block_group(trans, dir);
1870 out_unlock:
1871         nr = trans->blocks_used;
1872         btrfs_end_transaction_throttle(trans, root);
1873 fail:
1874         if (drop_inode) {
1875                 inode_dec_link_count(inode);
1876                 iput(inode);
1877         }
1878         btrfs_btree_balance_dirty(root, nr);
1879         return err;
1880 }
1881
1882 static int btrfs_create(struct inode *dir, struct dentry *dentry,
1883                         int mode, struct nameidata *nd)
1884 {
1885         struct btrfs_trans_handle *trans;
1886         struct btrfs_root *root = BTRFS_I(dir)->root;
1887         struct inode *inode = NULL;
1888         int err;
1889         int drop_inode = 0;
1890         unsigned long nr = 0;
1891         u64 objectid;
1892
1893         err = btrfs_check_free_space(root, 1, 0);
1894         if (err)
1895                 goto fail;
1896         trans = btrfs_start_transaction(root, 1);
1897         btrfs_set_trans_block_group(trans, dir);
1898
1899         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
1900         if (err) {
1901                 err = -ENOSPC;
1902                 goto out_unlock;
1903         }
1904
1905         inode = btrfs_new_inode(trans, root, dentry->d_name.name,
1906                                 dentry->d_name.len,
1907                                 dentry->d_parent->d_inode->i_ino,
1908                                 objectid, BTRFS_I(dir)->block_group, mode);
1909         err = PTR_ERR(inode);
1910         if (IS_ERR(inode))
1911                 goto out_unlock;
1912
1913         btrfs_set_trans_block_group(trans, inode);
1914         err = btrfs_add_nondir(trans, dentry, inode, 0);
1915         if (err)
1916                 drop_inode = 1;
1917         else {
1918                 inode->i_mapping->a_ops = &btrfs_aops;
1919                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
1920                 inode->i_fop = &btrfs_file_operations;
1921                 inode->i_op = &btrfs_file_inode_operations;
1922                 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1923                 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1924                                      inode->i_mapping, GFP_NOFS);
1925                 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1926                                      inode->i_mapping, GFP_NOFS);
1927                 BTRFS_I(inode)->delalloc_bytes = 0;
1928                 atomic_set(&BTRFS_I(inode)->ordered_writeback, 0);
1929                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
1930         }
1931         dir->i_sb->s_dirt = 1;
1932         btrfs_update_inode_block_group(trans, inode);
1933         btrfs_update_inode_block_group(trans, dir);
1934 out_unlock:
1935         nr = trans->blocks_used;
1936         btrfs_end_transaction_throttle(trans, root);
1937 fail:
1938         if (drop_inode) {
1939                 inode_dec_link_count(inode);
1940                 iput(inode);
1941         }
1942         btrfs_btree_balance_dirty(root, nr);
1943         return err;
1944 }
1945
1946 static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
1947                       struct dentry *dentry)
1948 {
1949         struct btrfs_trans_handle *trans;
1950         struct btrfs_root *root = BTRFS_I(dir)->root;
1951         struct inode *inode = old_dentry->d_inode;
1952         unsigned long nr = 0;
1953         int err;
1954         int drop_inode = 0;
1955
1956         if (inode->i_nlink == 0)
1957                 return -ENOENT;
1958
1959 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
1960         inode->i_nlink++;
1961 #else
1962         inc_nlink(inode);
1963 #endif
1964         err = btrfs_check_free_space(root, 1, 0);
1965         if (err)
1966                 goto fail;
1967         trans = btrfs_start_transaction(root, 1);
1968
1969         btrfs_set_trans_block_group(trans, dir);
1970         atomic_inc(&inode->i_count);
1971         err = btrfs_add_nondir(trans, dentry, inode, 1);
1972
1973         if (err)
1974                 drop_inode = 1;
1975
1976         dir->i_sb->s_dirt = 1;
1977         btrfs_update_inode_block_group(trans, dir);
1978         err = btrfs_update_inode(trans, root, inode);
1979
1980         if (err)
1981                 drop_inode = 1;
1982
1983         nr = trans->blocks_used;
1984         btrfs_end_transaction_throttle(trans, root);
1985 fail:
1986         if (drop_inode) {
1987                 inode_dec_link_count(inode);
1988                 iput(inode);
1989         }
1990         btrfs_btree_balance_dirty(root, nr);
1991         return err;
1992 }
1993
1994 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
1995 {
1996         struct inode *inode = NULL;
1997         struct btrfs_trans_handle *trans;
1998         struct btrfs_root *root = BTRFS_I(dir)->root;
1999         int err = 0;
2000         int drop_on_err = 0;
2001         u64 objectid = 0;
2002         unsigned long nr = 1;
2003
2004         err = btrfs_check_free_space(root, 1, 0);
2005         if (err)
2006                 goto out_unlock;
2007
2008         trans = btrfs_start_transaction(root, 1);
2009         btrfs_set_trans_block_group(trans, dir);
2010
2011         if (IS_ERR(trans)) {
2012                 err = PTR_ERR(trans);
2013                 goto out_unlock;
2014         }
2015
2016         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
2017         if (err) {
2018                 err = -ENOSPC;
2019                 goto out_unlock;
2020         }
2021
2022         inode = btrfs_new_inode(trans, root, dentry->d_name.name,
2023                                 dentry->d_name.len,
2024                                 dentry->d_parent->d_inode->i_ino, objectid,
2025                                 BTRFS_I(dir)->block_group, S_IFDIR | mode);
2026         if (IS_ERR(inode)) {
2027                 err = PTR_ERR(inode);
2028                 goto out_fail;
2029         }
2030
2031         drop_on_err = 1;
2032         inode->i_op = &btrfs_dir_inode_operations;
2033         inode->i_fop = &btrfs_dir_file_operations;
2034         btrfs_set_trans_block_group(trans, inode);
2035
2036         inode->i_size = 0;
2037         err = btrfs_update_inode(trans, root, inode);
2038         if (err)
2039                 goto out_fail;
2040
2041         err = btrfs_add_link(trans, dentry, inode, 0);
2042         if (err)
2043                 goto out_fail;
2044
2045         d_instantiate(dentry, inode);
2046         drop_on_err = 0;
2047         dir->i_sb->s_dirt = 1;
2048         btrfs_update_inode_block_group(trans, inode);
2049         btrfs_update_inode_block_group(trans, dir);
2050
2051 out_fail:
2052         nr = trans->blocks_used;
2053         btrfs_end_transaction_throttle(trans, root);
2054
2055 out_unlock:
2056         if (drop_on_err)
2057                 iput(inode);
2058         btrfs_btree_balance_dirty(root, nr);
2059         return err;
2060 }
2061
2062 static int merge_extent_mapping(struct extent_map_tree *em_tree,
2063                                 struct extent_map *existing,
2064                                 struct extent_map *em)
2065 {
2066         u64 start_diff;
2067         u64 new_end;
2068         int ret = 0;
2069         int real_blocks = existing->block_start < EXTENT_MAP_LAST_BYTE;
2070
2071         if (real_blocks && em->block_start >= EXTENT_MAP_LAST_BYTE)
2072                 goto invalid;
2073
2074         if (!real_blocks && em->block_start != existing->block_start)
2075                 goto invalid;
2076
2077         new_end = max(existing->start + existing->len, em->start + em->len);
2078
2079         if (existing->start >= em->start) {
2080                 if (em->start + em->len < existing->start)
2081                         goto invalid;
2082
2083                 start_diff = existing->start - em->start;
2084                 if (real_blocks && em->block_start + start_diff !=
2085                     existing->block_start)
2086                         goto invalid;
2087
2088                 em->len = new_end - em->start;
2089
2090                 remove_extent_mapping(em_tree, existing);
2091                 /* free for the tree */
2092                 free_extent_map(existing);
2093                 ret = add_extent_mapping(em_tree, em);
2094
2095         } else if (em->start > existing->start) {
2096
2097                 if (existing->start + existing->len < em->start)
2098                         goto invalid;
2099
2100                 start_diff = em->start - existing->start;
2101                 if (real_blocks && existing->block_start + start_diff !=
2102                     em->block_start)
2103                         goto invalid;
2104
2105                 remove_extent_mapping(em_tree, existing);
2106                 em->block_start = existing->block_start;
2107                 em->start = existing->start;
2108                 em->len = new_end - existing->start;
2109                 free_extent_map(existing);
2110
2111                 ret = add_extent_mapping(em_tree, em);
2112         } else {
2113                 goto invalid;
2114         }
2115         return ret;
2116
2117 invalid:
2118         printk("invalid extent map merge [%Lu %Lu %Lu] [%Lu %Lu %Lu]\n",
2119                existing->start, existing->len, existing->block_start,
2120                em->start, em->len, em->block_start);
2121         return -EIO;
2122 }
2123
2124 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
2125                                     size_t pg_offset, u64 start, u64 len,
2126                                     int create)
2127 {
2128         int ret;
2129         int err = 0;
2130         u64 bytenr;
2131         u64 extent_start = 0;
2132         u64 extent_end = 0;
2133         u64 objectid = inode->i_ino;
2134         u32 found_type;
2135         struct btrfs_path *path;
2136         struct btrfs_root *root = BTRFS_I(inode)->root;
2137         struct btrfs_file_extent_item *item;
2138         struct extent_buffer *leaf;
2139         struct btrfs_key found_key;
2140         struct extent_map *em = NULL;
2141         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
2142         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2143         struct btrfs_trans_handle *trans = NULL;
2144
2145         path = btrfs_alloc_path();
2146         BUG_ON(!path);
2147
2148 again:
2149         spin_lock(&em_tree->lock);
2150         em = lookup_extent_mapping(em_tree, start, len);
2151         if (em)
2152                 em->bdev = root->fs_info->fs_devices->latest_bdev;
2153         spin_unlock(&em_tree->lock);
2154
2155         if (em) {
2156                 if (em->start > start || em->start + em->len <= start)
2157                         free_extent_map(em);
2158                 else if (em->block_start == EXTENT_MAP_INLINE && page)
2159                         free_extent_map(em);
2160                 else
2161                         goto out;
2162         }
2163         em = alloc_extent_map(GFP_NOFS);
2164         if (!em) {
2165                 err = -ENOMEM;
2166                 goto out;
2167         }
2168
2169         em->start = EXTENT_MAP_HOLE;
2170         em->len = (u64)-1;
2171         em->bdev = root->fs_info->fs_devices->latest_bdev;
2172         ret = btrfs_lookup_file_extent(trans, root, path,
2173                                        objectid, start, trans != NULL);
2174         if (ret < 0) {
2175                 err = ret;
2176                 goto out;
2177         }
2178
2179         if (ret != 0) {
2180                 if (path->slots[0] == 0)
2181                         goto not_found;
2182                 path->slots[0]--;
2183         }
2184
2185         leaf = path->nodes[0];
2186         item = btrfs_item_ptr(leaf, path->slots[0],
2187                               struct btrfs_file_extent_item);
2188         /* are we inside the extent that was found? */
2189         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2190         found_type = btrfs_key_type(&found_key);
2191         if (found_key.objectid != objectid ||
2192             found_type != BTRFS_EXTENT_DATA_KEY) {
2193                 goto not_found;
2194         }
2195
2196         found_type = btrfs_file_extent_type(leaf, item);
2197         extent_start = found_key.offset;
2198         if (found_type == BTRFS_FILE_EXTENT_REG) {
2199                 extent_end = extent_start +
2200                        btrfs_file_extent_num_bytes(leaf, item);
2201                 err = 0;
2202                 if (start < extent_start || start >= extent_end) {
2203                         em->start = start;
2204                         if (start < extent_start) {
2205                                 if (start + len <= extent_start)
2206                                         goto not_found;
2207                                 em->len = extent_end - extent_start;
2208                         } else {
2209                                 em->len = len;
2210                         }
2211                         goto not_found_em;
2212                 }
2213                 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
2214                 if (bytenr == 0) {
2215                         em->start = extent_start;
2216                         em->len = extent_end - extent_start;
2217                         em->block_start = EXTENT_MAP_HOLE;
2218                         goto insert;
2219                 }
2220                 bytenr += btrfs_file_extent_offset(leaf, item);
2221                 em->block_start = bytenr;
2222                 em->start = extent_start;
2223                 em->len = extent_end - extent_start;
2224                 goto insert;
2225         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
2226                 u64 page_start;
2227                 unsigned long ptr;
2228                 char *map;
2229                 size_t size;
2230                 size_t extent_offset;
2231                 size_t copy_size;
2232
2233                 size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
2234                                                     path->slots[0]));
2235                 extent_end = (extent_start + size + root->sectorsize - 1) &
2236                         ~((u64)root->sectorsize - 1);
2237                 if (start < extent_start || start >= extent_end) {
2238                         em->start = start;
2239                         if (start < extent_start) {
2240                                 if (start + len <= extent_start)
2241                                         goto not_found;
2242                                 em->len = extent_end - extent_start;
2243                         } else {
2244                                 em->len = len;
2245                         }
2246                         goto not_found_em;
2247                 }
2248                 em->block_start = EXTENT_MAP_INLINE;
2249
2250                 if (!page) {
2251                         em->start = extent_start;
2252                         em->len = size;
2253                         goto out;
2254                 }
2255
2256                 page_start = page_offset(page) + pg_offset;
2257                 extent_offset = page_start - extent_start;
2258                 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
2259                                 size - extent_offset);
2260                 em->start = extent_start + extent_offset;
2261                 em->len = (copy_size + root->sectorsize - 1) &
2262                         ~((u64)root->sectorsize - 1);
2263                 map = kmap(page);
2264                 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
2265                 if (create == 0 && !PageUptodate(page)) {
2266                         read_extent_buffer(leaf, map + pg_offset, ptr,
2267                                            copy_size);
2268                         flush_dcache_page(page);
2269                 } else if (create && PageUptodate(page)) {
2270                         if (!trans) {
2271                                 kunmap(page);
2272                                 free_extent_map(em);
2273                                 em = NULL;
2274                                 btrfs_release_path(root, path);
2275                                 trans = btrfs_start_transaction(root, 1);
2276                                 goto again;
2277                         }
2278                         write_extent_buffer(leaf, map + pg_offset, ptr,
2279                                             copy_size);
2280                         btrfs_mark_buffer_dirty(leaf);
2281                 }
2282                 kunmap(page);
2283                 set_extent_uptodate(io_tree, em->start,
2284                                     extent_map_end(em) - 1, GFP_NOFS);
2285                 goto insert;
2286         } else {
2287                 printk("unkknown found_type %d\n", found_type);
2288                 WARN_ON(1);
2289         }
2290 not_found:
2291         em->start = start;
2292         em->len = len;
2293 not_found_em:
2294         em->block_start = EXTENT_MAP_HOLE;
2295 insert:
2296         btrfs_release_path(root, path);
2297         if (em->start > start || extent_map_end(em) <= start) {
2298                 printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->len, start, len);
2299                 err = -EIO;
2300                 goto out;
2301         }
2302
2303         err = 0;
2304         spin_lock(&em_tree->lock);
2305         ret = add_extent_mapping(em_tree, em);
2306         /* it is possible that someone inserted the extent into the tree
2307          * while we had the lock dropped.  It is also possible that
2308          * an overlapping map exists in the tree
2309          */
2310         if (ret == -EEXIST) {
2311                 struct extent_map *existing;
2312                 existing = lookup_extent_mapping(em_tree, start, len);
2313                 if (existing && (existing->start > start ||
2314                     existing->start + existing->len <= start)) {
2315                         free_extent_map(existing);
2316                         existing = NULL;
2317                 }
2318                 if (!existing) {
2319                         existing = lookup_extent_mapping(em_tree, em->start,
2320                                                          em->len);
2321                         if (existing) {
2322                                 err = merge_extent_mapping(em_tree, existing,
2323                                                            em);
2324                                 free_extent_map(existing);
2325                                 if (err) {
2326                                         free_extent_map(em);
2327                                         em = NULL;
2328                                 }
2329                         } else {
2330                                 err = -EIO;
2331                                 printk("failing to insert %Lu %Lu\n",
2332                                        start, len);
2333                                 free_extent_map(em);
2334                                 em = NULL;
2335                         }
2336                 } else {
2337                         free_extent_map(em);
2338                         em = existing;
2339                 }
2340         }
2341         spin_unlock(&em_tree->lock);
2342 out:
2343         btrfs_free_path(path);
2344         if (trans) {
2345                 ret = btrfs_end_transaction(trans, root);
2346                 if (!err)
2347                         err = ret;
2348         }
2349         if (err) {
2350                 free_extent_map(em);
2351                 WARN_ON(1);
2352                 return ERR_PTR(err);
2353         }
2354         return em;
2355 }
2356
2357 #if 0 /* waiting for O_DIRECT reads */
2358 static int btrfs_get_block(struct inode *inode, sector_t iblock,
2359                         struct buffer_head *bh_result, int create)
2360 {
2361         struct extent_map *em;
2362         u64 start = (u64)iblock << inode->i_blkbits;
2363         struct btrfs_multi_bio *multi = NULL;
2364         struct btrfs_root *root = BTRFS_I(inode)->root;
2365         u64 len;
2366         u64 logical;
2367         u64 map_length;
2368         int ret = 0;
2369
2370         em = btrfs_get_extent(inode, NULL, 0, start, bh_result->b_size, 0);
2371
2372         if (!em || IS_ERR(em))
2373                 goto out;
2374
2375         if (em->start > start || em->start + em->len <= start) {
2376             goto out;
2377         }
2378
2379         if (em->block_start == EXTENT_MAP_INLINE) {
2380                 ret = -EINVAL;
2381                 goto out;
2382         }
2383
2384         len = em->start + em->len - start;
2385         len = min_t(u64, len, INT_LIMIT(typeof(bh_result->b_size)));
2386
2387         if (em->block_start == EXTENT_MAP_HOLE ||
2388             em->block_start == EXTENT_MAP_DELALLOC) {
2389                 bh_result->b_size = len;
2390                 goto out;
2391         }
2392
2393         logical = start - em->start;
2394         logical = em->block_start + logical;
2395
2396         map_length = len;
2397         ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
2398                               logical, &map_length, &multi, 0);
2399         BUG_ON(ret);
2400         bh_result->b_blocknr = multi->stripes[0].physical >> inode->i_blkbits;
2401         bh_result->b_size = min(map_length, len);
2402
2403         bh_result->b_bdev = multi->stripes[0].dev->bdev;
2404         set_buffer_mapped(bh_result);
2405         kfree(multi);
2406 out:
2407         free_extent_map(em);
2408         return ret;
2409 }
2410 #endif
2411
2412 static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
2413                         const struct iovec *iov, loff_t offset,
2414                         unsigned long nr_segs)
2415 {
2416         return -EINVAL;
2417 #if 0
2418         struct file *file = iocb->ki_filp;
2419         struct inode *inode = file->f_mapping->host;
2420
2421         if (rw == WRITE)
2422                 return -EINVAL;
2423
2424         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2425                                   offset, nr_segs, btrfs_get_block, NULL);
2426 #endif
2427 }
2428
2429 static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
2430 {
2431         return extent_bmap(mapping, iblock, btrfs_get_extent);
2432 }
2433
2434 int btrfs_readpage(struct file *file, struct page *page)
2435 {
2436         struct extent_io_tree *tree;
2437         tree = &BTRFS_I(page->mapping->host)->io_tree;
2438         return extent_read_full_page(tree, page, btrfs_get_extent);
2439 }
2440
2441 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
2442 {
2443         struct extent_io_tree *tree;
2444
2445
2446         if (current->flags & PF_MEMALLOC) {
2447                 redirty_page_for_writepage(wbc, page);
2448                 unlock_page(page);
2449                 return 0;
2450         }
2451         tree = &BTRFS_I(page->mapping->host)->io_tree;
2452         return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
2453 }
2454
2455 static int btrfs_writepages(struct address_space *mapping,
2456                             struct writeback_control *wbc)
2457 {
2458         struct extent_io_tree *tree;
2459         tree = &BTRFS_I(mapping->host)->io_tree;
2460         return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
2461 }
2462
2463 static int
2464 btrfs_readpages(struct file *file, struct address_space *mapping,
2465                 struct list_head *pages, unsigned nr_pages)
2466 {
2467         struct extent_io_tree *tree;
2468         tree = &BTRFS_I(mapping->host)->io_tree;
2469         return extent_readpages(tree, mapping, pages, nr_pages,
2470                                 btrfs_get_extent);
2471 }
2472
2473 static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
2474 {
2475         struct extent_io_tree *tree;
2476         struct extent_map_tree *map;
2477         int ret;
2478
2479         tree = &BTRFS_I(page->mapping->host)->io_tree;
2480         map = &BTRFS_I(page->mapping->host)->extent_tree;
2481         ret = try_release_extent_mapping(map, tree, page, gfp_flags);
2482         if (ret == 1) {
2483                 invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
2484                 ClearPagePrivate(page);
2485                 set_page_private(page, 0);
2486                 page_cache_release(page);
2487         }
2488         return ret;
2489 }
2490
2491 static void btrfs_invalidatepage(struct page *page, unsigned long offset)
2492 {
2493         struct extent_io_tree *tree;
2494
2495         tree = &BTRFS_I(page->mapping->host)->io_tree;
2496         extent_invalidatepage(tree, page, offset);
2497         btrfs_releasepage(page, GFP_NOFS);
2498         if (PagePrivate(page)) {
2499                 invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
2500                 ClearPagePrivate(page);
2501                 set_page_private(page, 0);
2502                 page_cache_release(page);
2503         }
2504 }
2505
2506 /*
2507  * btrfs_page_mkwrite() is not allowed to change the file size as it gets
2508  * called from a page fault handler when a page is first dirtied. Hence we must
2509  * be careful to check for EOF conditions here. We set the page up correctly
2510  * for a written page which means we get ENOSPC checking when writing into
2511  * holes and correct delalloc and unwritten extent mapping on filesystems that
2512  * support these features.
2513  *
2514  * We are not allowed to take the i_mutex here so we have to play games to
2515  * protect against truncate races as the page could now be beyond EOF.  Because
2516  * vmtruncate() writes the inode size before removing pages, once we have the
2517  * page lock we can determine safely if the page is beyond EOF. If it is not
2518  * beyond EOF, then the page is guaranteed safe against truncation until we
2519  * unlock the page.
2520  */
2521 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
2522 {
2523         struct inode *inode = fdentry(vma->vm_file)->d_inode;
2524         struct btrfs_root *root = BTRFS_I(inode)->root;
2525         unsigned long end;
2526         loff_t size;
2527         int ret;
2528         u64 page_start;
2529
2530         ret = btrfs_check_free_space(root, PAGE_CACHE_SIZE, 0);
2531         if (ret)
2532                 goto out;
2533
2534         ret = -EINVAL;
2535
2536         lock_page(page);
2537         wait_on_page_writeback(page);
2538         size = i_size_read(inode);
2539         page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2540
2541         if ((page->mapping != inode->i_mapping) ||
2542             (page_start > size)) {
2543                 /* page got truncated out from underneath us */
2544                 goto out_unlock;
2545         }
2546
2547         /* page is wholly or partially inside EOF */
2548         if (page_start + PAGE_CACHE_SIZE > size)
2549                 end = size & ~PAGE_CACHE_MASK;
2550         else
2551                 end = PAGE_CACHE_SIZE;
2552
2553         ret = btrfs_cow_one_page(inode, page, end);
2554
2555 out_unlock:
2556         unlock_page(page);
2557 out:
2558         return ret;
2559 }
2560
2561 static void btrfs_truncate(struct inode *inode)
2562 {
2563         struct btrfs_root *root = BTRFS_I(inode)->root;
2564         int ret;
2565         struct btrfs_trans_handle *trans;
2566         unsigned long nr;
2567
2568         if (!S_ISREG(inode->i_mode))
2569                 return;
2570         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2571                 return;
2572
2573         btrfs_truncate_page(inode->i_mapping, inode->i_size);
2574
2575         trans = btrfs_start_transaction(root, 1);
2576         btrfs_set_trans_block_group(trans, inode);
2577
2578         /* FIXME, add redo link to tree so we don't leak on crash */
2579         ret = btrfs_truncate_in_trans(trans, root, inode,
2580                                       BTRFS_EXTENT_DATA_KEY);
2581         btrfs_update_inode(trans, root, inode);
2582         nr = trans->blocks_used;
2583
2584         ret = btrfs_end_transaction_throttle(trans, root);
2585         BUG_ON(ret);
2586         btrfs_btree_balance_dirty(root, nr);
2587 }
2588
2589 /*
2590  * Invalidate a single dcache entry at the root of the filesystem.
2591  * Needed after creation of snapshot or subvolume.
2592  */
2593 void btrfs_invalidate_dcache_root(struct btrfs_root *root, char *name,
2594                                   int namelen)
2595 {
2596         struct dentry *alias, *entry;
2597         struct qstr qstr;
2598
2599         alias = d_find_alias(root->fs_info->sb->s_root->d_inode);
2600         if (alias) {
2601                 qstr.name = name;
2602                 qstr.len = namelen;
2603                 /* change me if btrfs ever gets a d_hash operation */
2604                 qstr.hash = full_name_hash(qstr.name, qstr.len);
2605                 entry = d_lookup(alias, &qstr);
2606                 dput(alias);
2607                 if (entry) {
2608                         d_invalidate(entry);
2609                         dput(entry);
2610                 }
2611         }
2612 }
2613
2614 int btrfs_create_subvol_root(struct btrfs_root *new_root,
2615                 struct btrfs_trans_handle *trans, u64 new_dirid,
2616                 struct btrfs_block_group_cache *block_group)
2617 {
2618         struct inode *inode;
2619         int ret;
2620
2621         inode = btrfs_new_inode(trans, new_root, "..", 2, new_dirid,
2622                                 new_dirid, block_group, S_IFDIR | 0700);
2623         if (IS_ERR(inode))
2624                 return PTR_ERR(inode);
2625         inode->i_op = &btrfs_dir_inode_operations;
2626         inode->i_fop = &btrfs_dir_file_operations;
2627         new_root->inode = inode;
2628
2629         ret = btrfs_insert_inode_ref(trans, new_root, "..", 2, new_dirid,
2630                                      new_dirid);
2631         inode->i_nlink = 1;
2632         inode->i_size = 0;
2633
2634         return btrfs_update_inode(trans, new_root, inode);
2635 }
2636
2637 unsigned long btrfs_force_ra(struct address_space *mapping,
2638                               struct file_ra_state *ra, struct file *file,
2639                               pgoff_t offset, pgoff_t last_index)
2640 {
2641         pgoff_t req_size = last_index - offset + 1;
2642
2643 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
2644         offset = page_cache_readahead(mapping, ra, file, offset, req_size);
2645         return offset;
2646 #else
2647         page_cache_sync_readahead(mapping, ra, file, offset, req_size);
2648         return offset + req_size;
2649 #endif
2650 }
2651
2652 struct inode *btrfs_alloc_inode(struct super_block *sb)
2653 {
2654         struct btrfs_inode *ei;
2655
2656         ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
2657         if (!ei)
2658                 return NULL;
2659         ei->last_trans = 0;
2660         ei->ordered_trans = 0;
2661         return &ei->vfs_inode;
2662 }
2663
2664 void btrfs_destroy_inode(struct inode *inode)
2665 {
2666         WARN_ON(!list_empty(&inode->i_dentry));
2667         WARN_ON(inode->i_data.nrpages);
2668
2669         btrfs_drop_extent_cache(inode, 0, (u64)-1);
2670         kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
2671 }
2672
2673 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
2674 static void init_once(struct kmem_cache * cachep, void *foo)
2675 #else
2676 static void init_once(void * foo, struct kmem_cache * cachep,
2677                       unsigned long flags)
2678 #endif
2679 {
2680         struct btrfs_inode *ei = (struct btrfs_inode *) foo;
2681
2682         inode_init_once(&ei->vfs_inode);
2683 }
2684
2685 void btrfs_destroy_cachep(void)
2686 {
2687         if (btrfs_inode_cachep)
2688                 kmem_cache_destroy(btrfs_inode_cachep);
2689         if (btrfs_trans_handle_cachep)
2690                 kmem_cache_destroy(btrfs_trans_handle_cachep);
2691         if (btrfs_transaction_cachep)
2692                 kmem_cache_destroy(btrfs_transaction_cachep);
2693         if (btrfs_bit_radix_cachep)
2694                 kmem_cache_destroy(btrfs_bit_radix_cachep);
2695         if (btrfs_path_cachep)
2696                 kmem_cache_destroy(btrfs_path_cachep);
2697 }
2698
2699 struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
2700                                        unsigned long extra_flags,
2701 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
2702                                        void (*ctor)(struct kmem_cache *, void *)
2703 #else
2704                                        void (*ctor)(void *, struct kmem_cache *,
2705                                                     unsigned long)
2706 #endif
2707                                      )
2708 {
2709         return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
2710                                  SLAB_MEM_SPREAD | extra_flags), ctor
2711 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
2712                                  ,NULL
2713 #endif
2714                                 );
2715 }
2716
2717 int btrfs_init_cachep(void)
2718 {
2719         btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
2720                                           sizeof(struct btrfs_inode),
2721                                           0, init_once);
2722         if (!btrfs_inode_cachep)
2723                 goto fail;
2724         btrfs_trans_handle_cachep =
2725                         btrfs_cache_create("btrfs_trans_handle_cache",
2726                                            sizeof(struct btrfs_trans_handle),
2727                                            0, NULL);
2728         if (!btrfs_trans_handle_cachep)
2729                 goto fail;
2730         btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
2731                                              sizeof(struct btrfs_transaction),
2732                                              0, NULL);
2733         if (!btrfs_transaction_cachep)
2734                 goto fail;
2735         btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
2736                                          sizeof(struct btrfs_path),
2737                                          0, NULL);
2738         if (!btrfs_path_cachep)
2739                 goto fail;
2740         btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
2741                                               SLAB_DESTROY_BY_RCU, NULL);
2742         if (!btrfs_bit_radix_cachep)
2743                 goto fail;
2744         return 0;
2745 fail:
2746         btrfs_destroy_cachep();
2747         return -ENOMEM;
2748 }
2749
2750 static int btrfs_getattr(struct vfsmount *mnt,
2751                          struct dentry *dentry, struct kstat *stat)
2752 {
2753         struct inode *inode = dentry->d_inode;
2754         generic_fillattr(inode, stat);
2755         stat->blksize = PAGE_CACHE_SIZE;
2756         stat->blocks = inode->i_blocks + (BTRFS_I(inode)->delalloc_bytes >> 9);
2757         return 0;
2758 }
2759
2760 static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
2761                            struct inode * new_dir,struct dentry *new_dentry)
2762 {
2763         struct btrfs_trans_handle *trans;
2764         struct btrfs_root *root = BTRFS_I(old_dir)->root;
2765         struct inode *new_inode = new_dentry->d_inode;
2766         struct inode *old_inode = old_dentry->d_inode;
2767         struct timespec ctime = CURRENT_TIME;
2768         int ret;
2769
2770         if (S_ISDIR(old_inode->i_mode) && new_inode &&
2771             new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
2772                 return -ENOTEMPTY;
2773         }
2774
2775         ret = btrfs_check_free_space(root, 1, 0);
2776         if (ret)
2777                 goto out_unlock;
2778
2779         trans = btrfs_start_transaction(root, 1);
2780
2781         btrfs_set_trans_block_group(trans, new_dir);
2782
2783         old_dentry->d_inode->i_nlink++;
2784         old_dir->i_ctime = old_dir->i_mtime = ctime;
2785         new_dir->i_ctime = new_dir->i_mtime = ctime;
2786         old_inode->i_ctime = ctime;
2787
2788         ret = btrfs_unlink_trans(trans, root, old_dir, old_dentry);
2789         if (ret)
2790                 goto out_fail;
2791
2792         if (new_inode) {
2793                 new_inode->i_ctime = CURRENT_TIME;
2794                 ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
2795                 if (ret)
2796                         goto out_fail;
2797         }
2798         ret = btrfs_add_link(trans, new_dentry, old_inode, 1);
2799         if (ret)
2800                 goto out_fail;
2801
2802 out_fail:
2803         btrfs_end_transaction(trans, root);
2804 out_unlock:
2805         return ret;
2806 }
2807
2808 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
2809                          const char *symname)
2810 {
2811         struct btrfs_trans_handle *trans;
2812         struct btrfs_root *root = BTRFS_I(dir)->root;
2813         struct btrfs_path *path;
2814         struct btrfs_key key;
2815         struct inode *inode = NULL;
2816         int err;
2817         int drop_inode = 0;
2818         u64 objectid;
2819         int name_len;
2820         int datasize;
2821         unsigned long ptr;
2822         struct btrfs_file_extent_item *ei;
2823         struct extent_buffer *leaf;
2824         unsigned long nr = 0;
2825
2826         name_len = strlen(symname) + 1;
2827         if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
2828                 return -ENAMETOOLONG;
2829
2830         err = btrfs_check_free_space(root, 1, 0);
2831         if (err)
2832                 goto out_fail;
2833
2834         trans = btrfs_start_transaction(root, 1);
2835         btrfs_set_trans_block_group(trans, dir);
2836
2837         err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
2838         if (err) {
2839                 err = -ENOSPC;
2840                 goto out_unlock;
2841         }
2842
2843         inode = btrfs_new_inode(trans, root, dentry->d_name.name,
2844                                 dentry->d_name.len,
2845                                 dentry->d_parent->d_inode->i_ino, objectid,
2846                                 BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO);
2847         err = PTR_ERR(inode);
2848         if (IS_ERR(inode))
2849                 goto out_unlock;
2850
2851         btrfs_set_trans_block_group(trans, inode);
2852         err = btrfs_add_nondir(trans, dentry, inode, 0);
2853         if (err)
2854                 drop_inode = 1;
2855         else {
2856                 inode->i_mapping->a_ops = &btrfs_aops;
2857                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2858                 inode->i_fop = &btrfs_file_operations;
2859                 inode->i_op = &btrfs_file_inode_operations;
2860                 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
2861                 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
2862                                      inode->i_mapping, GFP_NOFS);
2863                 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
2864                                      inode->i_mapping, GFP_NOFS);
2865                 BTRFS_I(inode)->delalloc_bytes = 0;
2866                 atomic_set(&BTRFS_I(inode)->ordered_writeback, 0);
2867                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
2868         }
2869         dir->i_sb->s_dirt = 1;
2870         btrfs_update_inode_block_group(trans, inode);
2871         btrfs_update_inode_block_group(trans, dir);
2872         if (drop_inode)
2873                 goto out_unlock;
2874
2875         path = btrfs_alloc_path();
2876         BUG_ON(!path);
2877         key.objectid = inode->i_ino;
2878         key.offset = 0;
2879         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
2880         datasize = btrfs_file_extent_calc_inline_size(name_len);
2881         err = btrfs_insert_empty_item(trans, root, path, &key,
2882                                       datasize);
2883         if (err) {
2884                 drop_inode = 1;
2885                 goto out_unlock;
2886         }
2887         leaf = path->nodes[0];
2888         ei = btrfs_item_ptr(leaf, path->slots[0],
2889                             struct btrfs_file_extent_item);
2890         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
2891         btrfs_set_file_extent_type(leaf, ei,
2892                                    BTRFS_FILE_EXTENT_INLINE);
2893         ptr = btrfs_file_extent_inline_start(ei);
2894         write_extent_buffer(leaf, symname, ptr, name_len);
2895         btrfs_mark_buffer_dirty(leaf);
2896         btrfs_free_path(path);
2897
2898         inode->i_op = &btrfs_symlink_inode_operations;
2899         inode->i_mapping->a_ops = &btrfs_symlink_aops;
2900         inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2901         inode->i_size = name_len - 1;
2902         err = btrfs_update_inode(trans, root, inode);
2903         if (err)
2904                 drop_inode = 1;
2905
2906 out_unlock:
2907         nr = trans->blocks_used;
2908         btrfs_end_transaction_throttle(trans, root);
2909 out_fail:
2910         if (drop_inode) {
2911                 inode_dec_link_count(inode);
2912                 iput(inode);
2913         }
2914         btrfs_btree_balance_dirty(root, nr);
2915         return err;
2916 }
2917
2918 static int btrfs_permission(struct inode *inode, int mask,
2919                             struct nameidata *nd)
2920 {
2921         if (btrfs_test_flag(inode, READONLY) && (mask & MAY_WRITE))
2922                 return -EACCES;
2923         return generic_permission(inode, mask, NULL);
2924 }
2925
2926 static struct inode_operations btrfs_dir_inode_operations = {
2927         .lookup         = btrfs_lookup,
2928         .create         = btrfs_create,
2929         .unlink         = btrfs_unlink,
2930         .link           = btrfs_link,
2931         .mkdir          = btrfs_mkdir,
2932         .rmdir          = btrfs_rmdir,
2933         .rename         = btrfs_rename,
2934         .symlink        = btrfs_symlink,
2935         .setattr        = btrfs_setattr,
2936         .mknod          = btrfs_mknod,
2937         .setxattr       = generic_setxattr,
2938         .getxattr       = generic_getxattr,
2939         .listxattr      = btrfs_listxattr,
2940         .removexattr    = generic_removexattr,
2941         .permission     = btrfs_permission,
2942 };
2943 static struct inode_operations btrfs_dir_ro_inode_operations = {
2944         .lookup         = btrfs_lookup,
2945         .permission     = btrfs_permission,
2946 };
2947 static struct file_operations btrfs_dir_file_operations = {
2948         .llseek         = generic_file_llseek,
2949         .read           = generic_read_dir,
2950         .readdir        = btrfs_readdir,
2951         .unlocked_ioctl = btrfs_ioctl,
2952 #ifdef CONFIG_COMPAT
2953         .compat_ioctl   = btrfs_ioctl,
2954 #endif
2955         .release        = btrfs_release_file,
2956 };
2957
2958 static struct extent_io_ops btrfs_extent_io_ops = {
2959         .fill_delalloc = run_delalloc_range,
2960         .submit_bio_hook = btrfs_submit_bio_hook,
2961         .merge_bio_hook = btrfs_merge_bio_hook,
2962         .readpage_io_hook = btrfs_readpage_io_hook,
2963         .readpage_end_io_hook = btrfs_readpage_end_io_hook,
2964         .readpage_io_failed_hook = btrfs_io_failed_hook,
2965         .set_bit_hook = btrfs_set_bit_hook,
2966         .clear_bit_hook = btrfs_clear_bit_hook,
2967 };
2968
2969 static struct address_space_operations btrfs_aops = {
2970         .readpage       = btrfs_readpage,
2971         .writepage      = btrfs_writepage,
2972         .writepages     = btrfs_writepages,
2973         .readpages      = btrfs_readpages,
2974         .sync_page      = block_sync_page,
2975         .bmap           = btrfs_bmap,
2976         .direct_IO      = btrfs_direct_IO,
2977         .invalidatepage = btrfs_invalidatepage,
2978         .releasepage    = btrfs_releasepage,
2979         .set_page_dirty = __set_page_dirty_nobuffers,
2980 };
2981
2982 static struct address_space_operations btrfs_symlink_aops = {
2983         .readpage       = btrfs_readpage,
2984         .writepage      = btrfs_writepage,
2985         .invalidatepage = btrfs_invalidatepage,
2986         .releasepage    = btrfs_releasepage,
2987 };
2988
2989 static struct inode_operations btrfs_file_inode_operations = {
2990         .truncate       = btrfs_truncate,
2991         .getattr        = btrfs_getattr,
2992         .setattr        = btrfs_setattr,
2993         .setxattr       = generic_setxattr,
2994         .getxattr       = generic_getxattr,
2995         .listxattr      = btrfs_listxattr,
2996         .removexattr    = generic_removexattr,
2997         .permission     = btrfs_permission,
2998 };
2999 static struct inode_operations btrfs_special_inode_operations = {
3000         .getattr        = btrfs_getattr,
3001         .setattr        = btrfs_setattr,
3002         .permission     = btrfs_permission,
3003 };
3004 static struct inode_operations btrfs_symlink_inode_operations = {
3005         .readlink       = generic_readlink,
3006         .follow_link    = page_follow_link_light,
3007         .put_link       = page_put_link,
3008         .permission     = btrfs_permission,
3009 };