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