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