Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[~shefty/rdma-dev.git] / fs / btrfs / inode.c
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/bio.h>
21 #include <linux/buffer_head.h>
22 #include <linux/file.h>
23 #include <linux/fs.h>
24 #include <linux/pagemap.h>
25 #include <linux/highmem.h>
26 #include <linux/time.h>
27 #include <linux/init.h>
28 #include <linux/string.h>
29 #include <linux/backing-dev.h>
30 #include <linux/mpage.h>
31 #include <linux/swap.h>
32 #include <linux/writeback.h>
33 #include <linux/statfs.h>
34 #include <linux/compat.h>
35 #include <linux/bit_spinlock.h>
36 #include <linux/xattr.h>
37 #include <linux/posix_acl.h>
38 #include <linux/falloc.h>
39 #include <linux/slab.h>
40 #include <linux/ratelimit.h>
41 #include <linux/mount.h>
42 #include "compat.h"
43 #include "ctree.h"
44 #include "disk-io.h"
45 #include "transaction.h"
46 #include "btrfs_inode.h"
47 #include "ioctl.h"
48 #include "print-tree.h"
49 #include "ordered-data.h"
50 #include "xattr.h"
51 #include "tree-log.h"
52 #include "volumes.h"
53 #include "compression.h"
54 #include "locking.h"
55 #include "free-space-cache.h"
56 #include "inode-map.h"
57
58 struct btrfs_iget_args {
59         u64 ino;
60         struct btrfs_root *root;
61 };
62
63 static const struct inode_operations btrfs_dir_inode_operations;
64 static const struct inode_operations btrfs_symlink_inode_operations;
65 static const struct inode_operations btrfs_dir_ro_inode_operations;
66 static const struct inode_operations btrfs_special_inode_operations;
67 static const struct inode_operations btrfs_file_inode_operations;
68 static const struct address_space_operations btrfs_aops;
69 static const struct address_space_operations btrfs_symlink_aops;
70 static const struct file_operations btrfs_dir_file_operations;
71 static struct extent_io_ops btrfs_extent_io_ops;
72
73 static struct kmem_cache *btrfs_inode_cachep;
74 struct kmem_cache *btrfs_trans_handle_cachep;
75 struct kmem_cache *btrfs_transaction_cachep;
76 struct kmem_cache *btrfs_path_cachep;
77 struct kmem_cache *btrfs_free_space_cachep;
78
79 #define S_SHIFT 12
80 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
81         [S_IFREG >> S_SHIFT]    = BTRFS_FT_REG_FILE,
82         [S_IFDIR >> S_SHIFT]    = BTRFS_FT_DIR,
83         [S_IFCHR >> S_SHIFT]    = BTRFS_FT_CHRDEV,
84         [S_IFBLK >> S_SHIFT]    = BTRFS_FT_BLKDEV,
85         [S_IFIFO >> S_SHIFT]    = BTRFS_FT_FIFO,
86         [S_IFSOCK >> S_SHIFT]   = BTRFS_FT_SOCK,
87         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
88 };
89
90 static int btrfs_setsize(struct inode *inode, loff_t newsize);
91 static int btrfs_truncate(struct inode *inode);
92 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
93 static noinline int cow_file_range(struct inode *inode,
94                                    struct page *locked_page,
95                                    u64 start, u64 end, int *page_started,
96                                    unsigned long *nr_written, int unlock);
97 static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
98                                 struct btrfs_root *root, struct inode *inode);
99
100 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
101                                      struct inode *inode,  struct inode *dir,
102                                      const struct qstr *qstr)
103 {
104         int err;
105
106         err = btrfs_init_acl(trans, inode, dir);
107         if (!err)
108                 err = btrfs_xattr_security_init(trans, inode, dir, qstr);
109         return err;
110 }
111
112 /*
113  * this does all the hard work for inserting an inline extent into
114  * the btree.  The caller should have done a btrfs_drop_extents so that
115  * no overlapping inline items exist in the btree
116  */
117 static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
118                                 struct btrfs_root *root, struct inode *inode,
119                                 u64 start, size_t size, size_t compressed_size,
120                                 int compress_type,
121                                 struct page **compressed_pages)
122 {
123         struct btrfs_key key;
124         struct btrfs_path *path;
125         struct extent_buffer *leaf;
126         struct page *page = NULL;
127         char *kaddr;
128         unsigned long ptr;
129         struct btrfs_file_extent_item *ei;
130         int err = 0;
131         int ret;
132         size_t cur_size = size;
133         size_t datasize;
134         unsigned long offset;
135
136         if (compressed_size && compressed_pages)
137                 cur_size = compressed_size;
138
139         path = btrfs_alloc_path();
140         if (!path)
141                 return -ENOMEM;
142
143         path->leave_spinning = 1;
144
145         key.objectid = btrfs_ino(inode);
146         key.offset = start;
147         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
148         datasize = btrfs_file_extent_calc_inline_size(cur_size);
149
150         inode_add_bytes(inode, size);
151         ret = btrfs_insert_empty_item(trans, root, path, &key,
152                                       datasize);
153         BUG_ON(ret);
154         if (ret) {
155                 err = ret;
156                 goto fail;
157         }
158         leaf = path->nodes[0];
159         ei = btrfs_item_ptr(leaf, path->slots[0],
160                             struct btrfs_file_extent_item);
161         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
162         btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
163         btrfs_set_file_extent_encryption(leaf, ei, 0);
164         btrfs_set_file_extent_other_encoding(leaf, ei, 0);
165         btrfs_set_file_extent_ram_bytes(leaf, ei, size);
166         ptr = btrfs_file_extent_inline_start(ei);
167
168         if (compress_type != BTRFS_COMPRESS_NONE) {
169                 struct page *cpage;
170                 int i = 0;
171                 while (compressed_size > 0) {
172                         cpage = compressed_pages[i];
173                         cur_size = min_t(unsigned long, compressed_size,
174                                        PAGE_CACHE_SIZE);
175
176                         kaddr = kmap_atomic(cpage, KM_USER0);
177                         write_extent_buffer(leaf, kaddr, ptr, cur_size);
178                         kunmap_atomic(kaddr, KM_USER0);
179
180                         i++;
181                         ptr += cur_size;
182                         compressed_size -= cur_size;
183                 }
184                 btrfs_set_file_extent_compression(leaf, ei,
185                                                   compress_type);
186         } else {
187                 page = find_get_page(inode->i_mapping,
188                                      start >> PAGE_CACHE_SHIFT);
189                 btrfs_set_file_extent_compression(leaf, ei, 0);
190                 kaddr = kmap_atomic(page, KM_USER0);
191                 offset = start & (PAGE_CACHE_SIZE - 1);
192                 write_extent_buffer(leaf, kaddr + offset, ptr, size);
193                 kunmap_atomic(kaddr, KM_USER0);
194                 page_cache_release(page);
195         }
196         btrfs_mark_buffer_dirty(leaf);
197         btrfs_free_path(path);
198
199         /*
200          * we're an inline extent, so nobody can
201          * extend the file past i_size without locking
202          * a page we already have locked.
203          *
204          * We must do any isize and inode updates
205          * before we unlock the pages.  Otherwise we
206          * could end up racing with unlink.
207          */
208         BTRFS_I(inode)->disk_i_size = inode->i_size;
209         btrfs_update_inode(trans, root, inode);
210
211         return 0;
212 fail:
213         btrfs_free_path(path);
214         return err;
215 }
216
217
218 /*
219  * conditionally insert an inline extent into the file.  This
220  * does the checks required to make sure the data is small enough
221  * to fit as an inline extent.
222  */
223 static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
224                                  struct btrfs_root *root,
225                                  struct inode *inode, u64 start, u64 end,
226                                  size_t compressed_size, int compress_type,
227                                  struct page **compressed_pages)
228 {
229         u64 isize = i_size_read(inode);
230         u64 actual_end = min(end + 1, isize);
231         u64 inline_len = actual_end - start;
232         u64 aligned_end = (end + root->sectorsize - 1) &
233                         ~((u64)root->sectorsize - 1);
234         u64 hint_byte;
235         u64 data_len = inline_len;
236         int ret;
237
238         if (compressed_size)
239                 data_len = compressed_size;
240
241         if (start > 0 ||
242             actual_end >= PAGE_CACHE_SIZE ||
243             data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
244             (!compressed_size &&
245             (actual_end & (root->sectorsize - 1)) == 0) ||
246             end + 1 < isize ||
247             data_len > root->fs_info->max_inline) {
248                 return 1;
249         }
250
251         ret = btrfs_drop_extents(trans, inode, start, aligned_end,
252                                  &hint_byte, 1);
253         BUG_ON(ret);
254
255         if (isize > actual_end)
256                 inline_len = min_t(u64, isize, actual_end);
257         ret = insert_inline_extent(trans, root, inode, start,
258                                    inline_len, compressed_size,
259                                    compress_type, compressed_pages);
260         BUG_ON(ret);
261         btrfs_delalloc_release_metadata(inode, end + 1 - start);
262         btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
263         return 0;
264 }
265
266 struct async_extent {
267         u64 start;
268         u64 ram_size;
269         u64 compressed_size;
270         struct page **pages;
271         unsigned long nr_pages;
272         int compress_type;
273         struct list_head list;
274 };
275
276 struct async_cow {
277         struct inode *inode;
278         struct btrfs_root *root;
279         struct page *locked_page;
280         u64 start;
281         u64 end;
282         struct list_head extents;
283         struct btrfs_work work;
284 };
285
286 static noinline int add_async_extent(struct async_cow *cow,
287                                      u64 start, u64 ram_size,
288                                      u64 compressed_size,
289                                      struct page **pages,
290                                      unsigned long nr_pages,
291                                      int compress_type)
292 {
293         struct async_extent *async_extent;
294
295         async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
296         BUG_ON(!async_extent);
297         async_extent->start = start;
298         async_extent->ram_size = ram_size;
299         async_extent->compressed_size = compressed_size;
300         async_extent->pages = pages;
301         async_extent->nr_pages = nr_pages;
302         async_extent->compress_type = compress_type;
303         list_add_tail(&async_extent->list, &cow->extents);
304         return 0;
305 }
306
307 /*
308  * we create compressed extents in two phases.  The first
309  * phase compresses a range of pages that have already been
310  * locked (both pages and state bits are locked).
311  *
312  * This is done inside an ordered work queue, and the compression
313  * is spread across many cpus.  The actual IO submission is step
314  * two, and the ordered work queue takes care of making sure that
315  * happens in the same order things were put onto the queue by
316  * writepages and friends.
317  *
318  * If this code finds it can't get good compression, it puts an
319  * entry onto the work queue to write the uncompressed bytes.  This
320  * makes sure that both compressed inodes and uncompressed inodes
321  * are written in the same order that pdflush sent them down.
322  */
323 static noinline int compress_file_range(struct inode *inode,
324                                         struct page *locked_page,
325                                         u64 start, u64 end,
326                                         struct async_cow *async_cow,
327                                         int *num_added)
328 {
329         struct btrfs_root *root = BTRFS_I(inode)->root;
330         struct btrfs_trans_handle *trans;
331         u64 num_bytes;
332         u64 blocksize = root->sectorsize;
333         u64 actual_end;
334         u64 isize = i_size_read(inode);
335         int ret = 0;
336         struct page **pages = NULL;
337         unsigned long nr_pages;
338         unsigned long nr_pages_ret = 0;
339         unsigned long total_compressed = 0;
340         unsigned long total_in = 0;
341         unsigned long max_compressed = 128 * 1024;
342         unsigned long max_uncompressed = 128 * 1024;
343         int i;
344         int will_compress;
345         int compress_type = root->fs_info->compress_type;
346
347         /* if this is a small write inside eof, kick off a defragbot */
348         if (end <= BTRFS_I(inode)->disk_i_size && (end - start + 1) < 16 * 1024)
349                 btrfs_add_inode_defrag(NULL, inode);
350
351         actual_end = min_t(u64, isize, end + 1);
352 again:
353         will_compress = 0;
354         nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
355         nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
356
357         /*
358          * we don't want to send crud past the end of i_size through
359          * compression, that's just a waste of CPU time.  So, if the
360          * end of the file is before the start of our current
361          * requested range of bytes, we bail out to the uncompressed
362          * cleanup code that can deal with all of this.
363          *
364          * It isn't really the fastest way to fix things, but this is a
365          * very uncommon corner.
366          */
367         if (actual_end <= start)
368                 goto cleanup_and_bail_uncompressed;
369
370         total_compressed = actual_end - start;
371
372         /* we want to make sure that amount of ram required to uncompress
373          * an extent is reasonable, so we limit the total size in ram
374          * of a compressed extent to 128k.  This is a crucial number
375          * because it also controls how easily we can spread reads across
376          * cpus for decompression.
377          *
378          * We also want to make sure the amount of IO required to do
379          * a random read is reasonably small, so we limit the size of
380          * a compressed extent to 128k.
381          */
382         total_compressed = min(total_compressed, max_uncompressed);
383         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
384         num_bytes = max(blocksize,  num_bytes);
385         total_in = 0;
386         ret = 0;
387
388         /*
389          * we do compression for mount -o compress and when the
390          * inode has not been flagged as nocompress.  This flag can
391          * change at any time if we discover bad compression ratios.
392          */
393         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
394             (btrfs_test_opt(root, COMPRESS) ||
395              (BTRFS_I(inode)->force_compress) ||
396              (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
397                 WARN_ON(pages);
398                 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
399                 if (!pages) {
400                         /* just bail out to the uncompressed code */
401                         goto cont;
402                 }
403
404                 if (BTRFS_I(inode)->force_compress)
405                         compress_type = BTRFS_I(inode)->force_compress;
406
407                 ret = btrfs_compress_pages(compress_type,
408                                            inode->i_mapping, start,
409                                            total_compressed, pages,
410                                            nr_pages, &nr_pages_ret,
411                                            &total_in,
412                                            &total_compressed,
413                                            max_compressed);
414
415                 if (!ret) {
416                         unsigned long offset = total_compressed &
417                                 (PAGE_CACHE_SIZE - 1);
418                         struct page *page = pages[nr_pages_ret - 1];
419                         char *kaddr;
420
421                         /* zero the tail end of the last page, we might be
422                          * sending it down to disk
423                          */
424                         if (offset) {
425                                 kaddr = kmap_atomic(page, KM_USER0);
426                                 memset(kaddr + offset, 0,
427                                        PAGE_CACHE_SIZE - offset);
428                                 kunmap_atomic(kaddr, KM_USER0);
429                         }
430                         will_compress = 1;
431                 }
432         }
433 cont:
434         if (start == 0) {
435                 trans = btrfs_join_transaction(root);
436                 BUG_ON(IS_ERR(trans));
437                 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
438
439                 /* lets try to make an inline extent */
440                 if (ret || total_in < (actual_end - start)) {
441                         /* we didn't compress the entire range, try
442                          * to make an uncompressed inline extent.
443                          */
444                         ret = cow_file_range_inline(trans, root, inode,
445                                                     start, end, 0, 0, NULL);
446                 } else {
447                         /* try making a compressed inline extent */
448                         ret = cow_file_range_inline(trans, root, inode,
449                                                     start, end,
450                                                     total_compressed,
451                                                     compress_type, pages);
452                 }
453                 if (ret == 0) {
454                         /*
455                          * inline extent creation worked, we don't need
456                          * to create any more async work items.  Unlock
457                          * and free up our temp pages.
458                          */
459                         extent_clear_unlock_delalloc(inode,
460                              &BTRFS_I(inode)->io_tree,
461                              start, end, NULL,
462                              EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
463                              EXTENT_CLEAR_DELALLOC |
464                              EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
465
466                         btrfs_end_transaction(trans, root);
467                         goto free_pages_out;
468                 }
469                 btrfs_end_transaction(trans, root);
470         }
471
472         if (will_compress) {
473                 /*
474                  * we aren't doing an inline extent round the compressed size
475                  * up to a block size boundary so the allocator does sane
476                  * things
477                  */
478                 total_compressed = (total_compressed + blocksize - 1) &
479                         ~(blocksize - 1);
480
481                 /*
482                  * one last check to make sure the compression is really a
483                  * win, compare the page count read with the blocks on disk
484                  */
485                 total_in = (total_in + PAGE_CACHE_SIZE - 1) &
486                         ~(PAGE_CACHE_SIZE - 1);
487                 if (total_compressed >= total_in) {
488                         will_compress = 0;
489                 } else {
490                         num_bytes = total_in;
491                 }
492         }
493         if (!will_compress && pages) {
494                 /*
495                  * the compression code ran but failed to make things smaller,
496                  * free any pages it allocated and our page pointer array
497                  */
498                 for (i = 0; i < nr_pages_ret; i++) {
499                         WARN_ON(pages[i]->mapping);
500                         page_cache_release(pages[i]);
501                 }
502                 kfree(pages);
503                 pages = NULL;
504                 total_compressed = 0;
505                 nr_pages_ret = 0;
506
507                 /* flag the file so we don't compress in the future */
508                 if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
509                     !(BTRFS_I(inode)->force_compress)) {
510                         BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
511                 }
512         }
513         if (will_compress) {
514                 *num_added += 1;
515
516                 /* the async work queues will take care of doing actual
517                  * allocation on disk for these compressed pages,
518                  * and will submit them to the elevator.
519                  */
520                 add_async_extent(async_cow, start, num_bytes,
521                                  total_compressed, pages, nr_pages_ret,
522                                  compress_type);
523
524                 if (start + num_bytes < end) {
525                         start += num_bytes;
526                         pages = NULL;
527                         cond_resched();
528                         goto again;
529                 }
530         } else {
531 cleanup_and_bail_uncompressed:
532                 /*
533                  * No compression, but we still need to write the pages in
534                  * the file we've been given so far.  redirty the locked
535                  * page if it corresponds to our extent and set things up
536                  * for the async work queue to run cow_file_range to do
537                  * the normal delalloc dance
538                  */
539                 if (page_offset(locked_page) >= start &&
540                     page_offset(locked_page) <= end) {
541                         __set_page_dirty_nobuffers(locked_page);
542                         /* unlocked later on in the async handlers */
543                 }
544                 add_async_extent(async_cow, start, end - start + 1,
545                                  0, NULL, 0, BTRFS_COMPRESS_NONE);
546                 *num_added += 1;
547         }
548
549 out:
550         return 0;
551
552 free_pages_out:
553         for (i = 0; i < nr_pages_ret; i++) {
554                 WARN_ON(pages[i]->mapping);
555                 page_cache_release(pages[i]);
556         }
557         kfree(pages);
558
559         goto out;
560 }
561
562 /*
563  * phase two of compressed writeback.  This is the ordered portion
564  * of the code, which only gets called in the order the work was
565  * queued.  We walk all the async extents created by compress_file_range
566  * and send them down to the disk.
567  */
568 static noinline int submit_compressed_extents(struct inode *inode,
569                                               struct async_cow *async_cow)
570 {
571         struct async_extent *async_extent;
572         u64 alloc_hint = 0;
573         struct btrfs_trans_handle *trans;
574         struct btrfs_key ins;
575         struct extent_map *em;
576         struct btrfs_root *root = BTRFS_I(inode)->root;
577         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
578         struct extent_io_tree *io_tree;
579         int ret = 0;
580
581         if (list_empty(&async_cow->extents))
582                 return 0;
583
584
585         while (!list_empty(&async_cow->extents)) {
586                 async_extent = list_entry(async_cow->extents.next,
587                                           struct async_extent, list);
588                 list_del(&async_extent->list);
589
590                 io_tree = &BTRFS_I(inode)->io_tree;
591
592 retry:
593                 /* did the compression code fall back to uncompressed IO? */
594                 if (!async_extent->pages) {
595                         int page_started = 0;
596                         unsigned long nr_written = 0;
597
598                         lock_extent(io_tree, async_extent->start,
599                                          async_extent->start +
600                                          async_extent->ram_size - 1, GFP_NOFS);
601
602                         /* allocate blocks */
603                         ret = cow_file_range(inode, async_cow->locked_page,
604                                              async_extent->start,
605                                              async_extent->start +
606                                              async_extent->ram_size - 1,
607                                              &page_started, &nr_written, 0);
608
609                         /*
610                          * if page_started, cow_file_range inserted an
611                          * inline extent and took care of all the unlocking
612                          * and IO for us.  Otherwise, we need to submit
613                          * all those pages down to the drive.
614                          */
615                         if (!page_started && !ret)
616                                 extent_write_locked_range(io_tree,
617                                                   inode, async_extent->start,
618                                                   async_extent->start +
619                                                   async_extent->ram_size - 1,
620                                                   btrfs_get_extent,
621                                                   WB_SYNC_ALL);
622                         kfree(async_extent);
623                         cond_resched();
624                         continue;
625                 }
626
627                 lock_extent(io_tree, async_extent->start,
628                             async_extent->start + async_extent->ram_size - 1,
629                             GFP_NOFS);
630
631                 trans = btrfs_join_transaction(root);
632                 BUG_ON(IS_ERR(trans));
633                 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
634                 ret = btrfs_reserve_extent(trans, root,
635                                            async_extent->compressed_size,
636                                            async_extent->compressed_size,
637                                            0, alloc_hint,
638                                            (u64)-1, &ins, 1);
639                 btrfs_end_transaction(trans, root);
640
641                 if (ret) {
642                         int i;
643                         for (i = 0; i < async_extent->nr_pages; i++) {
644                                 WARN_ON(async_extent->pages[i]->mapping);
645                                 page_cache_release(async_extent->pages[i]);
646                         }
647                         kfree(async_extent->pages);
648                         async_extent->nr_pages = 0;
649                         async_extent->pages = NULL;
650                         unlock_extent(io_tree, async_extent->start,
651                                       async_extent->start +
652                                       async_extent->ram_size - 1, GFP_NOFS);
653                         goto retry;
654                 }
655
656                 /*
657                  * here we're doing allocation and writeback of the
658                  * compressed pages
659                  */
660                 btrfs_drop_extent_cache(inode, async_extent->start,
661                                         async_extent->start +
662                                         async_extent->ram_size - 1, 0);
663
664                 em = alloc_extent_map();
665                 BUG_ON(!em);
666                 em->start = async_extent->start;
667                 em->len = async_extent->ram_size;
668                 em->orig_start = em->start;
669
670                 em->block_start = ins.objectid;
671                 em->block_len = ins.offset;
672                 em->bdev = root->fs_info->fs_devices->latest_bdev;
673                 em->compress_type = async_extent->compress_type;
674                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
675                 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
676
677                 while (1) {
678                         write_lock(&em_tree->lock);
679                         ret = add_extent_mapping(em_tree, em);
680                         write_unlock(&em_tree->lock);
681                         if (ret != -EEXIST) {
682                                 free_extent_map(em);
683                                 break;
684                         }
685                         btrfs_drop_extent_cache(inode, async_extent->start,
686                                                 async_extent->start +
687                                                 async_extent->ram_size - 1, 0);
688                 }
689
690                 ret = btrfs_add_ordered_extent_compress(inode,
691                                                 async_extent->start,
692                                                 ins.objectid,
693                                                 async_extent->ram_size,
694                                                 ins.offset,
695                                                 BTRFS_ORDERED_COMPRESSED,
696                                                 async_extent->compress_type);
697                 BUG_ON(ret);
698
699                 /*
700                  * clear dirty, set writeback and unlock the pages.
701                  */
702                 extent_clear_unlock_delalloc(inode,
703                                 &BTRFS_I(inode)->io_tree,
704                                 async_extent->start,
705                                 async_extent->start +
706                                 async_extent->ram_size - 1,
707                                 NULL, EXTENT_CLEAR_UNLOCK_PAGE |
708                                 EXTENT_CLEAR_UNLOCK |
709                                 EXTENT_CLEAR_DELALLOC |
710                                 EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
711
712                 ret = btrfs_submit_compressed_write(inode,
713                                     async_extent->start,
714                                     async_extent->ram_size,
715                                     ins.objectid,
716                                     ins.offset, async_extent->pages,
717                                     async_extent->nr_pages);
718
719                 BUG_ON(ret);
720                 alloc_hint = ins.objectid + ins.offset;
721                 kfree(async_extent);
722                 cond_resched();
723         }
724
725         return 0;
726 }
727
728 static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
729                                       u64 num_bytes)
730 {
731         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
732         struct extent_map *em;
733         u64 alloc_hint = 0;
734
735         read_lock(&em_tree->lock);
736         em = search_extent_mapping(em_tree, start, num_bytes);
737         if (em) {
738                 /*
739                  * if block start isn't an actual block number then find the
740                  * first block in this inode and use that as a hint.  If that
741                  * block is also bogus then just don't worry about it.
742                  */
743                 if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
744                         free_extent_map(em);
745                         em = search_extent_mapping(em_tree, 0, 0);
746                         if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
747                                 alloc_hint = em->block_start;
748                         if (em)
749                                 free_extent_map(em);
750                 } else {
751                         alloc_hint = em->block_start;
752                         free_extent_map(em);
753                 }
754         }
755         read_unlock(&em_tree->lock);
756
757         return alloc_hint;
758 }
759
760 /*
761  * when extent_io.c finds a delayed allocation range in the file,
762  * the call backs end up in this code.  The basic idea is to
763  * allocate extents on disk for the range, and create ordered data structs
764  * in ram to track those extents.
765  *
766  * locked_page is the page that writepage had locked already.  We use
767  * it to make sure we don't do extra locks or unlocks.
768  *
769  * *page_started is set to one if we unlock locked_page and do everything
770  * required to start IO on it.  It may be clean and already done with
771  * IO when we return.
772  */
773 static noinline int cow_file_range(struct inode *inode,
774                                    struct page *locked_page,
775                                    u64 start, u64 end, int *page_started,
776                                    unsigned long *nr_written,
777                                    int unlock)
778 {
779         struct btrfs_root *root = BTRFS_I(inode)->root;
780         struct btrfs_trans_handle *trans;
781         u64 alloc_hint = 0;
782         u64 num_bytes;
783         unsigned long ram_size;
784         u64 disk_num_bytes;
785         u64 cur_alloc_size;
786         u64 blocksize = root->sectorsize;
787         struct btrfs_key ins;
788         struct extent_map *em;
789         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
790         int ret = 0;
791
792         BUG_ON(btrfs_is_free_space_inode(root, inode));
793         trans = btrfs_join_transaction(root);
794         BUG_ON(IS_ERR(trans));
795         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
796
797         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
798         num_bytes = max(blocksize,  num_bytes);
799         disk_num_bytes = num_bytes;
800         ret = 0;
801
802         /* if this is a small write inside eof, kick off defrag */
803         if (end <= BTRFS_I(inode)->disk_i_size && num_bytes < 64 * 1024)
804                 btrfs_add_inode_defrag(trans, inode);
805
806         if (start == 0) {
807                 /* lets try to make an inline extent */
808                 ret = cow_file_range_inline(trans, root, inode,
809                                             start, end, 0, 0, NULL);
810                 if (ret == 0) {
811                         extent_clear_unlock_delalloc(inode,
812                                      &BTRFS_I(inode)->io_tree,
813                                      start, end, NULL,
814                                      EXTENT_CLEAR_UNLOCK_PAGE |
815                                      EXTENT_CLEAR_UNLOCK |
816                                      EXTENT_CLEAR_DELALLOC |
817                                      EXTENT_CLEAR_DIRTY |
818                                      EXTENT_SET_WRITEBACK |
819                                      EXTENT_END_WRITEBACK);
820
821                         *nr_written = *nr_written +
822                              (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
823                         *page_started = 1;
824                         ret = 0;
825                         goto out;
826                 }
827         }
828
829         BUG_ON(disk_num_bytes >
830                btrfs_super_total_bytes(root->fs_info->super_copy));
831
832         alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
833         btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
834
835         while (disk_num_bytes > 0) {
836                 unsigned long op;
837
838                 cur_alloc_size = disk_num_bytes;
839                 ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
840                                            root->sectorsize, 0, alloc_hint,
841                                            (u64)-1, &ins, 1);
842                 BUG_ON(ret);
843
844                 em = alloc_extent_map();
845                 BUG_ON(!em);
846                 em->start = start;
847                 em->orig_start = em->start;
848                 ram_size = ins.offset;
849                 em->len = ins.offset;
850
851                 em->block_start = ins.objectid;
852                 em->block_len = ins.offset;
853                 em->bdev = root->fs_info->fs_devices->latest_bdev;
854                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
855
856                 while (1) {
857                         write_lock(&em_tree->lock);
858                         ret = add_extent_mapping(em_tree, em);
859                         write_unlock(&em_tree->lock);
860                         if (ret != -EEXIST) {
861                                 free_extent_map(em);
862                                 break;
863                         }
864                         btrfs_drop_extent_cache(inode, start,
865                                                 start + ram_size - 1, 0);
866                 }
867
868                 cur_alloc_size = ins.offset;
869                 ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
870                                                ram_size, cur_alloc_size, 0);
871                 BUG_ON(ret);
872
873                 if (root->root_key.objectid ==
874                     BTRFS_DATA_RELOC_TREE_OBJECTID) {
875                         ret = btrfs_reloc_clone_csums(inode, start,
876                                                       cur_alloc_size);
877                         BUG_ON(ret);
878                 }
879
880                 if (disk_num_bytes < cur_alloc_size)
881                         break;
882
883                 /* we're not doing compressed IO, don't unlock the first
884                  * page (which the caller expects to stay locked), don't
885                  * clear any dirty bits and don't set any writeback bits
886                  *
887                  * Do set the Private2 bit so we know this page was properly
888                  * setup for writepage
889                  */
890                 op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
891                 op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
892                         EXTENT_SET_PRIVATE2;
893
894                 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
895                                              start, start + ram_size - 1,
896                                              locked_page, op);
897                 disk_num_bytes -= cur_alloc_size;
898                 num_bytes -= cur_alloc_size;
899                 alloc_hint = ins.objectid + ins.offset;
900                 start += cur_alloc_size;
901         }
902 out:
903         ret = 0;
904         btrfs_end_transaction(trans, root);
905
906         return ret;
907 }
908
909 /*
910  * work queue call back to started compression on a file and pages
911  */
912 static noinline void async_cow_start(struct btrfs_work *work)
913 {
914         struct async_cow *async_cow;
915         int num_added = 0;
916         async_cow = container_of(work, struct async_cow, work);
917
918         compress_file_range(async_cow->inode, async_cow->locked_page,
919                             async_cow->start, async_cow->end, async_cow,
920                             &num_added);
921         if (num_added == 0)
922                 async_cow->inode = NULL;
923 }
924
925 /*
926  * work queue call back to submit previously compressed pages
927  */
928 static noinline void async_cow_submit(struct btrfs_work *work)
929 {
930         struct async_cow *async_cow;
931         struct btrfs_root *root;
932         unsigned long nr_pages;
933
934         async_cow = container_of(work, struct async_cow, work);
935
936         root = async_cow->root;
937         nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
938                 PAGE_CACHE_SHIFT;
939
940         atomic_sub(nr_pages, &root->fs_info->async_delalloc_pages);
941
942         if (atomic_read(&root->fs_info->async_delalloc_pages) <
943             5 * 1042 * 1024 &&
944             waitqueue_active(&root->fs_info->async_submit_wait))
945                 wake_up(&root->fs_info->async_submit_wait);
946
947         if (async_cow->inode)
948                 submit_compressed_extents(async_cow->inode, async_cow);
949 }
950
951 static noinline void async_cow_free(struct btrfs_work *work)
952 {
953         struct async_cow *async_cow;
954         async_cow = container_of(work, struct async_cow, work);
955         kfree(async_cow);
956 }
957
958 static int cow_file_range_async(struct inode *inode, struct page *locked_page,
959                                 u64 start, u64 end, int *page_started,
960                                 unsigned long *nr_written)
961 {
962         struct async_cow *async_cow;
963         struct btrfs_root *root = BTRFS_I(inode)->root;
964         unsigned long nr_pages;
965         u64 cur_end;
966         int limit = 10 * 1024 * 1042;
967
968         clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
969                          1, 0, NULL, GFP_NOFS);
970         while (start < end) {
971                 async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
972                 BUG_ON(!async_cow);
973                 async_cow->inode = inode;
974                 async_cow->root = root;
975                 async_cow->locked_page = locked_page;
976                 async_cow->start = start;
977
978                 if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
979                         cur_end = end;
980                 else
981                         cur_end = min(end, start + 512 * 1024 - 1);
982
983                 async_cow->end = cur_end;
984                 INIT_LIST_HEAD(&async_cow->extents);
985
986                 async_cow->work.func = async_cow_start;
987                 async_cow->work.ordered_func = async_cow_submit;
988                 async_cow->work.ordered_free = async_cow_free;
989                 async_cow->work.flags = 0;
990
991                 nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
992                         PAGE_CACHE_SHIFT;
993                 atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
994
995                 btrfs_queue_worker(&root->fs_info->delalloc_workers,
996                                    &async_cow->work);
997
998                 if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
999                         wait_event(root->fs_info->async_submit_wait,
1000                            (atomic_read(&root->fs_info->async_delalloc_pages) <
1001                             limit));
1002                 }
1003
1004                 while (atomic_read(&root->fs_info->async_submit_draining) &&
1005                       atomic_read(&root->fs_info->async_delalloc_pages)) {
1006                         wait_event(root->fs_info->async_submit_wait,
1007                           (atomic_read(&root->fs_info->async_delalloc_pages) ==
1008                            0));
1009                 }
1010
1011                 *nr_written += nr_pages;
1012                 start = cur_end + 1;
1013         }
1014         *page_started = 1;
1015         return 0;
1016 }
1017
1018 static noinline int csum_exist_in_range(struct btrfs_root *root,
1019                                         u64 bytenr, u64 num_bytes)
1020 {
1021         int ret;
1022         struct btrfs_ordered_sum *sums;
1023         LIST_HEAD(list);
1024
1025         ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
1026                                        bytenr + num_bytes - 1, &list, 0);
1027         if (ret == 0 && list_empty(&list))
1028                 return 0;
1029
1030         while (!list_empty(&list)) {
1031                 sums = list_entry(list.next, struct btrfs_ordered_sum, list);
1032                 list_del(&sums->list);
1033                 kfree(sums);
1034         }
1035         return 1;
1036 }
1037
1038 /*
1039  * when nowcow writeback call back.  This checks for snapshots or COW copies
1040  * of the extents that exist in the file, and COWs the file as required.
1041  *
1042  * If no cow copies or snapshots exist, we write directly to the existing
1043  * blocks on disk
1044  */
1045 static noinline int run_delalloc_nocow(struct inode *inode,
1046                                        struct page *locked_page,
1047                               u64 start, u64 end, int *page_started, int force,
1048                               unsigned long *nr_written)
1049 {
1050         struct btrfs_root *root = BTRFS_I(inode)->root;
1051         struct btrfs_trans_handle *trans;
1052         struct extent_buffer *leaf;
1053         struct btrfs_path *path;
1054         struct btrfs_file_extent_item *fi;
1055         struct btrfs_key found_key;
1056         u64 cow_start;
1057         u64 cur_offset;
1058         u64 extent_end;
1059         u64 extent_offset;
1060         u64 disk_bytenr;
1061         u64 num_bytes;
1062         int extent_type;
1063         int ret;
1064         int type;
1065         int nocow;
1066         int check_prev = 1;
1067         bool nolock;
1068         u64 ino = btrfs_ino(inode);
1069
1070         path = btrfs_alloc_path();
1071         if (!path)
1072                 return -ENOMEM;
1073
1074         nolock = btrfs_is_free_space_inode(root, inode);
1075
1076         if (nolock)
1077                 trans = btrfs_join_transaction_nolock(root);
1078         else
1079                 trans = btrfs_join_transaction(root);
1080
1081         BUG_ON(IS_ERR(trans));
1082         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1083
1084         cow_start = (u64)-1;
1085         cur_offset = start;
1086         while (1) {
1087                 ret = btrfs_lookup_file_extent(trans, root, path, ino,
1088                                                cur_offset, 0);
1089                 BUG_ON(ret < 0);
1090                 if (ret > 0 && path->slots[0] > 0 && check_prev) {
1091                         leaf = path->nodes[0];
1092                         btrfs_item_key_to_cpu(leaf, &found_key,
1093                                               path->slots[0] - 1);
1094                         if (found_key.objectid == ino &&
1095                             found_key.type == BTRFS_EXTENT_DATA_KEY)
1096                                 path->slots[0]--;
1097                 }
1098                 check_prev = 0;
1099 next_slot:
1100                 leaf = path->nodes[0];
1101                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1102                         ret = btrfs_next_leaf(root, path);
1103                         if (ret < 0)
1104                                 BUG_ON(1);
1105                         if (ret > 0)
1106                                 break;
1107                         leaf = path->nodes[0];
1108                 }
1109
1110                 nocow = 0;
1111                 disk_bytenr = 0;
1112                 num_bytes = 0;
1113                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1114
1115                 if (found_key.objectid > ino ||
1116                     found_key.type > BTRFS_EXTENT_DATA_KEY ||
1117                     found_key.offset > end)
1118                         break;
1119
1120                 if (found_key.offset > cur_offset) {
1121                         extent_end = found_key.offset;
1122                         extent_type = 0;
1123                         goto out_check;
1124                 }
1125
1126                 fi = btrfs_item_ptr(leaf, path->slots[0],
1127                                     struct btrfs_file_extent_item);
1128                 extent_type = btrfs_file_extent_type(leaf, fi);
1129
1130                 if (extent_type == BTRFS_FILE_EXTENT_REG ||
1131                     extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1132                         disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1133                         extent_offset = btrfs_file_extent_offset(leaf, fi);
1134                         extent_end = found_key.offset +
1135                                 btrfs_file_extent_num_bytes(leaf, fi);
1136                         if (extent_end <= start) {
1137                                 path->slots[0]++;
1138                                 goto next_slot;
1139                         }
1140                         if (disk_bytenr == 0)
1141                                 goto out_check;
1142                         if (btrfs_file_extent_compression(leaf, fi) ||
1143                             btrfs_file_extent_encryption(leaf, fi) ||
1144                             btrfs_file_extent_other_encoding(leaf, fi))
1145                                 goto out_check;
1146                         if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
1147                                 goto out_check;
1148                         if (btrfs_extent_readonly(root, disk_bytenr))
1149                                 goto out_check;
1150                         if (btrfs_cross_ref_exist(trans, root, ino,
1151                                                   found_key.offset -
1152                                                   extent_offset, disk_bytenr))
1153                                 goto out_check;
1154                         disk_bytenr += extent_offset;
1155                         disk_bytenr += cur_offset - found_key.offset;
1156                         num_bytes = min(end + 1, extent_end) - cur_offset;
1157                         /*
1158                          * force cow if csum exists in the range.
1159                          * this ensure that csum for a given extent are
1160                          * either valid or do not exist.
1161                          */
1162                         if (csum_exist_in_range(root, disk_bytenr, num_bytes))
1163                                 goto out_check;
1164                         nocow = 1;
1165                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1166                         extent_end = found_key.offset +
1167                                 btrfs_file_extent_inline_len(leaf, fi);
1168                         extent_end = ALIGN(extent_end, root->sectorsize);
1169                 } else {
1170                         BUG_ON(1);
1171                 }
1172 out_check:
1173                 if (extent_end <= start) {
1174                         path->slots[0]++;
1175                         goto next_slot;
1176                 }
1177                 if (!nocow) {
1178                         if (cow_start == (u64)-1)
1179                                 cow_start = cur_offset;
1180                         cur_offset = extent_end;
1181                         if (cur_offset > end)
1182                                 break;
1183                         path->slots[0]++;
1184                         goto next_slot;
1185                 }
1186
1187                 btrfs_release_path(path);
1188                 if (cow_start != (u64)-1) {
1189                         ret = cow_file_range(inode, locked_page, cow_start,
1190                                         found_key.offset - 1, page_started,
1191                                         nr_written, 1);
1192                         BUG_ON(ret);
1193                         cow_start = (u64)-1;
1194                 }
1195
1196                 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1197                         struct extent_map *em;
1198                         struct extent_map_tree *em_tree;
1199                         em_tree = &BTRFS_I(inode)->extent_tree;
1200                         em = alloc_extent_map();
1201                         BUG_ON(!em);
1202                         em->start = cur_offset;
1203                         em->orig_start = em->start;
1204                         em->len = num_bytes;
1205                         em->block_len = num_bytes;
1206                         em->block_start = disk_bytenr;
1207                         em->bdev = root->fs_info->fs_devices->latest_bdev;
1208                         set_bit(EXTENT_FLAG_PINNED, &em->flags);
1209                         while (1) {
1210                                 write_lock(&em_tree->lock);
1211                                 ret = add_extent_mapping(em_tree, em);
1212                                 write_unlock(&em_tree->lock);
1213                                 if (ret != -EEXIST) {
1214                                         free_extent_map(em);
1215                                         break;
1216                                 }
1217                                 btrfs_drop_extent_cache(inode, em->start,
1218                                                 em->start + em->len - 1, 0);
1219                         }
1220                         type = BTRFS_ORDERED_PREALLOC;
1221                 } else {
1222                         type = BTRFS_ORDERED_NOCOW;
1223                 }
1224
1225                 ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1226                                                num_bytes, num_bytes, type);
1227                 BUG_ON(ret);
1228
1229                 if (root->root_key.objectid ==
1230                     BTRFS_DATA_RELOC_TREE_OBJECTID) {
1231                         ret = btrfs_reloc_clone_csums(inode, cur_offset,
1232                                                       num_bytes);
1233                         BUG_ON(ret);
1234                 }
1235
1236                 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1237                                 cur_offset, cur_offset + num_bytes - 1,
1238                                 locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
1239                                 EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
1240                                 EXTENT_SET_PRIVATE2);
1241                 cur_offset = extent_end;
1242                 if (cur_offset > end)
1243                         break;
1244         }
1245         btrfs_release_path(path);
1246
1247         if (cur_offset <= end && cow_start == (u64)-1)
1248                 cow_start = cur_offset;
1249         if (cow_start != (u64)-1) {
1250                 ret = cow_file_range(inode, locked_page, cow_start, end,
1251                                      page_started, nr_written, 1);
1252                 BUG_ON(ret);
1253         }
1254
1255         if (nolock) {
1256                 ret = btrfs_end_transaction_nolock(trans, root);
1257                 BUG_ON(ret);
1258         } else {
1259                 ret = btrfs_end_transaction(trans, root);
1260                 BUG_ON(ret);
1261         }
1262         btrfs_free_path(path);
1263         return 0;
1264 }
1265
1266 /*
1267  * extent_io.c call back to do delayed allocation processing
1268  */
1269 static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1270                               u64 start, u64 end, int *page_started,
1271                               unsigned long *nr_written)
1272 {
1273         int ret;
1274         struct btrfs_root *root = BTRFS_I(inode)->root;
1275
1276         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)
1277                 ret = run_delalloc_nocow(inode, locked_page, start, end,
1278                                          page_started, 1, nr_written);
1279         else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)
1280                 ret = run_delalloc_nocow(inode, locked_page, start, end,
1281                                          page_started, 0, nr_written);
1282         else if (!btrfs_test_opt(root, COMPRESS) &&
1283                  !(BTRFS_I(inode)->force_compress) &&
1284                  !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
1285                 ret = cow_file_range(inode, locked_page, start, end,
1286                                       page_started, nr_written, 1);
1287         else
1288                 ret = cow_file_range_async(inode, locked_page, start, end,
1289                                            page_started, nr_written);
1290         return ret;
1291 }
1292
1293 static void btrfs_split_extent_hook(struct inode *inode,
1294                                     struct extent_state *orig, u64 split)
1295 {
1296         /* not delalloc, ignore it */
1297         if (!(orig->state & EXTENT_DELALLOC))
1298                 return;
1299
1300         spin_lock(&BTRFS_I(inode)->lock);
1301         BTRFS_I(inode)->outstanding_extents++;
1302         spin_unlock(&BTRFS_I(inode)->lock);
1303 }
1304
1305 /*
1306  * extent_io.c merge_extent_hook, used to track merged delayed allocation
1307  * extents so we can keep track of new extents that are just merged onto old
1308  * extents, such as when we are doing sequential writes, so we can properly
1309  * account for the metadata space we'll need.
1310  */
1311 static void btrfs_merge_extent_hook(struct inode *inode,
1312                                     struct extent_state *new,
1313                                     struct extent_state *other)
1314 {
1315         /* not delalloc, ignore it */
1316         if (!(other->state & EXTENT_DELALLOC))
1317                 return;
1318
1319         spin_lock(&BTRFS_I(inode)->lock);
1320         BTRFS_I(inode)->outstanding_extents--;
1321         spin_unlock(&BTRFS_I(inode)->lock);
1322 }
1323
1324 /*
1325  * extent_io.c set_bit_hook, used to track delayed allocation
1326  * bytes in this file, and to maintain the list of inodes that
1327  * have pending delalloc work to be done.
1328  */
1329 static void btrfs_set_bit_hook(struct inode *inode,
1330                                struct extent_state *state, int *bits)
1331 {
1332
1333         /*
1334          * set_bit and clear bit hooks normally require _irqsave/restore
1335          * but in this case, we are only testing for the DELALLOC
1336          * bit, which is only set or cleared with irqs on
1337          */
1338         if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1339                 struct btrfs_root *root = BTRFS_I(inode)->root;
1340                 u64 len = state->end + 1 - state->start;
1341                 bool do_list = !btrfs_is_free_space_inode(root, inode);
1342
1343                 if (*bits & EXTENT_FIRST_DELALLOC) {
1344                         *bits &= ~EXTENT_FIRST_DELALLOC;
1345                 } else {
1346                         spin_lock(&BTRFS_I(inode)->lock);
1347                         BTRFS_I(inode)->outstanding_extents++;
1348                         spin_unlock(&BTRFS_I(inode)->lock);
1349                 }
1350
1351                 spin_lock(&root->fs_info->delalloc_lock);
1352                 BTRFS_I(inode)->delalloc_bytes += len;
1353                 root->fs_info->delalloc_bytes += len;
1354                 if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1355                         list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
1356                                       &root->fs_info->delalloc_inodes);
1357                 }
1358                 spin_unlock(&root->fs_info->delalloc_lock);
1359         }
1360 }
1361
1362 /*
1363  * extent_io.c clear_bit_hook, see set_bit_hook for why
1364  */
1365 static void btrfs_clear_bit_hook(struct inode *inode,
1366                                  struct extent_state *state, int *bits)
1367 {
1368         /*
1369          * set_bit and clear bit hooks normally require _irqsave/restore
1370          * but in this case, we are only testing for the DELALLOC
1371          * bit, which is only set or cleared with irqs on
1372          */
1373         if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1374                 struct btrfs_root *root = BTRFS_I(inode)->root;
1375                 u64 len = state->end + 1 - state->start;
1376                 bool do_list = !btrfs_is_free_space_inode(root, inode);
1377
1378                 if (*bits & EXTENT_FIRST_DELALLOC) {
1379                         *bits &= ~EXTENT_FIRST_DELALLOC;
1380                 } else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
1381                         spin_lock(&BTRFS_I(inode)->lock);
1382                         BTRFS_I(inode)->outstanding_extents--;
1383                         spin_unlock(&BTRFS_I(inode)->lock);
1384                 }
1385
1386                 if (*bits & EXTENT_DO_ACCOUNTING)
1387                         btrfs_delalloc_release_metadata(inode, len);
1388
1389                 if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
1390                     && do_list)
1391                         btrfs_free_reserved_data_space(inode, len);
1392
1393                 spin_lock(&root->fs_info->delalloc_lock);
1394                 root->fs_info->delalloc_bytes -= len;
1395                 BTRFS_I(inode)->delalloc_bytes -= len;
1396
1397                 if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1398                     !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1399                         list_del_init(&BTRFS_I(inode)->delalloc_inodes);
1400                 }
1401                 spin_unlock(&root->fs_info->delalloc_lock);
1402         }
1403 }
1404
1405 /*
1406  * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
1407  * we don't create bios that span stripes or chunks
1408  */
1409 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1410                          size_t size, struct bio *bio,
1411                          unsigned long bio_flags)
1412 {
1413         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1414         struct btrfs_mapping_tree *map_tree;
1415         u64 logical = (u64)bio->bi_sector << 9;
1416         u64 length = 0;
1417         u64 map_length;
1418         int ret;
1419
1420         if (bio_flags & EXTENT_BIO_COMPRESSED)
1421                 return 0;
1422
1423         length = bio->bi_size;
1424         map_tree = &root->fs_info->mapping_tree;
1425         map_length = length;
1426         ret = btrfs_map_block(map_tree, READ, logical,
1427                               &map_length, NULL, 0);
1428
1429         if (map_length < length + size)
1430                 return 1;
1431         return ret;
1432 }
1433
1434 /*
1435  * in order to insert checksums into the metadata in large chunks,
1436  * we wait until bio submission time.   All the pages in the bio are
1437  * checksummed and sums are attached onto the ordered extent record.
1438  *
1439  * At IO completion time the cums attached on the ordered extent record
1440  * are inserted into the btree
1441  */
1442 static int __btrfs_submit_bio_start(struct inode *inode, int rw,
1443                                     struct bio *bio, int mirror_num,
1444                                     unsigned long bio_flags,
1445                                     u64 bio_offset)
1446 {
1447         struct btrfs_root *root = BTRFS_I(inode)->root;
1448         int ret = 0;
1449
1450         ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1451         BUG_ON(ret);
1452         return 0;
1453 }
1454
1455 /*
1456  * in order to insert checksums into the metadata in large chunks,
1457  * we wait until bio submission time.   All the pages in the bio are
1458  * checksummed and sums are attached onto the ordered extent record.
1459  *
1460  * At IO completion time the cums attached on the ordered extent record
1461  * are inserted into the btree
1462  */
1463 static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1464                           int mirror_num, unsigned long bio_flags,
1465                           u64 bio_offset)
1466 {
1467         struct btrfs_root *root = BTRFS_I(inode)->root;
1468         return btrfs_map_bio(root, rw, bio, mirror_num, 1);
1469 }
1470
1471 /*
1472  * extent_io.c submission hook. This does the right thing for csum calculation
1473  * on write, or reading the csums from the tree before a read
1474  */
1475 static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1476                           int mirror_num, unsigned long bio_flags,
1477                           u64 bio_offset)
1478 {
1479         struct btrfs_root *root = BTRFS_I(inode)->root;
1480         int ret = 0;
1481         int skip_sum;
1482
1483         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1484
1485         if (btrfs_is_free_space_inode(root, inode))
1486                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 2);
1487         else
1488                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
1489         BUG_ON(ret);
1490
1491         if (!(rw & REQ_WRITE)) {
1492                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
1493                         return btrfs_submit_compressed_read(inode, bio,
1494                                                     mirror_num, bio_flags);
1495                 } else if (!skip_sum) {
1496                         ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
1497                         if (ret)
1498                                 return ret;
1499                 }
1500                 goto mapit;
1501         } else if (!skip_sum) {
1502                 /* csum items have already been cloned */
1503                 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
1504                         goto mapit;
1505                 /* we're doing a write, do the async checksumming */
1506                 return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1507                                    inode, rw, bio, mirror_num,
1508                                    bio_flags, bio_offset,
1509                                    __btrfs_submit_bio_start,
1510                                    __btrfs_submit_bio_done);
1511         }
1512
1513 mapit:
1514         return btrfs_map_bio(root, rw, bio, mirror_num, 0);
1515 }
1516
1517 /*
1518  * given a list of ordered sums record them in the inode.  This happens
1519  * at IO completion time based on sums calculated at bio submission time.
1520  */
1521 static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1522                              struct inode *inode, u64 file_offset,
1523                              struct list_head *list)
1524 {
1525         struct btrfs_ordered_sum *sum;
1526
1527         list_for_each_entry(sum, list, list) {
1528                 btrfs_csum_file_blocks(trans,
1529                        BTRFS_I(inode)->root->fs_info->csum_root, sum);
1530         }
1531         return 0;
1532 }
1533
1534 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
1535                               struct extent_state **cached_state)
1536 {
1537         if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
1538                 WARN_ON(1);
1539         return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1540                                    cached_state, GFP_NOFS);
1541 }
1542
1543 /* see btrfs_writepage_start_hook for details on why this is required */
1544 struct btrfs_writepage_fixup {
1545         struct page *page;
1546         struct btrfs_work work;
1547 };
1548
1549 static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1550 {
1551         struct btrfs_writepage_fixup *fixup;
1552         struct btrfs_ordered_extent *ordered;
1553         struct extent_state *cached_state = NULL;
1554         struct page *page;
1555         struct inode *inode;
1556         u64 page_start;
1557         u64 page_end;
1558
1559         fixup = container_of(work, struct btrfs_writepage_fixup, work);
1560         page = fixup->page;
1561 again:
1562         lock_page(page);
1563         if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
1564                 ClearPageChecked(page);
1565                 goto out_page;
1566         }
1567
1568         inode = page->mapping->host;
1569         page_start = page_offset(page);
1570         page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;
1571
1572         lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1573                          &cached_state, GFP_NOFS);
1574
1575         /* already ordered? We're done */
1576         if (PagePrivate2(page))
1577                 goto out;
1578
1579         ordered = btrfs_lookup_ordered_extent(inode, page_start);
1580         if (ordered) {
1581                 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
1582                                      page_end, &cached_state, GFP_NOFS);
1583                 unlock_page(page);
1584                 btrfs_start_ordered_extent(inode, ordered, 1);
1585                 goto again;
1586         }
1587
1588         BUG();
1589         btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1590         ClearPageChecked(page);
1591 out:
1592         unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
1593                              &cached_state, GFP_NOFS);
1594 out_page:
1595         unlock_page(page);
1596         page_cache_release(page);
1597         kfree(fixup);
1598 }
1599
1600 /*
1601  * There are a few paths in the higher layers of the kernel that directly
1602  * set the page dirty bit without asking the filesystem if it is a
1603  * good idea.  This causes problems because we want to make sure COW
1604  * properly happens and the data=ordered rules are followed.
1605  *
1606  * In our case any range that doesn't have the ORDERED bit set
1607  * hasn't been properly setup for IO.  We kick off an async process
1608  * to fix it up.  The async helper will wait for ordered extents, set
1609  * the delalloc bit and make it safe to write the page.
1610  */
1611 static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1612 {
1613         struct inode *inode = page->mapping->host;
1614         struct btrfs_writepage_fixup *fixup;
1615         struct btrfs_root *root = BTRFS_I(inode)->root;
1616
1617         /* this page is properly in the ordered list */
1618         if (TestClearPagePrivate2(page))
1619                 return 0;
1620
1621         if (PageChecked(page))
1622                 return -EAGAIN;
1623
1624         fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
1625         if (!fixup)
1626                 return -EAGAIN;
1627
1628         SetPageChecked(page);
1629         page_cache_get(page);
1630         fixup->work.func = btrfs_writepage_fixup_worker;
1631         fixup->page = page;
1632         btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
1633         return -EAGAIN;
1634 }
1635
1636 static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
1637                                        struct inode *inode, u64 file_pos,
1638                                        u64 disk_bytenr, u64 disk_num_bytes,
1639                                        u64 num_bytes, u64 ram_bytes,
1640                                        u8 compression, u8 encryption,
1641                                        u16 other_encoding, int extent_type)
1642 {
1643         struct btrfs_root *root = BTRFS_I(inode)->root;
1644         struct btrfs_file_extent_item *fi;
1645         struct btrfs_path *path;
1646         struct extent_buffer *leaf;
1647         struct btrfs_key ins;
1648         u64 hint;
1649         int ret;
1650
1651         path = btrfs_alloc_path();
1652         if (!path)
1653                 return -ENOMEM;
1654
1655         path->leave_spinning = 1;
1656
1657         /*
1658          * we may be replacing one extent in the tree with another.
1659          * The new extent is pinned in the extent map, and we don't want
1660          * to drop it from the cache until it is completely in the btree.
1661          *
1662          * So, tell btrfs_drop_extents to leave this extent in the cache.
1663          * the caller is expected to unpin it and allow it to be merged
1664          * with the others.
1665          */
1666         ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
1667                                  &hint, 0);
1668         BUG_ON(ret);
1669
1670         ins.objectid = btrfs_ino(inode);
1671         ins.offset = file_pos;
1672         ins.type = BTRFS_EXTENT_DATA_KEY;
1673         ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1674         BUG_ON(ret);
1675         leaf = path->nodes[0];
1676         fi = btrfs_item_ptr(leaf, path->slots[0],
1677                             struct btrfs_file_extent_item);
1678         btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1679         btrfs_set_file_extent_type(leaf, fi, extent_type);
1680         btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
1681         btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
1682         btrfs_set_file_extent_offset(leaf, fi, 0);
1683         btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
1684         btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
1685         btrfs_set_file_extent_compression(leaf, fi, compression);
1686         btrfs_set_file_extent_encryption(leaf, fi, encryption);
1687         btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
1688
1689         btrfs_unlock_up_safe(path, 1);
1690         btrfs_set_lock_blocking(leaf);
1691
1692         btrfs_mark_buffer_dirty(leaf);
1693
1694         inode_add_bytes(inode, num_bytes);
1695
1696         ins.objectid = disk_bytenr;
1697         ins.offset = disk_num_bytes;
1698         ins.type = BTRFS_EXTENT_ITEM_KEY;
1699         ret = btrfs_alloc_reserved_file_extent(trans, root,
1700                                         root->root_key.objectid,
1701                                         btrfs_ino(inode), file_pos, &ins);
1702         BUG_ON(ret);
1703         btrfs_free_path(path);
1704
1705         return 0;
1706 }
1707
1708 /*
1709  * helper function for btrfs_finish_ordered_io, this
1710  * just reads in some of the csum leaves to prime them into ram
1711  * before we start the transaction.  It limits the amount of btree
1712  * reads required while inside the transaction.
1713  */
1714 /* as ordered data IO finishes, this gets called so we can finish
1715  * an ordered extent if the range of bytes in the file it covers are
1716  * fully written.
1717  */
1718 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1719 {
1720         struct btrfs_root *root = BTRFS_I(inode)->root;
1721         struct btrfs_trans_handle *trans = NULL;
1722         struct btrfs_ordered_extent *ordered_extent = NULL;
1723         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1724         struct extent_state *cached_state = NULL;
1725         int compress_type = 0;
1726         int ret;
1727         bool nolock;
1728
1729         ret = btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
1730                                              end - start + 1);
1731         if (!ret)
1732                 return 0;
1733         BUG_ON(!ordered_extent);
1734
1735         nolock = btrfs_is_free_space_inode(root, inode);
1736
1737         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
1738                 BUG_ON(!list_empty(&ordered_extent->list));
1739                 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1740                 if (!ret) {
1741                         if (nolock)
1742                                 trans = btrfs_join_transaction_nolock(root);
1743                         else
1744                                 trans = btrfs_join_transaction(root);
1745                         BUG_ON(IS_ERR(trans));
1746                         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1747                         ret = btrfs_update_inode_fallback(trans, root, inode);
1748                         BUG_ON(ret);
1749                 }
1750                 goto out;
1751         }
1752
1753         lock_extent_bits(io_tree, ordered_extent->file_offset,
1754                          ordered_extent->file_offset + ordered_extent->len - 1,
1755                          0, &cached_state, GFP_NOFS);
1756
1757         if (nolock)
1758                 trans = btrfs_join_transaction_nolock(root);
1759         else
1760                 trans = btrfs_join_transaction(root);
1761         BUG_ON(IS_ERR(trans));
1762         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1763
1764         if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
1765                 compress_type = ordered_extent->compress_type;
1766         if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1767                 BUG_ON(compress_type);
1768                 ret = btrfs_mark_extent_written(trans, inode,
1769                                                 ordered_extent->file_offset,
1770                                                 ordered_extent->file_offset +
1771                                                 ordered_extent->len);
1772                 BUG_ON(ret);
1773         } else {
1774                 BUG_ON(root == root->fs_info->tree_root);
1775                 ret = insert_reserved_file_extent(trans, inode,
1776                                                 ordered_extent->file_offset,
1777                                                 ordered_extent->start,
1778                                                 ordered_extent->disk_len,
1779                                                 ordered_extent->len,
1780                                                 ordered_extent->len,
1781                                                 compress_type, 0, 0,
1782                                                 BTRFS_FILE_EXTENT_REG);
1783                 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
1784                                    ordered_extent->file_offset,
1785                                    ordered_extent->len);
1786                 BUG_ON(ret);
1787         }
1788         unlock_extent_cached(io_tree, ordered_extent->file_offset,
1789                              ordered_extent->file_offset +
1790                              ordered_extent->len - 1, &cached_state, GFP_NOFS);
1791
1792         add_pending_csums(trans, inode, ordered_extent->file_offset,
1793                           &ordered_extent->list);
1794
1795         ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1796         if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1797                 ret = btrfs_update_inode_fallback(trans, root, inode);
1798                 BUG_ON(ret);
1799         }
1800         ret = 0;
1801 out:
1802         if (root != root->fs_info->tree_root)
1803                 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
1804         if (trans) {
1805                 if (nolock)
1806                         btrfs_end_transaction_nolock(trans, root);
1807                 else
1808                         btrfs_end_transaction(trans, root);
1809         }
1810
1811         /* once for us */
1812         btrfs_put_ordered_extent(ordered_extent);
1813         /* once for the tree */
1814         btrfs_put_ordered_extent(ordered_extent);
1815
1816         return 0;
1817 }
1818
1819 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1820                                 struct extent_state *state, int uptodate)
1821 {
1822         trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
1823
1824         ClearPagePrivate2(page);
1825         return btrfs_finish_ordered_io(page->mapping->host, start, end);
1826 }
1827
1828 /*
1829  * when reads are done, we need to check csums to verify the data is correct
1830  * if there's a match, we allow the bio to finish.  If not, the code in
1831  * extent_io.c will try to find good copies for us.
1832  */
1833 static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1834                                struct extent_state *state)
1835 {
1836         size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1837         struct inode *inode = page->mapping->host;
1838         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1839         char *kaddr;
1840         u64 private = ~(u32)0;
1841         int ret;
1842         struct btrfs_root *root = BTRFS_I(inode)->root;
1843         u32 csum = ~(u32)0;
1844
1845         if (PageChecked(page)) {
1846                 ClearPageChecked(page);
1847                 goto good;
1848         }
1849
1850         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
1851                 goto good;
1852
1853         if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
1854             test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
1855                 clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
1856                                   GFP_NOFS);
1857                 return 0;
1858         }
1859
1860         if (state && state->start == start) {
1861                 private = state->private;
1862                 ret = 0;
1863         } else {
1864                 ret = get_state_private(io_tree, start, &private);
1865         }
1866         kaddr = kmap_atomic(page, KM_USER0);
1867         if (ret)
1868                 goto zeroit;
1869
1870         csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
1871         btrfs_csum_final(csum, (char *)&csum);
1872         if (csum != private)
1873                 goto zeroit;
1874
1875         kunmap_atomic(kaddr, KM_USER0);
1876 good:
1877         return 0;
1878
1879 zeroit:
1880         printk_ratelimited(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
1881                        "private %llu\n",
1882                        (unsigned long long)btrfs_ino(page->mapping->host),
1883                        (unsigned long long)start, csum,
1884                        (unsigned long long)private);
1885         memset(kaddr + offset, 1, end - start + 1);
1886         flush_dcache_page(page);
1887         kunmap_atomic(kaddr, KM_USER0);
1888         if (private == 0)
1889                 return 0;
1890         return -EIO;
1891 }
1892
1893 struct delayed_iput {
1894         struct list_head list;
1895         struct inode *inode;
1896 };
1897
1898 void btrfs_add_delayed_iput(struct inode *inode)
1899 {
1900         struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
1901         struct delayed_iput *delayed;
1902
1903         if (atomic_add_unless(&inode->i_count, -1, 1))
1904                 return;
1905
1906         delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
1907         delayed->inode = inode;
1908
1909         spin_lock(&fs_info->delayed_iput_lock);
1910         list_add_tail(&delayed->list, &fs_info->delayed_iputs);
1911         spin_unlock(&fs_info->delayed_iput_lock);
1912 }
1913
1914 void btrfs_run_delayed_iputs(struct btrfs_root *root)
1915 {
1916         LIST_HEAD(list);
1917         struct btrfs_fs_info *fs_info = root->fs_info;
1918         struct delayed_iput *delayed;
1919         int empty;
1920
1921         spin_lock(&fs_info->delayed_iput_lock);
1922         empty = list_empty(&fs_info->delayed_iputs);
1923         spin_unlock(&fs_info->delayed_iput_lock);
1924         if (empty)
1925                 return;
1926
1927         down_read(&root->fs_info->cleanup_work_sem);
1928         spin_lock(&fs_info->delayed_iput_lock);
1929         list_splice_init(&fs_info->delayed_iputs, &list);
1930         spin_unlock(&fs_info->delayed_iput_lock);
1931
1932         while (!list_empty(&list)) {
1933                 delayed = list_entry(list.next, struct delayed_iput, list);
1934                 list_del(&delayed->list);
1935                 iput(delayed->inode);
1936                 kfree(delayed);
1937         }
1938         up_read(&root->fs_info->cleanup_work_sem);
1939 }
1940
1941 enum btrfs_orphan_cleanup_state {
1942         ORPHAN_CLEANUP_STARTED  = 1,
1943         ORPHAN_CLEANUP_DONE     = 2,
1944 };
1945
1946 /*
1947  * This is called in transaction commmit time. If there are no orphan
1948  * files in the subvolume, it removes orphan item and frees block_rsv
1949  * structure.
1950  */
1951 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
1952                               struct btrfs_root *root)
1953 {
1954         int ret;
1955
1956         if (!list_empty(&root->orphan_list) ||
1957             root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
1958                 return;
1959
1960         if (root->orphan_item_inserted &&
1961             btrfs_root_refs(&root->root_item) > 0) {
1962                 ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
1963                                             root->root_key.objectid);
1964                 BUG_ON(ret);
1965                 root->orphan_item_inserted = 0;
1966         }
1967
1968         if (root->orphan_block_rsv) {
1969                 WARN_ON(root->orphan_block_rsv->size > 0);
1970                 btrfs_free_block_rsv(root, root->orphan_block_rsv);
1971                 root->orphan_block_rsv = NULL;
1972         }
1973 }
1974
1975 /*
1976  * This creates an orphan entry for the given inode in case something goes
1977  * wrong in the middle of an unlink/truncate.
1978  *
1979  * NOTE: caller of this function should reserve 5 units of metadata for
1980  *       this function.
1981  */
1982 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
1983 {
1984         struct btrfs_root *root = BTRFS_I(inode)->root;
1985         struct btrfs_block_rsv *block_rsv = NULL;
1986         int reserve = 0;
1987         int insert = 0;
1988         int ret;
1989
1990         if (!root->orphan_block_rsv) {
1991                 block_rsv = btrfs_alloc_block_rsv(root);
1992                 if (!block_rsv)
1993                         return -ENOMEM;
1994         }
1995
1996         spin_lock(&root->orphan_lock);
1997         if (!root->orphan_block_rsv) {
1998                 root->orphan_block_rsv = block_rsv;
1999         } else if (block_rsv) {
2000                 btrfs_free_block_rsv(root, block_rsv);
2001                 block_rsv = NULL;
2002         }
2003
2004         if (list_empty(&BTRFS_I(inode)->i_orphan)) {
2005                 list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
2006 #if 0
2007                 /*
2008                  * For proper ENOSPC handling, we should do orphan
2009                  * cleanup when mounting. But this introduces backward
2010                  * compatibility issue.
2011                  */
2012                 if (!xchg(&root->orphan_item_inserted, 1))
2013                         insert = 2;
2014                 else
2015                         insert = 1;
2016 #endif
2017                 insert = 1;
2018         }
2019
2020         if (!BTRFS_I(inode)->orphan_meta_reserved) {
2021                 BTRFS_I(inode)->orphan_meta_reserved = 1;
2022                 reserve = 1;
2023         }
2024         spin_unlock(&root->orphan_lock);
2025
2026         /* grab metadata reservation from transaction handle */
2027         if (reserve) {
2028                 ret = btrfs_orphan_reserve_metadata(trans, inode);
2029                 BUG_ON(ret);
2030         }
2031
2032         /* insert an orphan item to track this unlinked/truncated file */
2033         if (insert >= 1) {
2034                 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
2035                 BUG_ON(ret && ret != -EEXIST);
2036         }
2037
2038         /* insert an orphan item to track subvolume contains orphan files */
2039         if (insert >= 2) {
2040                 ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
2041                                                root->root_key.objectid);
2042                 BUG_ON(ret);
2043         }
2044         return 0;
2045 }
2046
2047 /*
2048  * We have done the truncate/delete so we can go ahead and remove the orphan
2049  * item for this particular inode.
2050  */
2051 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
2052 {
2053         struct btrfs_root *root = BTRFS_I(inode)->root;
2054         int delete_item = 0;
2055         int release_rsv = 0;
2056         int ret = 0;
2057
2058         spin_lock(&root->orphan_lock);
2059         if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
2060                 list_del_init(&BTRFS_I(inode)->i_orphan);
2061                 delete_item = 1;
2062         }
2063
2064         if (BTRFS_I(inode)->orphan_meta_reserved) {
2065                 BTRFS_I(inode)->orphan_meta_reserved = 0;
2066                 release_rsv = 1;
2067         }
2068         spin_unlock(&root->orphan_lock);
2069
2070         if (trans && delete_item) {
2071                 ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
2072                 BUG_ON(ret);
2073         }
2074
2075         if (release_rsv)
2076                 btrfs_orphan_release_metadata(inode);
2077
2078         return 0;
2079 }
2080
2081 /*
2082  * this cleans up any orphans that may be left on the list from the last use
2083  * of this root.
2084  */
2085 int btrfs_orphan_cleanup(struct btrfs_root *root)
2086 {
2087         struct btrfs_path *path;
2088         struct extent_buffer *leaf;
2089         struct btrfs_key key, found_key;
2090         struct btrfs_trans_handle *trans;
2091         struct inode *inode;
2092         u64 last_objectid = 0;
2093         int ret = 0, nr_unlink = 0, nr_truncate = 0;
2094
2095         if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
2096                 return 0;
2097
2098         path = btrfs_alloc_path();
2099         if (!path) {
2100                 ret = -ENOMEM;
2101                 goto out;
2102         }
2103         path->reada = -1;
2104
2105         key.objectid = BTRFS_ORPHAN_OBJECTID;
2106         btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
2107         key.offset = (u64)-1;
2108
2109         while (1) {
2110                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2111                 if (ret < 0)
2112                         goto out;
2113
2114                 /*
2115                  * if ret == 0 means we found what we were searching for, which
2116                  * is weird, but possible, so only screw with path if we didn't
2117                  * find the key and see if we have stuff that matches
2118                  */
2119                 if (ret > 0) {
2120                         ret = 0;
2121                         if (path->slots[0] == 0)
2122                                 break;
2123                         path->slots[0]--;
2124                 }
2125
2126                 /* pull out the item */
2127                 leaf = path->nodes[0];
2128                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2129
2130                 /* make sure the item matches what we want */
2131                 if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
2132                         break;
2133                 if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
2134                         break;
2135
2136                 /* release the path since we're done with it */
2137                 btrfs_release_path(path);
2138
2139                 /*
2140                  * this is where we are basically btrfs_lookup, without the
2141                  * crossing root thing.  we store the inode number in the
2142                  * offset of the orphan item.
2143                  */
2144
2145                 if (found_key.offset == last_objectid) {
2146                         printk(KERN_ERR "btrfs: Error removing orphan entry, "
2147                                "stopping orphan cleanup\n");
2148                         ret = -EINVAL;
2149                         goto out;
2150                 }
2151
2152                 last_objectid = found_key.offset;
2153
2154                 found_key.objectid = found_key.offset;
2155                 found_key.type = BTRFS_INODE_ITEM_KEY;
2156                 found_key.offset = 0;
2157                 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
2158                 ret = PTR_RET(inode);
2159                 if (ret && ret != -ESTALE)
2160                         goto out;
2161
2162                 if (ret == -ESTALE && root == root->fs_info->tree_root) {
2163                         struct btrfs_root *dead_root;
2164                         struct btrfs_fs_info *fs_info = root->fs_info;
2165                         int is_dead_root = 0;
2166
2167                         /*
2168                          * this is an orphan in the tree root. Currently these
2169                          * could come from 2 sources:
2170                          *  a) a snapshot deletion in progress
2171                          *  b) a free space cache inode
2172                          * We need to distinguish those two, as the snapshot
2173                          * orphan must not get deleted.
2174                          * find_dead_roots already ran before us, so if this
2175                          * is a snapshot deletion, we should find the root
2176                          * in the dead_roots list
2177                          */
2178                         spin_lock(&fs_info->trans_lock);
2179                         list_for_each_entry(dead_root, &fs_info->dead_roots,
2180                                             root_list) {
2181                                 if (dead_root->root_key.objectid ==
2182                                     found_key.objectid) {
2183                                         is_dead_root = 1;
2184                                         break;
2185                                 }
2186                         }
2187                         spin_unlock(&fs_info->trans_lock);
2188                         if (is_dead_root) {
2189                                 /* prevent this orphan from being found again */
2190                                 key.offset = found_key.objectid - 1;
2191                                 continue;
2192                         }
2193                 }
2194                 /*
2195                  * Inode is already gone but the orphan item is still there,
2196                  * kill the orphan item.
2197                  */
2198                 if (ret == -ESTALE) {
2199                         trans = btrfs_start_transaction(root, 1);
2200                         if (IS_ERR(trans)) {
2201                                 ret = PTR_ERR(trans);
2202                                 goto out;
2203                         }
2204                         ret = btrfs_del_orphan_item(trans, root,
2205                                                     found_key.objectid);
2206                         BUG_ON(ret);
2207                         btrfs_end_transaction(trans, root);
2208                         continue;
2209                 }
2210
2211                 /*
2212                  * add this inode to the orphan list so btrfs_orphan_del does
2213                  * the proper thing when we hit it
2214                  */
2215                 spin_lock(&root->orphan_lock);
2216                 list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
2217                 spin_unlock(&root->orphan_lock);
2218
2219                 /* if we have links, this was a truncate, lets do that */
2220                 if (inode->i_nlink) {
2221                         if (!S_ISREG(inode->i_mode)) {
2222                                 WARN_ON(1);
2223                                 iput(inode);
2224                                 continue;
2225                         }
2226                         nr_truncate++;
2227                         /*
2228                          * Need to hold the imutex for reservation purposes, not
2229                          * a huge deal here but I have a WARN_ON in
2230                          * btrfs_delalloc_reserve_space to catch offenders.
2231                          */
2232                         mutex_lock(&inode->i_mutex);
2233                         ret = btrfs_truncate(inode);
2234                         mutex_unlock(&inode->i_mutex);
2235                 } else {
2236                         nr_unlink++;
2237                 }
2238
2239                 /* this will do delete_inode and everything for us */
2240                 iput(inode);
2241                 if (ret)
2242                         goto out;
2243         }
2244         /* release the path since we're done with it */
2245         btrfs_release_path(path);
2246
2247         root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
2248
2249         if (root->orphan_block_rsv)
2250                 btrfs_block_rsv_release(root, root->orphan_block_rsv,
2251                                         (u64)-1);
2252
2253         if (root->orphan_block_rsv || root->orphan_item_inserted) {
2254                 trans = btrfs_join_transaction(root);
2255                 if (!IS_ERR(trans))
2256                         btrfs_end_transaction(trans, root);
2257         }
2258
2259         if (nr_unlink)
2260                 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
2261         if (nr_truncate)
2262                 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
2263
2264 out:
2265         if (ret)
2266                 printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
2267         btrfs_free_path(path);
2268         return ret;
2269 }
2270
2271 /*
2272  * very simple check to peek ahead in the leaf looking for xattrs.  If we
2273  * don't find any xattrs, we know there can't be any acls.
2274  *
2275  * slot is the slot the inode is in, objectid is the objectid of the inode
2276  */
2277 static noinline int acls_after_inode_item(struct extent_buffer *leaf,
2278                                           int slot, u64 objectid)
2279 {
2280         u32 nritems = btrfs_header_nritems(leaf);
2281         struct btrfs_key found_key;
2282         int scanned = 0;
2283
2284         slot++;
2285         while (slot < nritems) {
2286                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
2287
2288                 /* we found a different objectid, there must not be acls */
2289                 if (found_key.objectid != objectid)
2290                         return 0;
2291
2292                 /* we found an xattr, assume we've got an acl */
2293                 if (found_key.type == BTRFS_XATTR_ITEM_KEY)
2294                         return 1;
2295
2296                 /*
2297                  * we found a key greater than an xattr key, there can't
2298                  * be any acls later on
2299                  */
2300                 if (found_key.type > BTRFS_XATTR_ITEM_KEY)
2301                         return 0;
2302
2303                 slot++;
2304                 scanned++;
2305
2306                 /*
2307                  * it goes inode, inode backrefs, xattrs, extents,
2308                  * so if there are a ton of hard links to an inode there can
2309                  * be a lot of backrefs.  Don't waste time searching too hard,
2310                  * this is just an optimization
2311                  */
2312                 if (scanned >= 8)
2313                         break;
2314         }
2315         /* we hit the end of the leaf before we found an xattr or
2316          * something larger than an xattr.  We have to assume the inode
2317          * has acls
2318          */
2319         return 1;
2320 }
2321
2322 /*
2323  * read an inode from the btree into the in-memory inode
2324  */
2325 static void btrfs_read_locked_inode(struct inode *inode)
2326 {
2327         struct btrfs_path *path;
2328         struct extent_buffer *leaf;
2329         struct btrfs_inode_item *inode_item;
2330         struct btrfs_timespec *tspec;
2331         struct btrfs_root *root = BTRFS_I(inode)->root;
2332         struct btrfs_key location;
2333         int maybe_acls;
2334         u32 rdev;
2335         int ret;
2336         bool filled = false;
2337
2338         ret = btrfs_fill_inode(inode, &rdev);
2339         if (!ret)
2340                 filled = true;
2341
2342         path = btrfs_alloc_path();
2343         if (!path)
2344                 goto make_bad;
2345
2346         path->leave_spinning = 1;
2347         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
2348
2349         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2350         if (ret)
2351                 goto make_bad;
2352
2353         leaf = path->nodes[0];
2354
2355         if (filled)
2356                 goto cache_acl;
2357
2358         inode_item = btrfs_item_ptr(leaf, path->slots[0],
2359                                     struct btrfs_inode_item);
2360         inode->i_mode = btrfs_inode_mode(leaf, inode_item);
2361         set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
2362         inode->i_uid = btrfs_inode_uid(leaf, inode_item);
2363         inode->i_gid = btrfs_inode_gid(leaf, inode_item);
2364         btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2365
2366         tspec = btrfs_inode_atime(inode_item);
2367         inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2368         inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2369
2370         tspec = btrfs_inode_mtime(inode_item);
2371         inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2372         inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2373
2374         tspec = btrfs_inode_ctime(inode_item);
2375         inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
2376         inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
2377
2378         inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2379         BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2380         BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2381         inode->i_generation = BTRFS_I(inode)->generation;
2382         inode->i_rdev = 0;
2383         rdev = btrfs_inode_rdev(leaf, inode_item);
2384
2385         BTRFS_I(inode)->index_cnt = (u64)-1;
2386         BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2387 cache_acl:
2388         /*
2389          * try to precache a NULL acl entry for files that don't have
2390          * any xattrs or acls
2391          */
2392         maybe_acls = acls_after_inode_item(leaf, path->slots[0],
2393                                            btrfs_ino(inode));
2394         if (!maybe_acls)
2395                 cache_no_acl(inode);
2396
2397         btrfs_free_path(path);
2398
2399         switch (inode->i_mode & S_IFMT) {
2400         case S_IFREG:
2401                 inode->i_mapping->a_ops = &btrfs_aops;
2402                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2403                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
2404                 inode->i_fop = &btrfs_file_operations;
2405                 inode->i_op = &btrfs_file_inode_operations;
2406                 break;
2407         case S_IFDIR:
2408                 inode->i_fop = &btrfs_dir_file_operations;
2409                 if (root == root->fs_info->tree_root)
2410                         inode->i_op = &btrfs_dir_ro_inode_operations;
2411                 else
2412                         inode->i_op = &btrfs_dir_inode_operations;
2413                 break;
2414         case S_IFLNK:
2415                 inode->i_op = &btrfs_symlink_inode_operations;
2416                 inode->i_mapping->a_ops = &btrfs_symlink_aops;
2417                 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2418                 break;
2419         default:
2420                 inode->i_op = &btrfs_special_inode_operations;
2421                 init_special_inode(inode, inode->i_mode, rdev);
2422                 break;
2423         }
2424
2425         btrfs_update_iflags(inode);
2426         return;
2427
2428 make_bad:
2429         btrfs_free_path(path);
2430         make_bad_inode(inode);
2431 }
2432
2433 /*
2434  * given a leaf and an inode, copy the inode fields into the leaf
2435  */
2436 static void fill_inode_item(struct btrfs_trans_handle *trans,
2437                             struct extent_buffer *leaf,
2438                             struct btrfs_inode_item *item,
2439                             struct inode *inode)
2440 {
2441         btrfs_set_inode_uid(leaf, item, inode->i_uid);
2442         btrfs_set_inode_gid(leaf, item, inode->i_gid);
2443         btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2444         btrfs_set_inode_mode(leaf, item, inode->i_mode);
2445         btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
2446
2447         btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
2448                                inode->i_atime.tv_sec);
2449         btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
2450                                 inode->i_atime.tv_nsec);
2451
2452         btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
2453                                inode->i_mtime.tv_sec);
2454         btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
2455                                 inode->i_mtime.tv_nsec);
2456
2457         btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
2458                                inode->i_ctime.tv_sec);
2459         btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
2460                                 inode->i_ctime.tv_nsec);
2461
2462         btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2463         btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2464         btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2465         btrfs_set_inode_transid(leaf, item, trans->transid);
2466         btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
2467         btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2468         btrfs_set_inode_block_group(leaf, item, 0);
2469 }
2470
2471 /*
2472  * copy everything in the in-memory inode into the btree.
2473  */
2474 static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
2475                                 struct btrfs_root *root, struct inode *inode)
2476 {
2477         struct btrfs_inode_item *inode_item;
2478         struct btrfs_path *path;
2479         struct extent_buffer *leaf;
2480         int ret;
2481
2482         path = btrfs_alloc_path();
2483         if (!path)
2484                 return -ENOMEM;
2485
2486         path->leave_spinning = 1;
2487         ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
2488                                  1);
2489         if (ret) {
2490                 if (ret > 0)
2491                         ret = -ENOENT;
2492                 goto failed;
2493         }
2494
2495         btrfs_unlock_up_safe(path, 1);
2496         leaf = path->nodes[0];
2497         inode_item = btrfs_item_ptr(leaf, path->slots[0],
2498                                     struct btrfs_inode_item);
2499
2500         fill_inode_item(trans, leaf, inode_item, inode);
2501         btrfs_mark_buffer_dirty(leaf);
2502         btrfs_set_inode_last_trans(trans, inode);
2503         ret = 0;
2504 failed:
2505         btrfs_free_path(path);
2506         return ret;
2507 }
2508
2509 /*
2510  * copy everything in the in-memory inode into the btree.
2511  */
2512 noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
2513                                 struct btrfs_root *root, struct inode *inode)
2514 {
2515         int ret;
2516
2517         /*
2518          * If the inode is a free space inode, we can deadlock during commit
2519          * if we put it into the delayed code.
2520          *
2521          * The data relocation inode should also be directly updated
2522          * without delay
2523          */
2524         if (!btrfs_is_free_space_inode(root, inode)
2525             && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
2526                 ret = btrfs_delayed_update_inode(trans, root, inode);
2527                 if (!ret)
2528                         btrfs_set_inode_last_trans(trans, inode);
2529                 return ret;
2530         }
2531
2532         return btrfs_update_inode_item(trans, root, inode);
2533 }
2534
2535 static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
2536                                 struct btrfs_root *root, struct inode *inode)
2537 {
2538         int ret;
2539
2540         ret = btrfs_update_inode(trans, root, inode);
2541         if (ret == -ENOSPC)
2542                 return btrfs_update_inode_item(trans, root, inode);
2543         return ret;
2544 }
2545
2546 /*
2547  * unlink helper that gets used here in inode.c and in the tree logging
2548  * recovery code.  It remove a link in a directory with a given name, and
2549  * also drops the back refs in the inode to the directory
2550  */
2551 static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2552                                 struct btrfs_root *root,
2553                                 struct inode *dir, struct inode *inode,
2554                                 const char *name, int name_len)
2555 {
2556         struct btrfs_path *path;
2557         int ret = 0;
2558         struct extent_buffer *leaf;
2559         struct btrfs_dir_item *di;
2560         struct btrfs_key key;
2561         u64 index;
2562         u64 ino = btrfs_ino(inode);
2563         u64 dir_ino = btrfs_ino(dir);
2564
2565         path = btrfs_alloc_path();
2566         if (!path) {
2567                 ret = -ENOMEM;
2568                 goto out;
2569         }
2570
2571         path->leave_spinning = 1;
2572         di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
2573                                     name, name_len, -1);
2574         if (IS_ERR(di)) {
2575                 ret = PTR_ERR(di);
2576                 goto err;
2577         }
2578         if (!di) {
2579                 ret = -ENOENT;
2580                 goto err;
2581         }
2582         leaf = path->nodes[0];
2583         btrfs_dir_item_key_to_cpu(leaf, di, &key);
2584         ret = btrfs_delete_one_dir_name(trans, root, path, di);
2585         if (ret)
2586                 goto err;
2587         btrfs_release_path(path);
2588
2589         ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
2590                                   dir_ino, &index);
2591         if (ret) {
2592                 printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2593                        "inode %llu parent %llu\n", name_len, name,
2594                        (unsigned long long)ino, (unsigned long long)dir_ino);
2595                 goto err;
2596         }
2597
2598         ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
2599         if (ret)
2600                 goto err;
2601
2602         ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
2603                                          inode, dir_ino);
2604         BUG_ON(ret != 0 && ret != -ENOENT);
2605
2606         ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
2607                                            dir, index);
2608         if (ret == -ENOENT)
2609                 ret = 0;
2610 err:
2611         btrfs_free_path(path);
2612         if (ret)
2613                 goto out;
2614
2615         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
2616         inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
2617         btrfs_update_inode(trans, root, dir);
2618 out:
2619         return ret;
2620 }
2621
2622 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2623                        struct btrfs_root *root,
2624                        struct inode *dir, struct inode *inode,
2625                        const char *name, int name_len)
2626 {
2627         int ret;
2628         ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
2629         if (!ret) {
2630                 btrfs_drop_nlink(inode);
2631                 ret = btrfs_update_inode(trans, root, inode);
2632         }
2633         return ret;
2634 }
2635                 
2636
2637 /* helper to check if there is any shared block in the path */
2638 static int check_path_shared(struct btrfs_root *root,
2639                              struct btrfs_path *path)
2640 {
2641         struct extent_buffer *eb;
2642         int level;
2643         u64 refs = 1;
2644
2645         for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2646                 int ret;
2647
2648                 if (!path->nodes[level])
2649                         break;
2650                 eb = path->nodes[level];
2651                 if (!btrfs_block_can_be_shared(root, eb))
2652                         continue;
2653                 ret = btrfs_lookup_extent_info(NULL, root, eb->start, eb->len,
2654                                                &refs, NULL);
2655                 if (refs > 1)
2656                         return 1;
2657         }
2658         return 0;
2659 }
2660
2661 /*
2662  * helper to start transaction for unlink and rmdir.
2663  *
2664  * unlink and rmdir are special in btrfs, they do not always free space.
2665  * so in enospc case, we should make sure they will free space before
2666  * allowing them to use the global metadata reservation.
2667  */
2668 static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
2669                                                        struct dentry *dentry)
2670 {
2671         struct btrfs_trans_handle *trans;
2672         struct btrfs_root *root = BTRFS_I(dir)->root;
2673         struct btrfs_path *path;
2674         struct btrfs_inode_ref *ref;
2675         struct btrfs_dir_item *di;
2676         struct inode *inode = dentry->d_inode;
2677         u64 index;
2678         int check_link = 1;
2679         int err = -ENOSPC;
2680         int ret;
2681         u64 ino = btrfs_ino(inode);
2682         u64 dir_ino = btrfs_ino(dir);
2683
2684         /*
2685          * 1 for the possible orphan item
2686          * 1 for the dir item
2687          * 1 for the dir index
2688          * 1 for the inode ref
2689          * 1 for the inode ref in the tree log
2690          * 2 for the dir entries in the log
2691          * 1 for the inode
2692          */
2693         trans = btrfs_start_transaction(root, 8);
2694         if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
2695                 return trans;
2696
2697         if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
2698                 return ERR_PTR(-ENOSPC);
2699
2700         /* check if there is someone else holds reference */
2701         if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
2702                 return ERR_PTR(-ENOSPC);
2703
2704         if (atomic_read(&inode->i_count) > 2)
2705                 return ERR_PTR(-ENOSPC);
2706
2707         if (xchg(&root->fs_info->enospc_unlink, 1))
2708                 return ERR_PTR(-ENOSPC);
2709
2710         path = btrfs_alloc_path();
2711         if (!path) {
2712                 root->fs_info->enospc_unlink = 0;
2713                 return ERR_PTR(-ENOMEM);
2714         }
2715
2716         /* 1 for the orphan item */
2717         trans = btrfs_start_transaction(root, 1);
2718         if (IS_ERR(trans)) {
2719                 btrfs_free_path(path);
2720                 root->fs_info->enospc_unlink = 0;
2721                 return trans;
2722         }
2723
2724         path->skip_locking = 1;
2725         path->search_commit_root = 1;
2726
2727         ret = btrfs_lookup_inode(trans, root, path,
2728                                 &BTRFS_I(dir)->location, 0);
2729         if (ret < 0) {
2730                 err = ret;
2731                 goto out;
2732         }
2733         if (ret == 0) {
2734                 if (check_path_shared(root, path))
2735                         goto out;
2736         } else {
2737                 check_link = 0;
2738         }
2739         btrfs_release_path(path);
2740
2741         ret = btrfs_lookup_inode(trans, root, path,
2742                                 &BTRFS_I(inode)->location, 0);
2743         if (ret < 0) {
2744                 err = ret;
2745                 goto out;
2746         }
2747         if (ret == 0) {
2748                 if (check_path_shared(root, path))
2749                         goto out;
2750         } else {
2751                 check_link = 0;
2752         }
2753         btrfs_release_path(path);
2754
2755         if (ret == 0 && S_ISREG(inode->i_mode)) {
2756                 ret = btrfs_lookup_file_extent(trans, root, path,
2757                                                ino, (u64)-1, 0);
2758                 if (ret < 0) {
2759                         err = ret;
2760                         goto out;
2761                 }
2762                 BUG_ON(ret == 0);
2763                 if (check_path_shared(root, path))
2764                         goto out;
2765                 btrfs_release_path(path);
2766         }
2767
2768         if (!check_link) {
2769                 err = 0;
2770                 goto out;
2771         }
2772
2773         di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
2774                                 dentry->d_name.name, dentry->d_name.len, 0);
2775         if (IS_ERR(di)) {
2776                 err = PTR_ERR(di);
2777                 goto out;
2778         }
2779         if (di) {
2780                 if (check_path_shared(root, path))
2781                         goto out;
2782         } else {
2783                 err = 0;
2784                 goto out;
2785         }
2786         btrfs_release_path(path);
2787
2788         ref = btrfs_lookup_inode_ref(trans, root, path,
2789                                 dentry->d_name.name, dentry->d_name.len,
2790                                 ino, dir_ino, 0);
2791         if (IS_ERR(ref)) {
2792                 err = PTR_ERR(ref);
2793                 goto out;
2794         }
2795         BUG_ON(!ref);
2796         if (check_path_shared(root, path))
2797                 goto out;
2798         index = btrfs_inode_ref_index(path->nodes[0], ref);
2799         btrfs_release_path(path);
2800
2801         /*
2802          * This is a commit root search, if we can lookup inode item and other
2803          * relative items in the commit root, it means the transaction of
2804          * dir/file creation has been committed, and the dir index item that we
2805          * delay to insert has also been inserted into the commit root. So
2806          * we needn't worry about the delayed insertion of the dir index item
2807          * here.
2808          */
2809         di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
2810                                 dentry->d_name.name, dentry->d_name.len, 0);
2811         if (IS_ERR(di)) {
2812                 err = PTR_ERR(di);
2813                 goto out;
2814         }
2815         BUG_ON(ret == -ENOENT);
2816         if (check_path_shared(root, path))
2817                 goto out;
2818
2819         err = 0;
2820 out:
2821         btrfs_free_path(path);
2822         /* Migrate the orphan reservation over */
2823         if (!err)
2824                 err = btrfs_block_rsv_migrate(trans->block_rsv,
2825                                 &root->fs_info->global_block_rsv,
2826                                 trans->bytes_reserved);
2827
2828         if (err) {
2829                 btrfs_end_transaction(trans, root);
2830                 root->fs_info->enospc_unlink = 0;
2831                 return ERR_PTR(err);
2832         }
2833
2834         trans->block_rsv = &root->fs_info->global_block_rsv;
2835         return trans;
2836 }
2837
2838 static void __unlink_end_trans(struct btrfs_trans_handle *trans,
2839                                struct btrfs_root *root)
2840 {
2841         if (trans->block_rsv == &root->fs_info->global_block_rsv) {
2842                 btrfs_block_rsv_release(root, trans->block_rsv,
2843                                         trans->bytes_reserved);
2844                 trans->block_rsv = &root->fs_info->trans_block_rsv;
2845                 BUG_ON(!root->fs_info->enospc_unlink);
2846                 root->fs_info->enospc_unlink = 0;
2847         }
2848         btrfs_end_transaction_throttle(trans, root);
2849 }
2850
2851 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
2852 {
2853         struct btrfs_root *root = BTRFS_I(dir)->root;
2854         struct btrfs_trans_handle *trans;
2855         struct inode *inode = dentry->d_inode;
2856         int ret;
2857         unsigned long nr = 0;
2858
2859         trans = __unlink_start_trans(dir, dentry);
2860         if (IS_ERR(trans))
2861                 return PTR_ERR(trans);
2862
2863         btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
2864
2865         ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
2866                                  dentry->d_name.name, dentry->d_name.len);
2867         if (ret)
2868                 goto out;
2869
2870         if (inode->i_nlink == 0) {
2871                 ret = btrfs_orphan_add(trans, inode);
2872                 if (ret)
2873                         goto out;
2874         }
2875
2876 out:
2877         nr = trans->blocks_used;
2878         __unlink_end_trans(trans, root);
2879         btrfs_btree_balance_dirty(root, nr);
2880         return ret;
2881 }
2882
2883 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
2884                         struct btrfs_root *root,
2885                         struct inode *dir, u64 objectid,
2886                         const char *name, int name_len)
2887 {
2888         struct btrfs_path *path;
2889         struct extent_buffer *leaf;
2890         struct btrfs_dir_item *di;
2891         struct btrfs_key key;
2892         u64 index;
2893         int ret;
2894         u64 dir_ino = btrfs_ino(dir);
2895
2896         path = btrfs_alloc_path();
2897         if (!path)
2898                 return -ENOMEM;
2899
2900         di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
2901                                    name, name_len, -1);
2902         BUG_ON(IS_ERR_OR_NULL(di));
2903
2904         leaf = path->nodes[0];
2905         btrfs_dir_item_key_to_cpu(leaf, di, &key);
2906         WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
2907         ret = btrfs_delete_one_dir_name(trans, root, path, di);
2908         BUG_ON(ret);
2909         btrfs_release_path(path);
2910
2911         ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
2912                                  objectid, root->root_key.objectid,
2913                                  dir_ino, &index, name, name_len);
2914         if (ret < 0) {
2915                 BUG_ON(ret != -ENOENT);
2916                 di = btrfs_search_dir_index_item(root, path, dir_ino,
2917                                                  name, name_len);
2918                 BUG_ON(IS_ERR_OR_NULL(di));
2919
2920                 leaf = path->nodes[0];
2921                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2922                 btrfs_release_path(path);
2923                 index = key.offset;
2924         }
2925         btrfs_release_path(path);
2926
2927         ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
2928         BUG_ON(ret);
2929
2930         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
2931         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
2932         ret = btrfs_update_inode(trans, root, dir);
2933         BUG_ON(ret);
2934
2935         btrfs_free_path(path);
2936         return 0;
2937 }
2938
2939 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
2940 {
2941         struct inode *inode = dentry->d_inode;
2942         int err = 0;
2943         struct btrfs_root *root = BTRFS_I(dir)->root;
2944         struct btrfs_trans_handle *trans;
2945         unsigned long nr = 0;
2946
2947         if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
2948             btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
2949                 return -ENOTEMPTY;
2950
2951         trans = __unlink_start_trans(dir, dentry);
2952         if (IS_ERR(trans))
2953                 return PTR_ERR(trans);
2954
2955         if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
2956                 err = btrfs_unlink_subvol(trans, root, dir,
2957                                           BTRFS_I(inode)->location.objectid,
2958                                           dentry->d_name.name,
2959                                           dentry->d_name.len);
2960                 goto out;
2961         }
2962
2963         err = btrfs_orphan_add(trans, inode);
2964         if (err)
2965                 goto out;
2966
2967         /* now the directory is empty */
2968         err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
2969                                  dentry->d_name.name, dentry->d_name.len);
2970         if (!err)
2971                 btrfs_i_size_write(inode, 0);
2972 out:
2973         nr = trans->blocks_used;
2974         __unlink_end_trans(trans, root);
2975         btrfs_btree_balance_dirty(root, nr);
2976
2977         return err;
2978 }
2979
2980 /*
2981  * this can truncate away extent items, csum items and directory items.
2982  * It starts at a high offset and removes keys until it can't find
2983  * any higher than new_size
2984  *
2985  * csum items that cross the new i_size are truncated to the new size
2986  * as well.
2987  *
2988  * min_type is the minimum key type to truncate down to.  If set to 0, this
2989  * will kill all the items on this inode, including the INODE_ITEM_KEY.
2990  */
2991 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
2992                                struct btrfs_root *root,
2993                                struct inode *inode,
2994                                u64 new_size, u32 min_type)
2995 {
2996         struct btrfs_path *path;
2997         struct extent_buffer *leaf;
2998         struct btrfs_file_extent_item *fi;
2999         struct btrfs_key key;
3000         struct btrfs_key found_key;
3001         u64 extent_start = 0;
3002         u64 extent_num_bytes = 0;
3003         u64 extent_offset = 0;
3004         u64 item_end = 0;
3005         u64 mask = root->sectorsize - 1;
3006         u32 found_type = (u8)-1;
3007         int found_extent;
3008         int del_item;
3009         int pending_del_nr = 0;
3010         int pending_del_slot = 0;
3011         int extent_type = -1;
3012         int encoding;
3013         int ret;
3014         int err = 0;
3015         u64 ino = btrfs_ino(inode);
3016
3017         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
3018
3019         path = btrfs_alloc_path();
3020         if (!path)
3021                 return -ENOMEM;
3022         path->reada = -1;
3023
3024         if (root->ref_cows || root == root->fs_info->tree_root)
3025                 btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
3026
3027         /*
3028          * This function is also used to drop the items in the log tree before
3029          * we relog the inode, so if root != BTRFS_I(inode)->root, it means
3030          * it is used to drop the loged items. So we shouldn't kill the delayed
3031          * items.
3032          */
3033         if (min_type == 0 && root == BTRFS_I(inode)->root)
3034                 btrfs_kill_delayed_inode_items(inode);
3035
3036         key.objectid = ino;
3037         key.offset = (u64)-1;
3038         key.type = (u8)-1;
3039
3040 search_again:
3041         path->leave_spinning = 1;
3042         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3043         if (ret < 0) {
3044                 err = ret;
3045                 goto out;
3046         }
3047
3048         if (ret > 0) {
3049                 /* there are no items in the tree for us to truncate, we're
3050                  * done
3051                  */
3052                 if (path->slots[0] == 0)
3053                         goto out;
3054                 path->slots[0]--;
3055         }
3056
3057         while (1) {
3058                 fi = NULL;
3059                 leaf = path->nodes[0];
3060                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
3061                 found_type = btrfs_key_type(&found_key);
3062                 encoding = 0;
3063
3064                 if (found_key.objectid != ino)
3065                         break;
3066
3067                 if (found_type < min_type)
3068                         break;
3069
3070                 item_end = found_key.offset;
3071                 if (found_type == BTRFS_EXTENT_DATA_KEY) {
3072                         fi = btrfs_item_ptr(leaf, path->slots[0],
3073                                             struct btrfs_file_extent_item);
3074                         extent_type = btrfs_file_extent_type(leaf, fi);
3075                         encoding = btrfs_file_extent_compression(leaf, fi);
3076                         encoding |= btrfs_file_extent_encryption(leaf, fi);
3077                         encoding |= btrfs_file_extent_other_encoding(leaf, fi);
3078
3079                         if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3080                                 item_end +=
3081                                     btrfs_file_extent_num_bytes(leaf, fi);
3082                         } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3083                                 item_end += btrfs_file_extent_inline_len(leaf,
3084                                                                          fi);
3085                         }
3086                         item_end--;
3087                 }
3088                 if (found_type > min_type) {
3089                         del_item = 1;
3090                 } else {
3091                         if (item_end < new_size)
3092                                 break;
3093                         if (found_key.offset >= new_size)
3094                                 del_item = 1;
3095                         else
3096                                 del_item = 0;
3097                 }
3098                 found_extent = 0;
3099                 /* FIXME, shrink the extent if the ref count is only 1 */
3100                 if (found_type != BTRFS_EXTENT_DATA_KEY)
3101                         goto delete;
3102
3103                 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3104                         u64 num_dec;
3105                         extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
3106                         if (!del_item && !encoding) {
3107                                 u64 orig_num_bytes =
3108                                         btrfs_file_extent_num_bytes(leaf, fi);
3109                                 extent_num_bytes = new_size -
3110                                         found_key.offset + root->sectorsize - 1;
3111                                 extent_num_bytes = extent_num_bytes &
3112                                         ~((u64)root->sectorsize - 1);
3113                                 btrfs_set_file_extent_num_bytes(leaf, fi,
3114                                                          extent_num_bytes);
3115                                 num_dec = (orig_num_bytes -
3116                                            extent_num_bytes);
3117                                 if (root->ref_cows && extent_start != 0)
3118                                         inode_sub_bytes(inode, num_dec);
3119                                 btrfs_mark_buffer_dirty(leaf);
3120                         } else {
3121                                 extent_num_bytes =
3122                                         btrfs_file_extent_disk_num_bytes(leaf,
3123                                                                          fi);
3124                                 extent_offset = found_key.offset -
3125                                         btrfs_file_extent_offset(leaf, fi);
3126
3127                                 /* FIXME blocksize != 4096 */
3128                                 num_dec = btrfs_file_extent_num_bytes(leaf, fi);
3129                                 if (extent_start != 0) {
3130                                         found_extent = 1;
3131                                         if (root->ref_cows)
3132                                                 inode_sub_bytes(inode, num_dec);
3133                                 }
3134                         }
3135                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3136                         /*
3137                          * we can't truncate inline items that have had
3138                          * special encodings
3139                          */
3140                         if (!del_item &&
3141                             btrfs_file_extent_compression(leaf, fi) == 0 &&
3142                             btrfs_file_extent_encryption(leaf, fi) == 0 &&
3143                             btrfs_file_extent_other_encoding(leaf, fi) == 0) {
3144                                 u32 size = new_size - found_key.offset;
3145
3146                                 if (root->ref_cows) {
3147                                         inode_sub_bytes(inode, item_end + 1 -
3148                                                         new_size);
3149                                 }
3150                                 size =
3151                                     btrfs_file_extent_calc_inline_size(size);
3152                                 ret = btrfs_truncate_item(trans, root, path,
3153                                                           size, 1);
3154                         } else if (root->ref_cows) {
3155                                 inode_sub_bytes(inode, item_end + 1 -
3156                                                 found_key.offset);
3157                         }
3158                 }
3159 delete:
3160                 if (del_item) {
3161                         if (!pending_del_nr) {
3162                                 /* no pending yet, add ourselves */
3163                                 pending_del_slot = path->slots[0];
3164                                 pending_del_nr = 1;
3165                         } else if (pending_del_nr &&
3166                                    path->slots[0] + 1 == pending_del_slot) {
3167                                 /* hop on the pending chunk */
3168                                 pending_del_nr++;
3169                                 pending_del_slot = path->slots[0];
3170                         } else {
3171                                 BUG();
3172                         }
3173                 } else {
3174                         break;
3175                 }
3176                 if (found_extent && (root->ref_cows ||
3177                                      root == root->fs_info->tree_root)) {
3178                         btrfs_set_path_blocking(path);
3179                         ret = btrfs_free_extent(trans, root, extent_start,
3180                                                 extent_num_bytes, 0,
3181                                                 btrfs_header_owner(leaf),
3182                                                 ino, extent_offset);
3183                         BUG_ON(ret);
3184                 }
3185
3186                 if (found_type == BTRFS_INODE_ITEM_KEY)
3187                         break;
3188
3189                 if (path->slots[0] == 0 ||
3190                     path->slots[0] != pending_del_slot) {
3191                         if (root->ref_cows &&
3192                             BTRFS_I(inode)->location.objectid !=
3193                                                 BTRFS_FREE_INO_OBJECTID) {
3194                                 err = -EAGAIN;
3195                                 goto out;
3196                         }
3197                         if (pending_del_nr) {
3198                                 ret = btrfs_del_items(trans, root, path,
3199                                                 pending_del_slot,
3200                                                 pending_del_nr);
3201                                 BUG_ON(ret);
3202                     &