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