1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/bio.h>
21 #include <linux/buffer_head.h>
22 #include <linux/file.h>
23 #include <linux/fs.h>
24 #include <linux/pagemap.h>
25 #include <linux/highmem.h>
26 #include <linux/time.h>
27 #include <linux/init.h>
28 #include <linux/string.h>
29 #include <linux/backing-dev.h>
30 #include <linux/mpage.h>
31 #include <linux/swap.h>
32 #include <linux/writeback.h>
33 #include <linux/statfs.h>
34 #include <linux/compat.h>
35 #include <linux/bit_spinlock.h>
36 #include <linux/xattr.h>
37 #include <linux/posix_acl.h>
38 #include <linux/falloc.h>
39 #include <linux/slab.h>
40 #include <linux/ratelimit.h>
41 #include <linux/mount.h>
42 #include <linux/btrfs.h>
43 #include <linux/blkdev.h>
44 #include <linux/posix_acl_xattr.h>
45 #include <linux/uio.h>
46 #include "ctree.h"
47 #include "disk-io.h"
48 #include "transaction.h"
49 #include "btrfs_inode.h"
50 #include "print-tree.h"
51 #include "ordered-data.h"
52 #include "xattr.h"
53 #include "tree-log.h"
54 #include "volumes.h"
55 #include "compression.h"
56 #include "locking.h"
57 #include "free-space-cache.h"
58 #include "inode-map.h"
59 #include "backref.h"
60 #include "hash.h"
61 #include "props.h"
62 #include "qgroup.h"
63 
64 struct btrfs_iget_args {
65 	struct btrfs_key *location;
66 	struct btrfs_root *root;
67 };
68 
69 static const struct inode_operations btrfs_dir_inode_operations;
70 static const struct inode_operations btrfs_symlink_inode_operations;
71 static const struct inode_operations btrfs_dir_ro_inode_operations;
72 static const struct inode_operations btrfs_special_inode_operations;
73 static const struct inode_operations btrfs_file_inode_operations;
74 static const struct address_space_operations btrfs_aops;
75 static const struct address_space_operations btrfs_symlink_aops;
76 static const struct file_operations btrfs_dir_file_operations;
77 static struct extent_io_ops btrfs_extent_io_ops;
78 
79 static struct kmem_cache *btrfs_inode_cachep;
80 static struct kmem_cache *btrfs_delalloc_work_cachep;
81 struct kmem_cache *btrfs_trans_handle_cachep;
82 struct kmem_cache *btrfs_transaction_cachep;
83 struct kmem_cache *btrfs_path_cachep;
84 struct kmem_cache *btrfs_free_space_cachep;
85 
86 #define S_SHIFT 12
87 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
88 	[S_IFREG >> S_SHIFT]	= BTRFS_FT_REG_FILE,
89 	[S_IFDIR >> S_SHIFT]	= BTRFS_FT_DIR,
90 	[S_IFCHR >> S_SHIFT]	= BTRFS_FT_CHRDEV,
91 	[S_IFBLK >> S_SHIFT]	= BTRFS_FT_BLKDEV,
92 	[S_IFIFO >> S_SHIFT]	= BTRFS_FT_FIFO,
93 	[S_IFSOCK >> S_SHIFT]	= BTRFS_FT_SOCK,
94 	[S_IFLNK >> S_SHIFT]	= BTRFS_FT_SYMLINK,
95 };
96 
97 static int btrfs_setsize(struct inode *inode, struct iattr *attr);
98 static int btrfs_truncate(struct inode *inode);
99 static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
100 static noinline int cow_file_range(struct inode *inode,
101 				   struct page *locked_page,
102 				   u64 start, u64 end, int *page_started,
103 				   unsigned long *nr_written, int unlock);
104 static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
105 					   u64 len, u64 orig_start,
106 					   u64 block_start, u64 block_len,
107 					   u64 orig_block_len, u64 ram_bytes,
108 					   int type);
109 
110 static int btrfs_dirty_inode(struct inode *inode);
111 
112 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
btrfs_test_inode_set_ops(struct inode * inode)113 void btrfs_test_inode_set_ops(struct inode *inode)
114 {
115 	BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
116 }
117 #endif
118 
btrfs_init_inode_security(struct btrfs_trans_handle * trans,struct inode * inode,struct inode * dir,const struct qstr * qstr)119 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
120 				     struct inode *inode,  struct inode *dir,
121 				     const struct qstr *qstr)
122 {
123 	int err;
124 
125 	err = btrfs_init_acl(trans, inode, dir);
126 	if (!err)
127 		err = btrfs_xattr_security_init(trans, inode, dir, qstr);
128 	return err;
129 }
130 
131 /*
132  * this does all the hard work for inserting an inline extent into
133  * the btree.  The caller should have done a btrfs_drop_extents so that
134  * no overlapping inline items exist in the btree
135  */
insert_inline_extent(struct btrfs_trans_handle * trans,struct btrfs_path * path,int extent_inserted,struct btrfs_root * root,struct inode * inode,u64 start,size_t size,size_t compressed_size,int compress_type,struct page ** compressed_pages)136 static int insert_inline_extent(struct btrfs_trans_handle *trans,
137 				struct btrfs_path *path, int extent_inserted,
138 				struct btrfs_root *root, struct inode *inode,
139 				u64 start, size_t size, size_t compressed_size,
140 				int compress_type,
141 				struct page **compressed_pages)
142 {
143 	struct extent_buffer *leaf;
144 	struct page *page = NULL;
145 	char *kaddr;
146 	unsigned long ptr;
147 	struct btrfs_file_extent_item *ei;
148 	int err = 0;
149 	int ret;
150 	size_t cur_size = size;
151 	unsigned long offset;
152 
153 	if (compressed_size && compressed_pages)
154 		cur_size = compressed_size;
155 
156 	inode_add_bytes(inode, size);
157 
158 	if (!extent_inserted) {
159 		struct btrfs_key key;
160 		size_t datasize;
161 
162 		key.objectid = btrfs_ino(inode);
163 		key.offset = start;
164 		key.type = BTRFS_EXTENT_DATA_KEY;
165 
166 		datasize = btrfs_file_extent_calc_inline_size(cur_size);
167 		path->leave_spinning = 1;
168 		ret = btrfs_insert_empty_item(trans, root, path, &key,
169 					      datasize);
170 		if (ret) {
171 			err = ret;
172 			goto fail;
173 		}
174 	}
175 	leaf = path->nodes[0];
176 	ei = btrfs_item_ptr(leaf, path->slots[0],
177 			    struct btrfs_file_extent_item);
178 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
179 	btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
180 	btrfs_set_file_extent_encryption(leaf, ei, 0);
181 	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
182 	btrfs_set_file_extent_ram_bytes(leaf, ei, size);
183 	ptr = btrfs_file_extent_inline_start(ei);
184 
185 	if (compress_type != BTRFS_COMPRESS_NONE) {
186 		struct page *cpage;
187 		int i = 0;
188 		while (compressed_size > 0) {
189 			cpage = compressed_pages[i];
190 			cur_size = min_t(unsigned long, compressed_size,
191 				       PAGE_CACHE_SIZE);
192 
193 			kaddr = kmap_atomic(cpage);
194 			write_extent_buffer(leaf, kaddr, ptr, cur_size);
195 			kunmap_atomic(kaddr);
196 
197 			i++;
198 			ptr += cur_size;
199 			compressed_size -= cur_size;
200 		}
201 		btrfs_set_file_extent_compression(leaf, ei,
202 						  compress_type);
203 	} else {
204 		page = find_get_page(inode->i_mapping,
205 				     start >> PAGE_CACHE_SHIFT);
206 		btrfs_set_file_extent_compression(leaf, ei, 0);
207 		kaddr = kmap_atomic(page);
208 		offset = start & (PAGE_CACHE_SIZE - 1);
209 		write_extent_buffer(leaf, kaddr + offset, ptr, size);
210 		kunmap_atomic(kaddr);
211 		page_cache_release(page);
212 	}
213 	btrfs_mark_buffer_dirty(leaf);
214 	btrfs_release_path(path);
215 
216 	/*
217 	 * we're an inline extent, so nobody can
218 	 * extend the file past i_size without locking
219 	 * a page we already have locked.
220 	 *
221 	 * We must do any isize and inode updates
222 	 * before we unlock the pages.  Otherwise we
223 	 * could end up racing with unlink.
224 	 */
225 	BTRFS_I(inode)->disk_i_size = inode->i_size;
226 	ret = btrfs_update_inode(trans, root, inode);
227 
228 	return ret;
229 fail:
230 	return err;
231 }
232 
233 
234 /*
235  * conditionally insert an inline extent into the file.  This
236  * does the checks required to make sure the data is small enough
237  * to fit as an inline extent.
238  */
cow_file_range_inline(struct btrfs_root * root,struct inode * inode,u64 start,u64 end,size_t compressed_size,int compress_type,struct page ** compressed_pages)239 static noinline int cow_file_range_inline(struct btrfs_root *root,
240 					  struct inode *inode, u64 start,
241 					  u64 end, size_t compressed_size,
242 					  int compress_type,
243 					  struct page **compressed_pages)
244 {
245 	struct btrfs_trans_handle *trans;
246 	u64 isize = i_size_read(inode);
247 	u64 actual_end = min(end + 1, isize);
248 	u64 inline_len = actual_end - start;
249 	u64 aligned_end = ALIGN(end, root->sectorsize);
250 	u64 data_len = inline_len;
251 	int ret;
252 	struct btrfs_path *path;
253 	int extent_inserted = 0;
254 	u32 extent_item_size;
255 
256 	if (compressed_size)
257 		data_len = compressed_size;
258 
259 	if (start > 0 ||
260 	    actual_end > PAGE_CACHE_SIZE ||
261 	    data_len > BTRFS_MAX_INLINE_DATA_SIZE(root) ||
262 	    (!compressed_size &&
263 	    (actual_end & (root->sectorsize - 1)) == 0) ||
264 	    end + 1 < isize ||
265 	    data_len > root->fs_info->max_inline) {
266 		return 1;
267 	}
268 
269 	path = btrfs_alloc_path();
270 	if (!path)
271 		return -ENOMEM;
272 
273 	trans = btrfs_join_transaction(root);
274 	if (IS_ERR(trans)) {
275 		btrfs_free_path(path);
276 		return PTR_ERR(trans);
277 	}
278 	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
279 
280 	if (compressed_size && compressed_pages)
281 		extent_item_size = btrfs_file_extent_calc_inline_size(
282 		   compressed_size);
283 	else
284 		extent_item_size = btrfs_file_extent_calc_inline_size(
285 		    inline_len);
286 
287 	ret = __btrfs_drop_extents(trans, root, inode, path,
288 				   start, aligned_end, NULL,
289 				   1, 1, extent_item_size, &extent_inserted);
290 	if (ret) {
291 		btrfs_abort_transaction(trans, root, ret);
292 		goto out;
293 	}
294 
295 	if (isize > actual_end)
296 		inline_len = min_t(u64, isize, actual_end);
297 	ret = insert_inline_extent(trans, path, extent_inserted,
298 				   root, inode, start,
299 				   inline_len, compressed_size,
300 				   compress_type, compressed_pages);
301 	if (ret && ret != -ENOSPC) {
302 		btrfs_abort_transaction(trans, root, ret);
303 		goto out;
304 	} else if (ret == -ENOSPC) {
305 		ret = 1;
306 		goto out;
307 	}
308 
309 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
310 	btrfs_delalloc_release_metadata(inode, end + 1 - start);
311 	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
312 out:
313 	/*
314 	 * Don't forget to free the reserved space, as for inlined extent
315 	 * it won't count as data extent, free them directly here.
316 	 * And at reserve time, it's always aligned to page size, so
317 	 * just free one page here.
318 	 */
319 	btrfs_qgroup_free_data(inode, 0, PAGE_CACHE_SIZE);
320 	btrfs_free_path(path);
321 	btrfs_end_transaction(trans, root);
322 	return ret;
323 }
324 
325 struct async_extent {
326 	u64 start;
327 	u64 ram_size;
328 	u64 compressed_size;
329 	struct page **pages;
330 	unsigned long nr_pages;
331 	int compress_type;
332 	struct list_head list;
333 };
334 
335 struct async_cow {
336 	struct inode *inode;
337 	struct btrfs_root *root;
338 	struct page *locked_page;
339 	u64 start;
340 	u64 end;
341 	struct list_head extents;
342 	struct btrfs_work work;
343 };
344 
add_async_extent(struct async_cow * cow,u64 start,u64 ram_size,u64 compressed_size,struct page ** pages,unsigned long nr_pages,int compress_type)345 static noinline int add_async_extent(struct async_cow *cow,
346 				     u64 start, u64 ram_size,
347 				     u64 compressed_size,
348 				     struct page **pages,
349 				     unsigned long nr_pages,
350 				     int compress_type)
351 {
352 	struct async_extent *async_extent;
353 
354 	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
355 	BUG_ON(!async_extent); /* -ENOMEM */
356 	async_extent->start = start;
357 	async_extent->ram_size = ram_size;
358 	async_extent->compressed_size = compressed_size;
359 	async_extent->pages = pages;
360 	async_extent->nr_pages = nr_pages;
361 	async_extent->compress_type = compress_type;
362 	list_add_tail(&async_extent->list, &cow->extents);
363 	return 0;
364 }
365 
inode_need_compress(struct inode * inode)366 static inline int inode_need_compress(struct inode *inode)
367 {
368 	struct btrfs_root *root = BTRFS_I(inode)->root;
369 
370 	/* force compress */
371 	if (btrfs_test_opt(root, FORCE_COMPRESS))
372 		return 1;
373 	/* bad compression ratios */
374 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
375 		return 0;
376 	if (btrfs_test_opt(root, COMPRESS) ||
377 	    BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS ||
378 	    BTRFS_I(inode)->force_compress)
379 		return 1;
380 	return 0;
381 }
382 
383 /*
384  * we create compressed extents in two phases.  The first
385  * phase compresses a range of pages that have already been
386  * locked (both pages and state bits are locked).
387  *
388  * This is done inside an ordered work queue, and the compression
389  * is spread across many cpus.  The actual IO submission is step
390  * two, and the ordered work queue takes care of making sure that
391  * happens in the same order things were put onto the queue by
392  * writepages and friends.
393  *
394  * If this code finds it can't get good compression, it puts an
395  * entry onto the work queue to write the uncompressed bytes.  This
396  * makes sure that both compressed inodes and uncompressed inodes
397  * are written in the same order that the flusher thread sent them
398  * down.
399  */
compress_file_range(struct inode * inode,struct page * locked_page,u64 start,u64 end,struct async_cow * async_cow,int * num_added)400 static noinline void compress_file_range(struct inode *inode,
401 					struct page *locked_page,
402 					u64 start, u64 end,
403 					struct async_cow *async_cow,
404 					int *num_added)
405 {
406 	struct btrfs_root *root = BTRFS_I(inode)->root;
407 	u64 num_bytes;
408 	u64 blocksize = root->sectorsize;
409 	u64 actual_end;
410 	u64 isize = i_size_read(inode);
411 	int ret = 0;
412 	struct page **pages = NULL;
413 	unsigned long nr_pages;
414 	unsigned long nr_pages_ret = 0;
415 	unsigned long total_compressed = 0;
416 	unsigned long total_in = 0;
417 	unsigned long max_compressed = 128 * 1024;
418 	unsigned long max_uncompressed = 128 * 1024;
419 	int i;
420 	int will_compress;
421 	int compress_type = root->fs_info->compress_type;
422 	int redirty = 0;
423 
424 	/* if this is a small write inside eof, kick off a defrag */
425 	if ((end - start + 1) < 16 * 1024 &&
426 	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
427 		btrfs_add_inode_defrag(NULL, inode);
428 
429 	actual_end = min_t(u64, isize, end + 1);
430 again:
431 	will_compress = 0;
432 	nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
433 	nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
434 
435 	/*
436 	 * we don't want to send crud past the end of i_size through
437 	 * compression, that's just a waste of CPU time.  So, if the
438 	 * end of the file is before the start of our current
439 	 * requested range of bytes, we bail out to the uncompressed
440 	 * cleanup code that can deal with all of this.
441 	 *
442 	 * It isn't really the fastest way to fix things, but this is a
443 	 * very uncommon corner.
444 	 */
445 	if (actual_end <= start)
446 		goto cleanup_and_bail_uncompressed;
447 
448 	total_compressed = actual_end - start;
449 
450 	/*
451 	 * skip compression for a small file range(<=blocksize) that
452 	 * isn't an inline extent, since it dosen't save disk space at all.
453 	 */
454 	if (total_compressed <= blocksize &&
455 	   (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
456 		goto cleanup_and_bail_uncompressed;
457 
458 	/* we want to make sure that amount of ram required to uncompress
459 	 * an extent is reasonable, so we limit the total size in ram
460 	 * of a compressed extent to 128k.  This is a crucial number
461 	 * because it also controls how easily we can spread reads across
462 	 * cpus for decompression.
463 	 *
464 	 * We also want to make sure the amount of IO required to do
465 	 * a random read is reasonably small, so we limit the size of
466 	 * a compressed extent to 128k.
467 	 */
468 	total_compressed = min(total_compressed, max_uncompressed);
469 	num_bytes = ALIGN(end - start + 1, blocksize);
470 	num_bytes = max(blocksize,  num_bytes);
471 	total_in = 0;
472 	ret = 0;
473 
474 	/*
475 	 * we do compression for mount -o compress and when the
476 	 * inode has not been flagged as nocompress.  This flag can
477 	 * change at any time if we discover bad compression ratios.
478 	 */
479 	if (inode_need_compress(inode)) {
480 		WARN_ON(pages);
481 		pages = kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS);
482 		if (!pages) {
483 			/* just bail out to the uncompressed code */
484 			goto cont;
485 		}
486 
487 		if (BTRFS_I(inode)->force_compress)
488 			compress_type = BTRFS_I(inode)->force_compress;
489 
490 		/*
491 		 * we need to call clear_page_dirty_for_io on each
492 		 * page in the range.  Otherwise applications with the file
493 		 * mmap'd can wander in and change the page contents while
494 		 * we are compressing them.
495 		 *
496 		 * If the compression fails for any reason, we set the pages
497 		 * dirty again later on.
498 		 */
499 		extent_range_clear_dirty_for_io(inode, start, end);
500 		redirty = 1;
501 		ret = btrfs_compress_pages(compress_type,
502 					   inode->i_mapping, start,
503 					   total_compressed, pages,
504 					   nr_pages, &nr_pages_ret,
505 					   &total_in,
506 					   &total_compressed,
507 					   max_compressed);
508 
509 		if (!ret) {
510 			unsigned long offset = total_compressed &
511 				(PAGE_CACHE_SIZE - 1);
512 			struct page *page = pages[nr_pages_ret - 1];
513 			char *kaddr;
514 
515 			/* zero the tail end of the last page, we might be
516 			 * sending it down to disk
517 			 */
518 			if (offset) {
519 				kaddr = kmap_atomic(page);
520 				memset(kaddr + offset, 0,
521 				       PAGE_CACHE_SIZE - offset);
522 				kunmap_atomic(kaddr);
523 			}
524 			will_compress = 1;
525 		}
526 	}
527 cont:
528 	if (start == 0) {
529 		/* lets try to make an inline extent */
530 		if (ret || total_in < (actual_end - start)) {
531 			/* we didn't compress the entire range, try
532 			 * to make an uncompressed inline extent.
533 			 */
534 			ret = cow_file_range_inline(root, inode, start, end,
535 						    0, 0, NULL);
536 		} else {
537 			/* try making a compressed inline extent */
538 			ret = cow_file_range_inline(root, inode, start, end,
539 						    total_compressed,
540 						    compress_type, pages);
541 		}
542 		if (ret <= 0) {
543 			unsigned long clear_flags = EXTENT_DELALLOC |
544 				EXTENT_DEFRAG;
545 			unsigned long page_error_op;
546 
547 			clear_flags |= (ret < 0) ? EXTENT_DO_ACCOUNTING : 0;
548 			page_error_op = ret < 0 ? PAGE_SET_ERROR : 0;
549 
550 			/*
551 			 * inline extent creation worked or returned error,
552 			 * we don't need to create any more async work items.
553 			 * Unlock and free up our temp pages.
554 			 */
555 			extent_clear_unlock_delalloc(inode, start, end, NULL,
556 						     clear_flags, PAGE_UNLOCK |
557 						     PAGE_CLEAR_DIRTY |
558 						     PAGE_SET_WRITEBACK |
559 						     page_error_op |
560 						     PAGE_END_WRITEBACK);
561 			goto free_pages_out;
562 		}
563 	}
564 
565 	if (will_compress) {
566 		/*
567 		 * we aren't doing an inline extent round the compressed size
568 		 * up to a block size boundary so the allocator does sane
569 		 * things
570 		 */
571 		total_compressed = ALIGN(total_compressed, blocksize);
572 
573 		/*
574 		 * one last check to make sure the compression is really a
575 		 * win, compare the page count read with the blocks on disk
576 		 */
577 		total_in = ALIGN(total_in, PAGE_CACHE_SIZE);
578 		if (total_compressed >= total_in) {
579 			will_compress = 0;
580 		} else {
581 			num_bytes = total_in;
582 		}
583 	}
584 	if (!will_compress && pages) {
585 		/*
586 		 * the compression code ran but failed to make things smaller,
587 		 * free any pages it allocated and our page pointer array
588 		 */
589 		for (i = 0; i < nr_pages_ret; i++) {
590 			WARN_ON(pages[i]->mapping);
591 			page_cache_release(pages[i]);
592 		}
593 		kfree(pages);
594 		pages = NULL;
595 		total_compressed = 0;
596 		nr_pages_ret = 0;
597 
598 		/* flag the file so we don't compress in the future */
599 		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
600 		    !(BTRFS_I(inode)->force_compress)) {
601 			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
602 		}
603 	}
604 	if (will_compress) {
605 		*num_added += 1;
606 
607 		/* the async work queues will take care of doing actual
608 		 * allocation on disk for these compressed pages,
609 		 * and will submit them to the elevator.
610 		 */
611 		add_async_extent(async_cow, start, num_bytes,
612 				 total_compressed, pages, nr_pages_ret,
613 				 compress_type);
614 
615 		if (start + num_bytes < end) {
616 			start += num_bytes;
617 			pages = NULL;
618 			cond_resched();
619 			goto again;
620 		}
621 	} else {
622 cleanup_and_bail_uncompressed:
623 		/*
624 		 * No compression, but we still need to write the pages in
625 		 * the file we've been given so far.  redirty the locked
626 		 * page if it corresponds to our extent and set things up
627 		 * for the async work queue to run cow_file_range to do
628 		 * the normal delalloc dance
629 		 */
630 		if (page_offset(locked_page) >= start &&
631 		    page_offset(locked_page) <= end) {
632 			__set_page_dirty_nobuffers(locked_page);
633 			/* unlocked later on in the async handlers */
634 		}
635 		if (redirty)
636 			extent_range_redirty_for_io(inode, start, end);
637 		add_async_extent(async_cow, start, end - start + 1,
638 				 0, NULL, 0, BTRFS_COMPRESS_NONE);
639 		*num_added += 1;
640 	}
641 
642 	return;
643 
644 free_pages_out:
645 	for (i = 0; i < nr_pages_ret; i++) {
646 		WARN_ON(pages[i]->mapping);
647 		page_cache_release(pages[i]);
648 	}
649 	kfree(pages);
650 }
651 
free_async_extent_pages(struct async_extent * async_extent)652 static void free_async_extent_pages(struct async_extent *async_extent)
653 {
654 	int i;
655 
656 	if (!async_extent->pages)
657 		return;
658 
659 	for (i = 0; i < async_extent->nr_pages; i++) {
660 		WARN_ON(async_extent->pages[i]->mapping);
661 		page_cache_release(async_extent->pages[i]);
662 	}
663 	kfree(async_extent->pages);
664 	async_extent->nr_pages = 0;
665 	async_extent->pages = NULL;
666 }
667 
668 /*
669  * phase two of compressed writeback.  This is the ordered portion
670  * of the code, which only gets called in the order the work was
671  * queued.  We walk all the async extents created by compress_file_range
672  * and send them down to the disk.
673  */
submit_compressed_extents(struct inode * inode,struct async_cow * async_cow)674 static noinline void submit_compressed_extents(struct inode *inode,
675 					      struct async_cow *async_cow)
676 {
677 	struct async_extent *async_extent;
678 	u64 alloc_hint = 0;
679 	struct btrfs_key ins;
680 	struct extent_map *em;
681 	struct btrfs_root *root = BTRFS_I(inode)->root;
682 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
683 	struct extent_io_tree *io_tree;
684 	int ret = 0;
685 
686 again:
687 	while (!list_empty(&async_cow->extents)) {
688 		async_extent = list_entry(async_cow->extents.next,
689 					  struct async_extent, list);
690 		list_del(&async_extent->list);
691 
692 		io_tree = &BTRFS_I(inode)->io_tree;
693 
694 retry:
695 		/* did the compression code fall back to uncompressed IO? */
696 		if (!async_extent->pages) {
697 			int page_started = 0;
698 			unsigned long nr_written = 0;
699 
700 			lock_extent(io_tree, async_extent->start,
701 					 async_extent->start +
702 					 async_extent->ram_size - 1);
703 
704 			/* allocate blocks */
705 			ret = cow_file_range(inode, async_cow->locked_page,
706 					     async_extent->start,
707 					     async_extent->start +
708 					     async_extent->ram_size - 1,
709 					     &page_started, &nr_written, 0);
710 
711 			/* JDM XXX */
712 
713 			/*
714 			 * if page_started, cow_file_range inserted an
715 			 * inline extent and took care of all the unlocking
716 			 * and IO for us.  Otherwise, we need to submit
717 			 * all those pages down to the drive.
718 			 */
719 			if (!page_started && !ret)
720 				extent_write_locked_range(io_tree,
721 						  inode, async_extent->start,
722 						  async_extent->start +
723 						  async_extent->ram_size - 1,
724 						  btrfs_get_extent,
725 						  WB_SYNC_ALL);
726 			else if (ret)
727 				unlock_page(async_cow->locked_page);
728 			kfree(async_extent);
729 			cond_resched();
730 			continue;
731 		}
732 
733 		lock_extent(io_tree, async_extent->start,
734 			    async_extent->start + async_extent->ram_size - 1);
735 
736 		ret = btrfs_reserve_extent(root,
737 					   async_extent->compressed_size,
738 					   async_extent->compressed_size,
739 					   0, alloc_hint, &ins, 1, 1);
740 		if (ret) {
741 			free_async_extent_pages(async_extent);
742 
743 			if (ret == -ENOSPC) {
744 				unlock_extent(io_tree, async_extent->start,
745 					      async_extent->start +
746 					      async_extent->ram_size - 1);
747 
748 				/*
749 				 * we need to redirty the pages if we decide to
750 				 * fallback to uncompressed IO, otherwise we
751 				 * will not submit these pages down to lower
752 				 * layers.
753 				 */
754 				extent_range_redirty_for_io(inode,
755 						async_extent->start,
756 						async_extent->start +
757 						async_extent->ram_size - 1);
758 
759 				goto retry;
760 			}
761 			goto out_free;
762 		}
763 		/*
764 		 * here we're doing allocation and writeback of the
765 		 * compressed pages
766 		 */
767 		btrfs_drop_extent_cache(inode, async_extent->start,
768 					async_extent->start +
769 					async_extent->ram_size - 1, 0);
770 
771 		em = alloc_extent_map();
772 		if (!em) {
773 			ret = -ENOMEM;
774 			goto out_free_reserve;
775 		}
776 		em->start = async_extent->start;
777 		em->len = async_extent->ram_size;
778 		em->orig_start = em->start;
779 		em->mod_start = em->start;
780 		em->mod_len = em->len;
781 
782 		em->block_start = ins.objectid;
783 		em->block_len = ins.offset;
784 		em->orig_block_len = ins.offset;
785 		em->ram_bytes = async_extent->ram_size;
786 		em->bdev = root->fs_info->fs_devices->latest_bdev;
787 		em->compress_type = async_extent->compress_type;
788 		set_bit(EXTENT_FLAG_PINNED, &em->flags);
789 		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
790 		em->generation = -1;
791 
792 		while (1) {
793 			write_lock(&em_tree->lock);
794 			ret = add_extent_mapping(em_tree, em, 1);
795 			write_unlock(&em_tree->lock);
796 			if (ret != -EEXIST) {
797 				free_extent_map(em);
798 				break;
799 			}
800 			btrfs_drop_extent_cache(inode, async_extent->start,
801 						async_extent->start +
802 						async_extent->ram_size - 1, 0);
803 		}
804 
805 		if (ret)
806 			goto out_free_reserve;
807 
808 		ret = btrfs_add_ordered_extent_compress(inode,
809 						async_extent->start,
810 						ins.objectid,
811 						async_extent->ram_size,
812 						ins.offset,
813 						BTRFS_ORDERED_COMPRESSED,
814 						async_extent->compress_type);
815 		if (ret) {
816 			btrfs_drop_extent_cache(inode, async_extent->start,
817 						async_extent->start +
818 						async_extent->ram_size - 1, 0);
819 			goto out_free_reserve;
820 		}
821 
822 		/*
823 		 * clear dirty, set writeback and unlock the pages.
824 		 */
825 		extent_clear_unlock_delalloc(inode, async_extent->start,
826 				async_extent->start +
827 				async_extent->ram_size - 1,
828 				NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
829 				PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
830 				PAGE_SET_WRITEBACK);
831 		ret = btrfs_submit_compressed_write(inode,
832 				    async_extent->start,
833 				    async_extent->ram_size,
834 				    ins.objectid,
835 				    ins.offset, async_extent->pages,
836 				    async_extent->nr_pages);
837 		if (ret) {
838 			struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
839 			struct page *p = async_extent->pages[0];
840 			const u64 start = async_extent->start;
841 			const u64 end = start + async_extent->ram_size - 1;
842 
843 			p->mapping = inode->i_mapping;
844 			tree->ops->writepage_end_io_hook(p, start, end,
845 							 NULL, 0);
846 			p->mapping = NULL;
847 			extent_clear_unlock_delalloc(inode, start, end, NULL, 0,
848 						     PAGE_END_WRITEBACK |
849 						     PAGE_SET_ERROR);
850 			free_async_extent_pages(async_extent);
851 		}
852 		alloc_hint = ins.objectid + ins.offset;
853 		kfree(async_extent);
854 		cond_resched();
855 	}
856 	return;
857 out_free_reserve:
858 	btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1);
859 out_free:
860 	extent_clear_unlock_delalloc(inode, async_extent->start,
861 				     async_extent->start +
862 				     async_extent->ram_size - 1,
863 				     NULL, EXTENT_LOCKED | EXTENT_DELALLOC |
864 				     EXTENT_DEFRAG | EXTENT_DO_ACCOUNTING,
865 				     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
866 				     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK |
867 				     PAGE_SET_ERROR);
868 	free_async_extent_pages(async_extent);
869 	kfree(async_extent);
870 	goto again;
871 }
872 
get_extent_allocation_hint(struct inode * inode,u64 start,u64 num_bytes)873 static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
874 				      u64 num_bytes)
875 {
876 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
877 	struct extent_map *em;
878 	u64 alloc_hint = 0;
879 
880 	read_lock(&em_tree->lock);
881 	em = search_extent_mapping(em_tree, start, num_bytes);
882 	if (em) {
883 		/*
884 		 * if block start isn't an actual block number then find the
885 		 * first block in this inode and use that as a hint.  If that
886 		 * block is also bogus then just don't worry about it.
887 		 */
888 		if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
889 			free_extent_map(em);
890 			em = search_extent_mapping(em_tree, 0, 0);
891 			if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
892 				alloc_hint = em->block_start;
893 			if (em)
894 				free_extent_map(em);
895 		} else {
896 			alloc_hint = em->block_start;
897 			free_extent_map(em);
898 		}
899 	}
900 	read_unlock(&em_tree->lock);
901 
902 	return alloc_hint;
903 }
904 
905 /*
906  * when extent_io.c finds a delayed allocation range in the file,
907  * the call backs end up in this code.  The basic idea is to
908  * allocate extents on disk for the range, and create ordered data structs
909  * in ram to track those extents.
910  *
911  * locked_page is the page that writepage had locked already.  We use
912  * it to make sure we don't do extra locks or unlocks.
913  *
914  * *page_started is set to one if we unlock locked_page and do everything
915  * required to start IO on it.  It may be clean and already done with
916  * IO when we return.
917  */
cow_file_range(struct inode * inode,struct page * locked_page,u64 start,u64 end,int * page_started,unsigned long * nr_written,int unlock)918 static noinline int cow_file_range(struct inode *inode,
919 				   struct page *locked_page,
920 				   u64 start, u64 end, int *page_started,
921 				   unsigned long *nr_written,
922 				   int unlock)
923 {
924 	struct btrfs_root *root = BTRFS_I(inode)->root;
925 	u64 alloc_hint = 0;
926 	u64 num_bytes;
927 	unsigned long ram_size;
928 	u64 disk_num_bytes;
929 	u64 cur_alloc_size;
930 	u64 blocksize = root->sectorsize;
931 	struct btrfs_key ins;
932 	struct extent_map *em;
933 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
934 	int ret = 0;
935 
936 	if (btrfs_is_free_space_inode(inode)) {
937 		WARN_ON_ONCE(1);
938 		ret = -EINVAL;
939 		goto out_unlock;
940 	}
941 
942 	num_bytes = ALIGN(end - start + 1, blocksize);
943 	num_bytes = max(blocksize,  num_bytes);
944 	disk_num_bytes = num_bytes;
945 
946 	/* if this is a small write inside eof, kick off defrag */
947 	if (num_bytes < 64 * 1024 &&
948 	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
949 		btrfs_add_inode_defrag(NULL, inode);
950 
951 	if (start == 0) {
952 		/* lets try to make an inline extent */
953 		ret = cow_file_range_inline(root, inode, start, end, 0, 0,
954 					    NULL);
955 		if (ret == 0) {
956 			extent_clear_unlock_delalloc(inode, start, end, NULL,
957 				     EXTENT_LOCKED | EXTENT_DELALLOC |
958 				     EXTENT_DEFRAG, PAGE_UNLOCK |
959 				     PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK |
960 				     PAGE_END_WRITEBACK);
961 
962 			*nr_written = *nr_written +
963 			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
964 			*page_started = 1;
965 			goto out;
966 		} else if (ret < 0) {
967 			goto out_unlock;
968 		}
969 	}
970 
971 	BUG_ON(disk_num_bytes >
972 	       btrfs_super_total_bytes(root->fs_info->super_copy));
973 
974 	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
975 	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
976 
977 	while (disk_num_bytes > 0) {
978 		unsigned long op;
979 
980 		cur_alloc_size = disk_num_bytes;
981 		ret = btrfs_reserve_extent(root, cur_alloc_size,
982 					   root->sectorsize, 0, alloc_hint,
983 					   &ins, 1, 1);
984 		if (ret < 0)
985 			goto out_unlock;
986 
987 		em = alloc_extent_map();
988 		if (!em) {
989 			ret = -ENOMEM;
990 			goto out_reserve;
991 		}
992 		em->start = start;
993 		em->orig_start = em->start;
994 		ram_size = ins.offset;
995 		em->len = ins.offset;
996 		em->mod_start = em->start;
997 		em->mod_len = em->len;
998 
999 		em->block_start = ins.objectid;
1000 		em->block_len = ins.offset;
1001 		em->orig_block_len = ins.offset;
1002 		em->ram_bytes = ram_size;
1003 		em->bdev = root->fs_info->fs_devices->latest_bdev;
1004 		set_bit(EXTENT_FLAG_PINNED, &em->flags);
1005 		em->generation = -1;
1006 
1007 		while (1) {
1008 			write_lock(&em_tree->lock);
1009 			ret = add_extent_mapping(em_tree, em, 1);
1010 			write_unlock(&em_tree->lock);
1011 			if (ret != -EEXIST) {
1012 				free_extent_map(em);
1013 				break;
1014 			}
1015 			btrfs_drop_extent_cache(inode, start,
1016 						start + ram_size - 1, 0);
1017 		}
1018 		if (ret)
1019 			goto out_reserve;
1020 
1021 		cur_alloc_size = ins.offset;
1022 		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
1023 					       ram_size, cur_alloc_size, 0);
1024 		if (ret)
1025 			goto out_drop_extent_cache;
1026 
1027 		if (root->root_key.objectid ==
1028 		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
1029 			ret = btrfs_reloc_clone_csums(inode, start,
1030 						      cur_alloc_size);
1031 			if (ret)
1032 				goto out_drop_extent_cache;
1033 		}
1034 
1035 		if (disk_num_bytes < cur_alloc_size)
1036 			break;
1037 
1038 		/* we're not doing compressed IO, don't unlock the first
1039 		 * page (which the caller expects to stay locked), don't
1040 		 * clear any dirty bits and don't set any writeback bits
1041 		 *
1042 		 * Do set the Private2 bit so we know this page was properly
1043 		 * setup for writepage
1044 		 */
1045 		op = unlock ? PAGE_UNLOCK : 0;
1046 		op |= PAGE_SET_PRIVATE2;
1047 
1048 		extent_clear_unlock_delalloc(inode, start,
1049 					     start + ram_size - 1, locked_page,
1050 					     EXTENT_LOCKED | EXTENT_DELALLOC,
1051 					     op);
1052 		disk_num_bytes -= cur_alloc_size;
1053 		num_bytes -= cur_alloc_size;
1054 		alloc_hint = ins.objectid + ins.offset;
1055 		start += cur_alloc_size;
1056 	}
1057 out:
1058 	return ret;
1059 
1060 out_drop_extent_cache:
1061 	btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0);
1062 out_reserve:
1063 	btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1);
1064 out_unlock:
1065 	extent_clear_unlock_delalloc(inode, start, end, locked_page,
1066 				     EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
1067 				     EXTENT_DELALLOC | EXTENT_DEFRAG,
1068 				     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
1069 				     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK);
1070 	goto out;
1071 }
1072 
1073 /*
1074  * work queue call back to started compression on a file and pages
1075  */
async_cow_start(struct btrfs_work * work)1076 static noinline void async_cow_start(struct btrfs_work *work)
1077 {
1078 	struct async_cow *async_cow;
1079 	int num_added = 0;
1080 	async_cow = container_of(work, struct async_cow, work);
1081 
1082 	compress_file_range(async_cow->inode, async_cow->locked_page,
1083 			    async_cow->start, async_cow->end, async_cow,
1084 			    &num_added);
1085 	if (num_added == 0) {
1086 		btrfs_add_delayed_iput(async_cow->inode);
1087 		async_cow->inode = NULL;
1088 	}
1089 }
1090 
1091 /*
1092  * work queue call back to submit previously compressed pages
1093  */
async_cow_submit(struct btrfs_work * work)1094 static noinline void async_cow_submit(struct btrfs_work *work)
1095 {
1096 	struct async_cow *async_cow;
1097 	struct btrfs_root *root;
1098 	unsigned long nr_pages;
1099 
1100 	async_cow = container_of(work, struct async_cow, work);
1101 
1102 	root = async_cow->root;
1103 	nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
1104 		PAGE_CACHE_SHIFT;
1105 
1106 	/*
1107 	 * atomic_sub_return implies a barrier for waitqueue_active
1108 	 */
1109 	if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
1110 	    5 * 1024 * 1024 &&
1111 	    waitqueue_active(&root->fs_info->async_submit_wait))
1112 		wake_up(&root->fs_info->async_submit_wait);
1113 
1114 	if (async_cow->inode)
1115 		submit_compressed_extents(async_cow->inode, async_cow);
1116 }
1117 
async_cow_free(struct btrfs_work * work)1118 static noinline void async_cow_free(struct btrfs_work *work)
1119 {
1120 	struct async_cow *async_cow;
1121 	async_cow = container_of(work, struct async_cow, work);
1122 	if (async_cow->inode)
1123 		btrfs_add_delayed_iput(async_cow->inode);
1124 	kfree(async_cow);
1125 }
1126 
cow_file_range_async(struct inode * inode,struct page * locked_page,u64 start,u64 end,int * page_started,unsigned long * nr_written)1127 static int cow_file_range_async(struct inode *inode, struct page *locked_page,
1128 				u64 start, u64 end, int *page_started,
1129 				unsigned long *nr_written)
1130 {
1131 	struct async_cow *async_cow;
1132 	struct btrfs_root *root = BTRFS_I(inode)->root;
1133 	unsigned long nr_pages;
1134 	u64 cur_end;
1135 	int limit = 10 * 1024 * 1024;
1136 
1137 	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
1138 			 1, 0, NULL, GFP_NOFS);
1139 	while (start < end) {
1140 		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
1141 		BUG_ON(!async_cow); /* -ENOMEM */
1142 		async_cow->inode = igrab(inode);
1143 		async_cow->root = root;
1144 		async_cow->locked_page = locked_page;
1145 		async_cow->start = start;
1146 
1147 		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS &&
1148 		    !btrfs_test_opt(root, FORCE_COMPRESS))
1149 			cur_end = end;
1150 		else
1151 			cur_end = min(end, start + 512 * 1024 - 1);
1152 
1153 		async_cow->end = cur_end;
1154 		INIT_LIST_HEAD(&async_cow->extents);
1155 
1156 		btrfs_init_work(&async_cow->work,
1157 				btrfs_delalloc_helper,
1158 				async_cow_start, async_cow_submit,
1159 				async_cow_free);
1160 
1161 		nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
1162 			PAGE_CACHE_SHIFT;
1163 		atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
1164 
1165 		btrfs_queue_work(root->fs_info->delalloc_workers,
1166 				 &async_cow->work);
1167 
1168 		if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
1169 			wait_event(root->fs_info->async_submit_wait,
1170 			   (atomic_read(&root->fs_info->async_delalloc_pages) <
1171 			    limit));
1172 		}
1173 
1174 		while (atomic_read(&root->fs_info->async_submit_draining) &&
1175 		      atomic_read(&root->fs_info->async_delalloc_pages)) {
1176 			wait_event(root->fs_info->async_submit_wait,
1177 			  (atomic_read(&root->fs_info->async_delalloc_pages) ==
1178 			   0));
1179 		}
1180 
1181 		*nr_written += nr_pages;
1182 		start = cur_end + 1;
1183 	}
1184 	*page_started = 1;
1185 	return 0;
1186 }
1187 
csum_exist_in_range(struct btrfs_root * root,u64 bytenr,u64 num_bytes)1188 static noinline int csum_exist_in_range(struct btrfs_root *root,
1189 					u64 bytenr, u64 num_bytes)
1190 {
1191 	int ret;
1192 	struct btrfs_ordered_sum *sums;
1193 	LIST_HEAD(list);
1194 
1195 	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
1196 				       bytenr + num_bytes - 1, &list, 0);
1197 	if (ret == 0 && list_empty(&list))
1198 		return 0;
1199 
1200 	while (!list_empty(&list)) {
1201 		sums = list_entry(list.next, struct btrfs_ordered_sum, list);
1202 		list_del(&sums->list);
1203 		kfree(sums);
1204 	}
1205 	return 1;
1206 }
1207 
1208 /*
1209  * when nowcow writeback call back.  This checks for snapshots or COW copies
1210  * of the extents that exist in the file, and COWs the file as required.
1211  *
1212  * If no cow copies or snapshots exist, we write directly to the existing
1213  * blocks on disk
1214  */
run_delalloc_nocow(struct inode * inode,struct page * locked_page,u64 start,u64 end,int * page_started,int force,unsigned long * nr_written)1215 static noinline int run_delalloc_nocow(struct inode *inode,
1216 				       struct page *locked_page,
1217 			      u64 start, u64 end, int *page_started, int force,
1218 			      unsigned long *nr_written)
1219 {
1220 	struct btrfs_root *root = BTRFS_I(inode)->root;
1221 	struct btrfs_trans_handle *trans;
1222 	struct extent_buffer *leaf;
1223 	struct btrfs_path *path;
1224 	struct btrfs_file_extent_item *fi;
1225 	struct btrfs_key found_key;
1226 	u64 cow_start;
1227 	u64 cur_offset;
1228 	u64 extent_end;
1229 	u64 extent_offset;
1230 	u64 disk_bytenr;
1231 	u64 num_bytes;
1232 	u64 disk_num_bytes;
1233 	u64 ram_bytes;
1234 	int extent_type;
1235 	int ret, err;
1236 	int type;
1237 	int nocow;
1238 	int check_prev = 1;
1239 	bool nolock;
1240 	u64 ino = btrfs_ino(inode);
1241 
1242 	path = btrfs_alloc_path();
1243 	if (!path) {
1244 		extent_clear_unlock_delalloc(inode, start, end, locked_page,
1245 					     EXTENT_LOCKED | EXTENT_DELALLOC |
1246 					     EXTENT_DO_ACCOUNTING |
1247 					     EXTENT_DEFRAG, PAGE_UNLOCK |
1248 					     PAGE_CLEAR_DIRTY |
1249 					     PAGE_SET_WRITEBACK |
1250 					     PAGE_END_WRITEBACK);
1251 		return -ENOMEM;
1252 	}
1253 
1254 	nolock = btrfs_is_free_space_inode(inode);
1255 
1256 	if (nolock)
1257 		trans = btrfs_join_transaction_nolock(root);
1258 	else
1259 		trans = btrfs_join_transaction(root);
1260 
1261 	if (IS_ERR(trans)) {
1262 		extent_clear_unlock_delalloc(inode, start, end, locked_page,
1263 					     EXTENT_LOCKED | EXTENT_DELALLOC |
1264 					     EXTENT_DO_ACCOUNTING |
1265 					     EXTENT_DEFRAG, PAGE_UNLOCK |
1266 					     PAGE_CLEAR_DIRTY |
1267 					     PAGE_SET_WRITEBACK |
1268 					     PAGE_END_WRITEBACK);
1269 		btrfs_free_path(path);
1270 		return PTR_ERR(trans);
1271 	}
1272 
1273 	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1274 
1275 	cow_start = (u64)-1;
1276 	cur_offset = start;
1277 	while (1) {
1278 		ret = btrfs_lookup_file_extent(trans, root, path, ino,
1279 					       cur_offset, 0);
1280 		if (ret < 0)
1281 			goto error;
1282 		if (ret > 0 && path->slots[0] > 0 && check_prev) {
1283 			leaf = path->nodes[0];
1284 			btrfs_item_key_to_cpu(leaf, &found_key,
1285 					      path->slots[0] - 1);
1286 			if (found_key.objectid == ino &&
1287 			    found_key.type == BTRFS_EXTENT_DATA_KEY)
1288 				path->slots[0]--;
1289 		}
1290 		check_prev = 0;
1291 next_slot:
1292 		leaf = path->nodes[0];
1293 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1294 			ret = btrfs_next_leaf(root, path);
1295 			if (ret < 0)
1296 				goto error;
1297 			if (ret > 0)
1298 				break;
1299 			leaf = path->nodes[0];
1300 		}
1301 
1302 		nocow = 0;
1303 		disk_bytenr = 0;
1304 		num_bytes = 0;
1305 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1306 
1307 		if (found_key.objectid > ino)
1308 			break;
1309 		if (WARN_ON_ONCE(found_key.objectid < ino) ||
1310 		    found_key.type < BTRFS_EXTENT_DATA_KEY) {
1311 			path->slots[0]++;
1312 			goto next_slot;
1313 		}
1314 		if (found_key.type > BTRFS_EXTENT_DATA_KEY ||
1315 		    found_key.offset > end)
1316 			break;
1317 
1318 		if (found_key.offset > cur_offset) {
1319 			extent_end = found_key.offset;
1320 			extent_type = 0;
1321 			goto out_check;
1322 		}
1323 
1324 		fi = btrfs_item_ptr(leaf, path->slots[0],
1325 				    struct btrfs_file_extent_item);
1326 		extent_type = btrfs_file_extent_type(leaf, fi);
1327 
1328 		ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1329 		if (extent_type == BTRFS_FILE_EXTENT_REG ||
1330 		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1331 			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1332 			extent_offset = btrfs_file_extent_offset(leaf, fi);
1333 			extent_end = found_key.offset +
1334 				btrfs_file_extent_num_bytes(leaf, fi);
1335 			disk_num_bytes =
1336 				btrfs_file_extent_disk_num_bytes(leaf, fi);
1337 			if (extent_end <= start) {
1338 				path->slots[0]++;
1339 				goto next_slot;
1340 			}
1341 			if (disk_bytenr == 0)
1342 				goto out_check;
1343 			if (btrfs_file_extent_compression(leaf, fi) ||
1344 			    btrfs_file_extent_encryption(leaf, fi) ||
1345 			    btrfs_file_extent_other_encoding(leaf, fi))
1346 				goto out_check;
1347 			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
1348 				goto out_check;
1349 			if (btrfs_extent_readonly(root, disk_bytenr))
1350 				goto out_check;
1351 			if (btrfs_cross_ref_exist(trans, root, ino,
1352 						  found_key.offset -
1353 						  extent_offset, disk_bytenr))
1354 				goto out_check;
1355 			disk_bytenr += extent_offset;
1356 			disk_bytenr += cur_offset - found_key.offset;
1357 			num_bytes = min(end + 1, extent_end) - cur_offset;
1358 			/*
1359 			 * if there are pending snapshots for this root,
1360 			 * we fall into common COW way.
1361 			 */
1362 			if (!nolock) {
1363 				err = btrfs_start_write_no_snapshoting(root);
1364 				if (!err)
1365 					goto out_check;
1366 			}
1367 			/*
1368 			 * force cow if csum exists in the range.
1369 			 * this ensure that csum for a given extent are
1370 			 * either valid or do not exist.
1371 			 */
1372 			if (csum_exist_in_range(root, disk_bytenr, num_bytes))
1373 				goto out_check;
1374 			nocow = 1;
1375 		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1376 			extent_end = found_key.offset +
1377 				btrfs_file_extent_inline_len(leaf,
1378 						     path->slots[0], fi);
1379 			extent_end = ALIGN(extent_end, root->sectorsize);
1380 		} else {
1381 			BUG_ON(1);
1382 		}
1383 out_check:
1384 		if (extent_end <= start) {
1385 			path->slots[0]++;
1386 			if (!nolock && nocow)
1387 				btrfs_end_write_no_snapshoting(root);
1388 			goto next_slot;
1389 		}
1390 		if (!nocow) {
1391 			if (cow_start == (u64)-1)
1392 				cow_start = cur_offset;
1393 			cur_offset = extent_end;
1394 			if (cur_offset > end)
1395 				break;
1396 			path->slots[0]++;
1397 			goto next_slot;
1398 		}
1399 
1400 		btrfs_release_path(path);
1401 		if (cow_start != (u64)-1) {
1402 			ret = cow_file_range(inode, locked_page,
1403 					     cow_start, found_key.offset - 1,
1404 					     page_started, nr_written, 1);
1405 			if (ret) {
1406 				if (!nolock && nocow)
1407 					btrfs_end_write_no_snapshoting(root);
1408 				goto error;
1409 			}
1410 			cow_start = (u64)-1;
1411 		}
1412 
1413 		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1414 			struct extent_map *em;
1415 			struct extent_map_tree *em_tree;
1416 			em_tree = &BTRFS_I(inode)->extent_tree;
1417 			em = alloc_extent_map();
1418 			BUG_ON(!em); /* -ENOMEM */
1419 			em->start = cur_offset;
1420 			em->orig_start = found_key.offset - extent_offset;
1421 			em->len = num_bytes;
1422 			em->block_len = num_bytes;
1423 			em->block_start = disk_bytenr;
1424 			em->orig_block_len = disk_num_bytes;
1425 			em->ram_bytes = ram_bytes;
1426 			em->bdev = root->fs_info->fs_devices->latest_bdev;
1427 			em->mod_start = em->start;
1428 			em->mod_len = em->len;
1429 			set_bit(EXTENT_FLAG_PINNED, &em->flags);
1430 			set_bit(EXTENT_FLAG_FILLING, &em->flags);
1431 			em->generation = -1;
1432 			while (1) {
1433 				write_lock(&em_tree->lock);
1434 				ret = add_extent_mapping(em_tree, em, 1);
1435 				write_unlock(&em_tree->lock);
1436 				if (ret != -EEXIST) {
1437 					free_extent_map(em);
1438 					break;
1439 				}
1440 				btrfs_drop_extent_cache(inode, em->start,
1441 						em->start + em->len - 1, 0);
1442 			}
1443 			type = BTRFS_ORDERED_PREALLOC;
1444 		} else {
1445 			type = BTRFS_ORDERED_NOCOW;
1446 		}
1447 
1448 		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1449 					       num_bytes, num_bytes, type);
1450 		BUG_ON(ret); /* -ENOMEM */
1451 
1452 		if (root->root_key.objectid ==
1453 		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
1454 			ret = btrfs_reloc_clone_csums(inode, cur_offset,
1455 						      num_bytes);
1456 			if (ret) {
1457 				if (!nolock && nocow)
1458 					btrfs_end_write_no_snapshoting(root);
1459 				goto error;
1460 			}
1461 		}
1462 
1463 		extent_clear_unlock_delalloc(inode, cur_offset,
1464 					     cur_offset + num_bytes - 1,
1465 					     locked_page, EXTENT_LOCKED |
1466 					     EXTENT_DELALLOC, PAGE_UNLOCK |
1467 					     PAGE_SET_PRIVATE2);
1468 		if (!nolock && nocow)
1469 			btrfs_end_write_no_snapshoting(root);
1470 		cur_offset = extent_end;
1471 		if (cur_offset > end)
1472 			break;
1473 	}
1474 	btrfs_release_path(path);
1475 
1476 	if (cur_offset <= end && cow_start == (u64)-1) {
1477 		cow_start = cur_offset;
1478 		cur_offset = end;
1479 	}
1480 
1481 	if (cow_start != (u64)-1) {
1482 		ret = cow_file_range(inode, locked_page, cow_start, end,
1483 				     page_started, nr_written, 1);
1484 		if (ret)
1485 			goto error;
1486 	}
1487 
1488 error:
1489 	err = btrfs_end_transaction(trans, root);
1490 	if (!ret)
1491 		ret = err;
1492 
1493 	if (ret && cur_offset < end)
1494 		extent_clear_unlock_delalloc(inode, cur_offset, end,
1495 					     locked_page, EXTENT_LOCKED |
1496 					     EXTENT_DELALLOC | EXTENT_DEFRAG |
1497 					     EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
1498 					     PAGE_CLEAR_DIRTY |
1499 					     PAGE_SET_WRITEBACK |
1500 					     PAGE_END_WRITEBACK);
1501 	btrfs_free_path(path);
1502 	return ret;
1503 }
1504 
need_force_cow(struct inode * inode,u64 start,u64 end)1505 static inline int need_force_cow(struct inode *inode, u64 start, u64 end)
1506 {
1507 
1508 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
1509 	    !(BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC))
1510 		return 0;
1511 
1512 	/*
1513 	 * @defrag_bytes is a hint value, no spinlock held here,
1514 	 * if is not zero, it means the file is defragging.
1515 	 * Force cow if given extent needs to be defragged.
1516 	 */
1517 	if (BTRFS_I(inode)->defrag_bytes &&
1518 	    test_range_bit(&BTRFS_I(inode)->io_tree, start, end,
1519 			   EXTENT_DEFRAG, 0, NULL))
1520 		return 1;
1521 
1522 	return 0;
1523 }
1524 
1525 /*
1526  * extent_io.c call back to do delayed allocation processing
1527  */
run_delalloc_range(struct inode * inode,struct page * locked_page,u64 start,u64 end,int * page_started,unsigned long * nr_written)1528 static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1529 			      u64 start, u64 end, int *page_started,
1530 			      unsigned long *nr_written)
1531 {
1532 	int ret;
1533 	int force_cow = need_force_cow(inode, start, end);
1534 
1535 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW && !force_cow) {
1536 		ret = run_delalloc_nocow(inode, locked_page, start, end,
1537 					 page_started, 1, nr_written);
1538 	} else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC && !force_cow) {
1539 		ret = run_delalloc_nocow(inode, locked_page, start, end,
1540 					 page_started, 0, nr_written);
1541 	} else if (!inode_need_compress(inode)) {
1542 		ret = cow_file_range(inode, locked_page, start, end,
1543 				      page_started, nr_written, 1);
1544 	} else {
1545 		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
1546 			&BTRFS_I(inode)->runtime_flags);
1547 		ret = cow_file_range_async(inode, locked_page, start, end,
1548 					   page_started, nr_written);
1549 	}
1550 	return ret;
1551 }
1552 
btrfs_split_extent_hook(struct inode * inode,struct extent_state * orig,u64 split)1553 static void btrfs_split_extent_hook(struct inode *inode,
1554 				    struct extent_state *orig, u64 split)
1555 {
1556 	u64 size;
1557 
1558 	/* not delalloc, ignore it */
1559 	if (!(orig->state & EXTENT_DELALLOC))
1560 		return;
1561 
1562 	size = orig->end - orig->start + 1;
1563 	if (size > BTRFS_MAX_EXTENT_SIZE) {
1564 		u64 num_extents;
1565 		u64 new_size;
1566 
1567 		/*
1568 		 * See the explanation in btrfs_merge_extent_hook, the same
1569 		 * applies here, just in reverse.
1570 		 */
1571 		new_size = orig->end - split + 1;
1572 		num_extents = div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
1573 					BTRFS_MAX_EXTENT_SIZE);
1574 		new_size = split - orig->start;
1575 		num_extents += div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
1576 					BTRFS_MAX_EXTENT_SIZE);
1577 		if (div64_u64(size + BTRFS_MAX_EXTENT_SIZE - 1,
1578 			      BTRFS_MAX_EXTENT_SIZE) >= num_extents)
1579 			return;
1580 	}
1581 
1582 	spin_lock(&BTRFS_I(inode)->lock);
1583 	BTRFS_I(inode)->outstanding_extents++;
1584 	spin_unlock(&BTRFS_I(inode)->lock);
1585 }
1586 
1587 /*
1588  * extent_io.c merge_extent_hook, used to track merged delayed allocation
1589  * extents so we can keep track of new extents that are just merged onto old
1590  * extents, such as when we are doing sequential writes, so we can properly
1591  * account for the metadata space we'll need.
1592  */
btrfs_merge_extent_hook(struct inode * inode,struct extent_state * new,struct extent_state * other)1593 static void btrfs_merge_extent_hook(struct inode *inode,
1594 				    struct extent_state *new,
1595 				    struct extent_state *other)
1596 {
1597 	u64 new_size, old_size;
1598 	u64 num_extents;
1599 
1600 	/* not delalloc, ignore it */
1601 	if (!(other->state & EXTENT_DELALLOC))
1602 		return;
1603 
1604 	if (new->start > other->start)
1605 		new_size = new->end - other->start + 1;
1606 	else
1607 		new_size = other->end - new->start + 1;
1608 
1609 	/* we're not bigger than the max, unreserve the space and go */
1610 	if (new_size <= BTRFS_MAX_EXTENT_SIZE) {
1611 		spin_lock(&BTRFS_I(inode)->lock);
1612 		BTRFS_I(inode)->outstanding_extents--;
1613 		spin_unlock(&BTRFS_I(inode)->lock);
1614 		return;
1615 	}
1616 
1617 	/*
1618 	 * We have to add up either side to figure out how many extents were
1619 	 * accounted for before we merged into one big extent.  If the number of
1620 	 * extents we accounted for is <= the amount we need for the new range
1621 	 * then we can return, otherwise drop.  Think of it like this
1622 	 *
1623 	 * [ 4k][MAX_SIZE]
1624 	 *
1625 	 * So we've grown the extent by a MAX_SIZE extent, this would mean we
1626 	 * need 2 outstanding extents, on one side we have 1 and the other side
1627 	 * we have 1 so they are == and we can return.  But in this case
1628 	 *
1629 	 * [MAX_SIZE+4k][MAX_SIZE+4k]
1630 	 *
1631 	 * Each range on their own accounts for 2 extents, but merged together
1632 	 * they are only 3 extents worth of accounting, so we need to drop in
1633 	 * this case.
1634 	 */
1635 	old_size = other->end - other->start + 1;
1636 	num_extents = div64_u64(old_size + BTRFS_MAX_EXTENT_SIZE - 1,
1637 				BTRFS_MAX_EXTENT_SIZE);
1638 	old_size = new->end - new->start + 1;
1639 	num_extents += div64_u64(old_size + BTRFS_MAX_EXTENT_SIZE - 1,
1640 				 BTRFS_MAX_EXTENT_SIZE);
1641 
1642 	if (div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
1643 		      BTRFS_MAX_EXTENT_SIZE) >= num_extents)
1644 		return;
1645 
1646 	spin_lock(&BTRFS_I(inode)->lock);
1647 	BTRFS_I(inode)->outstanding_extents--;
1648 	spin_unlock(&BTRFS_I(inode)->lock);
1649 }
1650 
btrfs_add_delalloc_inodes(struct btrfs_root * root,struct inode * inode)1651 static void btrfs_add_delalloc_inodes(struct btrfs_root *root,
1652 				      struct inode *inode)
1653 {
1654 	spin_lock(&root->delalloc_lock);
1655 	if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1656 		list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
1657 			      &root->delalloc_inodes);
1658 		set_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1659 			&BTRFS_I(inode)->runtime_flags);
1660 		root->nr_delalloc_inodes++;
1661 		if (root->nr_delalloc_inodes == 1) {
1662 			spin_lock(&root->fs_info->delalloc_root_lock);
1663 			BUG_ON(!list_empty(&root->delalloc_root));
1664 			list_add_tail(&root->delalloc_root,
1665 				      &root->fs_info->delalloc_roots);
1666 			spin_unlock(&root->fs_info->delalloc_root_lock);
1667 		}
1668 	}
1669 	spin_unlock(&root->delalloc_lock);
1670 }
1671 
btrfs_del_delalloc_inode(struct btrfs_root * root,struct inode * inode)1672 static void btrfs_del_delalloc_inode(struct btrfs_root *root,
1673 				     struct inode *inode)
1674 {
1675 	spin_lock(&root->delalloc_lock);
1676 	if (!list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1677 		list_del_init(&BTRFS_I(inode)->delalloc_inodes);
1678 		clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1679 			  &BTRFS_I(inode)->runtime_flags);
1680 		root->nr_delalloc_inodes--;
1681 		if (!root->nr_delalloc_inodes) {
1682 			spin_lock(&root->fs_info->delalloc_root_lock);
1683 			BUG_ON(list_empty(&root->delalloc_root));
1684 			list_del_init(&root->delalloc_root);
1685 			spin_unlock(&root->fs_info->delalloc_root_lock);
1686 		}
1687 	}
1688 	spin_unlock(&root->delalloc_lock);
1689 }
1690 
1691 /*
1692  * extent_io.c set_bit_hook, used to track delayed allocation
1693  * bytes in this file, and to maintain the list of inodes that
1694  * have pending delalloc work to be done.
1695  */
btrfs_set_bit_hook(struct inode * inode,struct extent_state * state,unsigned * bits)1696 static void btrfs_set_bit_hook(struct inode *inode,
1697 			       struct extent_state *state, unsigned *bits)
1698 {
1699 
1700 	if ((*bits & EXTENT_DEFRAG) && !(*bits & EXTENT_DELALLOC))
1701 		WARN_ON(1);
1702 	/*
1703 	 * set_bit and clear bit hooks normally require _irqsave/restore
1704 	 * but in this case, we are only testing for the DELALLOC
1705 	 * bit, which is only set or cleared with irqs on
1706 	 */
1707 	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1708 		struct btrfs_root *root = BTRFS_I(inode)->root;
1709 		u64 len = state->end + 1 - state->start;
1710 		bool do_list = !btrfs_is_free_space_inode(inode);
1711 
1712 		if (*bits & EXTENT_FIRST_DELALLOC) {
1713 			*bits &= ~EXTENT_FIRST_DELALLOC;
1714 		} else {
1715 			spin_lock(&BTRFS_I(inode)->lock);
1716 			BTRFS_I(inode)->outstanding_extents++;
1717 			spin_unlock(&BTRFS_I(inode)->lock);
1718 		}
1719 
1720 		/* For sanity tests */
1721 		if (btrfs_test_is_dummy_root(root))
1722 			return;
1723 
1724 		__percpu_counter_add(&root->fs_info->delalloc_bytes, len,
1725 				     root->fs_info->delalloc_batch);
1726 		spin_lock(&BTRFS_I(inode)->lock);
1727 		BTRFS_I(inode)->delalloc_bytes += len;
1728 		if (*bits & EXTENT_DEFRAG)
1729 			BTRFS_I(inode)->defrag_bytes += len;
1730 		if (do_list && !test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1731 					 &BTRFS_I(inode)->runtime_flags))
1732 			btrfs_add_delalloc_inodes(root, inode);
1733 		spin_unlock(&BTRFS_I(inode)->lock);
1734 	}
1735 }
1736 
1737 /*
1738  * extent_io.c clear_bit_hook, see set_bit_hook for why
1739  */
btrfs_clear_bit_hook(struct inode * inode,struct extent_state * state,unsigned * bits)1740 static void btrfs_clear_bit_hook(struct inode *inode,
1741 				 struct extent_state *state,
1742 				 unsigned *bits)
1743 {
1744 	u64 len = state->end + 1 - state->start;
1745 	u64 num_extents = div64_u64(len + BTRFS_MAX_EXTENT_SIZE -1,
1746 				    BTRFS_MAX_EXTENT_SIZE);
1747 
1748 	spin_lock(&BTRFS_I(inode)->lock);
1749 	if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG))
1750 		BTRFS_I(inode)->defrag_bytes -= len;
1751 	spin_unlock(&BTRFS_I(inode)->lock);
1752 
1753 	/*
1754 	 * set_bit and clear bit hooks normally require _irqsave/restore
1755 	 * but in this case, we are only testing for the DELALLOC
1756 	 * bit, which is only set or cleared with irqs on
1757 	 */
1758 	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1759 		struct btrfs_root *root = BTRFS_I(inode)->root;
1760 		bool do_list = !btrfs_is_free_space_inode(inode);
1761 
1762 		if (*bits & EXTENT_FIRST_DELALLOC) {
1763 			*bits &= ~EXTENT_FIRST_DELALLOC;
1764 		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
1765 			spin_lock(&BTRFS_I(inode)->lock);
1766 			BTRFS_I(inode)->outstanding_extents -= num_extents;
1767 			spin_unlock(&BTRFS_I(inode)->lock);
1768 		}
1769 
1770 		/*
1771 		 * We don't reserve metadata space for space cache inodes so we
1772 		 * don't need to call dellalloc_release_metadata if there is an
1773 		 * error.
1774 		 */
1775 		if (*bits & EXTENT_DO_ACCOUNTING &&
1776 		    root != root->fs_info->tree_root)
1777 			btrfs_delalloc_release_metadata(inode, len);
1778 
1779 		/* For sanity tests. */
1780 		if (btrfs_test_is_dummy_root(root))
1781 			return;
1782 
1783 		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
1784 		    && do_list && !(state->state & EXTENT_NORESERVE))
1785 			btrfs_free_reserved_data_space_noquota(inode,
1786 					state->start, len);
1787 
1788 		__percpu_counter_add(&root->fs_info->delalloc_bytes, -len,
1789 				     root->fs_info->delalloc_batch);
1790 		spin_lock(&BTRFS_I(inode)->lock);
1791 		BTRFS_I(inode)->delalloc_bytes -= len;
1792 		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1793 		    test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1794 			     &BTRFS_I(inode)->runtime_flags))
1795 			btrfs_del_delalloc_inode(root, inode);
1796 		spin_unlock(&BTRFS_I(inode)->lock);
1797 	}
1798 }
1799 
1800 /*
1801  * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
1802  * we don't create bios that span stripes or chunks
1803  */
btrfs_merge_bio_hook(int rw,struct page * page,unsigned long offset,size_t size,struct bio * bio,unsigned long bio_flags)1804 int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
1805 			 size_t size, struct bio *bio,
1806 			 unsigned long bio_flags)
1807 {
1808 	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1809 	u64 logical = (u64)bio->bi_iter.bi_sector << 9;
1810 	u64 length = 0;
1811 	u64 map_length;
1812 	int ret;
1813 
1814 	if (bio_flags & EXTENT_BIO_COMPRESSED)
1815 		return 0;
1816 
1817 	length = bio->bi_iter.bi_size;
1818 	map_length = length;
1819 	ret = btrfs_map_block(root->fs_info, rw, logical,
1820 			      &map_length, NULL, 0);
1821 	/* Will always return 0 with map_multi == NULL */
1822 	BUG_ON(ret < 0);
1823 	if (map_length < length + size)
1824 		return 1;
1825 	return 0;
1826 }
1827 
1828 /*
1829  * in order to insert checksums into the metadata in large chunks,
1830  * we wait until bio submission time.   All the pages in the bio are
1831  * checksummed and sums are attached onto the ordered extent record.
1832  *
1833  * At IO completion time the cums attached on the ordered extent record
1834  * are inserted into the btree
1835  */
__btrfs_submit_bio_start(struct inode * inode,int rw,struct bio * bio,int mirror_num,unsigned long bio_flags,u64 bio_offset)1836 static int __btrfs_submit_bio_start(struct inode *inode, int rw,
1837 				    struct bio *bio, int mirror_num,
1838 				    unsigned long bio_flags,
1839 				    u64 bio_offset)
1840 {
1841 	struct btrfs_root *root = BTRFS_I(inode)->root;
1842 	int ret = 0;
1843 
1844 	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1845 	BUG_ON(ret); /* -ENOMEM */
1846 	return 0;
1847 }
1848 
1849 /*
1850  * in order to insert checksums into the metadata in large chunks,
1851  * we wait until bio submission time.   All the pages in the bio are
1852  * checksummed and sums are attached onto the ordered extent record.
1853  *
1854  * At IO completion time the cums attached on the ordered extent record
1855  * are inserted into the btree
1856  */
__btrfs_submit_bio_done(struct inode * inode,int rw,struct bio * bio,int mirror_num,unsigned long bio_flags,u64 bio_offset)1857 static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1858 			  int mirror_num, unsigned long bio_flags,
1859 			  u64 bio_offset)
1860 {
1861 	struct btrfs_root *root = BTRFS_I(inode)->root;
1862 	int ret;
1863 
1864 	ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
1865 	if (ret) {
1866 		bio->bi_error = ret;
1867 		bio_endio(bio);
1868 	}
1869 	return ret;
1870 }
1871 
1872 /*
1873  * extent_io.c submission hook. This does the right thing for csum calculation
1874  * on write, or reading the csums from the tree before a read
1875  */
btrfs_submit_bio_hook(struct inode * inode,int rw,struct bio * bio,int mirror_num,unsigned long bio_flags,u64 bio_offset)1876 static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1877 			  int mirror_num, unsigned long bio_flags,
1878 			  u64 bio_offset)
1879 {
1880 	struct btrfs_root *root = BTRFS_I(inode)->root;
1881 	enum btrfs_wq_endio_type metadata = BTRFS_WQ_ENDIO_DATA;
1882 	int ret = 0;
1883 	int skip_sum;
1884 	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1885 
1886 	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1887 
1888 	if (btrfs_is_free_space_inode(inode))
1889 		metadata = BTRFS_WQ_ENDIO_FREE_SPACE;
1890 
1891 	if (!(rw & REQ_WRITE)) {
1892 		ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
1893 		if (ret)
1894 			goto out;
1895 
1896 		if (bio_flags & EXTENT_BIO_COMPRESSED) {
1897 			ret = btrfs_submit_compressed_read(inode, bio,
1898 							   mirror_num,
1899 							   bio_flags);
1900 			goto out;
1901 		} else if (!skip_sum) {
1902 			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
1903 			if (ret)
1904 				goto out;
1905 		}
1906 		goto mapit;
1907 	} else if (async && !skip_sum) {
1908 		/* csum items have already been cloned */
1909 		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
1910 			goto mapit;
1911 		/* we're doing a write, do the async checksumming */
1912 		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1913 				   inode, rw, bio, mirror_num,
1914 				   bio_flags, bio_offset,
1915 				   __btrfs_submit_bio_start,
1916 				   __btrfs_submit_bio_done);
1917 		goto out;
1918 	} else if (!skip_sum) {
1919 		ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1920 		if (ret)
1921 			goto out;
1922 	}
1923 
1924 mapit:
1925 	ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
1926 
1927 out:
1928 	if (ret < 0) {
1929 		bio->bi_error = ret;
1930 		bio_endio(bio);
1931 	}
1932 	return ret;
1933 }
1934 
1935 /*
1936  * given a list of ordered sums record them in the inode.  This happens
1937  * at IO completion time based on sums calculated at bio submission time.
1938  */
add_pending_csums(struct btrfs_trans_handle * trans,struct inode * inode,u64 file_offset,struct list_head * list)1939 static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1940 			     struct inode *inode, u64 file_offset,
1941 			     struct list_head *list)
1942 {
1943 	struct btrfs_ordered_sum *sum;
1944 
1945 	list_for_each_entry(sum, list, list) {
1946 		trans->adding_csums = 1;
1947 		btrfs_csum_file_blocks(trans,
1948 		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
1949 		trans->adding_csums = 0;
1950 	}
1951 	return 0;
1952 }
1953 
btrfs_set_extent_delalloc(struct inode * inode,u64 start,u64 end,struct extent_state ** cached_state)1954 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
1955 			      struct extent_state **cached_state)
1956 {
1957 	WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1958 	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1959 				   cached_state, GFP_NOFS);
1960 }
1961 
1962 /* see btrfs_writepage_start_hook for details on why this is required */
1963 struct btrfs_writepage_fixup {
1964 	struct page *page;
1965 	struct btrfs_work work;
1966 };
1967 
btrfs_writepage_fixup_worker(struct btrfs_work * work)1968 static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1969 {
1970 	struct btrfs_writepage_fixup *fixup;
1971 	struct btrfs_ordered_extent *ordered;
1972 	struct extent_state *cached_state = NULL;
1973 	struct page *page;
1974 	struct inode *inode;
1975 	u64 page_start;
1976 	u64 page_end;
1977 	int ret;
1978 
1979 	fixup = container_of(work, struct btrfs_writepage_fixup, work);
1980 	page = fixup->page;
1981 again:
1982 	lock_page(page);
1983 	if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
1984 		ClearPageChecked(page);
1985 		goto out_page;
1986 	}
1987 
1988 	inode = page->mapping->host;
1989 	page_start = page_offset(page);
1990 	page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;
1991 
1992 	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1993 			 &cached_state);
1994 
1995 	/* already ordered? We're done */
1996 	if (PagePrivate2(page))
1997 		goto out;
1998 
1999 	ordered = btrfs_lookup_ordered_extent(inode, page_start);
2000 	if (ordered) {
2001 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
2002 				     page_end, &cached_state, GFP_NOFS);
2003 		unlock_page(page);
2004 		btrfs_start_ordered_extent(inode, ordered, 1);
2005 		btrfs_put_ordered_extent(ordered);
2006 		goto again;
2007 	}
2008 
2009 	ret = btrfs_delalloc_reserve_space(inode, page_start,
2010 					   PAGE_CACHE_SIZE);
2011 	if (ret) {
2012 		mapping_set_error(page->mapping, ret);
2013 		end_extent_writepage(page, ret, page_start, page_end);
2014 		ClearPageChecked(page);
2015 		goto out;
2016 	 }
2017 
2018 	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
2019 	ClearPageChecked(page);
2020 	set_page_dirty(page);
2021 out:
2022 	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
2023 			     &cached_state, GFP_NOFS);
2024 out_page:
2025 	unlock_page(page);
2026 	page_cache_release(page);
2027 	kfree(fixup);
2028 }
2029 
2030 /*
2031  * There are a few paths in the higher layers of the kernel that directly
2032  * set the page dirty bit without asking the filesystem if it is a
2033  * good idea.  This causes problems because we want to make sure COW
2034  * properly happens and the data=ordered rules are followed.
2035  *
2036  * In our case any range that doesn't have the ORDERED bit set
2037  * hasn't been properly setup for IO.  We kick off an async process
2038  * to fix it up.  The async helper will wait for ordered extents, set
2039  * the delalloc bit and make it safe to write the page.
2040  */
btrfs_writepage_start_hook(struct page * page,u64 start,u64 end)2041 static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
2042 {
2043 	struct inode *inode = page->mapping->host;
2044 	struct btrfs_writepage_fixup *fixup;
2045 	struct btrfs_root *root = BTRFS_I(inode)->root;
2046 
2047 	/* this page is properly in the ordered list */
2048 	if (TestClearPagePrivate2(page))
2049 		return 0;
2050 
2051 	if (PageChecked(page))
2052 		return -EAGAIN;
2053 
2054 	fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
2055 	if (!fixup)
2056 		return -EAGAIN;
2057 
2058 	SetPageChecked(page);
2059 	page_cache_get(page);
2060 	btrfs_init_work(&fixup->work, btrfs_fixup_helper,
2061 			btrfs_writepage_fixup_worker, NULL, NULL);
2062 	fixup->page = page;
2063 	btrfs_queue_work(root->fs_info->fixup_workers, &fixup->work);
2064 	return -EBUSY;
2065 }
2066 
insert_reserved_file_extent(struct btrfs_trans_handle * trans,struct inode * inode,u64 file_pos,u64 disk_bytenr,u64 disk_num_bytes,u64 num_bytes,u64 ram_bytes,u8 compression,u8 encryption,u16 other_encoding,int extent_type)2067 static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
2068 				       struct inode *inode, u64 file_pos,
2069 				       u64 disk_bytenr, u64 disk_num_bytes,
2070 				       u64 num_bytes, u64 ram_bytes,
2071 				       u8 compression, u8 encryption,
2072 				       u16 other_encoding, int extent_type)
2073 {
2074 	struct btrfs_root *root = BTRFS_I(inode)->root;
2075 	struct btrfs_file_extent_item *fi;
2076 	struct btrfs_path *path;
2077 	struct extent_buffer *leaf;
2078 	struct btrfs_key ins;
2079 	int extent_inserted = 0;
2080 	int ret;
2081 
2082 	path = btrfs_alloc_path();
2083 	if (!path)
2084 		return -ENOMEM;
2085 
2086 	/*
2087 	 * we may be replacing one extent in the tree with another.
2088 	 * The new extent is pinned in the extent map, and we don't want
2089 	 * to drop it from the cache until it is completely in the btree.
2090 	 *
2091 	 * So, tell btrfs_drop_extents to leave this extent in the cache.
2092 	 * the caller is expected to unpin it and allow it to be merged
2093 	 * with the others.
2094 	 */
2095 	ret = __btrfs_drop_extents(trans, root, inode, path, file_pos,
2096 				   file_pos + num_bytes, NULL, 0,
2097 				   1, sizeof(*fi), &extent_inserted);
2098 	if (ret)
2099 		goto out;
2100 
2101 	if (!extent_inserted) {
2102 		ins.objectid = btrfs_ino(inode);
2103 		ins.offset = file_pos;
2104 		ins.type = BTRFS_EXTENT_DATA_KEY;
2105 
2106 		path->leave_spinning = 1;
2107 		ret = btrfs_insert_empty_item(trans, root, path, &ins,
2108 					      sizeof(*fi));
2109 		if (ret)
2110 			goto out;
2111 	}
2112 	leaf = path->nodes[0];
2113 	fi = btrfs_item_ptr(leaf, path->slots[0],
2114 			    struct btrfs_file_extent_item);
2115 	btrfs_set_file_extent_generation(leaf, fi, trans->transid);
2116 	btrfs_set_file_extent_type(leaf, fi, extent_type);
2117 	btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
2118 	btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
2119 	btrfs_set_file_extent_offset(leaf, fi, 0);
2120 	btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2121 	btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
2122 	btrfs_set_file_extent_compression(leaf, fi, compression);
2123 	btrfs_set_file_extent_encryption(leaf, fi, encryption);
2124 	btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
2125 
2126 	btrfs_mark_buffer_dirty(leaf);
2127 	btrfs_release_path(path);
2128 
2129 	inode_add_bytes(inode, num_bytes);
2130 
2131 	ins.objectid = disk_bytenr;
2132 	ins.offset = disk_num_bytes;
2133 	ins.type = BTRFS_EXTENT_ITEM_KEY;
2134 	ret = btrfs_alloc_reserved_file_extent(trans, root,
2135 					root->root_key.objectid,
2136 					btrfs_ino(inode), file_pos,
2137 					ram_bytes, &ins);
2138 	/*
2139 	 * Release the reserved range from inode dirty range map, as it is
2140 	 * already moved into delayed_ref_head
2141 	 */
2142 	btrfs_qgroup_release_data(inode, file_pos, ram_bytes);
2143 out:
2144 	btrfs_free_path(path);
2145 
2146 	return ret;
2147 }
2148 
2149 /* snapshot-aware defrag */
2150 struct sa_defrag_extent_backref {
2151 	struct rb_node node;
2152 	struct old_sa_defrag_extent *old;
2153 	u64 root_id;
2154 	u64 inum;
2155 	u64 file_pos;
2156 	u64 extent_offset;
2157 	u64 num_bytes;
2158 	u64 generation;
2159 };
2160 
2161 struct old_sa_defrag_extent {
2162 	struct list_head list;
2163 	struct new_sa_defrag_extent *new;
2164 
2165 	u64 extent_offset;
2166 	u64 bytenr;
2167 	u64 offset;
2168 	u64 len;
2169 	int count;
2170 };
2171 
2172 struct new_sa_defrag_extent {
2173 	struct rb_root root;
2174 	struct list_head head;
2175 	struct btrfs_path *path;
2176 	struct inode *inode;
2177 	u64 file_pos;
2178 	u64 len;
2179 	u64 bytenr;
2180 	u64 disk_len;
2181 	u8 compress_type;
2182 };
2183 
backref_comp(struct sa_defrag_extent_backref * b1,struct sa_defrag_extent_backref * b2)2184 static int backref_comp(struct sa_defrag_extent_backref *b1,
2185 			struct sa_defrag_extent_backref *b2)
2186 {
2187 	if (b1->root_id < b2->root_id)
2188 		return -1;
2189 	else if (b1->root_id > b2->root_id)
2190 		return 1;
2191 
2192 	if (b1->inum < b2->inum)
2193 		return -1;
2194 	else if (b1->inum > b2->inum)
2195 		return 1;
2196 
2197 	if (b1->file_pos < b2->file_pos)
2198 		return -1;
2199 	else if (b1->file_pos > b2->file_pos)
2200 		return 1;
2201 
2202 	/*
2203 	 * [------------------------------] ===> (a range of space)
2204 	 *     |<--->|   |<---->| =============> (fs/file tree A)
2205 	 * |<---------------------------->| ===> (fs/file tree B)
2206 	 *
2207 	 * A range of space can refer to two file extents in one tree while
2208 	 * refer to only one file extent in another tree.
2209 	 *
2210 	 * So we may process a disk offset more than one time(two extents in A)
2211 	 * and locate at the same extent(one extent in B), then insert two same
2212 	 * backrefs(both refer to the extent in B).
2213 	 */
2214 	return 0;
2215 }
2216 
backref_insert(struct rb_root * root,struct sa_defrag_extent_backref * backref)2217 static void backref_insert(struct rb_root *root,
2218 			   struct sa_defrag_extent_backref *backref)
2219 {
2220 	struct rb_node **p = &root->rb_node;
2221 	struct rb_node *parent = NULL;
2222 	struct sa_defrag_extent_backref *entry;
2223 	int ret;
2224 
2225 	while (*p) {
2226 		parent = *p;
2227 		entry = rb_entry(parent, struct sa_defrag_extent_backref, node);
2228 
2229 		ret = backref_comp(backref, entry);
2230 		if (ret < 0)
2231 			p = &(*p)->rb_left;
2232 		else
2233 			p = &(*p)->rb_right;
2234 	}
2235 
2236 	rb_link_node(&backref->node, parent, p);
2237 	rb_insert_color(&backref->node, root);
2238 }
2239 
2240 /*
2241  * Note the backref might has changed, and in this case we just return 0.
2242  */
record_one_backref(u64 inum,u64 offset,u64 root_id,void * ctx)2243 static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
2244 				       void *ctx)
2245 {
2246 	struct btrfs_file_extent_item *extent;
2247 	struct btrfs_fs_info *fs_info;
2248 	struct old_sa_defrag_extent *old = ctx;
2249 	struct new_sa_defrag_extent *new = old->new;
2250 	struct btrfs_path *path = new->path;
2251 	struct btrfs_key key;
2252 	struct btrfs_root *root;
2253 	struct sa_defrag_extent_backref *backref;
2254 	struct extent_buffer *leaf;
2255 	struct inode *inode = new->inode;
2256 	int slot;
2257 	int ret;
2258 	u64 extent_offset;
2259 	u64 num_bytes;
2260 
2261 	if (BTRFS_I(inode)->root->root_key.objectid == root_id &&
2262 	    inum == btrfs_ino(inode))
2263 		return 0;
2264 
2265 	key.objectid = root_id;
2266 	key.type = BTRFS_ROOT_ITEM_KEY;
2267 	key.offset = (u64)-1;
2268 
2269 	fs_info = BTRFS_I(inode)->root->fs_info;
2270 	root = btrfs_read_fs_root_no_name(fs_info, &key);
2271 	if (IS_ERR(root)) {
2272 		if (PTR_ERR(root) == -ENOENT)
2273 			return 0;
2274 		WARN_ON(1);
2275 		pr_debug("inum=%llu, offset=%llu, root_id=%llu\n",
2276 			 inum, offset, root_id);
2277 		return PTR_ERR(root);
2278 	}
2279 
2280 	key.objectid = inum;
2281 	key.type = BTRFS_EXTENT_DATA_KEY;
2282 	if (offset > (u64)-1 << 32)
2283 		key.offset = 0;
2284 	else
2285 		key.offset = offset;
2286 
2287 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2288 	if (WARN_ON(ret < 0))
2289 		return ret;
2290 	ret = 0;
2291 
2292 	while (1) {
2293 		cond_resched();
2294 
2295 		leaf = path->nodes[0];
2296 		slot = path->slots[0];
2297 
2298 		if (slot >= btrfs_header_nritems(leaf)) {
2299 			ret = btrfs_next_leaf(root, path);
2300 			if (ret < 0) {
2301 				goto out;
2302 			} else if (ret > 0) {
2303 				ret = 0;
2304 				goto out;
2305 			}
2306 			continue;
2307 		}
2308 
2309 		path->slots[0]++;
2310 
2311 		btrfs_item_key_to_cpu(leaf, &key, slot);
2312 
2313 		if (key.objectid > inum)
2314 			goto out;
2315 
2316 		if (key.objectid < inum || key.type != BTRFS_EXTENT_DATA_KEY)
2317 			continue;
2318 
2319 		extent = btrfs_item_ptr(leaf, slot,
2320 					struct btrfs_file_extent_item);
2321 
2322 		if (btrfs_file_extent_disk_bytenr(leaf, extent) != old->bytenr)
2323 			continue;
2324 
2325 		/*
2326 		 * 'offset' refers to the exact key.offset,
2327 		 * NOT the 'offset' field in btrfs_extent_data_ref, ie.
2328 		 * (key.offset - extent_offset).
2329 		 */
2330 		if (key.offset != offset)
2331 			continue;
2332 
2333 		extent_offset = btrfs_file_extent_offset(leaf, extent);
2334 		num_bytes = btrfs_file_extent_num_bytes(leaf, extent);
2335 
2336 		if (extent_offset >= old->extent_offset + old->offset +
2337 		    old->len || extent_offset + num_bytes <=
2338 		    old->extent_offset + old->offset)
2339 			continue;
2340 		break;
2341 	}
2342 
2343 	backref = kmalloc(sizeof(*backref), GFP_NOFS);
2344 	if (!backref) {
2345 		ret = -ENOENT;
2346 		goto out;
2347 	}
2348 
2349 	backref->root_id = root_id;
2350 	backref->inum = inum;
2351 	backref->file_pos = offset;
2352 	backref->num_bytes = num_bytes;
2353 	backref->extent_offset = extent_offset;
2354 	backref->generation = btrfs_file_extent_generation(leaf, extent);
2355 	backref->old = old;
2356 	backref_insert(&new->root, backref);
2357 	old->count++;
2358 out:
2359 	btrfs_release_path(path);
2360 	WARN_ON(ret);
2361 	return ret;
2362 }
2363 
record_extent_backrefs(struct btrfs_path * path,struct new_sa_defrag_extent * new)2364 static noinline bool record_extent_backrefs(struct btrfs_path *path,
2365 				   struct new_sa_defrag_extent *new)
2366 {
2367 	struct btrfs_fs_info *fs_info = BTRFS_I(new->inode)->root->fs_info;
2368 	struct old_sa_defrag_extent *old, *tmp;
2369 	int ret;
2370 
2371 	new->path = path;
2372 
2373 	list_for_each_entry_safe(old, tmp, &new->head, list) {
2374 		ret = iterate_inodes_from_logical(old->bytenr +
2375 						  old->extent_offset, fs_info,
2376 						  path, record_one_backref,
2377 						  old);
2378 		if (ret < 0 && ret != -ENOENT)
2379 			return false;
2380 
2381 		/* no backref to be processed for this extent */
2382 		if (!old->count) {
2383 			list_del(&old->list);
2384 			kfree(old);
2385 		}
2386 	}
2387 
2388 	if (list_empty(&new->head))
2389 		return false;
2390 
2391 	return true;
2392 }
2393 
relink_is_mergable(struct extent_buffer * leaf,struct btrfs_file_extent_item * fi,struct new_sa_defrag_extent * new)2394 static int relink_is_mergable(struct extent_buffer *leaf,
2395 			      struct btrfs_file_extent_item *fi,
2396 			      struct new_sa_defrag_extent *new)
2397 {
2398 	if (btrfs_file_extent_disk_bytenr(leaf, fi) != new->bytenr)
2399 		return 0;
2400 
2401 	if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2402 		return 0;
2403 
2404 	if (btrfs_file_extent_compression(leaf, fi) != new->compress_type)
2405 		return 0;
2406 
2407 	if (btrfs_file_extent_encryption(leaf, fi) ||
2408 	    btrfs_file_extent_other_encoding(leaf, fi))
2409 		return 0;
2410 
2411 	return 1;
2412 }
2413 
2414 /*
2415  * Note the backref might has changed, and in this case we just return 0.
2416  */
relink_extent_backref(struct btrfs_path * path,struct sa_defrag_extent_backref * prev,struct sa_defrag_extent_backref * backref)2417 static noinline int relink_extent_backref(struct btrfs_path *path,
2418 				 struct sa_defrag_extent_backref *prev,
2419 				 struct sa_defrag_extent_backref *backref)
2420 {
2421 	struct btrfs_file_extent_item *extent;
2422 	struct btrfs_file_extent_item *item;
2423 	struct btrfs_ordered_extent *ordered;
2424 	struct btrfs_trans_handle *trans;
2425 	struct btrfs_fs_info *fs_info;
2426 	struct btrfs_root *root;
2427 	struct btrfs_key key;
2428 	struct extent_buffer *leaf;
2429 	struct old_sa_defrag_extent *old = backref->old;
2430 	struct new_sa_defrag_extent *new = old->new;
2431 	struct inode *src_inode = new->inode;
2432 	struct inode *inode;
2433 	struct extent_state *cached = NULL;
2434 	int ret = 0;
2435 	u64 start;
2436 	u64 len;
2437 	u64 lock_start;
2438 	u64 lock_end;
2439 	bool merge = false;
2440 	int index;
2441 
2442 	if (prev && prev->root_id == backref->root_id &&
2443 	    prev->inum == backref->inum &&
2444 	    prev->file_pos + prev->num_bytes == backref->file_pos)
2445 		merge = true;
2446 
2447 	/* step 1: get root */
2448 	key.objectid = backref->root_id;
2449 	key.type = BTRFS_ROOT_ITEM_KEY;
2450 	key.offset = (u64)-1;
2451 
2452 	fs_info = BTRFS_I(src_inode)->root->fs_info;
2453 	index = srcu_read_lock(&fs_info->subvol_srcu);
2454 
2455 	root = btrfs_read_fs_root_no_name(fs_info, &key);
2456 	if (IS_ERR(root)) {
2457 		srcu_read_unlock(&fs_info->subvol_srcu, index);
2458 		if (PTR_ERR(root) == -ENOENT)
2459 			return 0;
2460 		return PTR_ERR(root);
2461 	}
2462 
2463 	if (btrfs_root_readonly(root)) {
2464 		srcu_read_unlock(&fs_info->subvol_srcu, index);
2465 		return 0;
2466 	}
2467 
2468 	/* step 2: get inode */
2469 	key.objectid = backref->inum;
2470 	key.type = BTRFS_INODE_ITEM_KEY;
2471 	key.offset = 0;
2472 
2473 	inode = btrfs_iget(fs_info->sb, &key, root, NULL);
2474 	if (IS_ERR(inode)) {
2475 		srcu_read_unlock(&fs_info->subvol_srcu, index);
2476 		return 0;
2477 	}
2478 
2479 	srcu_read_unlock(&fs_info->subvol_srcu, index);
2480 
2481 	/* step 3: relink backref */
2482 	lock_start = backref->file_pos;
2483 	lock_end = backref->file_pos + backref->num_bytes - 1;
2484 	lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
2485 			 0, &cached);
2486 
2487 	ordered = btrfs_lookup_first_ordered_extent(inode, lock_end);
2488 	if (ordered) {
2489 		btrfs_put_ordered_extent(ordered);
2490 		goto out_unlock;
2491 	}
2492 
2493 	trans = btrfs_join_transaction(root);
2494 	if (IS_ERR(trans)) {
2495 		ret = PTR_ERR(trans);
2496 		goto out_unlock;
2497 	}
2498 
2499 	key.objectid = backref->inum;
2500 	key.type = BTRFS_EXTENT_DATA_KEY;
2501 	key.offset = backref->file_pos;
2502 
2503 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2504 	if (ret < 0) {
2505 		goto out_free_path;
2506 	} else if (ret > 0) {
2507 		ret = 0;
2508 		goto out_free_path;
2509 	}
2510 
2511 	extent = btrfs_item_ptr(path->nodes[0], path->slots[0],
2512 				struct btrfs_file_extent_item);
2513 
2514 	if (btrfs_file_extent_generation(path->nodes[0], extent) !=
2515 	    backref->generation)
2516 		goto out_free_path;
2517 
2518 	btrfs_release_path(path);
2519 
2520 	start = backref->file_pos;
2521 	if (backref->extent_offset < old->extent_offset + old->offset)
2522 		start += old->extent_offset + old->offset -
2523 			 backref->extent_offset;
2524 
2525 	len = min(backref->extent_offset + backref->num_bytes,
2526 		  old->extent_offset + old->offset + old->len);
2527 	len -= max(backref->extent_offset, old->extent_offset + old->offset);
2528 
2529 	ret = btrfs_drop_extents(trans, root, inode, start,
2530 				 start + len, 1);
2531 	if (ret)
2532 		goto out_free_path;
2533 again:
2534 	key.objectid = btrfs_ino(inode);
2535 	key.type = BTRFS_EXTENT_DATA_KEY;
2536 	key.offset = start;
2537 
2538 	path->leave_spinning = 1;
2539 	if (merge) {
2540 		struct btrfs_file_extent_item *fi;
2541 		u64 extent_len;
2542 		struct btrfs_key found_key;
2543 
2544 		ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2545 		if (ret < 0)
2546 			goto out_free_path;
2547 
2548 		path->slots[0]--;
2549 		leaf = path->nodes[0];
2550 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2551 
2552 		fi = btrfs_item_ptr(leaf, path->slots[0],
2553 				    struct btrfs_file_extent_item);
2554 		extent_len = btrfs_file_extent_num_bytes(leaf, fi);
2555 
2556 		if (extent_len + found_key.offset == start &&
2557 		    relink_is_mergable(leaf, fi, new)) {
2558 			btrfs_set_file_extent_num_bytes(leaf, fi,
2559 							extent_len + len);
2560 			btrfs_mark_buffer_dirty(leaf);
2561 			inode_add_bytes(inode, len);
2562 
2563 			ret = 1;
2564 			goto out_free_path;
2565 		} else {
2566 			merge = false;
2567 			btrfs_release_path(path);
2568 			goto again;
2569 		}
2570 	}
2571 
2572 	ret = btrfs_insert_empty_item(trans, root, path, &key,
2573 					sizeof(*extent));
2574 	if (ret) {
2575 		btrfs_abort_transaction(trans, root, ret);
2576 		goto out_free_path;
2577 	}
2578 
2579 	leaf = path->nodes[0];
2580 	item = btrfs_item_ptr(leaf, path->slots[0],
2581 				struct btrfs_file_extent_item);
2582 	btrfs_set_file_extent_disk_bytenr(leaf, item, new->bytenr);
2583 	btrfs_set_file_extent_disk_num_bytes(leaf, item, new->disk_len);
2584 	btrfs_set_file_extent_offset(leaf, item, start - new->file_pos);
2585 	btrfs_set_file_extent_num_bytes(leaf, item, len);
2586 	btrfs_set_file_extent_ram_bytes(leaf, item, new->len);
2587 	btrfs_set_file_extent_generation(leaf, item, trans->transid);
2588 	btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
2589 	btrfs_set_file_extent_compression(leaf, item, new->compress_type);
2590 	btrfs_set_file_extent_encryption(leaf, item, 0);
2591 	btrfs_set_file_extent_other_encoding(leaf, item, 0);
2592 
2593 	btrfs_mark_buffer_dirty(leaf);
2594 	inode_add_bytes(inode, len);
2595 	btrfs_release_path(path);
2596 
2597 	ret = btrfs_inc_extent_ref(trans, root, new->bytenr,
2598 			new->disk_len, 0,
2599 			backref->root_id, backref->inum,
2600 			new->file_pos);	/* start - extent_offset */
2601 	if (ret) {
2602 		btrfs_abort_transaction(trans, root, ret);
2603 		goto out_free_path;
2604 	}
2605 
2606 	ret = 1;
2607 out_free_path:
2608 	btrfs_release_path(path);
2609 	path->leave_spinning = 0;
2610 	btrfs_end_transaction(trans, root);
2611 out_unlock:
2612 	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
2613 			     &cached, GFP_NOFS);
2614 	iput(inode);
2615 	return ret;
2616 }
2617 
free_sa_defrag_extent(struct new_sa_defrag_extent * new)2618 static void free_sa_defrag_extent(struct new_sa_defrag_extent *new)
2619 {
2620 	struct old_sa_defrag_extent *old, *tmp;
2621 
2622 	if (!new)
2623 		return;
2624 
2625 	list_for_each_entry_safe(old, tmp, &new->head, list) {
2626 		kfree(old);
2627 	}
2628 	kfree(new);
2629 }
2630 
relink_file_extents(struct new_sa_defrag_extent * new)2631 static void relink_file_extents(struct new_sa_defrag_extent *new)
2632 {
2633 	struct btrfs_path *path;
2634 	struct sa_defrag_extent_backref *backref;
2635 	struct sa_defrag_extent_backref *prev = NULL;
2636 	struct inode *inode;
2637 	struct btrfs_root *root;
2638 	struct rb_node *node;
2639 	int ret;
2640 
2641 	inode = new->inode;
2642 	root = BTRFS_I(inode)->root;
2643 
2644 	path = btrfs_alloc_path();
2645 	if (!path)
2646 		return;
2647 
2648 	if (!record_extent_backrefs(path, new)) {
2649 		btrfs_free_path(path);
2650 		goto out;
2651 	}
2652 	btrfs_release_path(path);
2653 
2654 	while (1) {
2655 		node = rb_first(&new->root);
2656 		if (!node)
2657 			break;
2658 		rb_erase(node, &new->root);
2659 
2660 		backref = rb_entry(node, struct sa_defrag_extent_backref, node);
2661 
2662 		ret = relink_extent_backref(path, prev, backref);
2663 		WARN_ON(ret < 0);
2664 
2665 		kfree(prev);
2666 
2667 		if (ret == 1)
2668 			prev = backref;
2669 		else
2670 			prev = NULL;
2671 		cond_resched();
2672 	}
2673 	kfree(prev);
2674 
2675 	btrfs_free_path(path);
2676 out:
2677 	free_sa_defrag_extent(new);
2678 
2679 	atomic_dec(&root->fs_info->defrag_running);
2680 	wake_up(&root->fs_info->transaction_wait);
2681 }
2682 
2683 static struct new_sa_defrag_extent *
record_old_file_extents(struct inode * inode,struct btrfs_ordered_extent * ordered)2684 record_old_file_extents(struct inode *inode,
2685 			struct btrfs_ordered_extent *ordered)
2686 {
2687 	struct btrfs_root *root = BTRFS_I(inode)->root;
2688 	struct btrfs_path *path;
2689 	struct btrfs_key key;
2690 	struct old_sa_defrag_extent *old;
2691 	struct new_sa_defrag_extent *new;
2692 	int ret;
2693 
2694 	new = kmalloc(sizeof(*new), GFP_NOFS);
2695 	if (!new)
2696 		return NULL;
2697 
2698 	new->inode = inode;
2699 	new->file_pos = ordered->file_offset;
2700 	new->len = ordered->len;
2701 	new->bytenr = ordered->start;
2702 	new->disk_len = ordered->disk_len;
2703 	new->compress_type = ordered->compress_type;
2704 	new->root = RB_ROOT;
2705 	INIT_LIST_HEAD(&new->head);
2706 
2707 	path = btrfs_alloc_path();
2708 	if (!path)
2709 		goto out_kfree;
2710 
2711 	key.objectid = btrfs_ino(inode);
2712 	key.type = BTRFS_EXTENT_DATA_KEY;
2713 	key.offset = new->file_pos;
2714 
2715 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2716 	if (ret < 0)
2717 		goto out_free_path;
2718 	if (ret > 0 && path->slots[0] > 0)
2719 		path->slots[0]--;
2720 
2721 	/* find out all the old extents for the file range */
2722 	while (1) {
2723 		struct btrfs_file_extent_item *extent;
2724 		struct extent_buffer *l;
2725 		int slot;
2726 		u64 num_bytes;
2727 		u64 offset;
2728 		u64 end;
2729 		u64 disk_bytenr;
2730 		u64 extent_offset;
2731 
2732 		l = path->nodes[0];
2733 		slot = path->slots[0];
2734 
2735 		if (slot >= btrfs_header_nritems(l)) {
2736 			ret = btrfs_next_leaf(root, path);
2737 			if (ret < 0)
2738 				goto out_free_path;
2739 			else if (ret > 0)
2740 				break;
2741 			continue;
2742 		}
2743 
2744 		btrfs_item_key_to_cpu(l, &key, slot);
2745 
2746 		if (key.objectid != btrfs_ino(inode))
2747 			break;
2748 		if (key.type != BTRFS_EXTENT_DATA_KEY)
2749 			break;
2750 		if (key.offset >= new->file_pos + new->len)
2751 			break;
2752 
2753 		extent = btrfs_item_ptr(l, slot, struct btrfs_file_extent_item);
2754 
2755 		num_bytes = btrfs_file_extent_num_bytes(l, extent);
2756 		if (key.offset + num_bytes < new->file_pos)
2757 			goto next;
2758 
2759 		disk_bytenr = btrfs_file_extent_disk_bytenr(l, extent);
2760 		if (!disk_bytenr)
2761 			goto next;
2762 
2763 		extent_offset = btrfs_file_extent_offset(l, extent);
2764 
2765 		old = kmalloc(sizeof(*old), GFP_NOFS);
2766 		if (!old)
2767 			goto out_free_path;
2768 
2769 		offset = max(new->file_pos, key.offset);
2770 		end = min(new->file_pos + new->len, key.offset + num_bytes);
2771 
2772 		old->bytenr = disk_bytenr;
2773 		old->extent_offset = extent_offset;
2774 		old->offset = offset - key.offset;
2775 		old->len = end - offset;
2776 		old->new = new;
2777 		old->count = 0;
2778 		list_add_tail(&old->list, &new->head);
2779 next:
2780 		path->slots[0]++;
2781 		cond_resched();
2782 	}
2783 
2784 	btrfs_free_path(path);
2785 	atomic_inc(&root->fs_info->defrag_running);
2786 
2787 	return new;
2788 
2789 out_free_path:
2790 	btrfs_free_path(path);
2791 out_kfree:
2792 	free_sa_defrag_extent(new);
2793 	return NULL;
2794 }
2795 
btrfs_release_delalloc_bytes(struct btrfs_root * root,u64 start,u64 len)2796 static void btrfs_release_delalloc_bytes(struct btrfs_root *root,
2797 					 u64 start, u64 len)
2798 {
2799 	struct btrfs_block_group_cache *cache;
2800 
2801 	cache = btrfs_lookup_block_group(root->fs_info, start);
2802 	ASSERT(cache);
2803 
2804 	spin_lock(&cache->lock);
2805 	cache->delalloc_bytes -= len;
2806 	spin_unlock(&cache->lock);
2807 
2808 	btrfs_put_block_group(cache);
2809 }
2810 
2811 /* as ordered data IO finishes, this gets called so we can finish
2812  * an ordered extent if the range of bytes in the file it covers are
2813  * fully written.
2814  */
btrfs_finish_ordered_io(struct btrfs_ordered_extent * ordered_extent)2815 static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2816 {
2817 	struct inode *inode = ordered_extent->inode;
2818 	struct btrfs_root *root = BTRFS_I(inode)->root;
2819 	struct btrfs_trans_handle *trans = NULL;
2820 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2821 	struct extent_state *cached_state = NULL;
2822 	struct new_sa_defrag_extent *new = NULL;
2823 	int compress_type = 0;
2824 	int ret = 0;
2825 	u64 logical_len = ordered_extent->len;
2826 	bool nolock;
2827 	bool truncated = false;
2828 
2829 	nolock = btrfs_is_free_space_inode(inode);
2830 
2831 	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
2832 		ret = -EIO;
2833 		goto out;
2834 	}
2835 
2836 	btrfs_free_io_failure_record(inode, ordered_extent->file_offset,
2837 				     ordered_extent->file_offset +
2838 				     ordered_extent->len - 1);
2839 
2840 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {
2841 		truncated = true;
2842 		logical_len = ordered_extent->truncated_len;
2843 		/* Truncated the entire extent, don't bother adding */
2844 		if (!logical_len)
2845 			goto out;
2846 	}
2847 
2848 	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
2849 		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
2850 
2851 		/*
2852 		 * For mwrite(mmap + memset to write) case, we still reserve
2853 		 * space for NOCOW range.
2854 		 * As NOCOW won't cause a new delayed ref, just free the space
2855 		 */
2856 		btrfs_qgroup_free_data(inode, ordered_extent->file_offset,
2857 				       ordered_extent->len);
2858 		btrfs_ordered_update_i_size(inode, 0, ordered_extent);
2859 		if (nolock)
2860 			trans = btrfs_join_transaction_nolock(root);
2861 		else
2862 			trans = btrfs_join_transaction(root);
2863 		if (IS_ERR(trans)) {
2864 			ret = PTR_ERR(trans);
2865 			trans = NULL;
2866 			goto out;
2867 		}
2868 		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2869 		ret = btrfs_update_inode_fallback(trans, root, inode);
2870 		if (ret) /* -ENOMEM or corruption */
2871 			btrfs_abort_transaction(trans, root, ret);
2872 		goto out;
2873 	}
2874 
2875 	lock_extent_bits(io_tree, ordered_extent->file_offset,
2876 			 ordered_extent->file_offset + ordered_extent->len - 1,
2877 			 0, &cached_state);
2878 
2879 	ret = test_range_bit(io_tree, ordered_extent->file_offset,
2880 			ordered_extent->file_offset + ordered_extent->len - 1,
2881 			EXTENT_DEFRAG, 1, cached_state);
2882 	if (ret) {
2883 		u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item);
2884 		if (0 && last_snapshot >= BTRFS_I(inode)->generation)
2885 			/* the inode is shared */
2886 			new = record_old_file_extents(inode, ordered_extent);
2887 
2888 		clear_extent_bit(io_tree, ordered_extent->file_offset,
2889 			ordered_extent->file_offset + ordered_extent->len - 1,
2890 			EXTENT_DEFRAG, 0, 0, &cached_state, GFP_NOFS);
2891 	}
2892 
2893 	if (nolock)
2894 		trans = btrfs_join_transaction_nolock(root);
2895 	else
2896 		trans = btrfs_join_transaction(root);
2897 	if (IS_ERR(trans)) {
2898 		ret = PTR_ERR(trans);
2899 		trans = NULL;
2900 		goto out_unlock;
2901 	}
2902 
2903 	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2904 
2905 	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
2906 		compress_type = ordered_extent->compress_type;
2907 	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
2908 		BUG_ON(compress_type);
2909 		ret = btrfs_mark_extent_written(trans, inode,
2910 						ordered_extent->file_offset,
2911 						ordered_extent->file_offset +
2912 						logical_len);
2913 	} else {
2914 		BUG_ON(root == root->fs_info->tree_root);
2915 		ret = insert_reserved_file_extent(trans, inode,
2916 						ordered_extent->file_offset,
2917 						ordered_extent->start,
2918 						ordered_extent->disk_len,
2919 						logical_len, logical_len,
2920 						compress_type, 0, 0,
2921 						BTRFS_FILE_EXTENT_REG);
2922 		if (!ret)
2923 			btrfs_release_delalloc_bytes(root,
2924 						     ordered_extent->start,
2925 						     ordered_extent->disk_len);
2926 	}
2927 	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
2928 			   ordered_extent->file_offset, ordered_extent->len,
2929 			   trans->transid);
2930 	if (ret < 0) {
2931 		btrfs_abort_transaction(trans, root, ret);
2932 		goto out_unlock;
2933 	}
2934 
2935 	add_pending_csums(trans, inode, ordered_extent->file_offset,
2936 			  &ordered_extent->list);
2937 
2938 	btrfs_ordered_update_i_size(inode, 0, ordered_extent);
2939 	ret = btrfs_update_inode_fallback(trans, root, inode);
2940 	if (ret) { /* -ENOMEM or corruption */
2941 		btrfs_abort_transaction(trans, root, ret);
2942 		goto out_unlock;
2943 	}
2944 	ret = 0;
2945 out_unlock:
2946 	unlock_extent_cached(io_tree, ordered_extent->file_offset,
2947 			     ordered_extent->file_offset +
2948 			     ordered_extent->len - 1, &cached_state, GFP_NOFS);
2949 out:
2950 	if (root != root->fs_info->tree_root)
2951 		btrfs_delalloc_release_metadata(inode, ordered_extent->len);
2952 	if (trans)
2953 		btrfs_end_transaction(trans, root);
2954 
2955 	if (ret || truncated) {
2956 		u64 start, end;
2957 
2958 		if (truncated)
2959 			start = ordered_extent->file_offset + logical_len;
2960 		else
2961 			start = ordered_extent->file_offset;
2962 		end = ordered_extent->file_offset + ordered_extent->len - 1;
2963 		clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS);
2964 
2965 		/* Drop the cache for the part of the extent we didn't write. */
2966 		btrfs_drop_extent_cache(inode, start, end, 0);
2967 
2968 		/*
2969 		 * If the ordered extent had an IOERR or something else went
2970 		 * wrong we need to return the space for this ordered extent
2971 		 * back to the allocator.  We only free the extent in the
2972 		 * truncated case if we didn't write out the extent at all.
2973 		 */
2974 		if ((ret || !logical_len) &&
2975 		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
2976 		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags))
2977 			btrfs_free_reserved_extent(root, ordered_extent->start,
2978 						   ordered_extent->disk_len, 1);
2979 	}
2980 
2981 
2982 	/*
2983 	 * This needs to be done to make sure anybody waiting knows we are done
2984 	 * updating everything for this ordered extent.
2985 	 */
2986 	btrfs_remove_ordered_extent(inode, ordered_extent);
2987 
2988 	/* for snapshot-aware defrag */
2989 	if (new) {
2990 		if (ret) {
2991 			free_sa_defrag_extent(new);
2992 			atomic_dec(&root->fs_info->defrag_running);
2993 		} else {
2994 			relink_file_extents(new);
2995 		}
2996 	}
2997 
2998 	/* once for us */
2999 	btrfs_put_ordered_extent(ordered_extent);
3000 	/* once for the tree */
3001 	btrfs_put_ordered_extent(ordered_extent);
3002 
3003 	return ret;
3004 }
3005 
finish_ordered_fn(struct btrfs_work * work)3006 static void finish_ordered_fn(struct btrfs_work *work)
3007 {
3008 	struct btrfs_ordered_extent *ordered_extent;
3009 	ordered_extent = container_of(work, struct btrfs_ordered_extent, work);
3010 	btrfs_finish_ordered_io(ordered_extent);
3011 }
3012 
btrfs_writepage_end_io_hook(struct page * page,u64 start,u64 end,struct extent_state * state,int uptodate)3013 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
3014 				struct extent_state *state, int uptodate)
3015 {
3016 	struct inode *inode = page->mapping->host;
3017 	struct btrfs_root *root = BTRFS_I(inode)->root;
3018 	struct btrfs_ordered_extent *ordered_extent = NULL;
3019 	struct btrfs_workqueue *wq;
3020 	btrfs_work_func_t func;
3021 
3022 	trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
3023 
3024 	ClearPagePrivate2(page);
3025 	if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
3026 					    end - start + 1, uptodate))
3027 		return 0;
3028 
3029 	if (btrfs_is_free_space_inode(inode)) {
3030 		wq = root->fs_info->endio_freespace_worker;
3031 		func = btrfs_freespace_write_helper;
3032 	} else {
3033 		wq = root->fs_info->endio_write_workers;
3034 		func = btrfs_endio_write_helper;
3035 	}
3036 
3037 	btrfs_init_work(&ordered_extent->work, func, finish_ordered_fn, NULL,
3038 			NULL);
3039 	btrfs_queue_work(wq, &ordered_extent->work);
3040 
3041 	return 0;
3042 }
3043 
__readpage_endio_check(struct inode * inode,struct btrfs_io_bio * io_bio,int icsum,struct page * page,int pgoff,u64 start,size_t len)3044 static int __readpage_endio_check(struct inode *inode,
3045 				  struct btrfs_io_bio *io_bio,
3046 				  int icsum, struct page *page,
3047 				  int pgoff, u64 start, size_t len)
3048 {
3049 	char *kaddr;
3050 	u32 csum_expected;
3051 	u32 csum = ~(u32)0;
3052 
3053 	csum_expected = *(((u32 *)io_bio->csum) + icsum);
3054 
3055 	kaddr = kmap_atomic(page);
3056 	csum = btrfs_csum_data(kaddr + pgoff, csum,  len);
3057 	btrfs_csum_final(csum, (char *)&csum);
3058 	if (csum != csum_expected)
3059 		goto zeroit;
3060 
3061 	kunmap_atomic(kaddr);
3062 	return 0;
3063 zeroit:
3064 	btrfs_warn_rl(BTRFS_I(inode)->root->fs_info,
3065 		"csum failed ino %llu off %llu csum %u expected csum %u",
3066 			   btrfs_ino(inode), start, csum, csum_expected);
3067 	memset(kaddr + pgoff, 1, len);
3068 	flush_dcache_page(page);
3069 	kunmap_atomic(kaddr);
3070 	if (csum_expected == 0)
3071 		return 0;
3072 	return -EIO;
3073 }
3074 
3075 /*
3076  * when reads are done, we need to check csums to verify the data is correct
3077  * if there's a match, we allow the bio to finish.  If not, the code in
3078  * extent_io.c will try to find good copies for us.
3079  */
btrfs_readpage_end_io_hook(struct btrfs_io_bio * io_bio,u64 phy_offset,struct page * page,u64 start,u64 end,int mirror)3080 static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
3081 				      u64 phy_offset, struct page *page,
3082 				      u64 start, u64 end, int mirror)
3083 {
3084 	size_t offset = start - page_offset(page);
3085 	struct inode *inode = page->mapping->host;
3086 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3087 	struct btrfs_root *root = BTRFS_I(inode)->root;
3088 
3089 	if (PageChecked(page)) {
3090 		ClearPageChecked(page);
3091 		return 0;
3092 	}
3093 
3094 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
3095 		return 0;
3096 
3097 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
3098 	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
3099 		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
3100 				  GFP_NOFS);
3101 		return 0;
3102 	}
3103 
3104 	phy_offset >>= inode->i_sb->s_blocksize_bits;
3105 	return __readpage_endio_check(inode, io_bio, phy_offset, page, offset,
3106 				      start, (size_t)(end - start + 1));
3107 }
3108 
3109 struct delayed_iput {
3110 	struct list_head list;
3111 	struct inode *inode;
3112 };
3113 
3114 /* JDM: If this is fs-wide, why can't we add a pointer to
3115  * btrfs_inode instead and avoid the allocation? */
btrfs_add_delayed_iput(struct inode * inode)3116 void btrfs_add_delayed_iput(struct inode *inode)
3117 {
3118 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
3119 	struct delayed_iput *delayed;
3120 
3121 	if (atomic_add_unless(&inode->i_count, -1, 1))
3122 		return;
3123 
3124 	delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
3125 	delayed->inode = inode;
3126 
3127 	spin_lock(&fs_info->delayed_iput_lock);
3128 	list_add_tail(&delayed->list, &fs_info->delayed_iputs);
3129 	spin_unlock(&fs_info->delayed_iput_lock);
3130 }
3131 
btrfs_run_delayed_iputs(struct btrfs_root * root)3132 void btrfs_run_delayed_iputs(struct btrfs_root *root)
3133 {
3134 	LIST_HEAD(list);
3135 	struct btrfs_fs_info *fs_info = root->fs_info;
3136 	struct delayed_iput *delayed;
3137 	int empty;
3138 
3139 	spin_lock(&fs_info->delayed_iput_lock);
3140 	empty = list_empty(&fs_info->delayed_iputs);
3141 	spin_unlock(&fs_info->delayed_iput_lock);
3142 	if (empty)
3143 		return;
3144 
3145 	spin_lock(&fs_info->delayed_iput_lock);
3146 	list_splice_init(&fs_info->delayed_iputs, &list);
3147 	spin_unlock(&fs_info->delayed_iput_lock);
3148 
3149 	while (!list_empty(&list)) {
3150 		delayed = list_entry(list.next, struct delayed_iput, list);
3151 		list_del(&delayed->list);
3152 		iput(delayed->inode);
3153 		kfree(delayed);
3154 	}
3155 }
3156 
3157 /*
3158  * This is called in transaction commit time. If there are no orphan
3159  * files in the subvolume, it removes orphan item and frees block_rsv
3160  * structure.
3161  */
btrfs_orphan_commit_root(struct btrfs_trans_handle * trans,struct btrfs_root * root)3162 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3163 			      struct btrfs_root *root)
3164 {
3165 	struct btrfs_block_rsv *block_rsv;
3166 	int ret;
3167 
3168 	if (atomic_read(&root->orphan_inodes) ||
3169 	    root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
3170 		return;
3171 
3172 	spin_lock(&root->orphan_lock);
3173 	if (atomic_read(&root->orphan_inodes)) {
3174 		spin_unlock(&root->orphan_lock);
3175 		return;
3176 	}
3177 
3178 	if (root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) {
3179 		spin_unlock(&root->orphan_lock);
3180 		return;
3181 	}
3182 
3183 	block_rsv = root->orphan_block_rsv;
3184 	root->orphan_block_rsv = NULL;
3185 	spin_unlock(&root->orphan_lock);
3186 
3187 	if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state) &&
3188 	    btrfs_root_refs(&root->root_item) > 0) {
3189 		ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
3190 					    root->root_key.objectid);
3191 		if (ret)
3192 			btrfs_abort_transaction(trans, root, ret);
3193 		else
3194 			clear_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
3195 				  &root->state);
3196 	}
3197 
3198 	if (block_rsv) {
3199 		WARN_ON(block_rsv->size > 0);
3200 		btrfs_free_block_rsv(root, block_rsv);
3201 	}
3202 }
3203 
3204 /*
3205  * This creates an orphan entry for the given inode in case something goes
3206  * wrong in the middle of an unlink/truncate.
3207  *
3208  * NOTE: caller of this function should reserve 5 units of metadata for
3209  *	 this function.
3210  */
btrfs_orphan_add(struct btrfs_trans_handle * trans,struct inode * inode)3211 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
3212 {
3213 	struct btrfs_root *root = BTRFS_I(inode)->root;
3214 	struct btrfs_block_rsv *block_rsv = NULL;
3215 	int reserve = 0;
3216 	int insert = 0;
3217 	int ret;
3218 
3219 	if (!root->orphan_block_rsv) {
3220 		block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
3221 		if (!block_rsv)
3222 			return -ENOMEM;
3223 	}
3224 
3225 	spin_lock(&root->orphan_lock);
3226 	if (!root->orphan_block_rsv) {
3227 		root->orphan_block_rsv = block_rsv;
3228 	} else if (block_rsv) {
3229 		btrfs_free_block_rsv(root, block_rsv);
3230 		block_rsv = NULL;
3231 	}
3232 
3233 	if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3234 			      &BTRFS_I(inode)->runtime_flags)) {
3235 #if 0
3236 		/*
3237 		 * For proper ENOSPC handling, we should do orphan
3238 		 * cleanup when mounting. But this introduces backward
3239 		 * compatibility issue.
3240 		 */
3241 		if (!xchg(&root->orphan_item_inserted, 1))
3242 			insert = 2;
3243 		else
3244 			insert = 1;
3245 #endif
3246 		insert = 1;
3247 		atomic_inc(&root->orphan_inodes);
3248 	}
3249 
3250 	if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3251 			      &BTRFS_I(inode)->runtime_flags))
3252 		reserve = 1;
3253 	spin_unlock(&root->orphan_lock);
3254 
3255 	/* grab metadata reservation from transaction handle */
3256 	if (reserve) {
3257 		ret = btrfs_orphan_reserve_metadata(trans, inode);
3258 		BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */
3259 	}
3260 
3261 	/* insert an orphan item to track this unlinked/truncated file */
3262 	if (insert >= 1) {
3263 		ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
3264 		if (ret) {
3265 			atomic_dec(&root->orphan_inodes);
3266 			if (reserve) {
3267 				clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3268 					  &BTRFS_I(inode)->runtime_flags);
3269 				btrfs_orphan_release_metadata(inode);
3270 			}
3271 			if (ret != -EEXIST) {
3272 				clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3273 					  &BTRFS_I(inode)->runtime_flags);
3274 				btrfs_abort_transaction(trans, root, ret);
3275 				return ret;
3276 			}
3277 		}
3278 		ret = 0;
3279 	}
3280 
3281 	/* insert an orphan item to track subvolume contains orphan files */
3282 	if (insert >= 2) {
3283 		ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
3284 					       root->root_key.objectid);
3285 		if (ret && ret != -EEXIST) {
3286 			btrfs_abort_transaction(trans, root, ret);
3287 			return ret;
3288 		}
3289 	}
3290 	return 0;
3291 }
3292 
3293 /*
3294  * We have done the truncate/delete so we can go ahead and remove the orphan
3295  * item for this particular inode.
3296  */
btrfs_orphan_del(struct btrfs_trans_handle * trans,struct inode * inode)3297 static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
3298 			    struct inode *inode)
3299 {
3300 	struct btrfs_root *root = BTRFS_I(inode)->root;
3301 	int delete_item = 0;
3302 	int release_rsv = 0;
3303 	int ret = 0;
3304 
3305 	spin_lock(&root->orphan_lock);
3306 	if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3307 			       &BTRFS_I(inode)->runtime_flags))
3308 		delete_item = 1;
3309 
3310 	if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3311 			       &BTRFS_I(inode)->runtime_flags))
3312 		release_rsv = 1;
3313 	spin_unlock(&root->orphan_lock);
3314 
3315 	if (delete_item) {
3316 		atomic_dec(&root->orphan_inodes);
3317 		if (trans)
3318 			ret = btrfs_del_orphan_item(trans, root,
3319 						    btrfs_ino(inode));
3320 	}
3321 
3322 	if (release_rsv)
3323 		btrfs_orphan_release_metadata(inode);
3324 
3325 	return ret;
3326 }
3327 
3328 /*
3329  * this cleans up any orphans that may be left on the list from the last use
3330  * of this root.
3331  */
btrfs_orphan_cleanup(struct btrfs_root * root)3332 int btrfs_orphan_cleanup(struct btrfs_root *root)
3333 {
3334 	struct btrfs_path *path;
3335 	struct extent_buffer *leaf;
3336 	struct btrfs_key key, found_key;
3337 	struct btrfs_trans_handle *trans;
3338 	struct inode *inode;
3339 	u64 last_objectid = 0;
3340 	int ret = 0, nr_unlink = 0, nr_truncate = 0;
3341 
3342 	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
3343 		return 0;
3344 
3345 	path = btrfs_alloc_path();
3346 	if (!path) {
3347 		ret = -ENOMEM;
3348 		goto out;
3349 	}
3350 	path->reada = -1;
3351 
3352 	key.objectid = BTRFS_ORPHAN_OBJECTID;
3353 	key.type = BTRFS_ORPHAN_ITEM_KEY;
3354 	key.offset = (u64)-1;
3355 
3356 	while (1) {
3357 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3358 		if (ret < 0)
3359 			goto out;
3360 
3361 		/*
3362 		 * if ret == 0 means we found what we were searching for, which
3363 		 * is weird, but possible, so only screw with path if we didn't
3364 		 * find the key and see if we have stuff that matches
3365 		 */
3366 		if (ret > 0) {
3367 			ret = 0;
3368 			if (path->slots[0] == 0)
3369 				break;
3370 			path->slots[0]--;
3371 		}
3372 
3373 		/* pull out the item */
3374 		leaf = path->nodes[0];
3375 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
3376 
3377 		/* make sure the item matches what we want */
3378 		if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
3379 			break;
3380 		if (found_key.type != BTRFS_ORPHAN_ITEM_KEY)
3381 			break;
3382 
3383 		/* release the path since we're done with it */
3384 		btrfs_release_path(path);
3385 
3386 		/*
3387 		 * this is where we are basically btrfs_lookup, without the
3388 		 * crossing root thing.  we store the inode number in the
3389 		 * offset of the orphan item.
3390 		 */
3391 
3392 		if (found_key.offset == last_objectid) {
3393 			btrfs_err(root->fs_info,
3394 				"Error removing orphan entry, stopping orphan cleanup");
3395 			ret = -EINVAL;
3396 			goto out;
3397 		}
3398 
3399 		last_objectid = found_key.offset;
3400 
3401 		found_key.objectid = found_key.offset;
3402 		found_key.type = BTRFS_INODE_ITEM_KEY;
3403 		found_key.offset = 0;
3404 		inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
3405 		ret = PTR_ERR_OR_ZERO(inode);
3406 		if (ret && ret != -ESTALE)
3407 			goto out;
3408 
3409 		if (ret == -ESTALE && root == root->fs_info->tree_root) {
3410 			struct btrfs_root *dead_root;
3411 			struct btrfs_fs_info *fs_info = root->fs_info;
3412 			int is_dead_root = 0;
3413 
3414 			/*
3415 			 * this is an orphan in the tree root. Currently these
3416 			 * could come from 2 sources:
3417 			 *  a) a snapshot deletion in progress
3418 			 *  b) a free space cache inode
3419 			 * We need to distinguish those two, as the snapshot
3420 			 * orphan must not get deleted.
3421 			 * find_dead_roots already ran before us, so if this
3422 			 * is a snapshot deletion, we should find the root
3423 			 * in the dead_roots list
3424 			 */
3425 			spin_lock(&fs_info->trans_lock);
3426 			list_for_each_entry(dead_root, &fs_info->dead_roots,
3427 					    root_list) {
3428 				if (dead_root->root_key.objectid ==
3429 				    found_key.objectid) {
3430 					is_dead_root = 1;
3431 					break;
3432 				}
3433 			}
3434 			spin_unlock(&fs_info->trans_lock);
3435 			if (is_dead_root) {
3436 				/* prevent this orphan from being found again */
3437 				key.offset = found_key.objectid - 1;
3438 				continue;
3439 			}
3440 		}
3441 		/*
3442 		 * Inode is already gone but the orphan item is still there,
3443 		 * kill the orphan item.
3444 		 */
3445 		if (ret == -ESTALE) {
3446 			trans = btrfs_start_transaction(root, 1);
3447 			if (IS_ERR(trans)) {
3448 				ret = PTR_ERR(trans);
3449 				goto out;
3450 			}
3451 			btrfs_debug(root->fs_info, "auto deleting %Lu",
3452 				found_key.objectid);
3453 			ret = btrfs_del_orphan_item(trans, root,
3454 						    found_key.objectid);
3455 			btrfs_end_transaction(trans, root);
3456 			if (ret)
3457 				goto out;
3458 			continue;
3459 		}
3460 
3461 		/*
3462 		 * add this inode to the orphan list so btrfs_orphan_del does
3463 		 * the proper thing when we hit it
3464 		 */
3465 		set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3466 			&BTRFS_I(inode)->runtime_flags);
3467 		atomic_inc(&root->orphan_inodes);
3468 
3469 		/* if we have links, this was a truncate, lets do that */
3470 		if (inode->i_nlink) {
3471 			if (WARN_ON(!S_ISREG(inode->i_mode))) {
3472 				iput(inode);
3473 				continue;
3474 			}
3475 			nr_truncate++;
3476 
3477 			/* 1 for the orphan item deletion. */
3478 			trans = btrfs_start_transaction(root, 1);
3479 			if (IS_ERR(trans)) {
3480 				iput(inode);
3481 				ret = PTR_ERR(trans);
3482 				goto out;
3483 			}
3484 			ret = btrfs_orphan_add(trans, inode);
3485 			btrfs_end_transaction(trans, root);
3486 			if (ret) {
3487 				iput(inode);
3488 				goto out;
3489 			}
3490 
3491 			ret = btrfs_truncate(inode);
3492 			if (ret)
3493 				btrfs_orphan_del(NULL, inode);
3494 		} else {
3495 			nr_unlink++;
3496 		}
3497 
3498 		/* this will do delete_inode and everything for us */
3499 		iput(inode);
3500 		if (ret)
3501 			goto out;
3502 	}
3503 	/* release the path since we're done with it */
3504 	btrfs_release_path(path);
3505 
3506 	root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
3507 
3508 	if (root->orphan_block_rsv)
3509 		btrfs_block_rsv_release(root, root->orphan_block_rsv,
3510 					(u64)-1);
3511 
3512 	if (root->orphan_block_rsv ||
3513 	    test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) {
3514 		trans = btrfs_join_transaction(root);
3515 		if (!IS_ERR(trans))
3516 			btrfs_end_transaction(trans, root);
3517 	}
3518 
3519 	if (nr_unlink)
3520 		btrfs_debug(root->fs_info, "unlinked %d orphans", nr_unlink);
3521 	if (nr_truncate)
3522 		btrfs_debug(root->fs_info, "truncated %d orphans", nr_truncate);
3523 
3524 out:
3525 	if (ret)
3526 		btrfs_err(root->fs_info,
3527 			"could not do orphan cleanup %d", ret);
3528 	btrfs_free_path(path);
3529 	return ret;
3530 }
3531 
3532 /*
3533  * very simple check to peek ahead in the leaf looking for xattrs.  If we
3534  * don't find any xattrs, we know there can't be any acls.
3535  *
3536  * slot is the slot the inode is in, objectid is the objectid of the inode
3537  */
acls_after_inode_item(struct extent_buffer * leaf,int slot,u64 objectid,int * first_xattr_slot)3538 static noinline int acls_after_inode_item(struct extent_buffer *leaf,
3539 					  int slot, u64 objectid,
3540 					  int *first_xattr_slot)
3541 {
3542 	u32 nritems = btrfs_header_nritems(leaf);
3543 	struct btrfs_key found_key;
3544 	static u64 xattr_access = 0;
3545 	static u64 xattr_default = 0;
3546 	int scanned = 0;
3547 
3548 	if (!xattr_access) {
3549 		xattr_access = btrfs_name_hash(POSIX_ACL_XATTR_ACCESS,
3550 					strlen(POSIX_ACL_XATTR_ACCESS));
3551 		xattr_default = btrfs_name_hash(POSIX_ACL_XATTR_DEFAULT,
3552 					strlen(POSIX_ACL_XATTR_DEFAULT));
3553 	}
3554 
3555 	slot++;
3556 	*first_xattr_slot = -1;
3557 	while (slot < nritems) {
3558 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
3559 
3560 		/* we found a different objectid, there must not be acls */
3561 		if (found_key.objectid != objectid)
3562 			return 0;
3563 
3564 		/* we found an xattr, assume we've got an acl */
3565 		if (found_key.type == BTRFS_XATTR_ITEM_KEY) {
3566 			if (*first_xattr_slot == -1)
3567 				*first_xattr_slot = slot;
3568 			if (found_key.offset == xattr_access ||
3569 			    found_key.offset == xattr_default)
3570 				return 1;
3571 		}
3572 
3573 		/*
3574 		 * we found a key greater than an xattr key, there can't
3575 		 * be any acls later on
3576 		 */
3577 		if (found_key.type > BTRFS_XATTR_ITEM_KEY)
3578 			return 0;
3579 
3580 		slot++;
3581 		scanned++;
3582 
3583 		/*
3584 		 * it goes inode, inode backrefs, xattrs, extents,
3585 		 * so if there are a ton of hard links to an inode there can
3586 		 * be a lot of backrefs.  Don't waste time searching too hard,
3587 		 * this is just an optimization
3588 		 */
3589 		if (scanned >= 8)
3590 			break;
3591 	}
3592 	/* we hit the end of the leaf before we found an xattr or
3593 	 * something larger than an xattr.  We have to assume the inode
3594 	 * has acls
3595 	 */
3596 	if (*first_xattr_slot == -1)
3597 		*first_xattr_slot = slot;
3598 	return 1;
3599 }
3600 
3601 /*
3602  * read an inode from the btree into the in-memory inode
3603  */
btrfs_read_locked_inode(struct inode * inode)3604 static void btrfs_read_locked_inode(struct inode *inode)
3605 {
3606 	struct btrfs_path *path;
3607 	struct extent_buffer *leaf;
3608 	struct btrfs_inode_item *inode_item;
3609 	struct btrfs_root *root = BTRFS_I(inode)->root;
3610 	struct btrfs_key location;
3611 	unsigned long ptr;
3612 	int maybe_acls;
3613 	u32 rdev;
3614 	int ret;
3615 	bool filled = false;
3616 	int first_xattr_slot;
3617 
3618 	ret = btrfs_fill_inode(inode, &rdev);
3619 	if (!ret)
3620 		filled = true;
3621 
3622 	path = btrfs_alloc_path();
3623 	if (!path)
3624 		goto make_bad;
3625 
3626 	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
3627 
3628 	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
3629 	if (ret)
3630 		goto make_bad;
3631 
3632 	leaf = path->nodes[0];
3633 
3634 	if (filled)
3635 		goto cache_index;
3636 
3637 	inode_item = btrfs_item_ptr(leaf, path->slots[0],
3638 				    struct btrfs_inode_item);
3639 	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
3640 	set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
3641 	i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
3642 	i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
3643 	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
3644 
3645 	inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime);
3646 	inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime);
3647 
3648 	inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime);
3649 	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime);
3650 
3651 	inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->ctime);
3652 	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->ctime);
3653 
3654 	BTRFS_I(inode)->i_otime.tv_sec =
3655 		btrfs_timespec_sec(leaf, &inode_item->otime);
3656 	BTRFS_I(inode)->i_otime.tv_nsec =
3657 		btrfs_timespec_nsec(leaf, &inode_item->otime);
3658 
3659 	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
3660 	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
3661 	BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);
3662 
3663 	inode->i_version = btrfs_inode_sequence(leaf, inode_item);
3664 	inode->i_generation = BTRFS_I(inode)->generation;
3665 	inode->i_rdev = 0;
3666 	rdev = btrfs_inode_rdev(leaf, inode_item);
3667 
3668 	BTRFS_I(inode)->index_cnt = (u64)-1;
3669 	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
3670 
3671 cache_index:
3672 	/*
3673 	 * If we were modified in the current generation and evicted from memory
3674 	 * and then re-read we need to do a full sync since we don't have any
3675 	 * idea about which extents were modified before we were evicted from
3676 	 * cache.
3677 	 *
3678 	 * This is required for both inode re-read from disk and delayed inode
3679 	 * in delayed_nodes_tree.
3680 	 */
3681 	if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
3682 		set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3683 			&BTRFS_I(inode)->runtime_flags);
3684 
3685 	/*
3686 	 * We don't persist the id of the transaction where an unlink operation
3687 	 * against the inode was last made. So here we assume the inode might
3688 	 * have been evicted, and therefore the exact value of last_unlink_trans
3689 	 * lost, and set it to last_trans to avoid metadata inconsistencies
3690 	 * between the inode and its parent if the inode is fsync'ed and the log
3691 	 * replayed. For example, in the scenario:
3692 	 *
3693 	 * touch mydir/foo
3694 	 * ln mydir/foo mydir/bar
3695 	 * sync
3696 	 * unlink mydir/bar
3697 	 * echo 2 > /proc/sys/vm/drop_caches   # evicts inode
3698 	 * xfs_io -c fsync mydir/foo
3699 	 * <power failure>
3700 	 * mount fs, triggers fsync log replay
3701 	 *
3702 	 * We must make sure that when we fsync our inode foo we also log its
3703 	 * parent inode, otherwise after log replay the parent still has the
3704 	 * dentry with the "bar" name but our inode foo has a link count of 1
3705 	 * and doesn't have an inode ref with the name "bar" anymore.
3706 	 *
3707 	 * Setting last_unlink_trans to last_trans is a pessimistic approach,
3708 	 * but it guarantees correctness at the expense of ocassional full
3709 	 * transaction commits on fsync if our inode is a directory, or if our
3710 	 * inode is not a directory, logging its parent unnecessarily.
3711 	 */
3712 	BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans;
3713 
3714 	path->slots[0]++;
3715 	if (inode->i_nlink != 1 ||
3716 	    path->slots[0] >= btrfs_header_nritems(leaf))
3717 		goto cache_acl;
3718 
3719 	btrfs_item_key_to_cpu(leaf, &location, path->slots[0]);
3720 	if (location.objectid != btrfs_ino(inode))
3721 		goto cache_acl;
3722 
3723 	ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
3724 	if (location.type == BTRFS_INODE_REF_KEY) {
3725 		struct btrfs_inode_ref *ref;
3726 
3727 		ref = (struct btrfs_inode_ref *)ptr;
3728 		BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref);
3729 	} else if (location.type == BTRFS_INODE_EXTREF_KEY) {
3730 		struct btrfs_inode_extref *extref;
3731 
3732 		extref = (struct btrfs_inode_extref *)ptr;
3733 		BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf,
3734 								     extref);
3735 	}
3736 cache_acl:
3737 	/*
3738 	 * try to precache a NULL acl entry for files that don't have
3739 	 * any xattrs or acls
3740 	 */
3741 	maybe_acls = acls_after_inode_item(leaf, path->slots[0],
3742 					   btrfs_ino(inode), &first_xattr_slot);
3743 	if (first_xattr_slot != -1) {
3744 		path->slots[0] = first_xattr_slot;
3745 		ret = btrfs_load_inode_props(inode, path);
3746 		if (ret)
3747 			btrfs_err(root->fs_info,
3748 				  "error loading props for ino %llu (root %llu): %d",
3749 				  btrfs_ino(inode),
3750 				  root->root_key.objectid, ret);
3751 	}
3752 	btrfs_free_path(path);
3753 
3754 	if (!maybe_acls)
3755 		cache_no_acl(inode);
3756 
3757 	switch (inode->i_mode & S_IFMT) {
3758 	case S_IFREG:
3759 		inode->i_mapping->a_ops = &btrfs_aops;
3760 		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
3761 		inode->i_fop = &btrfs_file_operations;
3762 		inode->i_op = &btrfs_file_inode_operations;
3763 		break;
3764 	case S_IFDIR:
3765 		inode->i_fop = &btrfs_dir_file_operations;
3766 		if (root == root->fs_info->tree_root)
3767 			inode->i_op = &btrfs_dir_ro_inode_operations;
3768 		else
3769 			inode->i_op = &btrfs_dir_inode_operations;
3770 		break;
3771 	case S_IFLNK:
3772 		inode->i_op = &btrfs_symlink_inode_operations;
3773 		inode->i_mapping->a_ops = &btrfs_symlink_aops;
3774 		break;
3775 	default:
3776 		inode->i_op = &btrfs_special_inode_operations;
3777 		init_special_inode(inode, inode->i_mode, rdev);
3778 		break;
3779 	}
3780 
3781 	btrfs_update_iflags(inode);
3782 	return;
3783 
3784 make_bad:
3785 	btrfs_free_path(path);
3786 	make_bad_inode(inode);
3787 }
3788 
3789 /*
3790  * given a leaf and an inode, copy the inode fields into the leaf
3791  */
fill_inode_item(struct btrfs_trans_handle * trans,struct extent_buffer * leaf,struct btrfs_inode_item * item,struct inode * inode)3792 static void fill_inode_item(struct btrfs_trans_handle *trans,
3793 			    struct extent_buffer *leaf,
3794 			    struct btrfs_inode_item *item,
3795 			    struct inode *inode)
3796 {
3797 	struct btrfs_map_token token;
3798 
3799 	btrfs_init_map_token(&token);
3800 
3801 	btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
3802 	btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
3803 	btrfs_set_token_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size,
3804 				   &token);
3805 	btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
3806 	btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
3807 
3808 	btrfs_set_token_timespec_sec(leaf, &item->atime,
3809 				     inode->i_atime.tv_sec, &token);
3810 	btrfs_set_token_timespec_nsec(leaf, &item->atime,
3811 				      inode->i_atime.tv_nsec, &token);
3812 
3813 	btrfs_set_token_timespec_sec(leaf, &item->mtime,
3814 				     inode->i_mtime.tv_sec, &token);
3815 	btrfs_set_token_timespec_nsec(leaf, &item->mtime,
3816 				      inode->i_mtime.tv_nsec, &token);
3817 
3818 	btrfs_set_token_timespec_sec(leaf, &item->ctime,
3819 				     inode->i_ctime.tv_sec, &token);
3820 	btrfs_set_token_timespec_nsec(leaf, &item->ctime,
3821 				      inode->i_ctime.tv_nsec, &token);
3822 
3823 	btrfs_set_token_timespec_sec(leaf, &item->otime,
3824 				     BTRFS_I(inode)->i_otime.tv_sec, &token);
3825 	btrfs_set_token_timespec_nsec(leaf, &item->otime,
3826 				      BTRFS_I(inode)->i_otime.tv_nsec, &token);
3827 
3828 	btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
3829 				     &token);
3830 	btrfs_set_token_inode_generation(leaf, item, BTRFS_I(inode)->generation,
3831 					 &token);
3832 	btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
3833 	btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
3834 	btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3835 	btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3836 	btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3837 }
3838 
3839 /*
3840  * copy everything in the in-memory inode into the btree.
3841  */
btrfs_update_inode_item(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * inode)3842 static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
3843 				struct btrfs_root *root, struct inode *inode)
3844 {
3845 	struct btrfs_inode_item *inode_item;
3846 	struct btrfs_path *path;
3847 	struct extent_buffer *leaf;
3848 	int ret;
3849 
3850 	path = btrfs_alloc_path();
3851 	if (!path)
3852 		return -ENOMEM;
3853 
3854 	path->leave_spinning = 1;
3855 	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
3856 				 1);
3857 	if (ret) {
3858 		if (ret > 0)
3859 			ret = -ENOENT;
3860 		goto failed;
3861 	}
3862 
3863 	leaf = path->nodes[0];
3864 	inode_item = btrfs_item_ptr(leaf, path->slots[0],
3865 				    struct btrfs_inode_item);
3866 
3867 	fill_inode_item(trans, leaf, inode_item, inode);
3868 	btrfs_mark_buffer_dirty(leaf);
3869 	btrfs_set_inode_last_trans(trans, inode);
3870 	ret = 0;
3871 failed:
3872 	btrfs_free_path(path);
3873 	return ret;
3874 }
3875 
3876 /*
3877  * copy everything in the in-memory inode into the btree.
3878  */
btrfs_update_inode(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * inode)3879 noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
3880 				struct btrfs_root *root, struct inode *inode)
3881 {
3882 	int ret;
3883 
3884 	/*
3885 	 * If the inode is a free space inode, we can deadlock during commit
3886 	 * if we put it into the delayed code.
3887 	 *
3888 	 * The data relocation inode should also be directly updated
3889 	 * without delay
3890 	 */
3891 	if (!btrfs_is_free_space_inode(inode)
3892 	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
3893 	    && !root->fs_info->log_root_recovering) {
3894 		btrfs_update_root_times(trans, root);
3895 
3896 		ret = btrfs_delayed_update_inode(trans, root, inode);
3897 		if (!ret)
3898 			btrfs_set_inode_last_trans(trans, inode);
3899 		return ret;
3900 	}
3901 
3902 	return btrfs_update_inode_item(trans, root, inode);
3903 }
3904 
btrfs_update_inode_fallback(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * inode)3905 noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3906 					 struct btrfs_root *root,
3907 					 struct inode *inode)
3908 {
3909 	int ret;
3910 
3911 	ret = btrfs_update_inode(trans, root, inode);
3912 	if (ret == -ENOSPC)
3913 		return btrfs_update_inode_item(trans, root, inode);
3914 	return ret;
3915 }
3916 
3917 /*
3918  * unlink helper that gets used here in inode.c and in the tree logging
3919  * recovery code.  It remove a link in a directory with a given name, and
3920  * also drops the back refs in the inode to the directory
3921  */
__btrfs_unlink_inode(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * dir,struct inode * inode,const char * name,int name_len)3922 static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3923 				struct btrfs_root *root,
3924 				struct inode *dir, struct inode *inode,
3925 				const char *name, int name_len)
3926 {
3927 	struct btrfs_path *path;
3928 	int ret = 0;
3929 	struct extent_buffer *leaf;
3930 	struct btrfs_dir_item *di;
3931 	struct btrfs_key key;
3932 	u64 index;
3933 	u64 ino = btrfs_ino(inode);
3934 	u64 dir_ino = btrfs_ino(dir);
3935 
3936 	path = btrfs_alloc_path();
3937 	if (!path) {
3938 		ret = -ENOMEM;
3939 		goto out;
3940 	}
3941 
3942 	path->leave_spinning = 1;
3943 	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3944 				    name, name_len, -1);
3945 	if (IS_ERR(di)) {
3946 		ret = PTR_ERR(di);
3947 		goto err;
3948 	}
3949 	if (!di) {
3950 		ret = -ENOENT;
3951 		goto err;
3952 	}
3953 	leaf = path->nodes[0];
3954 	btrfs_dir_item_key_to_cpu(leaf, di, &key);
3955 	ret = btrfs_delete_one_dir_name(trans, root, path, di);
3956 	if (ret)
3957 		goto err;
3958 	btrfs_release_path(path);
3959 
3960 	/*
3961 	 * If we don't have dir index, we have to get it by looking up
3962 	 * the inode ref, since we get the inode ref, remove it directly,
3963 	 * it is unnecessary to do delayed deletion.
3964 	 *
3965 	 * But if we have dir index, needn't search inode ref to get it.
3966 	 * Since the inode ref is close to the inode item, it is better
3967 	 * that we delay to delete it, and just do this deletion when
3968 	 * we update the inode item.
3969 	 */
3970 	if (BTRFS_I(inode)->dir_index) {
3971 		ret = btrfs_delayed_delete_inode_ref(inode);
3972 		if (!ret) {
3973 			index = BTRFS_I(inode)->dir_index;
3974 			goto skip_backref;
3975 		}
3976 	}
3977 
3978 	ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
3979 				  dir_ino, &index);
3980 	if (ret) {
3981 		btrfs_info(root->fs_info,
3982 			"failed to delete reference to %.*s, inode %llu parent %llu",
3983 			name_len, name, ino, dir_ino);
3984 		btrfs_abort_transaction(trans, root, ret);
3985 		goto err;
3986 	}
3987 skip_backref:
3988 	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3989 	if (ret) {
3990 		btrfs_abort_transaction(trans, root, ret);
3991 		goto err;
3992 	}
3993 
3994 	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
3995 					 inode, dir_ino);
3996 	if (ret != 0 && ret != -ENOENT) {
3997 		btrfs_abort_transaction(trans, root, ret);
3998 		goto err;
3999 	}
4000 
4001 	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
4002 					   dir, index);
4003 	if (ret == -ENOENT)
4004 		ret = 0;
4005 	else if (ret)
4006 		btrfs_abort_transaction(trans, root, ret);
4007 err:
4008 	btrfs_free_path(path);
4009 	if (ret)
4010 		goto out;
4011 
4012 	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
4013 	inode_inc_iversion(inode);
4014 	inode_inc_iversion(dir);
4015 	inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
4016 	ret = btrfs_update_inode(trans, root, dir);
4017 out:
4018 	return ret;
4019 }
4020 
btrfs_unlink_inode(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * dir,struct inode * inode,const char * name,int name_len)4021 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
4022 		       struct btrfs_root *root,
4023 		       struct inode *dir, struct inode *inode,
4024 		       const char *name, int name_len)
4025 {
4026 	int ret;
4027 	ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
4028 	if (!ret) {
4029 		drop_nlink(inode);
4030 		ret = btrfs_update_inode(trans, root, inode);
4031 	}
4032 	return ret;
4033 }
4034 
4035 /*
4036  * helper to start transaction for unlink and rmdir.
4037  *
4038  * unlink and rmdir are special in btrfs, they do not always free space, so
4039  * if we cannot make our reservations the normal way try and see if there is
4040  * plenty of slack room in the global reserve to migrate, otherwise we cannot
4041  * allow the unlink to occur.
4042  */
__unlink_start_trans(struct inode * dir)4043 static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir)
4044 {
4045 	struct btrfs_root *root = BTRFS_I(dir)->root;
4046 
4047 	/*
4048 	 * 1 for the possible orphan item
4049 	 * 1 for the dir item
4050 	 * 1 for the dir index
4051 	 * 1 for the inode ref
4052 	 * 1 for the inode
4053 	 */
4054 	return btrfs_start_transaction_fallback_global_rsv(root, 5, 5);
4055 }
4056 
btrfs_unlink(struct inode * dir,struct dentry * dentry)4057 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
4058 {
4059 	struct btrfs_root *root = BTRFS_I(dir)->root;
4060 	struct btrfs_trans_handle *trans;
4061 	struct inode *inode = d_inode(dentry);
4062 	int ret;
4063 
4064 	trans = __unlink_start_trans(dir);
4065 	if (IS_ERR(trans))
4066 		return PTR_ERR(trans);
4067 
4068 	btrfs_record_unlink_dir(trans, dir, d_inode(dentry), 0);
4069 
4070 	ret = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
4071 				 dentry->d_name.name, dentry->d_name.len);
4072 	if (ret)
4073 		goto out;
4074 
4075 	if (inode->i_nlink == 0) {
4076 		ret = btrfs_orphan_add(trans, inode);
4077 		if (ret)
4078 			goto out;
4079 	}
4080 
4081 out:
4082 	btrfs_end_transaction(trans, root);
4083 	btrfs_btree_balance_dirty(root);
4084 	return ret;
4085 }
4086 
btrfs_unlink_subvol(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * dir,u64 objectid,const char * name,int name_len)4087 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
4088 			struct btrfs_root *root,
4089 			struct inode *dir, u64 objectid,
4090 			const char *name, int name_len)
4091 {
4092 	struct btrfs_path *path;
4093 	struct extent_buffer *leaf;
4094 	struct btrfs_dir_item *di;
4095 	struct btrfs_key key;
4096 	u64 index;
4097 	int ret;
4098 	u64 dir_ino = btrfs_ino(dir);
4099 
4100 	path = btrfs_alloc_path();
4101 	if (!path)
4102 		return -ENOMEM;
4103 
4104 	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
4105 				   name, name_len, -1);
4106 	if (IS_ERR_OR_NULL(di)) {
4107 		if (!di)
4108 			ret = -ENOENT;
4109 		else
4110 			ret = PTR_ERR(di);
4111 		goto out;
4112 	}
4113 
4114 	leaf = path->nodes[0];
4115 	btrfs_dir_item_key_to_cpu(leaf, di, &key);
4116 	WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
4117 	ret = btrfs_delete_one_dir_name(trans, root, path, di);
4118 	if (ret) {
4119 		btrfs_abort_transaction(trans, root, ret);
4120 		goto out;
4121 	}
4122 	btrfs_release_path(path);
4123 
4124 	ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
4125 				 objectid, root->root_key.objectid,
4126 				 dir_ino, &index, name, name_len);
4127 	if (ret < 0) {
4128 		if (ret != -ENOENT) {
4129 			btrfs_abort_transaction(trans, root, ret);
4130 			goto out;
4131 		}
4132 		di = btrfs_search_dir_index_item(root, path, dir_ino,
4133 						 name, name_len);
4134 		if (IS_ERR_OR_NULL(di)) {
4135 			if (!di)
4136 				ret = -ENOENT;
4137 			else
4138 				ret = PTR_ERR(di);
4139 			btrfs_abort_transaction(trans, root, ret);
4140 			goto out;
4141 		}
4142 
4143 		leaf = path->nodes[0];
4144 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
4145 		btrfs_release_path(path);
4146 		index = key.offset;
4147 	}
4148 	btrfs_release_path(path);
4149 
4150 	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
4151 	if (ret) {
4152 		btrfs_abort_transaction(trans, root, ret);
4153 		goto out;
4154 	}
4155 
4156 	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
4157 	inode_inc_iversion(dir);
4158 	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
4159 	ret = btrfs_update_inode_fallback(trans, root, dir);
4160 	if (ret)
4161 		btrfs_abort_transaction(trans, root, ret);
4162 out:
4163 	btrfs_free_path(path);
4164 	return ret;
4165 }
4166 
btrfs_rmdir(struct inode * dir,struct dentry * dentry)4167 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
4168 {
4169 	struct inode *inode = d_inode(dentry);
4170 	int err = 0;
4171 	struct btrfs_root *root = BTRFS_I(dir)->root;
4172 	struct btrfs_trans_handle *trans;
4173 
4174 	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
4175 		return -ENOTEMPTY;
4176 	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
4177 		return -EPERM;
4178 
4179 	trans = __unlink_start_trans(dir);
4180 	if (IS_ERR(trans))
4181 		return PTR_ERR(trans);
4182 
4183 	if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
4184 		err = btrfs_unlink_subvol(trans, root, dir,
4185 					  BTRFS_I(inode)->location.objectid,
4186 					  dentry->d_name.name,
4187 					  dentry->d_name.len);
4188 		goto out;
4189 	}
4190 
4191 	err = btrfs_orphan_add(trans, inode);
4192 	if (err)
4193 		goto out;
4194 
4195 	/* now the directory is empty */
4196 	err = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
4197 				 dentry->d_name.name, dentry->d_name.len);
4198 	if (!err)
4199 		btrfs_i_size_write(inode, 0);
4200 out:
4201 	btrfs_end_transaction(trans, root);
4202 	btrfs_btree_balance_dirty(root);
4203 
4204 	return err;
4205 }
4206 
truncate_space_check(struct btrfs_trans_handle * trans,struct btrfs_root * root,u64 bytes_deleted)4207 static int truncate_space_check(struct btrfs_trans_handle *trans,
4208 				struct btrfs_root *root,
4209 				u64 bytes_deleted)
4210 {
4211 	int ret;
4212 
4213 	bytes_deleted = btrfs_csum_bytes_to_leaves(root, bytes_deleted);
4214 	ret = btrfs_block_rsv_add(root, &root->fs_info->trans_block_rsv,
4215 				  bytes_deleted, BTRFS_RESERVE_NO_FLUSH);
4216 	if (!ret)
4217 		trans->bytes_reserved += bytes_deleted;
4218 	return ret;
4219 
4220 }
4221 
truncate_inline_extent(struct inode * inode,struct btrfs_path * path,struct btrfs_key * found_key,const u64 item_end,const u64 new_size)4222 static int truncate_inline_extent(struct inode *inode,
4223 				  struct btrfs_path *path,
4224 				  struct btrfs_key *found_key,
4225 				  const u64 item_end,
4226 				  const u64 new_size)
4227 {
4228 	struct extent_buffer *leaf = path->nodes[0];
4229 	int slot = path->slots[0];
4230 	struct btrfs_file_extent_item *fi;
4231 	u32 size = (u32)(new_size - found_key->offset);
4232 	struct btrfs_root *root = BTRFS_I(inode)->root;
4233 
4234 	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
4235 
4236 	if (btrfs_file_extent_compression(leaf, fi) != BTRFS_COMPRESS_NONE) {
4237 		loff_t offset = new_size;
4238 		loff_t page_end = ALIGN(offset, PAGE_CACHE_SIZE);
4239 
4240 		/*
4241 		 * Zero out the remaining of the last page of our inline extent,
4242 		 * instead of directly truncating our inline extent here - that
4243 		 * would be much more complex (decompressing all the data, then
4244 		 * compressing the truncated data, which might be bigger than
4245 		 * the size of the inline extent, resize the extent, etc).
4246 		 * We release the path because to get the page we might need to
4247 		 * read the extent item from disk (data not in the page cache).
4248 		 */
4249 		btrfs_release_path(path);
4250 		return btrfs_truncate_page(inode, offset, page_end - offset, 0);
4251 	}
4252 
4253 	btrfs_set_file_extent_ram_bytes(leaf, fi, size);
4254 	size = btrfs_file_extent_calc_inline_size(size);
4255 	btrfs_truncate_item(root, path, size, 1);
4256 
4257 	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state))
4258 		inode_sub_bytes(inode, item_end + 1 - new_size);
4259 
4260 	return 0;
4261 }
4262 
4263 /*
4264  * this can truncate away extent items, csum items and directory items.
4265  * It starts at a high offset and removes keys until it can't find
4266  * any higher than new_size
4267  *
4268  * csum items that cross the new i_size are truncated to the new size
4269  * as well.
4270  *
4271  * min_type is the minimum key type to truncate down to.  If set to 0, this
4272  * will kill all the items on this inode, including the INODE_ITEM_KEY.
4273  */
btrfs_truncate_inode_items(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * inode,u64 new_size,u32 min_type)4274 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
4275 			       struct btrfs_root *root,
4276 			       struct inode *inode,
4277 			       u64 new_size, u32 min_type)
4278 {
4279 	struct btrfs_path *path;
4280 	struct extent_buffer *leaf;
4281 	struct btrfs_file_extent_item *fi;
4282 	struct btrfs_key key;
4283 	struct btrfs_key found_key;
4284 	u64 extent_start = 0;
4285 	u64 extent_num_bytes = 0;
4286 	u64 extent_offset = 0;
4287 	u64 item_end = 0;
4288 	u64 last_size = new_size;
4289 	u32 found_type = (u8)-1;
4290 	int found_extent;
4291 	int del_item;
4292 	int pending_del_nr = 0;
4293 	int pending_del_slot = 0;
4294 	int extent_type = -1;
4295 	int ret;
4296 	int err = 0;
4297 	u64 ino = btrfs_ino(inode);
4298 	u64 bytes_deleted = 0;
4299 	bool be_nice = 0;
4300 	bool should_throttle = 0;
4301 	bool should_end = 0;
4302 
4303 	BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
4304 
4305 	/*
4306 	 * for non-free space inodes and ref cows, we want to back off from
4307 	 * time to time
4308 	 */
4309 	if (!btrfs_is_free_space_inode(inode) &&
4310 	    test_bit(BTRFS_ROOT_REF_COWS, &root->state))
4311 		be_nice = 1;
4312 
4313 	path = btrfs_alloc_path();
4314 	if (!path)
4315 		return -ENOMEM;
4316 	path->reada = -1;
4317 
4318 	/*
4319 	 * We want to drop from the next block forward in case this new size is
4320 	 * not block aligned since we will be keeping the last block of the
4321 	 * extent just the way it is.
4322 	 */
4323 	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
4324 	    root == root->fs_info->tree_root)
4325 		btrfs_drop_extent_cache(inode, ALIGN(new_size,
4326 					root->sectorsize), (u64)-1, 0);
4327 
4328 	/*
4329 	 * This function is also used to drop the items in the log tree before
4330 	 * we relog the inode, so if root != BTRFS_I(inode)->root, it means
4331 	 * it is used to drop the loged items. So we shouldn't kill the delayed
4332 	 * items.
4333 	 */
4334 	if (min_type == 0 && root == BTRFS_I(inode)->root)
4335 		btrfs_kill_delayed_inode_items(inode);
4336 
4337 	key.objectid = ino;
4338 	key.offset = (u64)-1;
4339 	key.type = (u8)-1;
4340 
4341 search_again:
4342 	/*
4343 	 * with a 16K leaf size and 128MB extents, you can actually queue
4344 	 * up a huge file in a single leaf.  Most of the time that
4345 	 * bytes_deleted is > 0, it will be huge by the time we get here
4346 	 */
4347 	if (be_nice && bytes_deleted > 32 * 1024 * 1024) {
4348 		if (btrfs_should_end_transaction(trans, root)) {
4349 			err = -EAGAIN;
4350 			goto error;
4351 		}
4352 	}
4353 
4354 
4355 	path->leave_spinning = 1;
4356 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
4357 	if (ret < 0) {
4358 		err = ret;
4359 		goto out;
4360 	}
4361 
4362 	if (ret > 0) {
4363 		/* there are no items in the tree for us to truncate, we're
4364 		 * done
4365 		 */
4366 		if (path->slots[0] == 0)
4367 			goto out;
4368 		path->slots[0]--;
4369 	}
4370 
4371 	while (1) {
4372 		fi = NULL;
4373 		leaf = path->nodes[0];
4374 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
4375 		found_type = found_key.type;
4376 
4377 		if (found_key.objectid != ino)
4378 			break;
4379 
4380 		if (found_type < min_type)
4381 			break;
4382 
4383 		item_end = found_key.offset;
4384 		if (found_type == BTRFS_EXTENT_DATA_KEY) {
4385 			fi = btrfs_item_ptr(leaf, path->slots[0],
4386 					    struct btrfs_file_extent_item);
4387 			extent_type = btrfs_file_extent_type(leaf, fi);
4388 			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
4389 				item_end +=
4390 				    btrfs_file_extent_num_bytes(leaf, fi);
4391 			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4392 				item_end += btrfs_file_extent_inline_len(leaf,
4393 							 path->slots[0], fi);
4394 			}
4395 			item_end--;
4396 		}
4397 		if (found_type > min_type) {
4398 			del_item = 1;
4399 		} else {
4400 			if (item_end < new_size)
4401 				break;
4402 			if (found_key.offset >= new_size)
4403 				del_item = 1;
4404 			else
4405 				del_item = 0;
4406 		}
4407 		found_extent = 0;
4408 		/* FIXME, shrink the extent if the ref count is only 1 */
4409 		if (found_type != BTRFS_EXTENT_DATA_KEY)
4410 			goto delete;
4411 
4412 		if (del_item)
4413 			last_size = found_key.offset;
4414 		else
4415 			last_size = new_size;
4416 
4417 		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
4418 			u64 num_dec;
4419 			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
4420 			if (!del_item) {
4421 				u64 orig_num_bytes =
4422 					btrfs_file_extent_num_bytes(leaf, fi);
4423 				extent_num_bytes = ALIGN(new_size -
4424 						found_key.offset,
4425 						root->sectorsize);
4426 				btrfs_set_file_extent_num_bytes(leaf, fi,
4427 							 extent_num_bytes);
4428 				num_dec = (orig_num_bytes -
4429 					   extent_num_bytes);
4430 				if (test_bit(BTRFS_ROOT_REF_COWS,
4431 					     &root->state) &&
4432 				    extent_start != 0)
4433 					inode_sub_bytes(inode, num_dec);
4434 				btrfs_mark_buffer_dirty(leaf);
4435 			} else {
4436 				extent_num_bytes =
4437 					btrfs_file_extent_disk_num_bytes(leaf,
4438 									 fi);
4439 				extent_offset = found_key.offset -
4440 					btrfs_file_extent_offset(leaf, fi);
4441 
4442 				/* FIXME blocksize != 4096 */
4443 				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
4444 				if (extent_start != 0) {
4445 					found_extent = 1;
4446 					if (test_bit(BTRFS_ROOT_REF_COWS,
4447 						     &root->state))
4448 						inode_sub_bytes(inode, num_dec);
4449 				}
4450 			}
4451 		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4452 			/*
4453 			 * we can't truncate inline items that have had
4454 			 * special encodings
4455 			 */
4456 			if (!del_item &&
4457 			    btrfs_file_extent_encryption(leaf, fi) == 0 &&
4458 			    btrfs_file_extent_other_encoding(leaf, fi) == 0) {
4459 
4460 				/*
4461 				 * Need to release path in order to truncate a
4462 				 * compressed extent. So delete any accumulated
4463 				 * extent items so far.
4464 				 */
4465 				if (btrfs_file_extent_compression(leaf, fi) !=
4466 				    BTRFS_COMPRESS_NONE && pending_del_nr) {
4467 					err = btrfs_del_items(trans, root, path,
4468 							      pending_del_slot,
4469 							      pending_del_nr);
4470 					if (err) {
4471 						btrfs_abort_transaction(trans,
4472 									root,
4473 									err);
4474 						goto error;
4475 					}
4476 					pending_del_nr = 0;
4477 				}
4478 
4479 				err = truncate_inline_extent(inode, path,
4480 							     &found_key,
4481 							     item_end,
4482 							     new_size);
4483 				if (err) {
4484 					btrfs_abort_transaction(trans,
4485 								root, err);
4486 					goto error;
4487 				}
4488 			} else if (test_bit(BTRFS_ROOT_REF_COWS,
4489 					    &root->state)) {
4490 				inode_sub_bytes(inode, item_end + 1 - new_size);
4491 			}
4492 		}
4493 delete:
4494 		if (del_item) {
4495 			if (!pending_del_nr) {
4496 				/* no pending yet, add ourselves */
4497 				pending_del_slot = path->slots[0];
4498 				pending_del_nr = 1;
4499 			} else if (pending_del_nr &&
4500 				   path->slots[0] + 1 == pending_del_slot) {
4501 				/* hop on the pending chunk */
4502 				pending_del_nr++;
4503 				pending_del_slot = path->slots[0];
4504 			} else {
4505 				BUG();
4506 			}
4507 		} else {
4508 			break;
4509 		}
4510 		should_throttle = 0;
4511 
4512 		if (found_extent &&
4513 		    (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
4514 		     root == root->fs_info->tree_root)) {
4515 			btrfs_set_path_blocking(path);
4516 			bytes_deleted += extent_num_bytes;
4517 			ret = btrfs_free_extent(trans, root, extent_start,
4518 						extent_num_bytes, 0,
4519 						btrfs_header_owner(leaf),
4520 						ino, extent_offset);
4521 			BUG_ON(ret);
4522 			if (btrfs_should_throttle_delayed_refs(trans, root))
4523 				btrfs_async_run_delayed_refs(root,
4524 					trans->delayed_ref_updates * 2, 0);
4525 			if (be_nice) {
4526 				if (truncate_space_check(trans, root,
4527 							 extent_num_bytes)) {
4528 					should_end = 1;
4529 				}
4530 				if (btrfs_should_throttle_delayed_refs(trans,
4531 								       root)) {
4532 					should_throttle = 1;
4533 				}
4534 			}
4535 		}
4536 
4537 		if (found_type == BTRFS_INODE_ITEM_KEY)
4538 			break;
4539 
4540 		if (path->slots[0] == 0 ||
4541 		    path->slots[0] != pending_del_slot ||
4542 		    should_throttle || should_end) {
4543 			if (pending_del_nr) {
4544 				ret = btrfs_del_items(trans, root, path,
4545 						pending_del_slot,
4546 						pending_del_nr);
4547 				if (ret) {
4548 					btrfs_abort_transaction(trans,
4549 								root, ret);
4550 					goto error;
4551 				}
4552 				pending_del_nr = 0;
4553 			}
4554 			btrfs_release_path(path);
4555 			if (should_throttle) {
4556 				unsigned long updates = trans->delayed_ref_updates;
4557 				if (updates) {
4558 					trans->delayed_ref_updates = 0;
4559 					ret = btrfs_run_delayed_refs(trans, root, updates * 2);
4560 					if (ret && !err)
4561 						err = ret;
4562 				}
4563 			}
4564 			/*
4565 			 * if we failed to refill our space rsv, bail out
4566 			 * and let the transaction restart
4567 			 */
4568 			if (should_end) {
4569 				err = -EAGAIN;
4570 				goto error;
4571 			}
4572 			goto search_again;
4573 		} else {
4574 			path->slots[0]--;
4575 		}
4576 	}
4577 out:
4578 	if (pending_del_nr) {
4579 		ret = btrfs_del_items(trans, root, path, pending_del_slot,
4580 				      pending_del_nr);
4581 		if (ret)
4582 			btrfs_abort_transaction(trans, root, ret);
4583 	}
4584 error:
4585 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
4586 		btrfs_ordered_update_i_size(inode, last_size, NULL);
4587 
4588 	btrfs_free_path(path);
4589 
4590 	if (be_nice && bytes_deleted > 32 * 1024 * 1024) {
4591 		unsigned long updates = trans->delayed_ref_updates;
4592 		if (updates) {
4593 			trans->delayed_ref_updates = 0;
4594 			ret = btrfs_run_delayed_refs(trans, root, updates * 2);
4595 			if (ret && !err)
4596 				err = ret;
4597 		}
4598 	}
4599 	return err;
4600 }
4601 
4602 /*
4603  * btrfs_truncate_page - read, zero a chunk and write a page
4604  * @inode - inode that we're zeroing
4605  * @from - the offset to start zeroing
4606  * @len - the length to zero, 0 to zero the entire range respective to the
4607  *	offset
4608  * @front - zero up to the offset instead of from the offset on
4609  *
4610  * This will find the page for the "from" offset and cow the page and zero the
4611  * part we want to zero.  This is used with truncate and hole punching.
4612  */
btrfs_truncate_page(struct inode * inode,loff_t from,loff_t len,int front)4613 int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
4614 			int front)
4615 {
4616 	struct address_space *mapping = inode->i_mapping;
4617 	struct btrfs_root *root = BTRFS_I(inode)->root;
4618 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4619 	struct btrfs_ordered_extent *ordered;
4620 	struct extent_state *cached_state = NULL;
4621 	char *kaddr;
4622 	u32 blocksize = root->sectorsize;
4623 	pgoff_t index = from >> PAGE_CACHE_SHIFT;
4624 	unsigned offset = from & (PAGE_CACHE_SIZE-1);
4625 	struct page *page;
4626 	gfp_t mask = btrfs_alloc_write_mask(mapping);
4627 	int ret = 0;
4628 	u64 page_start;
4629 	u64 page_end;
4630 
4631 	if ((offset & (blocksize - 1)) == 0 &&
4632 	    (!len || ((len & (blocksize - 1)) == 0)))
4633 		goto out;
4634 	ret = btrfs_delalloc_reserve_space(inode,
4635 			round_down(from, PAGE_CACHE_SIZE), PAGE_CACHE_SIZE);
4636 	if (ret)
4637 		goto out;
4638 
4639 again:
4640 	page = find_or_create_page(mapping, index, mask);
4641 	if (!page) {
4642 		btrfs_delalloc_release_space(inode,
4643 				round_down(from, PAGE_CACHE_SIZE),
4644 				PAGE_CACHE_SIZE);
4645 		ret = -ENOMEM;
4646 		goto out;
4647 	}
4648 
4649 	page_start = page_offset(page);
4650 	page_end = page_start + PAGE_CACHE_SIZE - 1;
4651 
4652 	if (!PageUptodate(page)) {
4653 		ret = btrfs_readpage(NULL, page);
4654 		lock_page(page);
4655 		if (page->mapping != mapping) {
4656 			unlock_page(page);
4657 			page_cache_release(page);
4658 			goto again;
4659 		}
4660 		if (!PageUptodate(page)) {
4661 			ret = -EIO;
4662 			goto out_unlock;
4663 		}
4664 	}
4665 	wait_on_page_writeback(page);
4666 
4667 	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
4668 	set_page_extent_mapped(page);
4669 
4670 	ordered = btrfs_lookup_ordered_extent(inode, page_start);
4671 	if (ordered) {
4672 		unlock_extent_cached(io_tree, page_start, page_end,
4673 				     &cached_state, GFP_NOFS);
4674 		unlock_page(page);
4675 		page_cache_release(page);
4676 		btrfs_start_ordered_extent(inode, ordered, 1);
4677 		btrfs_put_ordered_extent(ordered);
4678 		goto again;
4679 	}
4680 
4681 	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
4682 			  EXTENT_DIRTY | EXTENT_DELALLOC |
4683 			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
4684 			  0, 0, &cached_state, GFP_NOFS);
4685 
4686 	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
4687 					&cached_state);
4688 	if (ret) {
4689 		unlock_extent_cached(io_tree, page_start, page_end,
4690 				     &cached_state, GFP_NOFS);
4691 		goto out_unlock;
4692 	}
4693 
4694 	if (offset != PAGE_CACHE_SIZE) {
4695 		if (!len)
4696 			len = PAGE_CACHE_SIZE - offset;
4697 		kaddr = kmap(page);
4698 		if (front)
4699 			memset(kaddr, 0, offset);
4700 		else
4701 			memset(kaddr + offset, 0, len);
4702 		flush_dcache_page(page);
4703 		kunmap(page);
4704 	}
4705 	ClearPageChecked(page);
4706 	set_page_dirty(page);
4707 	unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
4708 			     GFP_NOFS);
4709 
4710 out_unlock:
4711 	if (ret)
4712 		btrfs_delalloc_release_space(inode, page_start,
4713 					     PAGE_CACHE_SIZE);
4714 	unlock_page(page);
4715 	page_cache_release(page);
4716 out:
4717 	return ret;
4718 }
4719 
maybe_insert_hole(struct btrfs_root * root,struct inode * inode,u64 offset,u64 len)4720 static int maybe_insert_hole(struct btrfs_root *root, struct inode *inode,
4721 			     u64 offset, u64 len)
4722 {
4723 	struct btrfs_trans_handle *trans;
4724 	int ret;
4725 
4726 	/*
4727 	 * Still need to make sure the inode looks like it's been updated so
4728 	 * that any holes get logged if we fsync.
4729 	 */
4730 	if (btrfs_fs_incompat(root->fs_info, NO_HOLES)) {
4731 		BTRFS_I(inode)->last_trans = root->fs_info->generation;
4732 		BTRFS_I(inode)->last_sub_trans = root->log_transid;
4733 		BTRFS_I(inode)->last_log_commit = root->last_log_commit;
4734 		return 0;
4735 	}
4736 
4737 	/*
4738 	 * 1 - for the one we're dropping
4739 	 * 1 - for the one we're adding
4740 	 * 1 - for updating the inode.
4741 	 */
4742 	trans = btrfs_start_transaction(root, 3);
4743 	if (IS_ERR(trans))
4744 		return PTR_ERR(trans);
4745 
4746 	ret = btrfs_drop_extents(trans, root, inode, offset, offset + len, 1);
4747 	if (ret) {
4748 		btrfs_abort_transaction(trans, root, ret);
4749 		btrfs_end_transaction(trans, root);
4750 		return ret;
4751 	}
4752 
4753 	ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset,
4754 				       0, 0, len, 0, len, 0, 0, 0);
4755 	if (ret)
4756 		btrfs_abort_transaction(trans, root, ret);
4757 	else
4758 		btrfs_update_inode(trans, root, inode);
4759 	btrfs_end_transaction(trans, root);
4760 	return ret;
4761 }
4762 
4763 /*
4764  * This function puts in dummy file extents for the area we're creating a hole
4765  * for.  So if we are truncating this file to a larger size we need to insert
4766  * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
4767  * the range between oldsize and size
4768  */
btrfs_cont_expand(struct inode * inode,loff_t oldsize,loff_t size)4769 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4770 {
4771 	struct btrfs_root *root = BTRFS_I(inode)->root;
4772 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4773 	struct extent_map *em = NULL;
4774 	struct extent_state *cached_state = NULL;
4775 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4776 	u64 hole_start = ALIGN(oldsize, root->sectorsize);
4777 	u64 block_end = ALIGN(size, root->sectorsize);
4778 	u64 last_byte;
4779 	u64 cur_offset;
4780 	u64 hole_size;
4781 	int err = 0;
4782 
4783 	/*
4784 	 * If our size started in the middle of a page we need to zero out the
4785 	 * rest of the page before we expand the i_size, otherwise we could
4786 	 * expose stale data.
4787 	 */
4788 	err = btrfs_truncate_page(inode, oldsize, 0, 0);
4789 	if (err)
4790 		return err;
4791 
4792 	if (size <= hole_start)
4793 		return 0;
4794 
4795 	while (1) {
4796 		struct btrfs_ordered_extent *ordered;
4797 
4798 		lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
4799 				 &cached_state);
4800 		ordered = btrfs_lookup_ordered_range(inode, hole_start,
4801 						     block_end - hole_start);
4802 		if (!ordered)
4803 			break;
4804 		unlock_extent_cached(io_tree, hole_start, block_end - 1,
4805 				     &cached_state, GFP_NOFS);
4806 		btrfs_start_ordered_extent(inode, ordered, 1);
4807 		btrfs_put_ordered_extent(ordered);
4808 	}
4809 
4810 	cur_offset = hole_start;
4811 	while (1) {
4812 		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
4813 				block_end - cur_offset, 0);
4814 		if (IS_ERR(em)) {
4815 			err = PTR_ERR(em);
4816 			em = NULL;
4817 			break;
4818 		}
4819 		last_byte = min(extent_map_end(em), block_end);
4820 		last_byte = ALIGN(last_byte , root->sectorsize);
4821 		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
4822 			struct extent_map *hole_em;
4823 			hole_size = last_byte - cur_offset;
4824 
4825 			err = maybe_insert_hole(root, inode, cur_offset,
4826 						hole_size);
4827 			if (err)
4828 				break;
4829 			btrfs_drop_extent_cache(inode, cur_offset,
4830 						cur_offset + hole_size - 1, 0);
4831 			hole_em = alloc_extent_map();
4832 			if (!hole_em) {
4833 				set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
4834 					&BTRFS_I(inode)->runtime_flags);
4835 				goto next;
4836 			}
4837 			hole_em->start = cur_offset;
4838 			hole_em->len = hole_size;
4839 			hole_em->orig_start = cur_offset;
4840 
4841 			hole_em->block_start = EXTENT_MAP_HOLE;
4842 			hole_em->block_len = 0;
4843 			hole_em->orig_block_len = 0;
4844 			hole_em->ram_bytes = hole_size;
4845 			hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
4846 			hole_em->compress_type = BTRFS_COMPRESS_NONE;
4847 			hole_em->generation = root->fs_info->generation;
4848 
4849 			while (1) {
4850 				write_lock(&em_tree->lock);
4851 				err = add_extent_mapping(em_tree, hole_em, 1);
4852 				write_unlock(&em_tree->lock);
4853 				if (err != -EEXIST)
4854 					break;
4855 				btrfs_drop_extent_cache(inode, cur_offset,
4856 							cur_offset +
4857 							hole_size - 1, 0);
4858 			}
4859 			free_extent_map(hole_em);
4860 		}
4861 next:
4862 		free_extent_map(em);
4863 		em = NULL;
4864 		cur_offset = last_byte;
4865 		if (cur_offset >= block_end)
4866 			break;
4867 	}
4868 	free_extent_map(em);
4869 	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
4870 			     GFP_NOFS);
4871 	return err;
4872 }
4873 
wait_snapshoting_atomic_t(atomic_t * a)4874 static int wait_snapshoting_atomic_t(atomic_t *a)
4875 {
4876 	schedule();
4877 	return 0;
4878 }
4879 
wait_for_snapshot_creation(struct btrfs_root * root)4880 static void wait_for_snapshot_creation(struct btrfs_root *root)
4881 {
4882 	while (true) {
4883 		int ret;
4884 
4885 		ret = btrfs_start_write_no_snapshoting(root);
4886 		if (ret)
4887 			break;
4888 		wait_on_atomic_t(&root->will_be_snapshoted,
4889 				 wait_snapshoting_atomic_t,
4890 				 TASK_UNINTERRUPTIBLE);
4891 	}
4892 }
4893 
btrfs_setsize(struct inode * inode,struct iattr * attr)4894 static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4895 {
4896 	struct btrfs_root *root = BTRFS_I(inode)->root;
4897 	struct btrfs_trans_handle *trans;
4898 	loff_t oldsize = i_size_read(inode);
4899 	loff_t newsize = attr->ia_size;
4900 	int mask = attr->ia_valid;
4901 	int ret;
4902 
4903 	/*
4904 	 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
4905 	 * special case where we need to update the times despite not having
4906 	 * these flags set.  For all other operations the VFS set these flags
4907 	 * explicitly if it wants a timestamp update.
4908 	 */
4909 	if (newsize != oldsize) {
4910 		inode_inc_iversion(inode);
4911 		if (!(mask & (ATTR_CTIME | ATTR_MTIME)))
4912 			inode->i_ctime = inode->i_mtime =
4913 				current_fs_time(inode->i_sb);
4914 	}
4915 
4916 	if (newsize > oldsize) {
4917 		truncate_pagecache(inode, newsize);
4918 		/*
4919 		 * Don't do an expanding truncate while snapshoting is ongoing.
4920 		 * This is to ensure the snapshot captures a fully consistent
4921 		 * state of this file - if the snapshot captures this expanding
4922 		 * truncation, it must capture all writes that happened before
4923 		 * this truncation.
4924 		 */
4925 		wait_for_snapshot_creation(root);
4926 		ret = btrfs_cont_expand(inode, oldsize, newsize);
4927 		if (ret) {
4928 			btrfs_end_write_no_snapshoting(root);
4929 			return ret;
4930 		}
4931 
4932 		trans = btrfs_start_transaction(root, 1);
4933 		if (IS_ERR(trans)) {
4934 			btrfs_end_write_no_snapshoting(root);
4935 			return PTR_ERR(trans);
4936 		}
4937 
4938 		i_size_write(inode, newsize);
4939 		btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
4940 		ret = btrfs_update_inode(trans, root, inode);
4941 		btrfs_end_write_no_snapshoting(root);
4942 		btrfs_end_transaction(trans, root);
4943 	} else {
4944 
4945 		/*
4946 		 * We're truncating a file that used to have good data down to
4947 		 * zero. Make sure it gets into the ordered flush list so that
4948 		 * any new writes get down to disk quickly.
4949 		 */
4950 		if (newsize == 0)
4951 			set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
4952 				&BTRFS_I(inode)->runtime_flags);
4953 
4954 		/*
4955 		 * 1 for the orphan item we're going to add
4956 		 * 1 for the orphan item deletion.
4957 		 */
4958 		trans = btrfs_start_transaction(root, 2);
4959 		if (IS_ERR(trans))
4960 			return PTR_ERR(trans);
4961 
4962 		/*
4963 		 * We need to do this in case we fail at _any_ point during the
4964 		 * actual truncate.  Once we do the truncate_setsize we could
4965 		 * invalidate pages which forces any outstanding ordered io to
4966 		 * be instantly completed which will give us extents that need
4967 		 * to be truncated.  If we fail to get an orphan inode down we
4968 		 * could have left over extents that were never meant to live,
4969 		 * so we need to garuntee from this point on that everything
4970 		 * will be consistent.
4971 		 */
4972 		ret = btrfs_orphan_add(trans, inode);
4973 		btrfs_end_transaction(trans, root);
4974 		if (ret)
4975 			return ret;
4976 
4977 		/* we don't support swapfiles, so vmtruncate shouldn't fail */
4978 		truncate_setsize(inode, newsize);
4979 
4980 		/* Disable nonlocked read DIO to avoid the end less truncate */
4981 		btrfs_inode_block_unlocked_dio(inode);
4982 		inode_dio_wait(inode);
4983 		btrfs_inode_resume_unlocked_dio(inode);
4984 
4985 		ret = btrfs_truncate(inode);
4986 		if (ret && inode->i_nlink) {
4987 			int err;
4988 
4989 			/*
4990 			 * failed to truncate, disk_i_size is only adjusted down
4991 			 * as we remove extents, so it should represent the true
4992 			 * size of the inode, so reset the in memory size and
4993 			 * delete our orphan entry.
4994 			 */
4995 			trans = btrfs_join_transaction(root);
4996 			if (IS_ERR(trans)) {
4997 				btrfs_orphan_del(NULL, inode);
4998 				return ret;
4999 			}
5000 			i_size_write(inode, BTRFS_I(inode)->disk_i_size);
5001 			err = btrfs_orphan_del(trans, inode);
5002 			if (err)
5003 				btrfs_abort_transaction(trans, root, err);
5004 			btrfs_end_transaction(trans, root);
5005 		}
5006 	}
5007 
5008 	return ret;
5009 }
5010 
btrfs_setattr(struct dentry * dentry,struct iattr * attr)5011 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
5012 {
5013 	struct inode *inode = d_inode(dentry);
5014 	struct btrfs_root *root = BTRFS_I(inode)->root;
5015 	int err;
5016 
5017 	if (btrfs_root_readonly(root))
5018 		return -EROFS;
5019 
5020 	err = inode_change_ok(inode, attr);
5021 	if (err)
5022 		return err;
5023 
5024 	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
5025 		err = btrfs_setsize(inode, attr);
5026 		if (err)
5027 			return err;
5028 	}
5029 
5030 	if (attr->ia_valid) {
5031 		setattr_copy(inode, attr);
5032 		inode_inc_iversion(inode);
5033 		err = btrfs_dirty_inode(inode);
5034 
5035 		if (!err && attr->ia_valid & ATTR_MODE)
5036 			err = posix_acl_chmod(inode, inode->i_mode);
5037 	}
5038 
5039 	return err;
5040 }
5041 
5042 /*
5043  * While truncating the inode pages during eviction, we get the VFS calling
5044  * btrfs_invalidatepage() against each page of the inode. This is slow because
5045  * the calls to btrfs_invalidatepage() result in a huge amount of calls to
5046  * lock_extent_bits() and clear_extent_bit(), which keep merging and splitting
5047  * extent_state structures over and over, wasting lots of time.
5048  *
5049  * Therefore if the inode is being evicted, let btrfs_invalidatepage() skip all
5050  * those expensive operations on a per page basis and do only the ordered io
5051  * finishing, while we release here the extent_map and extent_state structures,
5052  * without the excessive merging and splitting.
5053  */
evict_inode_truncate_pages(struct inode * inode)5054 static void evict_inode_truncate_pages(struct inode *inode)
5055 {
5056 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
5057 	struct extent_map_tree *map_tree = &BTRFS_I(inode)->extent_tree;
5058 	struct rb_node *node;
5059 
5060 	ASSERT(inode->i_state & I_FREEING);
5061 	truncate_inode_pages_final(&inode->i_data);
5062 
5063 	write_lock(&map_tree->lock);
5064 	while (!RB_EMPTY_ROOT(&map_tree->map)) {
5065 		struct extent_map *em;
5066 
5067 		node = rb_first(&map_tree->map);
5068 		em = rb_entry(node, struct extent_map, rb_node);
5069 		clear_bit(EXTENT_FLAG_PINNED, &em->flags);
5070 		clear_bit(EXTENT_FLAG_LOGGING, &em->flags);
5071 		remove_extent_mapping(map_tree, em);
5072 		free_extent_map(em);
5073 		if (need_resched()) {
5074 			write_unlock(&map_tree->lock);
5075 			cond_resched();
5076 			write_lock(&map_tree->lock);
5077 		}
5078 	}
5079 	write_unlock(&map_tree->lock);
5080 
5081 	/*
5082 	 * Keep looping until we have no more ranges in the io tree.
5083 	 * We can have ongoing bios started by readpages (called from readahead)
5084 	 * that have their endio callback (extent_io.c:end_bio_extent_readpage)
5085 	 * still in progress (unlocked the pages in the bio but did not yet
5086 	 * unlocked the ranges in the io tree). Therefore this means some
5087 	 * ranges can still be locked and eviction started because before
5088 	 * submitting those bios, which are executed by a separate task (work
5089 	 * queue kthread), inode references (inode->i_count) were not taken
5090 	 * (which would be dropped in the end io callback of each bio).
5091 	 * Therefore here we effectively end up waiting for those bios and
5092 	 * anyone else holding locked ranges without having bumped the inode's
5093 	 * reference count - if we don't do it, when they access the inode's
5094 	 * io_tree to unlock a range it may be too late, leading to an
5095 	 * use-after-free issue.
5096 	 */
5097 	spin_lock(&io_tree->lock);
5098 	while (!RB_EMPTY_ROOT(&io_tree->state)) {
5099 		struct extent_state *state;
5100 		struct extent_state *cached_state = NULL;
5101 		u64 start;
5102 		u64 end;
5103 
5104 		node = rb_first(&io_tree->state);
5105 		state = rb_entry(node, struct extent_state, rb_node);
5106 		start = state->start;
5107 		end = state->end;
5108 		spin_unlock(&io_tree->lock);
5109 
5110 		lock_extent_bits(io_tree, start, end, 0, &cached_state);
5111 
5112 		/*
5113 		 * If still has DELALLOC flag, the extent didn't reach disk,
5114 		 * and its reserved space won't be freed by delayed_ref.
5115 		 * So we need to free its reserved space here.
5116 		 * (Refer to comment in btrfs_invalidatepage, case 2)
5117 		 *
5118 		 * Note, end is the bytenr of last byte, so we need + 1 here.
5119 		 */
5120 		if (state->state & EXTENT_DELALLOC)
5121 			btrfs_qgroup_free_data(inode, start, end - start + 1);
5122 
5123 		clear_extent_bit(io_tree, start, end,
5124 				 EXTENT_LOCKED | EXTENT_DIRTY |
5125 				 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
5126 				 EXTENT_DEFRAG, 1, 1,
5127 				 &cached_state, GFP_NOFS);
5128 
5129 		cond_resched();
5130 		spin_lock(&io_tree->lock);
5131 	}
5132 	spin_unlock(&io_tree->lock);
5133 }
5134 
btrfs_evict_inode(struct inode * inode)5135 void btrfs_evict_inode(struct inode *inode)
5136 {
5137 	struct btrfs_trans_handle *trans;
5138 	struct btrfs_root *root = BTRFS_I(inode)->root;
5139 	struct btrfs_block_rsv *rsv, *global_rsv;
5140 	int steal_from_global = 0;
5141 	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
5142 	int ret;
5143 
5144 	trace_btrfs_inode_evict(inode);
5145 
5146 	evict_inode_truncate_pages(inode);
5147 
5148 	if (inode->i_nlink &&
5149 	    ((btrfs_root_refs(&root->root_item) != 0 &&
5150 	      root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||
5151 	     btrfs_is_free_space_inode(inode)))
5152 		goto no_delete;
5153 
5154 	if (is_bad_inode(inode)) {
5155 		btrfs_orphan_del(NULL, inode);
5156 		goto no_delete;
5157 	}
5158 	/* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
5159 	if (!special_file(inode->i_mode))
5160 		btrfs_wait_ordered_range(inode, 0, (u64)-1);
5161 
5162 	btrfs_free_io_failure_record(inode, 0, (u64)-1);
5163 
5164 	if (root->fs_info->log_root_recovering) {
5165 		BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
5166 				 &BTRFS_I(inode)->runtime_flags));
5167 		goto no_delete;
5168 	}
5169 
5170 	if (inode->i_nlink > 0) {
5171 		BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&
5172 		       root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID);
5173 		goto no_delete;
5174 	}
5175 
5176 	ret = btrfs_commit_inode_delayed_inode(inode);
5177 	if (ret) {
5178 		btrfs_orphan_del(NULL, inode);
5179 		goto no_delete;
5180 	}
5181 
5182 	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
5183 	if (!rsv) {
5184 		btrfs_orphan_del(NULL, inode);
5185 		goto no_delete;
5186 	}
5187 	rsv->size = min_size;
5188 	rsv->failfast = 1;
5189 	global_rsv = &root->fs_info->global_block_rsv;
5190 
5191 	btrfs_i_size_write(inode, 0);
5192 
5193 	/*
5194 	 * This is a bit simpler than btrfs_truncate since we've already
5195 	 * reserved our space for our orphan item in the unlink, so we just
5196 	 * need to reserve some slack space in case we add bytes and update
5197 	 * inode item when doing the truncate.
5198 	 */
5199 	while (1) {
5200 		ret = btrfs_block_rsv_refill(root, rsv, min_size,
5201 					     BTRFS_RESERVE_FLUSH_LIMIT);
5202 
5203 		/*
5204 		 * Try and steal from the global reserve since we will
5205 		 * likely not use this space anyway, we want to try as
5206 		 * hard as possible to get this to work.
5207 		 */
5208 		if (ret)
5209 			steal_from_global++;
5210 		else
5211 			steal_from_global = 0;
5212 		ret = 0;
5213 
5214 		/*
5215 		 * steal_from_global == 0: we reserved stuff, hooray!
5216 		 * steal_from_global == 1: we didn't reserve stuff, boo!
5217 		 * steal_from_global == 2: we've committed, still not a lot of
5218 		 * room but maybe we'll have room in the global reserve this
5219 		 * time.
5220 		 * steal_from_global == 3: abandon all hope!
5221 		 */
5222 		if (steal_from_global > 2) {
5223 			btrfs_warn(root->fs_info,
5224 				"Could not get space for a delete, will truncate on mount %d",
5225 				ret);
5226 			btrfs_orphan_del(NULL, inode);
5227 			btrfs_free_block_rsv(root, rsv);
5228 			goto no_delete;
5229 		}
5230 
5231 		trans = btrfs_join_transaction(root);
5232 		if (IS_ERR(trans)) {
5233 			btrfs_orphan_del(NULL, inode);
5234 			btrfs_free_block_rsv(root, rsv);
5235 			goto no_delete;
5236 		}
5237 
5238 		/*
5239 		 * We can't just steal from the global reserve, we need tomake
5240 		 * sure there is room to do it, if not we need to commit and try
5241 		 * again.
5242 		 */
5243 		if (steal_from_global) {
5244 			if (!btrfs_check_space_for_delayed_refs(trans, root))
5245 				ret = btrfs_block_rsv_migrate(global_rsv, rsv,
5246 							      min_size);
5247 			else
5248 				ret = -ENOSPC;
5249 		}
5250 
5251 		/*
5252 		 * Couldn't steal from the global reserve, we have too much
5253 		 * pending stuff built up, commit the transaction and try it
5254 		 * again.
5255 		 */
5256 		if (ret) {
5257 			ret = btrfs_commit_transaction(trans, root);
5258 			if (ret) {
5259 				btrfs_orphan_del(NULL, inode);
5260 				btrfs_free_block_rsv(root, rsv);
5261 				goto no_delete;
5262 			}
5263 			continue;
5264 		} else {
5265 			steal_from_global = 0;
5266 		}
5267 
5268 		trans->block_rsv = rsv;
5269 
5270 		ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
5271 		if (ret != -ENOSPC && ret != -EAGAIN)
5272 			break;
5273 
5274 		trans->block_rsv = &root->fs_info->trans_block_rsv;
5275 		btrfs_end_transaction(trans, root);
5276 		trans = NULL;
5277 		btrfs_btree_balance_dirty(root);
5278 	}
5279 
5280 	btrfs_free_block_rsv(root, rsv);
5281 
5282 	/*
5283 	 * Errors here aren't a big deal, it just means we leave orphan items
5284 	 * in the tree.  They will be cleaned up on the next mount.
5285 	 */
5286 	if (ret == 0) {
5287 		trans->block_rsv = root->orphan_block_rsv;
5288 		btrfs_orphan_del(trans, inode);
5289 	} else {
5290 		btrfs_orphan_del(NULL, inode);
5291 	}
5292 
5293 	trans->block_rsv = &root->fs_info->trans_block_rsv;
5294 	if (!(root == root->fs_info->tree_root ||
5295 	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
5296 		btrfs_return_ino(root, btrfs_ino(inode));
5297 
5298 	btrfs_end_transaction(trans, root);
5299 	btrfs_btree_balance_dirty(root);
5300 no_delete:
5301 	btrfs_remove_delayed_node(inode);
5302 	clear_inode(inode);
5303 	return;
5304 }
5305 
5306 /*
5307  * this returns the key found in the dir entry in the location pointer.
5308  * If no dir entries were found, location->objectid is 0.
5309  */
btrfs_inode_by_name(struct inode * dir,struct dentry * dentry,struct btrfs_key * location)5310 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
5311 			       struct btrfs_key *location)
5312 {
5313 	const char *name = dentry->d_name.name;
5314 	int namelen = dentry->d_name.len;
5315 	struct btrfs_dir_item *di;
5316 	struct btrfs_path *path;
5317 	struct btrfs_root *root = BTRFS_I(dir)->root;
5318 	int ret = 0;
5319 
5320 	path = btrfs_alloc_path();
5321 	if (!path)
5322 		return -ENOMEM;
5323 
5324 	di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
5325 				    namelen, 0);
5326 	if (IS_ERR(di))
5327 		ret = PTR_ERR(di);
5328 
5329 	if (IS_ERR_OR_NULL(di))
5330 		goto out_err;
5331 
5332 	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
5333 out:
5334 	btrfs_free_path(path);
5335 	return ret;
5336 out_err:
5337 	location->objectid = 0;
5338 	goto out;
5339 }
5340 
5341 /*
5342  * when we hit a tree root in a directory, the btrfs part of the inode
5343  * needs to be changed to reflect the root directory of the tree root.  This
5344  * is kind of like crossing a mount point.
5345  */
fixup_tree_root_location(struct btrfs_root * root,struct inode * dir,struct dentry * dentry,struct btrfs_key * location,struct btrfs_root ** sub_root)5346 static int fixup_tree_root_location(struct btrfs_root *root,
5347 				    struct inode *dir,
5348 				    struct dentry *dentry,
5349 				    struct btrfs_key *location,
5350 				    struct btrfs_root **sub_root)
5351 {
5352 	struct btrfs_path *path;
5353 	struct btrfs_root *new_root;
5354 	struct btrfs_root_ref *ref;
5355 	struct extent_buffer *leaf;
5356 	struct btrfs_key key;
5357 	int ret;
5358 	int err = 0;
5359 
5360 	path = btrfs_alloc_path();
5361 	if (!path) {
5362 		err = -ENOMEM;
5363 		goto out;
5364 	}
5365 
5366 	err = -ENOENT;
5367 	key.objectid = BTRFS_I(dir)->root->root_key.objectid;
5368 	key.type = BTRFS_ROOT_REF_KEY;
5369 	key.offset = location->objectid;
5370 
5371 	ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, path,
5372 				0, 0);
5373 	if (ret) {
5374 		if (ret < 0)
5375 			err = ret;
5376 		goto out;
5377 	}
5378 
5379 	leaf = path->nodes[0];
5380 	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
5381 	if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
5382 	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
5383 		goto out;
5384 
5385 	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
5386 				   (unsigned long)(ref + 1),
5387 				   dentry->d_name.len);
5388 	if (ret)
5389 		goto out;
5390 
5391 	btrfs_release_path(path);
5392 
5393 	new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
5394 	if (IS_ERR(new_root)) {
5395 		err = PTR_ERR(new_root);
5396 		goto out;
5397 	}
5398 
5399 	*sub_root = new_root;
5400 	location->objectid = btrfs_root_dirid(&new_root->root_item);
5401 	location->type = BTRFS_INODE_ITEM_KEY;
5402 	location->offset = 0;
5403 	err = 0;
5404 out:
5405 	btrfs_free_path(path);
5406 	return err;
5407 }
5408 
inode_tree_add(struct inode * inode)5409 static void inode_tree_add(struct inode *inode)
5410 {
5411 	struct btrfs_root *root = BTRFS_I(inode)->root;
5412 	struct btrfs_inode *entry;
5413 	struct rb_node **p;
5414 	struct rb_node *parent;
5415 	struct rb_node *new = &BTRFS_I(inode)->rb_node;
5416 	u64 ino = btrfs_ino(inode);
5417 
5418 	if (inode_unhashed(inode))
5419 		return;
5420 	parent = NULL;
5421 	spin_lock(&root->inode_lock);
5422 	p = &root->inode_tree.rb_node;
5423 	while (*p) {
5424 		parent = *p;
5425 		entry = rb_entry(parent, struct btrfs_inode, rb_node);
5426 
5427 		if (ino < btrfs_ino(&entry->vfs_inode))
5428 			p = &parent->rb_left;
5429 		else if (ino > btrfs_ino(&entry->vfs_inode))
5430 			p = &parent->rb_right;
5431 		else {
5432 			WARN_ON(!(entry->vfs_inode.i_state &
5433 				  (I_WILL_FREE | I_FREEING)));
5434 			rb_replace_node(parent, new, &root->inode_tree);
5435 			RB_CLEAR_NODE(parent);
5436 			spin_unlock(&root->inode_lock);
5437 			return;
5438 		}
5439 	}
5440 	rb_link_node(new, parent, p);
5441 	rb_insert_color(new, &root->inode_tree);
5442 	spin_unlock(&root->inode_lock);
5443 }
5444 
inode_tree_del(struct inode * inode)5445 static void inode_tree_del(struct inode *inode)
5446 {
5447 	struct btrfs_root *root = BTRFS_I(inode)->root;
5448 	int empty = 0;
5449 
5450 	spin_lock(&root->inode_lock);
5451 	if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
5452 		rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
5453 		RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
5454 		empty = RB_EMPTY_ROOT(&root->inode_tree);
5455 	}
5456 	spin_unlock(&root->inode_lock);
5457 
5458 	if (empty && btrfs_root_refs(&root->root_item) == 0) {
5459 		synchronize_srcu(&root->fs_info->subvol_srcu);
5460 		spin_lock(&root->inode_lock);
5461 		empty = RB_EMPTY_ROOT(&root->inode_tree);
5462 		spin_unlock(&root->inode_lock);
5463 		if (empty)
5464 			btrfs_add_dead_root(root);
5465 	}
5466 }
5467 
btrfs_invalidate_inodes(struct btrfs_root * root)5468 void btrfs_invalidate_inodes(struct btrfs_root *root)
5469 {
5470 	struct rb_node *node;
5471 	struct rb_node *prev;
5472 	struct btrfs_inode *entry;
5473 	struct inode *inode;
5474 	u64 objectid = 0;
5475 
5476 	if (!test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
5477 		WARN_ON(btrfs_root_refs(&root->root_item) != 0);
5478 
5479 	spin_lock(&root->inode_lock);
5480 again:
5481 	node = root->inode_tree.rb_node;
5482 	prev = NULL;
5483 	while (node) {
5484 		prev = node;
5485 		entry = rb_entry(node, struct btrfs_inode, rb_node);
5486 
5487 		if (objectid < btrfs_ino(&entry->vfs_inode))
5488 			node = node->rb_left;
5489 		else if (objectid > btrfs_ino(&entry->vfs_inode))
5490 			node = node->rb_right;
5491 		else
5492 			break;
5493 	}
5494 	if (!node) {
5495 		while (prev) {
5496 			entry = rb_entry(prev, struct btrfs_inode, rb_node);
5497 			if (objectid <= btrfs_ino(&entry->vfs_inode)) {
5498 				node = prev;
5499 				break;
5500 			}
5501 			prev = rb_next(prev);
5502 		}
5503 	}
5504 	while (node) {
5505 		entry = rb_entry(node, struct btrfs_inode, rb_node);
5506 		objectid = btrfs_ino(&entry->vfs_inode) + 1;
5507 		inode = igrab(&entry->vfs_inode);
5508 		if (inode) {
5509 			spin_unlock(&root->inode_lock);
5510 			if (atomic_read(&inode->i_count) > 1)
5511 				d_prune_aliases(inode);
5512 			/*
5513 			 * btrfs_drop_inode will have it removed from
5514 			 * the inode cache when its usage count
5515 			 * hits zero.
5516 			 */
5517 			iput(inode);
5518 			cond_resched();
5519 			spin_lock(&root->inode_lock);
5520 			goto again;
5521 		}
5522 
5523 		if (cond_resched_lock(&root->inode_lock))
5524 			goto again;
5525 
5526 		node = rb_next(node);
5527 	}
5528 	spin_unlock(&root->inode_lock);
5529 }
5530 
btrfs_init_locked_inode(struct inode * inode,void * p)5531 static int btrfs_init_locked_inode(struct inode *inode, void *p)
5532 {
5533 	struct btrfs_iget_args *args = p;
5534 	inode->i_ino = args->location->objectid;
5535 	memcpy(&BTRFS_I(inode)->location, args->location,
5536 	       sizeof(*args->location));
5537 	BTRFS_I(inode)->root = args->root;
5538 	return 0;
5539 }
5540 
btrfs_find_actor(struct inode * inode,void * opaque)5541 static int btrfs_find_actor(struct inode *inode, void *opaque)
5542 {
5543 	struct btrfs_iget_args *args = opaque;
5544 	return args->location->objectid == BTRFS_I(inode)->location.objectid &&
5545 		args->root == BTRFS_I(inode)->root;
5546 }
5547 
btrfs_iget_locked(struct super_block * s,struct btrfs_key * location,struct btrfs_root * root)5548 static struct inode *btrfs_iget_locked(struct super_block *s,
5549 				       struct btrfs_key *location,
5550 				       struct btrfs_root *root)
5551 {
5552 	struct inode *inode;
5553 	struct btrfs_iget_args args;
5554 	unsigned long hashval = btrfs_inode_hash(location->objectid, root);
5555 
5556 	args.location = location;
5557 	args.root = root;
5558 
5559 	inode = iget5_locked(s, hashval, btrfs_find_actor,
5560 			     btrfs_init_locked_inode,
5561 			     (void *)&args);
5562 	return inode;
5563 }
5564 
5565 /* Get an inode object given its location and corresponding root.
5566  * Returns in *is_new if the inode was read from disk
5567  */
btrfs_iget(struct super_block * s,struct btrfs_key * location,struct btrfs_root * root,int * new)5568 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
5569 			 struct btrfs_root *root, int *new)
5570 {
5571 	struct inode *inode;
5572 
5573 	inode = btrfs_iget_locked(s, location, root);
5574 	if (!inode)
5575 		return ERR_PTR(-ENOMEM);
5576 
5577 	if (inode->i_state & I_NEW) {
5578 		btrfs_read_locked_inode(inode);
5579 		if (!is_bad_inode(inode)) {
5580 			inode_tree_add(inode);
5581 			unlock_new_inode(inode);
5582 			if (new)
5583 				*new = 1;
5584 		} else {
5585 			unlock_new_inode(inode);
5586 			iput(inode);
5587 			inode = ERR_PTR(-ESTALE);
5588 		}
5589 	}
5590 
5591 	return inode;
5592 }
5593 
new_simple_dir(struct super_block * s,struct btrfs_key * key,struct btrfs_root * root)5594 static struct inode *new_simple_dir(struct super_block *s,
5595 				    struct btrfs_key *key,
5596 				    struct btrfs_root *root)
5597 {
5598 	struct inode *inode = new_inode(s);
5599 
5600 	if (!inode)
5601 		return ERR_PTR(-ENOMEM);
5602 
5603 	BTRFS_I(inode)->root = root;
5604 	memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
5605 	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
5606 
5607 	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
5608 	inode->i_op = &btrfs_dir_ro_inode_operations;
5609 	inode->i_fop = &simple_dir_operations;
5610 	inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
5611 	inode->i_mtime = CURRENT_TIME;
5612 	inode->i_atime = inode->i_mtime;
5613 	inode->i_ctime = inode->i_mtime;
5614 	BTRFS_I(inode)->i_otime = inode->i_mtime;
5615 
5616 	return inode;
5617 }
5618 
btrfs_lookup_dentry(struct inode * dir,struct dentry * dentry)5619 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
5620 {
5621 	struct inode *inode;
5622 	struct btrfs_root *root = BTRFS_I(dir)->root;
5623 	struct btrfs_root *sub_root = root;
5624 	struct btrfs_key location;
5625 	int index;
5626 	int ret = 0;
5627 
5628 	if (dentry->d_name.len > BTRFS_NAME_LEN)
5629 		return ERR_PTR(-ENAMETOOLONG);
5630 
5631 	ret = btrfs_inode_by_name(dir, dentry, &location);
5632 	if (ret < 0)
5633 		return ERR_PTR(ret);
5634 
5635 	if (location.objectid == 0)
5636 		return ERR_PTR(-ENOENT);
5637 
5638 	if (location.type == BTRFS_INODE_ITEM_KEY) {
5639 		inode = btrfs_iget(dir->i_sb, &location, root, NULL);
5640 		return inode;
5641 	}
5642 
5643 	BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);
5644 
5645 	index = srcu_read_lock(&root->fs_info->subvol_srcu);
5646 	ret = fixup_tree_root_location(root, dir, dentry,
5647 				       &location, &sub_root);
5648 	if (ret < 0) {
5649 		if (ret != -ENOENT)
5650 			inode = ERR_PTR(ret);
5651 		else
5652 			inode = new_simple_dir(dir->i_sb, &location, sub_root);
5653 	} else {
5654 		inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
5655 	}
5656 	srcu_read_unlock(&root->fs_info->subvol_srcu, index);
5657 
5658 	if (!IS_ERR(inode) && root != sub_root) {
5659 		down_read(&root->fs_info->cleanup_work_sem);
5660 		if (!(inode->i_sb->s_flags & MS_RDONLY))
5661 			ret = btrfs_orphan_cleanup(sub_root);
5662 		up_read(&root->fs_info->cleanup_work_sem);
5663 		if (ret) {
5664 			iput(inode);
5665 			inode = ERR_PTR(ret);
5666 		}
5667 	}
5668 
5669 	return inode;
5670 }
5671 
btrfs_dentry_delete(const struct dentry * dentry)5672 static int btrfs_dentry_delete(const struct dentry *dentry)
5673 {
5674 	struct btrfs_root *root;
5675 	struct inode *inode = d_inode(dentry);
5676 
5677 	if (!inode && !IS_ROOT(dentry))
5678 		inode = d_inode(dentry->d_parent);
5679 
5680 	if (inode) {
5681 		root = BTRFS_I(inode)->root;
5682 		if (btrfs_root_refs(&root->root_item) == 0)
5683 			return 1;
5684 
5685 		if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
5686 			return 1;
5687 	}
5688 	return 0;
5689 }
5690 
btrfs_dentry_release(struct dentry * dentry)5691 static void btrfs_dentry_release(struct dentry *dentry)
5692 {
5693 	kfree(dentry->d_fsdata);
5694 }
5695 
btrfs_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)5696 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
5697 				   unsigned int flags)
5698 {
5699 	struct inode *inode;
5700 
5701 	inode = btrfs_lookup_dentry(dir, dentry);
5702 	if (IS_ERR(inode)) {
5703 		if (PTR_ERR(inode) == -ENOENT)
5704 			inode = NULL;
5705 		else
5706 			return ERR_CAST(inode);
5707 	}
5708 
5709 	return d_splice_alias(inode, dentry);
5710 }
5711 
5712 unsigned char btrfs_filetype_table[] = {
5713 	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
5714 };
5715 
btrfs_real_readdir(struct file * file,struct dir_context * ctx)5716 static int btrfs_real_readdir(struct file *file, struct dir_context *ctx)
5717 {
5718 	struct inode *inode = file_inode(file);
5719 	struct btrfs_root *root = BTRFS_I(inode)->root;
5720 	struct btrfs_item *item;
5721 	struct btrfs_dir_item *di;
5722 	struct btrfs_key key;
5723 	struct btrfs_key found_key;
5724 	struct btrfs_path *path;
5725 	struct list_head ins_list;
5726 	struct list_head del_list;
5727 	int ret;
5728 	struct extent_buffer *leaf;
5729 	int slot;
5730 	unsigned char d_type;
5731 	int over = 0;
5732 	u32 di_cur;
5733 	u32 di_total;
5734 	u32 di_len;
5735 	int key_type = BTRFS_DIR_INDEX_KEY;
5736 	char tmp_name[32];
5737 	char *name_ptr;
5738 	int name_len;
5739 	int is_curr = 0;	/* ctx->pos points to the current index? */
5740 	bool emitted;
5741 
5742 	/* FIXME, use a real flag for deciding about the key type */
5743 	if (root->fs_info->tree_root == root)
5744 		key_type = BTRFS_DIR_ITEM_KEY;
5745 
5746 	if (!dir_emit_dots(file, ctx))
5747 		return 0;
5748 
5749 	path = btrfs_alloc_path();
5750 	if (!path)
5751 		return -ENOMEM;
5752 
5753 	path->reada = 1;
5754 
5755 	if (key_type == BTRFS_DIR_INDEX_KEY) {
5756 		INIT_LIST_HEAD(&ins_list);
5757 		INIT_LIST_HEAD(&del_list);
5758 		btrfs_get_delayed_items(inode, &ins_list, &del_list);
5759 	}
5760 
5761 	key.type = key_type;
5762 	key.offset = ctx->pos;
5763 	key.objectid = btrfs_ino(inode);
5764 
5765 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5766 	if (ret < 0)
5767 		goto err;
5768 
5769 	emitted = false;
5770 	while (1) {
5771 		leaf = path->nodes[0];
5772 		slot = path->slots[0];
5773 		if (slot >= btrfs_header_nritems(leaf)) {
5774 			ret = btrfs_next_leaf(root, path);
5775 			if (ret < 0)
5776 				goto err;
5777 			else if (ret > 0)
5778 				break;
5779 			continue;
5780 		}
5781 
5782 		item = btrfs_item_nr(slot);
5783 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
5784 
5785 		if (found_key.objectid != key.objectid)
5786 			break;
5787 		if (found_key.type != key_type)
5788 			break;
5789 		if (found_key.offset < ctx->pos)
5790 			goto next;
5791 		if (key_type == BTRFS_DIR_INDEX_KEY &&
5792 		    btrfs_should_delete_dir_index(&del_list,
5793 						  found_key.offset))
5794 			goto next;
5795 
5796 		ctx->pos = found_key.offset;
5797 		is_curr = 1;
5798 
5799 		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
5800 		di_cur = 0;
5801 		di_total = btrfs_item_size(leaf, item);
5802 
5803 		while (di_cur < di_total) {
5804 			struct btrfs_key location;
5805 
5806 			if (verify_dir_item(root, leaf, di))
5807 				break;
5808 
5809 			name_len = btrfs_dir_name_len(leaf, di);
5810 			if (name_len <= sizeof(tmp_name)) {
5811 				name_ptr = tmp_name;
5812 			} else {
5813 				name_ptr = kmalloc(name_len, GFP_NOFS);
5814 				if (!name_ptr) {
5815 					ret = -ENOMEM;
5816 					goto err;
5817 				}
5818 			}
5819 			read_extent_buffer(leaf, name_ptr,
5820 					   (unsigned long)(di + 1), name_len);
5821 
5822 			d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
5823 			btrfs_dir_item_key_to_cpu(leaf, di, &location);
5824 
5825 
5826 			/* is this a reference to our own snapshot? If so
5827 			 * skip it.
5828 			 *
5829 			 * In contrast to old kernels, we insert the snapshot's
5830 			 * dir item and dir index after it has been created, so
5831 			 * we won't find a reference to our own snapshot. We
5832 			 * still keep the following code for backward
5833 			 * compatibility.
5834 			 */
5835 			if (location.type == BTRFS_ROOT_ITEM_KEY &&
5836 			    location.objectid == root->root_key.objectid) {
5837 				over = 0;
5838 				goto skip;
5839 			}
5840 			over = !dir_emit(ctx, name_ptr, name_len,
5841 				       location.objectid, d_type);
5842 
5843 skip:
5844 			if (name_ptr != tmp_name)
5845 				kfree(name_ptr);
5846 
5847 			if (over)
5848 				goto nopos;
5849 			emitted = true;
5850 			di_len = btrfs_dir_name_len(leaf, di) +
5851 				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
5852 			di_cur += di_len;
5853 			di = (struct btrfs_dir_item *)((char *)di + di_len);
5854 		}
5855 next:
5856 		path->slots[0]++;
5857 	}
5858 
5859 	if (key_type == BTRFS_DIR_INDEX_KEY) {
5860 		if (is_curr)
5861 			ctx->pos++;
5862 		ret = btrfs_readdir_delayed_dir_index(ctx, &ins_list, &emitted);
5863 		if (ret)
5864 			goto nopos;
5865 	}
5866 
5867 	/*
5868 	 * If we haven't emitted any dir entry, we must not touch ctx->pos as
5869 	 * it was was set to the termination value in previous call. We assume
5870 	 * that "." and ".." were emitted if we reach this point and set the
5871 	 * termination value as well for an empty directory.
5872 	 */
5873 	if (ctx->pos > 2 && !emitted)
5874 		goto nopos;
5875 
5876 	/* Reached end of directory/root. Bump pos past the last item. */
5877 	ctx->pos++;
5878 
5879 	/*
5880 	 * Stop new entries from being returned after we return the last
5881 	 * entry.
5882 	 *
5883 	 * New directory entries are assigned a strictly increasing
5884 	 * offset.  This means that new entries created during readdir
5885 	 * are *guaranteed* to be seen in the future by that readdir.
5886 	 * This has broken buggy programs which operate on names as
5887 	 * they're returned by readdir.  Until we re-use freed offsets
5888 	 * we have this hack to stop new entries from being returned
5889 	 * under the assumption that they'll never reach this huge
5890 	 * offset.
5891 	 *
5892 	 * This is being careful not to overflow 32bit loff_t unless the
5893 	 * last entry requires it because doing so has broken 32bit apps
5894 	 * in the past.
5895 	 */
5896 	if (key_type == BTRFS_DIR_INDEX_KEY) {
5897 		if (ctx->pos >= INT_MAX)
5898 			ctx->pos = LLONG_MAX;
5899 		else
5900 			ctx->pos = INT_MAX;
5901 	}
5902 nopos:
5903 	ret = 0;
5904 err:
5905 	if (key_type == BTRFS_DIR_INDEX_KEY)
5906 		btrfs_put_delayed_items(&ins_list, &del_list);
5907 	btrfs_free_path(path);
5908 	return ret;
5909 }
5910 
btrfs_write_inode(struct inode * inode,struct writeback_control * wbc)5911 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
5912 {
5913 	struct btrfs_root *root = BTRFS_I(inode)->root;
5914 	struct btrfs_trans_handle *trans;
5915 	int ret = 0;
5916 	bool nolock = false;
5917 
5918 	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5919 		return 0;
5920 
5921 	if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
5922 		nolock = true;
5923 
5924 	if (wbc->sync_mode == WB_SYNC_ALL) {
5925 		if (nolock)
5926 			trans = btrfs_join_transaction_nolock(root);
5927 		else
5928 			trans = btrfs_join_transaction(root);
5929 		if (IS_ERR(trans))
5930 			return PTR_ERR(trans);
5931 		ret = btrfs_commit_transaction(trans, root);
5932 	}
5933 	return ret;
5934 }
5935 
5936 /*
5937  * This is somewhat expensive, updating the tree every time the
5938  * inode changes.  But, it is most likely to find the inode in cache.
5939  * FIXME, needs more benchmarking...there are no reasons other than performance
5940  * to keep or drop this code.
5941  */
btrfs_dirty_inode(struct inode * inode)5942 static int btrfs_dirty_inode(struct inode *inode)
5943 {
5944 	struct btrfs_root *root = BTRFS_I(inode)->root;
5945 	struct btrfs_trans_handle *trans;
5946 	int ret;
5947 
5948 	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5949 		return 0;
5950 
5951 	trans = btrfs_join_transaction(root);
5952 	if (IS_ERR(trans))
5953 		return PTR_ERR(trans);
5954 
5955 	ret = btrfs_update_inode(trans, root, inode);
5956 	if (ret && ret == -ENOSPC) {
5957 		/* whoops, lets try again with the full transaction */
5958 		btrfs_end_transaction(trans, root);
5959 		trans = btrfs_start_transaction(root, 1);
5960 		if (IS_ERR(trans))
5961 			return PTR_ERR(trans);
5962 
5963 		ret = btrfs_update_inode(trans, root, inode);
5964 	}
5965 	btrfs_end_transaction(trans, root);
5966 	if (BTRFS_I(inode)->delayed_node)
5967 		btrfs_balance_delayed_items(root);
5968 
5969 	return ret;
5970 }
5971 
5972 /*
5973  * This is a copy of file_update_time.  We need this so we can return error on
5974  * ENOSPC for updating the inode in the case of file write and mmap writes.
5975  */
btrfs_update_time(struct inode * inode,struct timespec * now,int flags)5976 static int btrfs_update_time(struct inode *inode, struct timespec *now,
5977 			     int flags)
5978 {
5979 	struct btrfs_root *root = BTRFS_I(inode)->root;
5980 
5981 	if (btrfs_root_readonly(root))
5982 		return -EROFS;
5983 
5984 	if (flags & S_VERSION)
5985 		inode_inc_iversion(inode);
5986 	if (flags & S_CTIME)
5987 		inode->i_ctime = *now;
5988 	if (flags & S_MTIME)
5989 		inode->i_mtime = *now;
5990 	if (flags & S_ATIME)
5991 		inode->i_atime = *now;
5992 	return btrfs_dirty_inode(inode);
5993 }
5994 
5995 /*
5996  * find the highest existing sequence number in a directory
5997  * and then set the in-memory index_cnt variable to reflect
5998  * free sequence numbers
5999  */
btrfs_set_inode_index_count(struct inode * inode)6000 static int btrfs_set_inode_index_count(struct inode *inode)
6001 {
6002 	struct btrfs_root *root = BTRFS_I(inode)->root;
6003 	struct btrfs_key key, found_key;
6004 	struct btrfs_path *path;
6005 	struct extent_buffer *leaf;
6006 	int ret;
6007 
6008 	key.objectid = btrfs_ino(inode);
6009 	key.type = BTRFS_DIR_INDEX_KEY;
6010 	key.offset = (u64)-1;
6011 
6012 	path = btrfs_alloc_path();
6013 	if (!path)
6014 		return -ENOMEM;
6015 
6016 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6017 	if (ret < 0)
6018 		goto out;
6019 	/* FIXME: we should be able to handle this */
6020 	if (ret == 0)
6021 		goto out;
6022 	ret = 0;
6023 
6024 	/*
6025 	 * MAGIC NUMBER EXPLANATION:
6026 	 * since we search a directory based on f_pos we have to start at 2
6027 	 * since '.' and '..' have f_pos of 0 and 1 respectively, so everybody
6028 	 * else has to start at 2
6029 	 */
6030 	if (path->slots[0] == 0) {
6031 		BTRFS_I(inode)->index_cnt = 2;
6032 		goto out;
6033 	}
6034 
6035 	path->slots[0]--;
6036 
6037 	leaf = path->nodes[0];
6038 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6039 
6040 	if (found_key.objectid != btrfs_ino(inode) ||
6041 	    found_key.type != BTRFS_DIR_INDEX_KEY) {
6042 		BTRFS_I(inode)->index_cnt = 2;
6043 		goto out;
6044 	}
6045 
6046 	BTRFS_I(inode)->index_cnt = found_key.offset + 1;
6047 out:
6048 	btrfs_free_path(path);
6049 	return ret;
6050 }
6051 
6052 /*
6053  * helper to find a free sequence number in a given directory.  This current
6054  * code is very simple, later versions will do smarter things in the btree
6055  */
btrfs_set_inode_index(struct inode * dir,u64 * index)6056 int btrfs_set_inode_index(struct inode *dir, u64 *index)
6057 {
6058 	int ret = 0;
6059 
6060 	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
6061 		ret = btrfs_inode_delayed_dir_index_count(dir);
6062 		if (ret) {
6063 			ret = btrfs_set_inode_index_count(dir);
6064 			if (ret)
6065 				return ret;
6066 		}
6067 	}
6068 
6069 	*index = BTRFS_I(dir)->index_cnt;
6070 	BTRFS_I(dir)->index_cnt++;
6071 
6072 	return ret;
6073 }
6074 
btrfs_insert_inode_locked(struct inode * inode)6075 static int btrfs_insert_inode_locked(struct inode *inode)
6076 {
6077 	struct btrfs_iget_args args;
6078 	args.location = &BTRFS_I(inode)->location;
6079 	args.root = BTRFS_I(inode)->root;
6080 
6081 	return insert_inode_locked4(inode,
6082 		   btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root),
6083 		   btrfs_find_actor, &args);
6084 }
6085 
btrfs_new_inode(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * dir,const char * name,int name_len,u64 ref_objectid,u64 objectid,umode_t mode,u64 * index)6086 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
6087 				     struct btrfs_root *root,
6088 				     struct inode *dir,
6089 				     const char *name, int name_len,
6090 				     u64 ref_objectid, u64 objectid,
6091 				     umode_t mode, u64 *index)
6092 {
6093 	struct inode *inode;
6094 	struct btrfs_inode_item *inode_item;
6095 	struct btrfs_key *location;
6096 	struct btrfs_path *path;
6097 	struct btrfs_inode_ref *ref;
6098 	struct btrfs_key key[2];
6099 	u32 sizes[2];
6100 	int nitems = name ? 2 : 1;
6101 	unsigned long ptr;
6102 	int ret;
6103 
6104 	path = btrfs_alloc_path();
6105 	if (!path)
6106 		return ERR_PTR(-ENOMEM);
6107 
6108 	inode = new_inode(root->fs_info->sb);
6109 	if (!inode) {
6110 		btrfs_free_path(path);
6111 		return ERR_PTR(-ENOMEM);
6112 	}
6113 
6114 	/*
6115 	 * O_TMPFILE, set link count to 0, so that after this point,
6116 	 * we fill in an inode item with the correct link count.
6117 	 */
6118 	if (!name)
6119 		set_nlink(inode, 0);
6120 
6121 	/*
6122 	 * we have to initialize this early, so we can reclaim the inode
6123 	 * number if we fail afterwards in this function.
6124 	 */
6125 	inode->i_ino = objectid;
6126 
6127 	if (dir && name) {
6128 		trace_btrfs_inode_request(dir);
6129 
6130 		ret = btrfs_set_inode_index(dir, index);
6131 		if (ret) {
6132 			btrfs_free_path(path);
6133 			iput(inode);
6134 			return ERR_PTR(ret);
6135 		}
6136 	} else if (dir) {
6137 		*index = 0;
6138 	}
6139 	/*
6140 	 * index_cnt is ignored for everything but a dir,
6141 	 * btrfs_get_inode_index_count has an explanation for the magic
6142 	 * number
6143 	 */
6144 	BTRFS_I(inode)->index_cnt = 2;
6145 	BTRFS_I(inode)->dir_index = *index;
6146 	BTRFS_I(inode)->root = root;
6147 	BTRFS_I(inode)->generation = trans->transid;
6148 	inode->i_generation = BTRFS_I(inode)->generation;
6149 
6150 	/*
6151 	 * We could have gotten an inode number from somebody who was fsynced
6152 	 * and then removed in this same transaction, so let's just set full
6153 	 * sync since it will be a full sync anyway and this will blow away the
6154 	 * old info in the log.
6155 	 */
6156 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
6157 
6158 	key[0].objectid = objectid;
6159 	key[0].type = BTRFS_INODE_ITEM_KEY;
6160 	key[0].offset = 0;
6161 
6162 	sizes[0] = sizeof(struct btrfs_inode_item);
6163 
6164 	if (name) {
6165 		/*
6166 		 * Start new inodes with an inode_ref. This is slightly more
6167 		 * efficient for small numbers of hard links since they will
6168 		 * be packed into one item. Extended refs will kick in if we
6169 		 * add more hard links than can fit in the ref item.
6170 		 */
6171 		key[1].objectid = objectid;
6172 		key[1].type = BTRFS_INODE_REF_KEY;
6173 		key[1].offset = ref_objectid;
6174 
6175 		sizes[1] = name_len + sizeof(*ref);
6176 	}
6177 
6178 	location = &BTRFS_I(inode)->location;
6179 	location->objectid = objectid;
6180 	location->offset = 0;
6181 	location->type = BTRFS_INODE_ITEM_KEY;
6182 
6183 	ret = btrfs_insert_inode_locked(inode);
6184 	if (ret < 0)
6185 		goto fail;
6186 
6187 	path->leave_spinning = 1;
6188 	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, nitems);
6189 	if (ret != 0)
6190 		goto fail_unlock;
6191 
6192 	inode_init_owner(inode, dir, mode);
6193 	inode_set_bytes(inode, 0);
6194 
6195 	inode->i_mtime = CURRENT_TIME;
6196 	inode->i_atime = inode->i_mtime;
6197 	inode->i_ctime = inode->i_mtime;
6198 	BTRFS_I(inode)->i_otime = inode->i_mtime;
6199 
6200 	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
6201 				  struct btrfs_inode_item);
6202 	memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
6203 			     sizeof(*inode_item));
6204 	fill_inode_item(trans, path->nodes[0], inode_item, inode);
6205 
6206 	if (name) {
6207 		ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
6208 				     struct btrfs_inode_ref);
6209 		btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
6210 		btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
6211 		ptr = (unsigned long)(ref + 1);
6212 		write_extent_buffer(path->nodes[0], name, ptr, name_len);
6213 	}
6214 
6215 	btrfs_mark_buffer_dirty(path->nodes[0]);
6216 	btrfs_free_path(path);
6217 
6218 	btrfs_inherit_iflags(inode, dir);
6219 
6220 	if (S_ISREG(mode)) {
6221 		if (btrfs_test_opt(root, NODATASUM))
6222 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
6223 		if (btrfs_test_opt(root, NODATACOW))
6224 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |
6225 				BTRFS_INODE_NODATASUM;
6226 	}
6227 
6228 	inode_tree_add(inode);
6229 
6230 	trace_btrfs_inode_new(inode);
6231 	btrfs_set_inode_last_trans(trans, inode);
6232 
6233 	btrfs_update_root_times(trans, root);
6234 
6235 	ret = btrfs_inode_inherit_props(trans, inode, dir);
6236 	if (ret)
6237 		btrfs_err(root->fs_info,
6238 			  "error inheriting props for ino %llu (root %llu): %d",
6239 			  btrfs_ino(inode), root->root_key.objectid, ret);
6240 
6241 	return inode;
6242 
6243 fail_unlock:
6244 	unlock_new_inode(inode);
6245 fail:
6246 	if (dir && name)
6247 		BTRFS_I(dir)->index_cnt--;
6248 	btrfs_free_path(path);
6249 	iput(inode);
6250 	return ERR_PTR(ret);
6251 }
6252 
btrfs_inode_type(struct inode * inode)6253 static inline u8 btrfs_inode_type(struct inode *inode)
6254 {
6255 	return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
6256 }
6257 
6258 /*
6259  * utility function to add 'inode' into 'parent_inode' with
6260  * a give name and a given sequence number.
6261  * if 'add_backref' is true, also insert a backref from the
6262  * inode to the parent directory.
6263  */
btrfs_add_link(struct btrfs_trans_handle * trans,struct inode * parent_inode,struct inode * inode,const char * name,int name_len,int add_backref,u64 index)6264 int btrfs_add_link(struct btrfs_trans_handle *trans,
6265 		   struct inode *parent_inode, struct inode *inode,
6266 		   const char *name, int name_len, int add_backref, u64 index)
6267 {
6268 	int ret = 0;
6269 	struct btrfs_key key;
6270 	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
6271 	u64 ino = btrfs_ino(inode);
6272 	u64 parent_ino = btrfs_ino(parent_inode);
6273 
6274 	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
6275 		memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
6276 	} else {
6277 		key.objectid = ino;
6278 		key.type = BTRFS_INODE_ITEM_KEY;
6279 		key.offset = 0;
6280 	}
6281 
6282 	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
6283 		ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
6284 					 key.objectid, root->root_key.objectid,
6285 					 parent_ino, index, name, name_len);
6286 	} else if (add_backref) {
6287 		ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
6288 					     parent_ino, index);
6289 	}
6290 
6291 	/* Nothing to clean up yet */
6292 	if (ret)
6293 		return ret;
6294 
6295 	ret = btrfs_insert_dir_item(trans, root, name, name_len,
6296 				    parent_inode, &key,
6297 				    btrfs_inode_type(inode), index);
6298 	if (ret == -EEXIST || ret == -EOVERFLOW)
6299 		goto fail_dir_item;
6300 	else if (ret) {
6301 		btrfs_abort_transaction(trans, root, ret);
6302 		return ret;
6303 	}
6304 
6305 	btrfs_i_size_write(parent_inode, parent_inode->i_size +
6306 			   name_len * 2);
6307 	inode_inc_iversion(parent_inode);
6308 	parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
6309 	ret = btrfs_update_inode(trans, root, parent_inode);
6310 	if (ret)
6311 		btrfs_abort_transaction(trans, root, ret);
6312 	return ret;
6313 
6314 fail_dir_item:
6315 	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
6316 		u64 local_index;
6317 		int err;
6318 		err = btrfs_del_root_ref(trans, root->fs_info->tree_root,
6319 				 key.objectid, root->root_key.objectid,
6320 				 parent_ino, &local_index, name, name_len);
6321 
6322 	} else if (add_backref) {
6323 		u64 local_index;
6324 		int err;
6325 
6326 		err = btrfs_del_inode_ref(trans, root, name, name_len,
6327 					  ino, parent_ino, &local_index);
6328 	}
6329 	return ret;
6330 }
6331 
btrfs_add_nondir(struct btrfs_trans_handle * trans,struct inode * dir,struct dentry * dentry,struct inode * inode,int backref,u64 index)6332 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
6333 			    struct inode *dir, struct dentry *dentry,
6334 			    struct inode *inode, int backref, u64 index)
6335 {
6336 	int err = btrfs_add_link(trans, dir, inode,
6337 				 dentry->d_name.name, dentry->d_name.len,
6338 				 backref, index);
6339 	if (err > 0)
6340 		err = -EEXIST;
6341 	return err;
6342 }
6343 
btrfs_mknod(struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)6344 static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
6345 			umode_t mode, dev_t rdev)
6346 {
6347 	struct btrfs_trans_handle *trans;
6348 	struct btrfs_root *root = BTRFS_I(dir)->root;
6349 	struct inode *inode = NULL;
6350 	int err;
6351 	int drop_inode = 0;
6352 	u64 objectid;
6353 	u64 index = 0;
6354 
6355 	/*
6356 	 * 2 for inode item and ref
6357 	 * 2 for dir items
6358 	 * 1 for xattr if selinux is on
6359 	 */
6360 	trans = btrfs_start_transaction(root, 5);
6361 	if (IS_ERR(trans))
6362 		return PTR_ERR(trans);
6363 
6364 	err = btrfs_find_free_ino(root, &objectid);
6365 	if (err)
6366 		goto out_unlock;
6367 
6368 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
6369 				dentry->d_name.len, btrfs_ino(dir), objectid,
6370 				mode, &index);
6371 	if (IS_ERR(inode)) {
6372 		err = PTR_ERR(inode);
6373 		goto out_unlock;
6374 	}
6375 
6376 	/*
6377 	* If the active LSM wants to access the inode during
6378 	* d_instantiate it needs these. Smack checks to see
6379 	* if the filesystem supports xattrs by looking at the
6380 	* ops vector.
6381 	*/
6382 	inode->i_op = &btrfs_special_inode_operations;
6383 	init_special_inode(inode, inode->i_mode, rdev);
6384 
6385 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
6386 	if (err)
6387 		goto out_unlock_inode;
6388 
6389 	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
6390 	if (err) {
6391 		goto out_unlock_inode;
6392 	} else {
6393 		btrfs_update_inode(trans, root, inode);
6394 		unlock_new_inode(inode);
6395 		d_instantiate(dentry, inode);
6396 	}
6397 
6398 out_unlock:
6399 	btrfs_end_transaction(trans, root);
6400 	btrfs_balance_delayed_items(root);
6401 	btrfs_btree_balance_dirty(root);
6402 	if (drop_inode) {
6403 		inode_dec_link_count(inode);
6404 		iput(inode);
6405 	}
6406 	return err;
6407 
6408 out_unlock_inode:
6409 	drop_inode = 1;
6410 	unlock_new_inode(inode);
6411 	goto out_unlock;
6412 
6413 }
6414 
btrfs_create(struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)6415 static int btrfs_create(struct inode *dir, struct dentry *dentry,
6416 			umode_t mode, bool excl)
6417 {
6418 	struct btrfs_trans_handle *trans;
6419 	struct btrfs_root *root = BTRFS_I(dir)->root;
6420 	struct inode *inode = NULL;
6421 	int drop_inode_on_err = 0;
6422 	int err;
6423 	u64 objectid;
6424 	u64 index = 0;
6425 
6426 	/*
6427 	 * 2 for inode item and ref
6428 	 * 2 for dir items
6429 	 * 1 for xattr if selinux is on
6430 	 */
6431 	trans = btrfs_start_transaction(root, 5);
6432 	if (IS_ERR(trans))
6433 		return PTR_ERR(trans);
6434 
6435 	err = btrfs_find_free_ino(root, &objectid);
6436 	if (err)
6437 		goto out_unlock;
6438 
6439 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
6440 				dentry->d_name.len, btrfs_ino(dir), objectid,
6441 				mode, &index);
6442 	if (IS_ERR(inode)) {
6443 		err = PTR_ERR(inode);
6444 		goto out_unlock;
6445 	}
6446 	drop_inode_on_err = 1;
6447 	/*
6448 	* If the active LSM wants to access the inode during
6449 	* d_instantiate it needs these. Smack checks to see
6450 	* if the filesystem supports xattrs by looking at the
6451 	* ops vector.
6452 	*/
6453 	inode->i_fop = &btrfs_file_operations;
6454 	inode->i_op = &btrfs_file_inode_operations;
6455 	inode->i_mapping->a_ops = &btrfs_aops;
6456 
6457 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
6458 	if (err)
6459 		goto out_unlock_inode;
6460 
6461 	err = btrfs_update_inode(trans, root, inode);
6462 	if (err)
6463 		goto out_unlock_inode;
6464 
6465 	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
6466 	if (err)
6467 		goto out_unlock_inode;
6468 
6469 	BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
6470 	unlock_new_inode(inode);
6471 	d_instantiate(dentry, inode);
6472 
6473 out_unlock:
6474 	btrfs_end_transaction(trans, root);
6475 	if (err && drop_inode_on_err) {
6476 		inode_dec_link_count(inode);
6477 		iput(inode);
6478 	}
6479 	btrfs_balance_delayed_items(root);
6480 	btrfs_btree_balance_dirty(root);
6481 	return err;
6482 
6483 out_unlock_inode:
6484 	unlock_new_inode(inode);
6485 	goto out_unlock;
6486 
6487 }
6488 
btrfs_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)6489 static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
6490 		      struct dentry *dentry)
6491 {
6492 	struct btrfs_trans_handle *trans = NULL;
6493 	struct btrfs_root *root = BTRFS_I(dir)->root;
6494 	struct inode *inode = d_inode(old_dentry);
6495 	u64 index;
6496 	int err;
6497 	int drop_inode = 0;
6498 
6499 	/* do not allow sys_link's with other subvols of the same device */
6500 	if (root->objectid != BTRFS_I(inode)->root->objectid)
6501 		return -EXDEV;
6502 
6503 	if (inode->i_nlink >= BTRFS_LINK_MAX)
6504 		return -EMLINK;
6505 
6506 	err = btrfs_set_inode_index(dir, &index);
6507 	if (err)
6508 		goto fail;
6509 
6510 	/*
6511 	 * 2 items for inode and inode ref
6512 	 * 2 items for dir items
6513 	 * 1 item for parent inode
6514 	 */
6515 	trans = btrfs_start_transaction(root, 5);
6516 	if (IS_ERR(trans)) {
6517 		err = PTR_ERR(trans);
6518 		trans = NULL;
6519 		goto fail;
6520 	}
6521 
6522 	/* There are several dir indexes for this inode, clear the cache. */
6523 	BTRFS_I(inode)->dir_index = 0ULL;
6524 	inc_nlink(inode);
6525 	inode_inc_iversion(inode);
6526 	inode->i_ctime = CURRENT_TIME;
6527 	ihold(inode);
6528 	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
6529 
6530 	err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
6531 
6532 	if (err) {
6533 		drop_inode = 1;
6534 	} else {
6535 		struct dentry *parent = dentry->d_parent;
6536 		err = btrfs_update_inode(trans, root, inode);
6537 		if (err)
6538 			goto fail;
6539 		if (inode->i_nlink == 1) {
6540 			/*
6541 			 * If new hard link count is 1, it's a file created
6542 			 * with open(2) O_TMPFILE flag.
6543 			 */
6544 			err = btrfs_orphan_del(trans, inode);
6545 			if (err)
6546 				goto fail;
6547 		}
6548 		d_instantiate(dentry, inode);
6549 		btrfs_log_new_name(trans, inode, NULL, parent);
6550 	}
6551 
6552 	btrfs_balance_delayed_items(root);
6553 fail:
6554 	if (trans)
6555 		btrfs_end_transaction(trans, root);
6556 	if (drop_inode) {
6557 		inode_dec_link_count(inode);
6558 		iput(inode);
6559 	}
6560 	btrfs_btree_balance_dirty(root);
6561 	return err;
6562 }
6563 
btrfs_mkdir(struct inode * dir,struct dentry * dentry,umode_t mode)6564 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
6565 {
6566 	struct inode *inode = NULL;
6567 	struct btrfs_trans_handle *trans;
6568 	struct btrfs_root *root = BTRFS_I(dir)->root;
6569 	int err = 0;
6570 	int drop_on_err = 0;
6571 	u64 objectid = 0;
6572 	u64 index = 0;
6573 
6574 	/*
6575 	 * 2 items for inode and ref
6576 	 * 2 items for dir items
6577 	 * 1 for xattr if selinux is on
6578 	 */
6579 	trans = btrfs_start_transaction(root, 5);
6580 	if (IS_ERR(trans))
6581 		return PTR_ERR(trans);
6582 
6583 	err = btrfs_find_free_ino(root, &objectid);
6584 	if (err)
6585 		goto out_fail;
6586 
6587 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
6588 				dentry->d_name.len, btrfs_ino(dir), objectid,
6589 				S_IFDIR | mode, &index);
6590 	if (IS_ERR(inode)) {
6591 		err = PTR_ERR(inode);
6592 		goto out_fail;
6593 	}
6594 
6595 	drop_on_err = 1;
6596 	/* these must be set before we unlock the inode */
6597 	inode->i_op = &btrfs_dir_inode_operations;
6598 	inode->i_fop = &btrfs_dir_file_operations;
6599 
6600 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
6601 	if (err)
6602 		goto out_fail_inode;
6603 
6604 	btrfs_i_size_write(inode, 0);
6605 	err = btrfs_update_inode(trans, root, inode);
6606 	if (err)
6607 		goto out_fail_inode;
6608 
6609 	err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
6610 			     dentry->d_name.len, 0, index);
6611 	if (err)
6612 		goto out_fail_inode;
6613 
6614 	d_instantiate(dentry, inode);
6615 	/*
6616 	 * mkdir is special.  We're unlocking after we call d_instantiate
6617 	 * to avoid a race with nfsd calling d_instantiate.
6618 	 */
6619 	unlock_new_inode(inode);
6620 	drop_on_err = 0;
6621 
6622 out_fail:
6623 	btrfs_end_transaction(trans, root);
6624 	if (drop_on_err) {
6625 		inode_dec_link_count(inode);
6626 		iput(inode);
6627 	}
6628 	btrfs_balance_delayed_items(root);
6629 	btrfs_btree_balance_dirty(root);
6630 	return err;
6631 
6632 out_fail_inode:
6633 	unlock_new_inode(inode);
6634 	goto out_fail;
6635 }
6636 
6637 /* Find next extent map of a given extent map, caller needs to ensure locks */
next_extent_map(struct extent_map * em)6638 static struct extent_map *next_extent_map(struct extent_map *em)
6639 {
6640 	struct rb_node *next;
6641 
6642 	next = rb_next(&em->rb_node);
6643 	if (!next)
6644 		return NULL;
6645 	return container_of(next, struct extent_map, rb_node);
6646 }
6647 
prev_extent_map(struct extent_map * em)6648 static struct extent_map *prev_extent_map(struct extent_map *em)
6649 {
6650 	struct rb_node *prev;
6651 
6652 	prev = rb_prev(&em->rb_node);
6653 	if (!prev)
6654 		return NULL;
6655 	return container_of(prev, struct extent_map, rb_node);
6656 }
6657 
6658 /* helper for btfs_get_extent.  Given an existing extent in the tree,
6659  * the existing extent is the nearest extent to map_start,
6660  * and an extent that you want to insert, deal with overlap and insert
6661  * the best fitted new extent into the tree.
6662  */
merge_extent_mapping(struct extent_map_tree * em_tree,struct extent_map * existing,struct extent_map * em,u64 map_start)6663 static int merge_extent_mapping(struct extent_map_tree *em_tree,
6664 				struct extent_map *existing,
6665 				struct extent_map *em,
6666 				u64 map_start)
6667 {
6668 	struct extent_map *prev;
6669 	struct extent_map *next;
6670 	u64 start;
6671 	u64 end;
6672 	u64 start_diff;
6673 
6674 	BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
6675 
6676 	if (existing->start > map_start) {
6677 		next = existing;
6678 		prev = prev_extent_map(next);
6679 	} else {
6680 		prev = existing;
6681 		next = next_extent_map(prev);
6682 	}
6683 
6684 	start = prev ? extent_map_end(prev) : em->start;
6685 	start = max_t(u64, start, em->start);
6686 	end = next ? next->start : extent_map_end(em);
6687 	end = min_t(u64, end, extent_map_end(em));
6688 	start_diff = start - em->start;
6689 	em->start = start;
6690 	em->len = end - start;
6691 	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
6692 	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
6693 		em->block_start += start_diff;
6694 		em->block_len -= start_diff;
6695 	}
6696 	return add_extent_mapping(em_tree, em, 0);
6697 }
6698 
uncompress_inline(struct btrfs_path * path,struct inode * inode,struct page * page,size_t pg_offset,u64 extent_offset,struct btrfs_file_extent_item * item)6699 static noinline int uncompress_inline(struct btrfs_path *path,
6700 				      struct inode *inode, struct page *page,
6701 				      size_t pg_offset, u64 extent_offset,
6702 				      struct btrfs_file_extent_item *item)
6703 {
6704 	int ret;
6705 	struct extent_buffer *leaf = path->nodes[0];
6706 	char *tmp;
6707 	size_t max_size;
6708 	unsigned long inline_size;
6709 	unsigned long ptr;
6710 	int compress_type;
6711 
6712 	WARN_ON(pg_offset != 0);
6713 	compress_type = btrfs_file_extent_compression(leaf, item);
6714 	max_size = btrfs_file_extent_ram_bytes(leaf, item);
6715 	inline_size = btrfs_file_extent_inline_item_len(leaf,
6716 					btrfs_item_nr(path->slots[0]));
6717 	tmp = kmalloc(inline_size, GFP_NOFS);
6718 	if (!tmp)
6719 		return -ENOMEM;
6720 	ptr = btrfs_file_extent_inline_start(item);
6721 
6722 	read_extent_buffer(leaf, tmp, ptr, inline_size);
6723 
6724 	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
6725 	ret = btrfs_decompress(compress_type, tmp, page,
6726 			       extent_offset, inline_size, max_size);
6727 	kfree(tmp);
6728 	return ret;
6729 }
6730 
6731 /*
6732  * a bit scary, this does extent mapping from logical file offset to the disk.
6733  * the ugly parts come from merging extents from the disk with the in-ram
6734  * representation.  This gets more complex because of the data=ordered code,
6735  * where the in-ram extents might be locked pending data=ordered completion.
6736  *
6737  * This also copies inline extents directly into the page.
6738  */
6739 
btrfs_get_extent(struct inode * inode,struct page * page,size_t pg_offset,u64 start,u64 len,int create)6740 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
6741 				    size_t pg_offset, u64 start, u64 len,
6742 				    int create)
6743 {
6744 	int ret;
6745 	int err = 0;
6746 	u64 extent_start = 0;
6747 	u64 extent_end = 0;
6748 	u64 objectid = btrfs_ino(inode);
6749 	u32 found_type;
6750 	struct btrfs_path *path = NULL;
6751 	struct btrfs_root *root = BTRFS_I(inode)->root;
6752 	struct btrfs_file_extent_item *item;
6753 	struct extent_buffer *leaf;
6754 	struct btrfs_key found_key;
6755 	struct extent_map *em = NULL;
6756 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
6757 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
6758 	struct btrfs_trans_handle *trans = NULL;
6759 	const bool new_inline = !page || create;
6760 
6761 again:
6762 	read_lock(&em_tree->lock);
6763 	em = lookup_extent_mapping(em_tree, start, len);
6764 	if (em)
6765 		em->bdev = root->fs_info->fs_devices->latest_bdev;
6766 	read_unlock(&em_tree->lock);
6767 
6768 	if (em) {
6769 		if (em->start > start || em->start + em->len <= start)
6770 			free_extent_map(em);
6771 		else if (em->block_start == EXTENT_MAP_INLINE && page)
6772 			free_extent_map(em);
6773 		else
6774 			goto out;
6775 	}
6776 	em = alloc_extent_map();
6777 	if (!em) {
6778 		err = -ENOMEM;
6779 		goto out;
6780 	}
6781 	em->bdev = root->fs_info->fs_devices->latest_bdev;
6782 	em->start = EXTENT_MAP_HOLE;
6783 	em->orig_start = EXTENT_MAP_HOLE;
6784 	em->len = (u64)-1;
6785 	em->block_len = (u64)-1;
6786 
6787 	if (!path) {
6788 		path = btrfs_alloc_path();
6789 		if (!path) {
6790 			err = -ENOMEM;
6791 			goto out;
6792 		}
6793 		/*
6794 		 * Chances are we'll be called again, so go ahead and do
6795 		 * readahead
6796 		 */
6797 		path->reada = 1;
6798 	}
6799 
6800 	ret = btrfs_lookup_file_extent(trans, root, path,
6801 				       objectid, start, trans != NULL);
6802 	if (ret < 0) {
6803 		err = ret;
6804 		goto out;
6805 	}
6806 
6807 	if (ret != 0) {
6808 		if (path->slots[0] == 0)
6809 			goto not_found;
6810 		path->slots[0]--;
6811 	}
6812 
6813 	leaf = path->nodes[0];
6814 	item = btrfs_item_ptr(leaf, path->slots[0],
6815 			      struct btrfs_file_extent_item);
6816 	/* are we inside the extent that was found? */
6817 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6818 	found_type = found_key.type;
6819 	if (found_key.objectid != objectid ||
6820 	    found_type != BTRFS_EXTENT_DATA_KEY) {
6821 		/*
6822 		 * If we backup past the first extent we want to move forward
6823 		 * and see if there is an extent in front of us, otherwise we'll
6824 		 * say there is a hole for our whole search range which can
6825 		 * cause problems.
6826 		 */
6827 		extent_end = start;
6828 		goto next;
6829 	}
6830 
6831 	found_type = btrfs_file_extent_type(leaf, item);
6832 	extent_start = found_key.offset;
6833 	if (found_type == BTRFS_FILE_EXTENT_REG ||
6834 	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
6835 		extent_end = extent_start +
6836 		       btrfs_file_extent_num_bytes(leaf, item);
6837 	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6838 		size_t size;
6839 		size = btrfs_file_extent_inline_len(leaf, path->slots[0], item);
6840 		extent_end = ALIGN(extent_start + size, root->sectorsize);
6841 	}
6842 next:
6843 	if (start >= extent_end) {
6844 		path->slots[0]++;
6845 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
6846 			ret = btrfs_next_leaf(root, path);
6847 			if (ret < 0) {
6848 				err = ret;
6849 				goto out;
6850 			}
6851 			if (ret > 0)
6852 				goto not_found;
6853 			leaf = path->nodes[0];
6854 		}
6855 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6856 		if (found_key.objectid != objectid ||
6857 		    found_key.type != BTRFS_EXTENT_DATA_KEY)
6858 			goto not_found;
6859 		if (start + len <= found_key.offset)
6860 			goto not_found;
6861 		if (start > found_key.offset)
6862 			goto next;
6863 		em->start = start;
6864 		em->orig_start = start;
6865 		em->len = found_key.offset - start;
6866 		goto not_found_em;
6867 	}
6868 
6869 	btrfs_extent_item_to_extent_map(inode, path, item, new_inline, em);
6870 
6871 	if (found_type == BTRFS_FILE_EXTENT_REG ||
6872 	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
6873 		goto insert;
6874 	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6875 		unsigned long ptr;
6876 		char *map;
6877 		size_t size;
6878 		size_t extent_offset;
6879 		size_t copy_size;
6880 
6881 		if (new_inline)
6882 			goto out;
6883 
6884 		size = btrfs_file_extent_inline_len(leaf, path->slots[0], item);
6885 		extent_offset = page_offset(page) + pg_offset - extent_start;
6886 		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
6887 				size - extent_offset);
6888 		em->start = extent_start + extent_offset;
6889 		em->len = ALIGN(copy_size, root->sectorsize);
6890 		em->orig_block_len = em->len;
6891 		em->orig_start = em->start;
6892 		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
6893 		if (create == 0 && !PageUptodate(page)) {
6894 			if (btrfs_file_extent_compression(leaf, item) !=
6895 			    BTRFS_COMPRESS_NONE) {
6896 				ret = uncompress_inline(path, inode, page,
6897 							pg_offset,
6898 							extent_offset, item);
6899 				if (ret) {
6900 					err = ret;
6901 					goto out;
6902 				}
6903 			} else {
6904 				map = kmap(page);
6905 				read_extent_buffer(leaf, map + pg_offset, ptr,
6906 						   copy_size);
6907 				if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
6908 					memset(map + pg_offset + copy_size, 0,
6909 					       PAGE_CACHE_SIZE - pg_offset -
6910 					       copy_size);
6911 				}
6912 				kunmap(page);
6913 			}
6914 			flush_dcache_page(page);
6915 		} else if (create && PageUptodate(page)) {
6916 			BUG();
6917 			if (!trans) {
6918 				kunmap(page);
6919 				free_extent_map(em);
6920 				em = NULL;
6921 
6922 				btrfs_release_path(path);
6923 				trans = btrfs_join_transaction(root);
6924 
6925 				if (IS_ERR(trans))
6926 					return ERR_CAST(trans);
6927 				goto again;
6928 			}
6929 			map = kmap(page);
6930 			write_extent_buffer(leaf, map + pg_offset, ptr,
6931 					    copy_size);
6932 			kunmap(page);
6933 			btrfs_mark_buffer_dirty(leaf);
6934 		}
6935 		set_extent_uptodate(io_tree, em->start,
6936 				    extent_map_end(em) - 1, NULL, GFP_NOFS);
6937 		goto insert;
6938 	}
6939 not_found:
6940 	em->start = start;
6941 	em->orig_start = start;
6942 	em->len = len;
6943 not_found_em:
6944 	em->block_start = EXTENT_MAP_HOLE;
6945 	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
6946 insert:
6947 	btrfs_release_path(path);
6948 	if (em->start > start || extent_map_end(em) <= start) {
6949 		btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]",
6950 			em->start, em->len, start, len);
6951 		err = -EIO;
6952 		goto out;
6953 	}
6954 
6955 	err = 0;
6956 	write_lock(&em_tree->lock);
6957 	ret = add_extent_mapping(em_tree, em, 0);
6958 	/* it is possible that someone inserted the extent into the tree
6959 	 * while we had the lock dropped.  It is also possible that
6960 	 * an overlapping map exists in the tree
6961 	 */
6962 	if (ret == -EEXIST) {
6963 		struct extent_map *existing;
6964 
6965 		ret = 0;
6966 
6967 		existing = search_extent_mapping(em_tree, start, len);
6968 		/*
6969 		 * existing will always be non-NULL, since there must be
6970 		 * extent causing the -EEXIST.
6971 		 */
6972 		if (start >= extent_map_end(existing) ||
6973 		    start <= existing->start) {
6974 			/*
6975 			 * The existing extent map is the one nearest to
6976 			 * the [start, start + len) range which overlaps
6977 			 */
6978 			err = merge_extent_mapping(em_tree, existing,
6979 						   em, start);
6980 			free_extent_map(existing);
6981 			if (err) {
6982 				free_extent_map(em);
6983 				em = NULL;
6984 			}
6985 		} else {
6986 			free_extent_map(em);
6987 			em = existing;
6988 			err = 0;
6989 		}
6990 	}
6991 	write_unlock(&em_tree->lock);
6992 out:
6993 
6994 	trace_btrfs_get_extent(root, em);
6995 
6996 	btrfs_free_path(path);
6997 	if (trans) {
6998 		ret = btrfs_end_transaction(trans, root);
6999 		if (!err)
7000 			err = ret;
7001 	}
7002 	if (err) {
7003 		free_extent_map(em);
7004 		return ERR_PTR(err);
7005 	}
7006 	BUG_ON(!em); /* Error is always set */
7007 	return em;
7008 }
7009 
btrfs_get_extent_fiemap(struct inode * inode,struct page * page,size_t pg_offset,u64 start,u64 len,int create)7010 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
7011 					   size_t pg_offset, u64 start, u64 len,
7012 					   int create)
7013 {
7014 	struct extent_map *em;
7015 	struct extent_map *hole_em = NULL;
7016 	u64 range_start = start;
7017 	u64 end;
7018 	u64 found;
7019 	u64 found_end;
7020 	int err = 0;
7021 
7022 	em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
7023 	if (IS_ERR(em))
7024 		return em;
7025 	if (em) {
7026 		/*
7027 		 * if our em maps to
7028 		 * -  a hole or
7029 		 * -  a pre-alloc extent,
7030 		 * there might actually be delalloc bytes behind it.
7031 		 */
7032 		if (em->block_start != EXTENT_MAP_HOLE &&
7033 		    !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
7034 			return em;
7035 		else
7036 			hole_em = em;
7037 	}
7038 
7039 	/* check to see if we've wrapped (len == -1 or similar) */
7040 	end = start + len;
7041 	if (end < start)
7042 		end = (u64)-1;
7043 	else
7044 		end -= 1;
7045 
7046 	em = NULL;
7047 
7048 	/* ok, we didn't find anything, lets look for delalloc */
7049 	found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
7050 				 end, len, EXTENT_DELALLOC, 1);
7051 	found_end = range_start + found;
7052 	if (found_end < range_start)
7053 		found_end = (u64)-1;
7054 
7055 	/*
7056 	 * we didn't find anything useful, return
7057 	 * the original results from get_extent()
7058 	 */
7059 	if (range_start > end || found_end <= start) {
7060 		em = hole_em;
7061 		hole_em = NULL;
7062 		goto out;
7063 	}
7064 
7065 	/* adjust the range_start to make sure it doesn't
7066 	 * go backwards from the start they passed in
7067 	 */
7068 	range_start = max(start, range_start);
7069 	found = found_end - range_start;
7070 
7071 	if (found > 0) {
7072 		u64 hole_start = start;
7073 		u64 hole_len = len;
7074 
7075 		em = alloc_extent_map();
7076 		if (!em) {
7077 			err = -ENOMEM;
7078 			goto out;
7079 		}
7080 		/*
7081 		 * when btrfs_get_extent can't find anything it
7082 		 * returns one huge hole
7083 		 *
7084 		 * make sure what it found really fits our range, and
7085 		 * adjust to make sure it is based on the start from
7086 		 * the caller
7087 		 */
7088 		if (hole_em) {
7089 			u64 calc_end = extent_map_end(hole_em);
7090 
7091 			if (calc_end <= start || (hole_em->start > end)) {
7092 				free_extent_map(hole_em);
7093 				hole_em = NULL;
7094 			} else {
7095 				hole_start = max(hole_em->start, start);
7096 				hole_len = calc_end - hole_start;
7097 			}
7098 		}
7099 		em->bdev = NULL;
7100 		if (hole_em && range_start > hole_start) {
7101 			/* our hole starts before our delalloc, so we
7102 			 * have to return just the parts of the hole
7103 			 * that go until  the delalloc starts
7104 			 */
7105 			em->len = min(hole_len,
7106 				      range_start - hole_start);
7107 			em->start = hole_start;
7108 			em->orig_start = hole_start;
7109 			/*
7110 			 * don't adjust block start at all,
7111 			 * it is fixed at EXTENT_MAP_HOLE
7112 			 */
7113 			em->block_start = hole_em->block_start;
7114 			em->block_len = hole_len;
7115 			if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
7116 				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
7117 		} else {
7118 			em->start = range_start;
7119 			em->len = found;
7120 			em->orig_start = range_start;
7121 			em->block_start = EXTENT_MAP_DELALLOC;
7122 			em->block_len = found;
7123 		}
7124 	} else if (hole_em) {
7125 		return hole_em;
7126 	}
7127 out:
7128 
7129 	free_extent_map(hole_em);
7130 	if (err) {
7131 		free_extent_map(em);
7132 		return ERR_PTR(err);
7133 	}
7134 	return em;
7135 }
7136 
btrfs_new_extent_direct(struct inode * inode,u64 start,u64 len)7137 static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
7138 						  u64 start, u64 len)
7139 {
7140 	struct btrfs_root *root = BTRFS_I(inode)->root;
7141 	struct extent_map *em;
7142 	struct btrfs_key ins;
7143 	u64 alloc_hint;
7144 	int ret;
7145 
7146 	alloc_hint = get_extent_allocation_hint(inode, start, len);
7147 	ret = btrfs_reserve_extent(root, len, root->sectorsize, 0,
7148 				   alloc_hint, &ins, 1, 1);
7149 	if (ret)
7150 		return ERR_PTR(ret);
7151 
7152 	em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
7153 			      ins.offset, ins.offset, ins.offset, 0);
7154 	if (IS_ERR(em)) {
7155 		btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1);
7156 		return em;
7157 	}
7158 
7159 	ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
7160 					   ins.offset, ins.offset, 0);
7161 	if (ret) {
7162 		btrfs_free_reserved_extent(root, ins.objectid, ins.offset, 1);
7163 		free_extent_map(em);
7164 		return ERR_PTR(ret);
7165 	}
7166 
7167 	return em;
7168 }
7169 
7170 /*
7171  * returns 1 when the nocow is safe, < 1 on error, 0 if the
7172  * block must be cow'd
7173  */
can_nocow_extent(struct inode * inode,u64 offset,u64 * len,u64 * orig_start,u64 * orig_block_len,u64 * ram_bytes)7174 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
7175 			      u64 *orig_start, u64 *orig_block_len,
7176 			      u64 *ram_bytes)
7177 {
7178 	struct btrfs_trans_handle *trans;
7179 	struct btrfs_path *path;
7180 	int ret;
7181 	struct extent_buffer *leaf;
7182 	struct btrfs_root *root = BTRFS_I(inode)->root;
7183 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
7184 	struct btrfs_file_extent_item *fi;
7185 	struct btrfs_key key;
7186 	u64 disk_bytenr;
7187 	u64 backref_offset;
7188 	u64 extent_end;
7189 	u64 num_bytes;
7190 	int slot;
7191 	int found_type;
7192 	bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW);
7193 
7194 	path = btrfs_alloc_path();
7195 	if (!path)
7196 		return -ENOMEM;
7197 
7198 	ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(inode),
7199 				       offset, 0);
7200 	if (ret < 0)
7201 		goto out;
7202 
7203 	slot = path->slots[0];
7204 	if (ret == 1) {
7205 		if (slot == 0) {
7206 			/* can't find the item, must cow */
7207 			ret = 0;
7208 			goto out;
7209 		}
7210 		slot--;
7211 	}
7212 	ret = 0;
7213 	leaf = path->nodes[0];
7214 	btrfs_item_key_to_cpu(leaf, &key, slot);
7215 	if (key.objectid != btrfs_ino(inode) ||
7216 	    key.type != BTRFS_EXTENT_DATA_KEY) {
7217 		/* not our file or wrong item type, must cow */
7218 		goto out;
7219 	}
7220 
7221 	if (key.offset > offset) {
7222 		/* Wrong offset, must cow */
7223 		goto out;
7224 	}
7225 
7226 	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
7227 	found_type = btrfs_file_extent_type(leaf, fi);
7228 	if (found_type != BTRFS_FILE_EXTENT_REG &&
7229 	    found_type != BTRFS_FILE_EXTENT_PREALLOC) {
7230 		/* not a regular extent, must cow */
7231 		goto out;
7232 	}
7233 
7234 	if (!nocow && found_type == BTRFS_FILE_EXTENT_REG)
7235 		goto out;
7236 
7237 	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
7238 	if (extent_end <= offset)
7239 		goto out;
7240 
7241 	disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
7242 	if (disk_bytenr == 0)
7243 		goto out;
7244 
7245 	if (btrfs_file_extent_compression(leaf, fi) ||
7246 	    btrfs_file_extent_encryption(leaf, fi) ||
7247 	    btrfs_file_extent_other_encoding(leaf, fi))
7248 		goto out;
7249 
7250 	backref_offset = btrfs_file_extent_offset(leaf, fi);
7251 
7252 	if (orig_start) {
7253 		*orig_start = key.offset - backref_offset;
7254 		*orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
7255 		*ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
7256 	}
7257 
7258 	if (btrfs_extent_readonly(root, disk_bytenr))
7259 		goto out;
7260 
7261 	num_bytes = min(offset + *len, extent_end) - offset;
7262 	if (!nocow && found_type == BTRFS_FILE_EXTENT_PREALLOC) {
7263 		u64 range_end;
7264 
7265 		range_end = round_up(offset + num_bytes, root->sectorsize) - 1;
7266 		ret = test_range_bit(io_tree, offset, range_end,
7267 				     EXTENT_DELALLOC, 0, NULL);
7268 		if (ret) {
7269 			ret = -EAGAIN;
7270 			goto out;
7271 		}
7272 	}
7273 
7274 	btrfs_release_path(path);
7275 
7276 	/*
7277 	 * look for other files referencing this extent, if we
7278 	 * find any we must cow
7279 	 */
7280 	trans = btrfs_join_transaction(root);
7281 	if (IS_ERR(trans)) {
7282 		ret = 0;
7283 		goto out;
7284 	}
7285 
7286 	ret = btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
7287 				    key.offset - backref_offset, disk_bytenr);
7288 	btrfs_end_transaction(trans, root);
7289 	if (ret) {
7290 		ret = 0;
7291 		goto out;
7292 	}
7293 
7294 	/*
7295 	 * adjust disk_bytenr and num_bytes to cover just the bytes
7296 	 * in this extent we are about to write.  If there
7297 	 * are any csums in that range we have to cow in order
7298 	 * to keep the csums correct
7299 	 */
7300 	disk_bytenr += backref_offset;
7301 	disk_bytenr += offset - key.offset;
7302 	if (csum_exist_in_range(root, disk_bytenr, num_bytes))
7303 				goto out;
7304 	/*
7305 	 * all of the above have passed, it is safe to overwrite this extent
7306 	 * without cow
7307 	 */
7308 	*len = num_bytes;
7309 	ret = 1;
7310 out:
7311 	btrfs_free_path(path);
7312 	return ret;
7313 }
7314 
btrfs_page_exists_in_range(struct inode * inode,loff_t start,loff_t end)7315 bool btrfs_page_exists_in_range(struct inode *inode, loff_t start, loff_t end)
7316 {
7317 	struct radix_tree_root *root = &inode->i_mapping->page_tree;
7318 	int found = false;
7319 	void **pagep = NULL;
7320 	struct page *page = NULL;
7321 	int start_idx;
7322 	int end_idx;
7323 
7324 	start_idx = start >> PAGE_CACHE_SHIFT;
7325 
7326 	/*
7327 	 * end is the last byte in the last page.  end == start is legal
7328 	 */
7329 	end_idx = end >> PAGE_CACHE_SHIFT;
7330 
7331 	rcu_read_lock();
7332 
7333 	/* Most of the code in this while loop is lifted from
7334 	 * find_get_page.  It's been modified to begin searching from a
7335 	 * page and return just the first page found in that range.  If the
7336 	 * found idx is less than or equal to the end idx then we know that
7337 	 * a page exists.  If no pages are found or if those pages are
7338 	 * outside of the range then we're fine (yay!) */
7339 	while (page == NULL &&
7340 	       radix_tree_gang_lookup_slot(root, &pagep, NULL, start_idx, 1)) {
7341 		page = radix_tree_deref_slot(pagep);
7342 		if (unlikely(!page))
7343 			break;
7344 
7345 		if (radix_tree_exception(page)) {
7346 			if (radix_tree_deref_retry(page)) {
7347 				page = NULL;
7348 				continue;
7349 			}
7350 			/*
7351 			 * Otherwise, shmem/tmpfs must be storing a swap entry
7352 			 * here as an exceptional entry: so return it without
7353 			 * attempting to raise page count.
7354 			 */
7355 			page = NULL;
7356 			break; /* TODO: Is this relevant for this use case? */
7357 		}
7358 
7359 		if (!page_cache_get_speculative(page)) {
7360 			page = NULL;
7361 			continue;
7362 		}
7363 
7364 		/*
7365 		 * Has the page moved?
7366 		 * This is part of the lockless pagecache protocol. See
7367 		 * include/linux/pagemap.h for details.
7368 		 */
7369 		if (unlikely(page != *pagep)) {
7370 			page_cache_release(page);
7371 			page = NULL;
7372 		}
7373 	}
7374 
7375 	if (page) {
7376 		if (page->index <= end_idx)
7377 			found = true;
7378 		page_cache_release(page);
7379 	}
7380 
7381 	rcu_read_unlock();
7382 	return found;
7383 }
7384 
lock_extent_direct(struct inode * inode,u64 lockstart,u64 lockend,struct extent_state ** cached_state,int writing)7385 static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
7386 			      struct extent_state **cached_state, int writing)
7387 {
7388 	struct btrfs_ordered_extent *ordered;
7389 	int ret = 0;
7390 
7391 	while (1) {
7392 		lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
7393 				 0, cached_state);
7394 		/*
7395 		 * We're concerned with the entire range that we're going to be
7396 		 * doing DIO to, so we need to make sure theres no ordered
7397 		 * extents in this range.
7398 		 */
7399 		ordered = btrfs_lookup_ordered_range(inode, lockstart,
7400 						     lockend - lockstart + 1);
7401 
7402 		/*
7403 		 * We need to make sure there are no buffered pages in this
7404 		 * range either, we could have raced between the invalidate in
7405 		 * generic_file_direct_write and locking the extent.  The
7406 		 * invalidate needs to happen so that reads after a write do not
7407 		 * get stale data.
7408 		 */
7409 		if (!ordered &&
7410 		    (!writing ||
7411 		     !btrfs_page_exists_in_range(inode, lockstart, lockend)))
7412 			break;
7413 
7414 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
7415 				     cached_state, GFP_NOFS);
7416 
7417 		if (ordered) {
7418 			btrfs_start_ordered_extent(inode, ordered, 1);
7419 			btrfs_put_ordered_extent(ordered);
7420 		} else {
7421 			/* Screw you mmap */
7422 			ret = btrfs_fdatawrite_range(inode, lockstart, lockend);
7423 			if (ret)
7424 				break;
7425 			ret = filemap_fdatawait_range(inode->i_mapping,
7426 						      lockstart,
7427 						      lockend);
7428 			if (ret)
7429 				break;
7430 
7431 			/*
7432 			 * If we found a page that couldn't be invalidated just
7433 			 * fall back to buffered.
7434 			 */
7435 			ret = invalidate_inode_pages2_range(inode->i_mapping,
7436 					lockstart >> PAGE_CACHE_SHIFT,
7437 					lockend >> PAGE_CACHE_SHIFT);
7438 			if (ret)
7439 				break;
7440 		}
7441 
7442 		cond_resched();
7443 	}
7444 
7445 	return ret;
7446 }
7447 
create_pinned_em(struct inode * inode,u64 start,u64 len,u64 orig_start,u64 block_start,u64 block_len,u64 orig_block_len,u64 ram_bytes,int type)7448 static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
7449 					   u64 len, u64 orig_start,
7450 					   u64 block_start, u64 block_len,
7451 					   u64 orig_block_len, u64 ram_bytes,
7452 					   int type)
7453 {
7454 	struct extent_map_tree *em_tree;
7455 	struct extent_map *em;
7456 	struct btrfs_root *root = BTRFS_I(inode)->root;
7457 	int ret;
7458 
7459 	em_tree = &BTRFS_I(inode)->extent_tree;
7460 	em = alloc_extent_map();
7461 	if (!em)
7462 		return ERR_PTR(-ENOMEM);
7463 
7464 	em->start = start;
7465 	em->orig_start = orig_start;
7466 	em->mod_start = start;
7467 	em->mod_len = len;
7468 	em->len = len;
7469 	em->block_len = block_len;
7470 	em->block_start = block_start;
7471 	em->bdev = root->fs_info->fs_devices->latest_bdev;
7472 	em->orig_block_len = orig_block_len;
7473 	em->ram_bytes = ram_bytes;
7474 	em->generation = -1;
7475 	set_bit(EXTENT_FLAG_PINNED, &em->flags);
7476 	if (type == BTRFS_ORDERED_PREALLOC)
7477 		set_bit(EXTENT_FLAG_FILLING, &em->flags);
7478 
7479 	do {
7480 		btrfs_drop_extent_cache(inode, em->start,
7481 				em->start + em->len - 1, 0);
7482 		write_lock(&em_tree->lock);
7483 		ret = add_extent_mapping(em_tree, em, 1);
7484 		write_unlock(&em_tree->lock);
7485 	} while (ret == -EEXIST);
7486 
7487 	if (ret) {
7488 		free_extent_map(em);
7489 		return ERR_PTR(ret);
7490 	}
7491 
7492 	return em;
7493 }
7494 
7495 struct btrfs_dio_data {
7496 	u64 outstanding_extents;
7497 	u64 reserve;
7498 };
7499 
adjust_dio_outstanding_extents(struct inode * inode,struct btrfs_dio_data * dio_data,const u64 len)7500 static void adjust_dio_outstanding_extents(struct inode *inode,
7501 					   struct btrfs_dio_data *dio_data,
7502 					   const u64 len)
7503 {
7504 	unsigned num_extents;
7505 
7506 	num_extents = (unsigned) div64_u64(len + BTRFS_MAX_EXTENT_SIZE - 1,
7507 					   BTRFS_MAX_EXTENT_SIZE);
7508 	/*
7509 	 * If we have an outstanding_extents count still set then we're
7510 	 * within our reservation, otherwise we need to adjust our inode
7511 	 * counter appropriately.
7512 	 */
7513 	if (dio_data->outstanding_extents) {
7514 		dio_data->outstanding_extents -= num_extents;
7515 	} else {
7516 		spin_lock(&BTRFS_I(inode)->lock);
7517 		BTRFS_I(inode)->outstanding_extents += num_extents;
7518 		spin_unlock(&BTRFS_I(inode)->lock);
7519 	}
7520 }
7521 
btrfs_get_blocks_direct(struct inode * inode,sector_t iblock,struct buffer_head * bh_result,int create)7522 static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
7523 				   struct buffer_head *bh_result, int create)
7524 {
7525 	struct extent_map *em;
7526 	struct btrfs_root *root = BTRFS_I(inode)->root;
7527 	struct extent_state *cached_state = NULL;
7528 	struct btrfs_dio_data *dio_data = NULL;
7529 	u64 start = iblock << inode->i_blkbits;
7530 	u64 lockstart, lockend;
7531 	u64 len = bh_result->b_size;
7532 	int unlock_bits = EXTENT_LOCKED;
7533 	int ret = 0;
7534 
7535 	if (create)
7536 		unlock_bits |= EXTENT_DIRTY;
7537 	else
7538 		len = min_t(u64, len, root->sectorsize);
7539 
7540 	lockstart = start;
7541 	lockend = start + len - 1;
7542 
7543 	if (current->journal_info) {
7544 		/*
7545 		 * Need to pull our outstanding extents and set journal_info to NULL so
7546 		 * that anything that needs to check if there's a transction doesn't get
7547 		 * confused.
7548 		 */
7549 		dio_data = current->journal_info;
7550 		current->journal_info = NULL;
7551 	}
7552 
7553 	/*
7554 	 * If this errors out it's because we couldn't invalidate pagecache for
7555 	 * this range and we need to fallback to buffered.
7556 	 */
7557 	if (lock_extent_direct(inode, lockstart, lockend, &cached_state,
7558 			       create)) {
7559 		ret = -ENOTBLK;
7560 		goto err;
7561 	}
7562 
7563 	em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
7564 	if (IS_ERR(em)) {
7565 		ret = PTR_ERR(em);
7566 		goto unlock_err;
7567 	}
7568 
7569 	/*
7570 	 * Ok for INLINE and COMPRESSED extents we need to fallback on buffered
7571 	 * io.  INLINE is special, and we could probably kludge it in here, but
7572 	 * it's still buffered so for safety lets just fall back to the generic
7573 	 * buffered path.
7574 	 *
7575 	 * For COMPRESSED we _have_ to read the entire extent in so we can
7576 	 * decompress it, so there will be buffering required no matter what we
7577 	 * do, so go ahead and fallback to buffered.
7578 	 *
7579 	 * We return -ENOTBLK because thats what makes DIO go ahead and go back
7580 	 * to buffered IO.  Don't blame me, this is the price we pay for using
7581 	 * the generic code.
7582 	 */
7583 	if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||
7584 	    em->block_start == EXTENT_MAP_INLINE) {
7585 		free_extent_map(em);
7586 		ret = -ENOTBLK;
7587 		goto unlock_err;
7588 	}
7589 
7590 	/* Just a good old fashioned hole, return */
7591 	if (!create && (em->block_start == EXTENT_MAP_HOLE ||
7592 			test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
7593 		free_extent_map(em);
7594 		goto unlock_err;
7595 	}
7596 
7597 	/*
7598 	 * We don't allocate a new extent in the following cases
7599 	 *
7600 	 * 1) The inode is marked as NODATACOW.  In this case we'll just use the
7601 	 * existing extent.
7602 	 * 2) The extent is marked as PREALLOC.  We're good to go here and can
7603 	 * just use the extent.
7604 	 *
7605 	 */
7606 	if (!create) {
7607 		len = min(len, em->len - (start - em->start));
7608 		lockstart = start + len;
7609 		goto unlock;
7610 	}
7611 
7612 	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
7613 	    ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
7614 	     em->block_start != EXTENT_MAP_HOLE)) {
7615 		int type;
7616 		u64 block_start, orig_start, orig_block_len, ram_bytes;
7617 
7618 		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
7619 			type = BTRFS_ORDERED_PREALLOC;
7620 		else
7621 			type = BTRFS_ORDERED_NOCOW;
7622 		len = min(len, em->len - (start - em->start));
7623 		block_start = em->block_start + (start - em->start);
7624 
7625 		if (can_nocow_extent(inode, start, &len, &orig_start,
7626 				     &orig_block_len, &ram_bytes) == 1) {
7627 			if (type == BTRFS_ORDERED_PREALLOC) {
7628 				free_extent_map(em);
7629 				em = create_pinned_em(inode, start, len,
7630 						       orig_start,
7631 						       block_start, len,
7632 						       orig_block_len,
7633 						       ram_bytes, type);
7634 				if (IS_ERR(em)) {
7635 					ret = PTR_ERR(em);
7636 					goto unlock_err;
7637 				}
7638 			}
7639 
7640 			ret = btrfs_add_ordered_extent_dio(inode, start,
7641 					   block_start, len, len, type);
7642 			if (ret) {
7643 				free_extent_map(em);
7644 				goto unlock_err;
7645 			}
7646 			goto unlock;
7647 		}
7648 	}
7649 
7650 	/*
7651 	 * this will cow the extent, reset the len in case we changed
7652 	 * it above
7653 	 */
7654 	len = bh_result->b_size;
7655 	free_extent_map(em);
7656 	em = btrfs_new_extent_direct(inode, start, len);
7657 	if (IS_ERR(em)) {
7658 		ret = PTR_ERR(em);
7659 		goto unlock_err;
7660 	}
7661 	len = min(len, em->len - (start - em->start));
7662 unlock:
7663 	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
7664 		inode->i_blkbits;
7665 	bh_result->b_size = len;
7666 	bh_result->b_bdev = em->bdev;
7667 	set_buffer_mapped(bh_result);
7668 	if (create) {
7669 		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
7670 			set_buffer_new(bh_result);
7671 
7672 		/*
7673 		 * Need to update the i_size under the extent lock so buffered
7674 		 * readers will get the updated i_size when we unlock.
7675 		 */
7676 		if (start + len > i_size_read(inode))
7677 			i_size_write(inode, start + len);
7678 
7679 		adjust_dio_outstanding_extents(inode, dio_data, len);
7680 		btrfs_free_reserved_data_space(inode, start, len);
7681 		WARN_ON(dio_data->reserve < len);
7682 		dio_data->reserve -= len;
7683 		current->journal_info = dio_data;
7684 	}
7685 
7686 	/*
7687 	 * In the case of write we need to clear and unlock the entire range,
7688 	 * in the case of read we need to unlock only the end area that we
7689 	 * aren't using if there is any left over space.
7690 	 */
7691 	if (lockstart < lockend) {
7692 		clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
7693 				 lockend, unlock_bits, 1, 0,
7694 				 &cached_state, GFP_NOFS);
7695 	} else {
7696 		free_extent_state(cached_state);
7697 	}
7698 
7699 	free_extent_map(em);
7700 
7701 	return 0;
7702 
7703 unlock_err:
7704 	clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
7705 			 unlock_bits, 1, 0, &cached_state, GFP_NOFS);
7706 err:
7707 	if (dio_data)
7708 		current->journal_info = dio_data;
7709 	/*
7710 	 * Compensate the delalloc release we do in btrfs_direct_IO() when we
7711 	 * write less data then expected, so that we don't underflow our inode's
7712 	 * outstanding extents counter.
7713 	 */
7714 	if (create && dio_data)
7715 		adjust_dio_outstanding_extents(inode, dio_data, len);
7716 
7717 	return ret;
7718 }
7719 
submit_dio_repair_bio(struct inode * inode,struct bio * bio,int rw,int mirror_num)7720 static inline int submit_dio_repair_bio(struct inode *inode, struct bio *bio,
7721 					int rw, int mirror_num)
7722 {
7723 	struct btrfs_root *root = BTRFS_I(inode)->root;
7724 	int ret;
7725 
7726 	BUG_ON(rw & REQ_WRITE);
7727 
7728 	bio_get(bio);
7729 
7730 	ret = btrfs_bio_wq_end_io(root->fs_info, bio,
7731 				  BTRFS_WQ_ENDIO_DIO_REPAIR);
7732 	if (ret)
7733 		goto err;
7734 
7735 	ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
7736 err:
7737 	bio_put(bio);
7738 	return ret;
7739 }
7740 
btrfs_check_dio_repairable(struct inode * inode,struct bio * failed_bio,struct io_failure_record * failrec,int failed_mirror)7741 static int btrfs_check_dio_repairable(struct inode *inode,
7742 				      struct bio *failed_bio,
7743 				      struct io_failure_record *failrec,
7744 				      int failed_mirror)
7745 {
7746 	int num_copies;
7747 
7748 	num_copies = btrfs_num_copies(BTRFS_I(inode)->root->fs_info,
7749 				      failrec->logical, failrec->len);
7750 	if (num_copies == 1) {
7751 		/*
7752 		 * we only have a single copy of the data, so don't bother with
7753 		 * all the retry and error correction code that follows. no
7754 		 * matter what the error is, it is very likely to persist.
7755 		 */
7756 		pr_debug("Check DIO Repairable: cannot repair, num_copies=%d, next_mirror %d, failed_mirror %d\n",
7757 			 num_copies, failrec->this_mirror, failed_mirror);
7758 		return 0;
7759 	}
7760 
7761 	failrec->failed_mirror = failed_mirror;
7762 	failrec->this_mirror++;
7763 	if (failrec->this_mirror == failed_mirror)
7764 		failrec->this_mirror++;
7765 
7766 	if (failrec->this_mirror > num_copies) {
7767 		pr_debug("Check DIO Repairable: (fail) num_copies=%d, next_mirror %d, failed_mirror %d\n",
7768 			 num_copies, failrec->this_mirror, failed_mirror);
7769 		return 0;
7770 	}
7771 
7772 	return 1;
7773 }
7774 
dio_read_error(struct inode * inode,struct bio * failed_bio,struct page * page,u64 start,u64 end,int failed_mirror,bio_end_io_t * repair_endio,void * repair_arg)7775 static int dio_read_error(struct inode *inode, struct bio *failed_bio,
7776 			  struct page *page, u64 start, u64 end,
7777 			  int failed_mirror, bio_end_io_t *repair_endio,
7778 			  void *repair_arg)
7779 {
7780 	struct io_failure_record *failrec;
7781 	struct bio *bio;
7782 	int isector;
7783 	int read_mode;
7784 	int ret;
7785 
7786 	BUG_ON(failed_bio->bi_rw & REQ_WRITE);
7787 
7788 	ret = btrfs_get_io_failure_record(inode, start, end, &failrec);
7789 	if (ret)
7790 		return ret;
7791 
7792 	ret = btrfs_check_dio_repairable(inode, failed_bio, failrec,
7793 					 failed_mirror);
7794 	if (!ret) {
7795 		free_io_failure(inode, failrec);
7796 		return -EIO;
7797 	}
7798 
7799 	if (failed_bio->bi_vcnt > 1)
7800 		read_mode = READ_SYNC | REQ_FAILFAST_DEV;
7801 	else
7802 		read_mode = READ_SYNC;
7803 
7804 	isector = start - btrfs_io_bio(failed_bio)->logical;
7805 	isector >>= inode->i_sb->s_blocksize_bits;
7806 	bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page,
7807 				      0, isector, repair_endio, repair_arg);
7808 	if (!bio) {
7809 		free_io_failure(inode, failrec);
7810 		return -EIO;
7811 	}
7812 
7813 	btrfs_debug(BTRFS_I(inode)->root->fs_info,
7814 		    "Repair DIO Read Error: submitting new dio read[%#x] to this_mirror=%d, in_validation=%d\n",
7815 		    read_mode, failrec->this_mirror, failrec->in_validation);
7816 
7817 	ret = submit_dio_repair_bio(inode, bio, read_mode,
7818 				    failrec->this_mirror);
7819 	if (ret) {
7820 		free_io_failure(inode, failrec);
7821 		bio_put(bio);
7822 	}
7823 
7824 	return ret;
7825 }
7826 
7827 struct btrfs_retry_complete {
7828 	struct completion done;
7829 	struct inode *inode;
7830 	u64 start;
7831 	int uptodate;
7832 };
7833 
btrfs_retry_endio_nocsum(struct bio * bio)7834 static void btrfs_retry_endio_nocsum(struct bio *bio)
7835 {
7836 	struct btrfs_retry_complete *done = bio->bi_private;
7837 	struct bio_vec *bvec;
7838 	int i;
7839 
7840 	if (bio->bi_error)
7841 		goto end;
7842 
7843 	done->uptodate = 1;
7844 	bio_for_each_segment_all(bvec, bio, i)
7845 		clean_io_failure(done->inode, done->start, bvec->bv_page, 0);
7846 end:
7847 	complete(&done->done);
7848 	bio_put(bio);
7849 }
7850 
__btrfs_correct_data_nocsum(struct inode * inode,struct btrfs_io_bio * io_bio)7851 static int __btrfs_correct_data_nocsum(struct inode *inode,
7852 				       struct btrfs_io_bio *io_bio)
7853 {
7854 	struct bio_vec *bvec;
7855 	struct btrfs_retry_complete done;
7856 	u64 start;
7857 	int i;
7858 	int ret;
7859 
7860 	start = io_bio->logical;
7861 	done.inode = inode;
7862 
7863 	bio_for_each_segment_all(bvec, &io_bio->bio, i) {
7864 try_again:
7865 		done.uptodate = 0;
7866 		done.start = start;
7867 		init_completion(&done.done);
7868 
7869 		ret = dio_read_error(inode, &io_bio->bio, bvec->bv_page, start,
7870 				     start + bvec->bv_len - 1,
7871 				     io_bio->mirror_num,
7872 				     btrfs_retry_endio_nocsum, &done);
7873 		if (ret)
7874 			return ret;
7875 
7876 		wait_for_completion(&done.done);
7877 
7878 		if (!done.uptodate) {
7879 			/* We might have another mirror, so try again */
7880 			goto try_again;
7881 		}
7882 
7883 		start += bvec->bv_len;
7884 	}
7885 
7886 	return 0;
7887 }
7888 
btrfs_retry_endio(struct bio * bio)7889 static void btrfs_retry_endio(struct bio *bio)
7890 {
7891 	struct btrfs_retry_complete *done = bio->bi_private;
7892 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
7893 	struct bio_vec *bvec;
7894 	int uptodate;
7895 	int ret;
7896 	int i;
7897 
7898 	if (bio->bi_error)
7899 		goto end;
7900 
7901 	uptodate = 1;
7902 	bio_for_each_segment_all(bvec, bio, i) {
7903 		ret = __readpage_endio_check(done->inode, io_bio, i,
7904 					     bvec->bv_page, 0,
7905 					     done->start, bvec->bv_len);
7906 		if (!ret)
7907 			clean_io_failure(done->inode, done->start,
7908 					 bvec->bv_page, 0);
7909 		else
7910 			uptodate = 0;
7911 	}
7912 
7913 	done->uptodate = uptodate;
7914 end:
7915 	complete(&done->done);
7916 	bio_put(bio);
7917 }
7918 
__btrfs_subio_endio_read(struct inode * inode,struct btrfs_io_bio * io_bio,int err)7919 static int __btrfs_subio_endio_read(struct inode *inode,
7920 				    struct btrfs_io_bio *io_bio, int err)
7921 {
7922 	struct bio_vec *bvec;
7923 	struct btrfs_retry_complete done;
7924 	u64 start;
7925 	u64 offset = 0;
7926 	int i;
7927 	int ret;
7928 
7929 	err = 0;
7930 	start = io_bio->logical;
7931 	done.inode = inode;
7932 
7933 	bio_for_each_segment_all(bvec, &io_bio->bio, i) {
7934 		ret = __readpage_endio_check(inode, io_bio, i, bvec->bv_page,
7935 					     0, start, bvec->bv_len);
7936 		if (likely(!ret))
7937 			goto next;
7938 try_again:
7939 		done.uptodate = 0;
7940 		done.start = start;
7941 		init_completion(&done.done);
7942 
7943 		ret = dio_read_error(inode, &io_bio->bio, bvec->bv_page, start,
7944 				     start + bvec->bv_len - 1,
7945 				     io_bio->mirror_num,
7946 				     btrfs_retry_endio, &done);
7947 		if (ret) {
7948 			err = ret;
7949 			goto next;
7950 		}
7951 
7952 		wait_for_completion(&done.done);
7953 
7954 		if (!done.uptodate) {
7955 			/* We might have another mirror, so try again */
7956 			goto try_again;
7957 		}
7958 next:
7959 		offset += bvec->bv_len;
7960 		start += bvec->bv_len;
7961 	}
7962 
7963 	return err;
7964 }
7965 
btrfs_subio_endio_read(struct inode * inode,struct btrfs_io_bio * io_bio,int err)7966 static int btrfs_subio_endio_read(struct inode *inode,
7967 				  struct btrfs_io_bio *io_bio, int err)
7968 {
7969 	bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
7970 
7971 	if (skip_csum) {
7972 		if (unlikely(err))
7973 			return __btrfs_correct_data_nocsum(inode, io_bio);
7974 		else
7975 			return 0;
7976 	} else {
7977 		return __btrfs_subio_endio_read(inode, io_bio, err);
7978 	}
7979 }
7980 
btrfs_endio_direct_read(struct bio * bio)7981 static void btrfs_endio_direct_read(struct bio *bio)
7982 {
7983 	struct btrfs_dio_private *dip = bio->bi_private;
7984 	struct inode *inode = dip->inode;
7985 	struct bio *dio_bio;
7986 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
7987 	int err = bio->bi_error;
7988 
7989 	if (dip->flags & BTRFS_DIO_ORIG_BIO_SUBMITTED)
7990 		err = btrfs_subio_endio_read(inode, io_bio, err);
7991 
7992 	unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
7993 		      dip->logical_offset + dip->bytes - 1);
7994 	dio_bio = dip->dio_bio;
7995 
7996 	kfree(dip);
7997 
7998 	dio_bio->bi_error = bio->bi_error;
7999 	dio_end_io(dio_bio, bio->bi_error);
8000 
8001 	if (io_bio->end_io)
8002 		io_bio->end_io(io_bio, err);
8003 	bio_put(bio);
8004 }
8005 
btrfs_endio_direct_write(struct bio * bio)8006 static void btrfs_endio_direct_write(struct bio *bio)
8007 {
8008 	struct btrfs_dio_private *dip = bio->bi_private;
8009 	struct inode *inode = dip->inode;
8010 	struct btrfs_root *root = BTRFS_I(inode)->root;
8011 	struct btrfs_ordered_extent *ordered = NULL;
8012 	u64 ordered_offset = dip->logical_offset;
8013 	u64 ordered_bytes = dip->bytes;
8014 	struct bio *dio_bio;
8015 	int ret;
8016 
8017 again:
8018 	ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
8019 						   &ordered_offset,
8020 						   ordered_bytes,
8021 						   !bio->bi_error);
8022 	if (!ret)
8023 		goto out_test;
8024 
8025 	btrfs_init_work(&ordered->work, btrfs_endio_write_helper,
8026 			finish_ordered_fn, NULL, NULL);
8027 	btrfs_queue_work(root->fs_info->endio_write_workers,
8028 			 &ordered->work);
8029 out_test:
8030 	/*
8031 	 * our bio might span multiple ordered extents.  If we haven't
8032 	 * completed the accounting for the whole dio, go back and try again
8033 	 */
8034 	if (ordered_offset < dip->logical_offset + dip->bytes) {
8035 		ordered_bytes = dip->logical_offset + dip->bytes -
8036 			ordered_offset;
8037 		ordered = NULL;
8038 		goto again;
8039 	}
8040 	dio_bio = dip->dio_bio;
8041 
8042 	kfree(dip);
8043 
8044 	dio_bio->bi_error = bio->bi_error;
8045 	dio_end_io(dio_bio, bio->bi_error);
8046 	bio_put(bio);
8047 }
8048 
__btrfs_submit_bio_start_direct_io(struct inode * inode,int rw,struct bio * bio,int mirror_num,unsigned long bio_flags,u64 offset)8049 static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
8050 				    struct bio *bio, int mirror_num,
8051 				    unsigned long bio_flags, u64 offset)
8052 {
8053 	int ret;
8054 	struct btrfs_root *root = BTRFS_I(inode)->root;
8055 	ret = btrfs_csum_one_bio(root, inode, bio, offset, 1);
8056 	BUG_ON(ret); /* -ENOMEM */
8057 	return 0;
8058 }
8059 
btrfs_end_dio_bio(struct bio * bio)8060 static void btrfs_end_dio_bio(struct bio *bio)
8061 {
8062 	struct btrfs_dio_private *dip = bio->bi_private;
8063 	int err = bio->bi_error;
8064 
8065 	if (err)
8066 		btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
8067 			   "direct IO failed ino %llu rw %lu sector %#Lx len %u err no %d",
8068 			   btrfs_ino(dip->inode), bio->bi_rw,
8069 			   (unsigned long long)bio->bi_iter.bi_sector,
8070 			   bio->bi_iter.bi_size, err);
8071 
8072 	if (dip->subio_endio)
8073 		err = dip->subio_endio(dip->inode, btrfs_io_bio(bio), err);
8074 
8075 	if (err) {
8076 		dip->errors = 1;
8077 
8078 		/*
8079 		 * before atomic variable goto zero, we must make sure
8080 		 * dip->errors is perceived to be set.
8081 		 */
8082 		smp_mb__before_atomic();
8083 	}
8084 
8085 	/* if there are more bios still pending for this dio, just exit */
8086 	if (!atomic_dec_and_test(&dip->pending_bios))
8087 		goto out;
8088 
8089 	if (dip->errors) {
8090 		bio_io_error(dip->orig_bio);
8091 	} else {
8092 		dip->dio_bio->bi_error = 0;
8093 		bio_endio(dip->orig_bio);
8094 	}
8095 out:
8096 	bio_put(bio);
8097 }
8098 
btrfs_dio_bio_alloc(struct block_device * bdev,u64 first_sector,gfp_t gfp_flags)8099 static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
8100 				       u64 first_sector, gfp_t gfp_flags)
8101 {
8102 	struct bio *bio;
8103 	bio = btrfs_bio_alloc(bdev, first_sector, BIO_MAX_PAGES, gfp_flags);
8104 	if (bio)
8105 		bio_associate_current(bio);
8106 	return bio;
8107 }
8108 
btrfs_lookup_and_bind_dio_csum(struct btrfs_root * root,struct inode * inode,struct btrfs_dio_private * dip,struct bio * bio,u64 file_offset)8109 static inline int btrfs_lookup_and_bind_dio_csum(struct btrfs_root *root,
8110 						 struct inode *inode,
8111 						 struct btrfs_dio_private *dip,
8112 						 struct bio *bio,
8113 						 u64 file_offset)
8114 {
8115 	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
8116 	struct btrfs_io_bio *orig_io_bio = btrfs_io_bio(dip->orig_bio);
8117 	int ret;
8118 
8119 	/*
8120 	 * We load all the csum data we need when we submit
8121 	 * the first bio to reduce the csum tree search and
8122 	 * contention.
8123 	 */
8124 	if (dip->logical_offset == file_offset) {
8125 		ret = btrfs_lookup_bio_sums_dio(root, inode, dip->orig_bio,
8126 						file_offset);
8127 		if (ret)
8128 			return ret;
8129 	}
8130 
8131 	if (bio == dip->orig_bio)
8132 		return 0;
8133 
8134 	file_offset -= dip->logical_offset;
8135 	file_offset >>= inode->i_sb->s_blocksize_bits;
8136 	io_bio->csum = (u8 *)(((u32 *)orig_io_bio->csum) + file_offset);
8137 
8138 	return 0;
8139 }
8140 
__btrfs_submit_dio_bio(struct bio * bio,struct inode * inode,int rw,u64 file_offset,int skip_sum,int async_submit)8141 static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
8142 					 int rw, u64 file_offset, int skip_sum,
8143 					 int async_submit)
8144 {
8145 	struct btrfs_dio_private *dip = bio->bi_private;
8146 	int write = rw & REQ_WRITE;
8147 	struct btrfs_root *root = BTRFS_I(inode)->root;
8148 	int ret;
8149 
8150 	if (async_submit)
8151 		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
8152 
8153 	bio_get(bio);
8154 
8155 	if (!write) {
8156 		ret = btrfs_bio_wq_end_io(root->fs_info, bio,
8157 				BTRFS_WQ_ENDIO_DATA);
8158 		if (ret)
8159 			goto err;
8160 	}
8161 
8162 	if (skip_sum)
8163 		goto map;
8164 
8165 	if (write && async_submit) {
8166 		ret = btrfs_wq_submit_bio(root->fs_info,
8167 				   inode, rw, bio, 0, 0,
8168 				   file_offset,
8169 				   __btrfs_submit_bio_start_direct_io,
8170 				   __btrfs_submit_bio_done);
8171 		goto err;
8172 	} else if (write) {
8173 		/*
8174 		 * If we aren't doing async submit, calculate the csum of the
8175 		 * bio now.
8176 		 */
8177 		ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
8178 		if (ret)
8179 			goto err;
8180 	} else {
8181 		ret = btrfs_lookup_and_bind_dio_csum(root, inode, dip, bio,
8182 						     file_offset);
8183 		if (ret)
8184 			goto err;
8185 	}
8186 map:
8187 	ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
8188 err:
8189 	bio_put(bio);
8190 	return ret;
8191 }
8192 
btrfs_submit_direct_hook(int rw,struct btrfs_dio_private * dip,int skip_sum)8193 static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
8194 				    int skip_sum)
8195 {
8196 	struct inode *inode = dip->inode;
8197 	struct btrfs_root *root = BTRFS_I(inode)->root;
8198 	struct bio *bio;
8199 	struct bio *orig_bio = dip->orig_bio;
8200 	struct bio_vec *bvec = orig_bio->bi_io_vec;
8201 	u64 start_sector = orig_bio->bi_iter.bi_sector;
8202 	u64 file_offset = dip->logical_offset;
8203 	u64 submit_len = 0;
8204 	u64 map_length;
8205 	int nr_pages = 0;
8206 	int ret;
8207 	int async_submit = 0;
8208 
8209 	map_length = orig_bio->bi_iter.bi_size;
8210 	ret = btrfs_map_block(root->fs_info, rw, start_sector << 9,
8211 			      &map_length, NULL, 0);
8212 	if (ret)
8213 		return -EIO;
8214 
8215 	if (map_length >= orig_bio->bi_iter.bi_size) {
8216 		bio = orig_bio;
8217 		dip->flags |= BTRFS_DIO_ORIG_BIO_SUBMITTED;
8218 		goto submit;
8219 	}
8220 
8221 	/* async crcs make it difficult to collect full stripe writes. */
8222 	if (btrfs_get_alloc_profile(root, 1) & BTRFS_BLOCK_GROUP_RAID56_MASK)
8223 		async_submit = 0;
8224 	else
8225 		async_submit = 1;
8226 
8227 	bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
8228 	if (!bio)
8229 		return -ENOMEM;
8230 
8231 	bio->bi_private = dip;
8232 	bio->bi_end_io = btrfs_end_dio_bio;
8233 	btrfs_io_bio(bio)->logical = file_offset;
8234 	atomic_inc(&dip->pending_bios);
8235 
8236 	while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
8237 		if (map_length < submit_len + bvec->bv_len ||
8238 		    bio_add_page(bio, bvec->bv_page, bvec->bv_len,
8239 				 bvec->bv_offset) < bvec->bv_len) {
8240 			/*
8241 			 * inc the count before we submit the bio so
8242 			 * we know the end IO handler won't happen before
8243 			 * we inc the count. Otherwise, the dip might get freed
8244 			 * before we're done setting it up
8245 			 */
8246 			atomic_inc(&dip->pending_bios);
8247 			ret = __btrfs_submit_dio_bio(bio, inode, rw,
8248 						     file_offset, skip_sum,
8249 						     async_submit);
8250 			if (ret) {
8251 				bio_put(bio);
8252 				atomic_dec(&dip->pending_bios);
8253 				goto out_err;
8254 			}
8255 
8256 			start_sector += submit_len >> 9;
8257 			file_offset += submit_len;
8258 
8259 			submit_len = 0;
8260 			nr_pages = 0;
8261 
8262 			bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
8263 						  start_sector, GFP_NOFS);
8264 			if (!bio)
8265 				goto out_err;
8266 			bio->bi_private = dip;
8267 			bio->bi_end_io = btrfs_end_dio_bio;
8268 			btrfs_io_bio(bio)->logical = file_offset;
8269 
8270 			map_length = orig_bio->bi_iter.bi_size;
8271 			ret = btrfs_map_block(root->fs_info, rw,
8272 					      start_sector << 9,
8273 					      &map_length, NULL, 0);
8274 			if (ret) {
8275 				bio_put(bio);
8276 				goto out_err;
8277 			}
8278 		} else {
8279 			submit_len += bvec->bv_len;
8280 			nr_pages++;
8281 			bvec++;
8282 		}
8283 	}
8284 
8285 submit:
8286 	ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
8287 				     async_submit);
8288 	if (!ret)
8289 		return 0;
8290 
8291 	bio_put(bio);
8292 out_err:
8293 	dip->errors = 1;
8294 	/*
8295 	 * before atomic variable goto zero, we must
8296 	 * make sure dip->errors is perceived to be set.
8297 	 */
8298 	smp_mb__before_atomic();
8299 	if (atomic_dec_and_test(&dip->pending_bios))
8300 		bio_io_error(dip->orig_bio);
8301 
8302 	/* bio_end_io() will handle error, so we needn't return it */
8303 	return 0;
8304 }
8305 
btrfs_submit_direct(int rw,struct bio * dio_bio,struct inode * inode,loff_t file_offset)8306 static void btrfs_submit_direct(int rw, struct bio *dio_bio,
8307 				struct inode *inode, loff_t file_offset)
8308 {
8309 	struct btrfs_dio_private *dip = NULL;
8310 	struct bio *io_bio = NULL;
8311 	struct btrfs_io_bio *btrfs_bio;
8312 	int skip_sum;
8313 	int write = rw & REQ_WRITE;
8314 	int ret = 0;
8315 
8316 	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
8317 
8318 	io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);
8319 	if (!io_bio) {
8320 		ret = -ENOMEM;
8321 		goto free_ordered;
8322 	}
8323 
8324 	dip = kzalloc(sizeof(*dip), GFP_NOFS);
8325 	if (!dip) {
8326 		ret = -ENOMEM;
8327 		goto free_ordered;
8328 	}
8329 
8330 	dip->private = dio_bio->bi_private;
8331 	dip->inode = inode;
8332 	dip->logical_offset = file_offset;
8333 	dip->bytes = dio_bio->bi_iter.bi_size;
8334 	dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;
8335 	io_bio->bi_private = dip;
8336 	dip->orig_bio = io_bio;
8337 	dip->dio_bio = dio_bio;
8338 	atomic_set(&dip->pending_bios, 0);
8339 	btrfs_bio = btrfs_io_bio(io_bio);
8340 	btrfs_bio->logical = file_offset;
8341 
8342 	if (write) {
8343 		io_bio->bi_end_io = btrfs_endio_direct_write;
8344 	} else {
8345 		io_bio->bi_end_io = btrfs_endio_direct_read;
8346 		dip->subio_endio = btrfs_subio_endio_read;
8347 	}
8348 
8349 	ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
8350 	if (!ret)
8351 		return;
8352 
8353 	if (btrfs_bio->end_io)
8354 		btrfs_bio->end_io(btrfs_bio, ret);
8355 
8356 free_ordered:
8357 	/*
8358 	 * If we arrived here it means either we failed to submit the dip
8359 	 * or we either failed to clone the dio_bio or failed to allocate the
8360 	 * dip. If we cloned the dio_bio and allocated the dip, we can just
8361 	 * call bio_endio against our io_bio so that we get proper resource
8362 	 * cleanup if we fail to submit the dip, otherwise, we must do the
8363 	 * same as btrfs_endio_direct_[write|read] because we can't call these
8364 	 * callbacks - they require an allocated dip and a clone of dio_bio.
8365 	 */
8366 	if (io_bio && dip) {
8367 		io_bio->bi_error = -EIO;
8368 		bio_endio(io_bio);
8369 		/*
8370 		 * The end io callbacks free our dip, do the final put on io_bio
8371 		 * and all the cleanup and final put for dio_bio (through
8372 		 * dio_end_io()).
8373 		 */
8374 		dip = NULL;
8375 		io_bio = NULL;
8376 	} else {
8377 		if (write) {
8378 			struct btrfs_ordered_extent *ordered;
8379 
8380 			ordered = btrfs_lookup_ordered_extent(inode,
8381 							      file_offset);
8382 			set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
8383 			/*
8384 			 * Decrements our ref on the ordered extent and removes
8385 			 * the ordered extent from the inode's ordered tree,
8386 			 * doing all the proper resource cleanup such as for the
8387 			 * reserved space and waking up any waiters for this
8388 			 * ordered extent (through btrfs_remove_ordered_extent).
8389 			 */
8390 			btrfs_finish_ordered_io(ordered);
8391 		} else {
8392 			unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
8393 			      file_offset + dio_bio->bi_iter.bi_size - 1);
8394 		}
8395 		dio_bio->bi_error = -EIO;
8396 		/*
8397 		 * Releases and cleans up our dio_bio, no need to bio_put()
8398 		 * nor bio_endio()/bio_io_error() against dio_bio.
8399 		 */
8400 		dio_end_io(dio_bio, ret);
8401 	}
8402 	if (io_bio)
8403 		bio_put(io_bio);
8404 	kfree(dip);
8405 }
8406 
check_direct_IO(struct btrfs_root * root,struct kiocb * iocb,const struct iov_iter * iter,loff_t offset)8407 static ssize_t check_direct_IO(struct btrfs_root *root, struct kiocb *iocb,
8408 			const struct iov_iter *iter, loff_t offset)
8409 {
8410 	int seg;
8411 	int i;
8412 	unsigned blocksize_mask = root->sectorsize - 1;
8413 	ssize_t retval = -EINVAL;
8414 
8415 	if (offset & blocksize_mask)
8416 		goto out;
8417 
8418 	if (iov_iter_alignment(iter) & blocksize_mask)
8419 		goto out;
8420 
8421 	/* If this is a write we don't need to check anymore */
8422 	if (iov_iter_rw(iter) == WRITE)
8423 		return 0;
8424 	/*
8425 	 * Check to make sure we don't have duplicate iov_base's in this
8426 	 * iovec, if so return EINVAL, otherwise we'll get csum errors
8427 	 * when reading back.
8428 	 */
8429 	for (seg = 0; seg < iter->nr_segs; seg++) {
8430 		for (i = seg + 1; i < iter->nr_segs; i++) {
8431 			if (iter->iov[seg].iov_base == iter->iov[i].iov_base)
8432 				goto out;
8433 		}
8434 	}
8435 	retval = 0;
8436 out:
8437 	return retval;
8438 }
8439 
btrfs_direct_IO(struct kiocb * iocb,struct iov_iter * iter,loff_t offset)8440 static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
8441 			       loff_t offset)
8442 {
8443 	struct file *file = iocb->ki_filp;
8444 	struct inode *inode = file->f_mapping->host;
8445 	struct btrfs_root *root = BTRFS_I(inode)->root;
8446 	struct btrfs_dio_data dio_data = { 0 };
8447 	size_t count = 0;
8448 	int flags = 0;
8449 	bool wakeup = true;
8450 	bool relock = false;
8451 	ssize_t ret;
8452 
8453 	if (check_direct_IO(BTRFS_I(inode)->root, iocb, iter, offset))
8454 		return 0;
8455 
8456 	inode_dio_begin(inode);
8457 	smp_mb__after_atomic();
8458 
8459 	/*
8460 	 * The generic stuff only does filemap_write_and_wait_range, which
8461 	 * isn't enough if we've written compressed pages to this area, so
8462 	 * we need to flush the dirty pages again to make absolutely sure
8463 	 * that any outstanding dirty pages are on disk.
8464 	 */
8465 	count = iov_iter_count(iter);
8466 	if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
8467 		     &BTRFS_I(inode)->runtime_flags))
8468 		filemap_fdatawrite_range(inode->i_mapping, offset,
8469 					 offset + count - 1);
8470 
8471 	if (iov_iter_rw(iter) == WRITE) {
8472 		/*
8473 		 * If the write DIO is beyond the EOF, we need update
8474 		 * the isize, but it is protected by i_mutex. So we can
8475 		 * not unlock the i_mutex at this case.
8476 		 */
8477 		if (offset + count <= inode->i_size) {
8478 			mutex_unlock(&inode->i_mutex);
8479 			relock = true;
8480 		}
8481 		ret = btrfs_delalloc_reserve_space(inode, offset, count);
8482 		if (ret)
8483 			goto out;
8484 		dio_data.outstanding_extents = div64_u64(count +
8485 						BTRFS_MAX_EXTENT_SIZE - 1,
8486 						BTRFS_MAX_EXTENT_SIZE);
8487 
8488 		/*
8489 		 * We need to know how many extents we reserved so that we can
8490 		 * do the accounting properly if we go over the number we
8491 		 * originally calculated.  Abuse current->journal_info for this.
8492 		 */
8493 		dio_data.reserve = round_up(count, root->sectorsize);
8494 		current->journal_info = &dio_data;
8495 	} else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
8496 				     &BTRFS_I(inode)->runtime_flags)) {
8497 		inode_dio_end(inode);
8498 		flags = DIO_LOCKING | DIO_SKIP_HOLES;
8499 		wakeup = false;
8500 	}
8501 
8502 	ret = __blockdev_direct_IO(iocb, inode,
8503 				   BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
8504 				   iter, offset, btrfs_get_blocks_direct, NULL,
8505 				   btrfs_submit_direct, flags);
8506 	if (iov_iter_rw(iter) == WRITE) {
8507 		current->journal_info = NULL;
8508 		if (ret < 0 && ret != -EIOCBQUEUED) {
8509 			if (dio_data.reserve)
8510 				btrfs_delalloc_release_space(inode, offset,
8511 							     dio_data.reserve);
8512 		} else if (ret >= 0 && (size_t)ret < count)
8513 			btrfs_delalloc_release_space(inode, offset,
8514 						     count - (size_t)ret);
8515 	}
8516 out:
8517 	if (wakeup)
8518 		inode_dio_end(inode);
8519 	if (relock)
8520 		mutex_lock(&inode->i_mutex);
8521 
8522 	return ret;
8523 }
8524 
8525 #define BTRFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC)
8526 
btrfs_fiemap(struct inode * inode,struct fiemap_extent_info * fieinfo,__u64 start,__u64 len)8527 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
8528 		__u64 start, __u64 len)
8529 {
8530 	int	ret;
8531 
8532 	ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
8533 	if (ret)
8534 		return ret;
8535 
8536 	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
8537 }
8538 
btrfs_readpage(struct file * file,struct page * page)8539 int btrfs_readpage(struct file *file, struct page *page)
8540 {
8541 	struct extent_io_tree *tree;
8542 	tree = &BTRFS_I(page->mapping->host)->io_tree;
8543 	return extent_read_full_page(tree, page, btrfs_get_extent, 0);
8544 }
8545 
btrfs_writepage(struct page * page,struct writeback_control * wbc)8546 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
8547 {
8548 	struct extent_io_tree *tree;
8549 	struct inode *inode = page->mapping->host;
8550 	int ret;
8551 
8552 	if (current->flags & PF_MEMALLOC) {
8553 		redirty_page_for_writepage(wbc, page);
8554 		unlock_page(page);
8555 		return 0;
8556 	}
8557 
8558 	/*
8559 	 * If we are under memory pressure we will call this directly from the
8560 	 * VM, we need to make sure we have the inode referenced for the ordered
8561 	 * extent.  If not just return like we didn't do anything.
8562 	 */
8563 	if (!igrab(inode)) {
8564 		redirty_page_for_writepage(wbc, page);
8565 		return AOP_WRITEPAGE_ACTIVATE;
8566 	}
8567 	tree = &BTRFS_I(page->mapping->host)->io_tree;
8568 	ret = extent_write_full_page(tree, page, btrfs_get_extent, wbc);
8569 	btrfs_add_delayed_iput(inode);
8570 	return ret;
8571 }
8572 
btrfs_writepages(struct address_space * mapping,struct writeback_control * wbc)8573 static int btrfs_writepages(struct address_space *mapping,
8574 			    struct writeback_control *wbc)
8575 {
8576 	struct extent_io_tree *tree;
8577 
8578 	tree = &BTRFS_I(mapping->host)->io_tree;
8579 	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
8580 }
8581 
8582 static int
btrfs_readpages(struct file * file,struct address_space * mapping,struct list_head * pages,unsigned nr_pages)8583 btrfs_readpages(struct file *file, struct address_space *mapping,
8584 		struct list_head *pages, unsigned nr_pages)
8585 {
8586 	struct extent_io_tree *tree;
8587 	tree = &BTRFS_I(mapping->host)->io_tree;
8588 	return extent_readpages(tree, mapping, pages, nr_pages,
8589 				btrfs_get_extent);
8590 }
__btrfs_releasepage(struct page * page,gfp_t gfp_flags)8591 static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
8592 {
8593 	struct extent_io_tree *tree;
8594 	struct extent_map_tree *map;
8595 	int ret;
8596 
8597 	tree = &BTRFS_I(page->mapping->host)->io_tree;
8598 	map = &BTRFS_I(page->mapping->host)->extent_tree;
8599 	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
8600 	if (ret == 1) {
8601 		ClearPagePrivate(page);
8602 		set_page_private(page, 0);
8603 		page_cache_release(page);
8604 	}
8605 	return ret;
8606 }
8607 
btrfs_releasepage(struct page * page,gfp_t gfp_flags)8608 static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
8609 {
8610 	if (PageWriteback(page) || PageDirty(page))
8611 		return 0;
8612 	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
8613 }
8614 
btrfs_invalidatepage(struct page * page,unsigned int offset,unsigned int length)8615 static void btrfs_invalidatepage(struct page *page, unsigned int offset,
8616 				 unsigned int length)
8617 {
8618 	struct inode *inode = page->mapping->host;
8619 	struct extent_io_tree *tree;
8620 	struct btrfs_ordered_extent *ordered;
8621 	struct extent_state *cached_state = NULL;
8622 	u64 page_start = page_offset(page);
8623 	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
8624 	int inode_evicting = inode->i_state & I_FREEING;
8625 
8626 	/*
8627 	 * we have the page locked, so new writeback can't start,
8628 	 * and the dirty bit won't be cleared while we are here.
8629 	 *
8630 	 * Wait for IO on this page so that we can safely clear
8631 	 * the PagePrivate2 bit and do ordered accounting
8632 	 */
8633 	wait_on_page_writeback(page);
8634 
8635 	tree = &BTRFS_I(inode)->io_tree;
8636 	if (offset) {
8637 		btrfs_releasepage(page, GFP_NOFS);
8638 		return;
8639 	}
8640 
8641 	if (!inode_evicting)
8642 		lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
8643 	ordered = btrfs_lookup_ordered_extent(inode, page_start);
8644 	if (ordered) {
8645 		/*
8646 		 * IO on this page will never be started, so we need
8647 		 * to account for any ordered extents now
8648 		 */
8649 		if (!inode_evicting)
8650 			clear_extent_bit(tree, page_start, page_end,
8651 					 EXTENT_DIRTY | EXTENT_DELALLOC |
8652 					 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
8653 					 EXTENT_DEFRAG, 1, 0, &cached_state,
8654 					 GFP_NOFS);
8655 		/*
8656 		 * whoever cleared the private bit is responsible
8657 		 * for the finish_ordered_io
8658 		 */
8659 		if (TestClearPagePrivate2(page)) {
8660 			struct btrfs_ordered_inode_tree *tree;
8661 			u64 new_len;
8662 
8663 			tree = &BTRFS_I(inode)->ordered_tree;
8664 
8665 			spin_lock_irq(&tree->lock);
8666 			set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
8667 			new_len = page_start - ordered->file_offset;
8668 			if (new_len < ordered->truncated_len)
8669 				ordered->truncated_len = new_len;
8670 			spin_unlock_irq(&tree->lock);
8671 
8672 			if (btrfs_dec_test_ordered_pending(inode, &ordered,
8673 							   page_start,
8674 							   PAGE_CACHE_SIZE, 1))
8675 				btrfs_finish_ordered_io(ordered);
8676 		}
8677 		btrfs_put_ordered_extent(ordered);
8678 		if (!inode_evicting) {
8679 			cached_state = NULL;
8680 			lock_extent_bits(tree, page_start, page_end, 0,
8681 					 &cached_state);
8682 		}
8683 	}
8684 
8685 	/*
8686 	 * Qgroup reserved space handler
8687 	 * Page here will be either
8688 	 * 1) Already written to disk
8689 	 *    In this case, its reserved space is released from data rsv map
8690 	 *    and will be freed by delayed_ref handler finally.
8691 	 *    So even we call qgroup_free_data(), it won't decrease reserved
8692 	 *    space.
8693 	 * 2) Not written to disk
8694 	 *    This means the reserved space should be freed here.
8695 	 */
8696 	btrfs_qgroup_free_data(inode, page_start, PAGE_CACHE_SIZE);
8697 	if (!inode_evicting) {
8698 		clear_extent_bit(tree, page_start, page_end,
8699 				 EXTENT_LOCKED | EXTENT_DIRTY |
8700 				 EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
8701 				 EXTENT_DEFRAG, 1, 1,
8702 				 &cached_state, GFP_NOFS);
8703 
8704 		__btrfs_releasepage(page, GFP_NOFS);
8705 	}
8706 
8707 	ClearPageChecked(page);
8708 	if (PagePrivate(page)) {
8709 		ClearPagePrivate(page);
8710 		set_page_private(page, 0);
8711 		page_cache_release(page);
8712 	}
8713 }
8714 
8715 /*
8716  * btrfs_page_mkwrite() is not allowed to change the file size as it gets
8717  * called from a page fault handler when a page is first dirtied. Hence we must
8718  * be careful to check for EOF conditions here. We set the page up correctly
8719  * for a written page which means we get ENOSPC checking when writing into
8720  * holes and correct delalloc and unwritten extent mapping on filesystems that
8721  * support these features.
8722  *
8723  * We are not allowed to take the i_mutex here so we have to play games to
8724  * protect against truncate races as the page could now be beyond EOF.  Because
8725  * vmtruncate() writes the inode size before removing pages, once we have the
8726  * page lock we can determine safely if the page is beyond EOF. If it is not
8727  * beyond EOF, then the page is guaranteed safe against truncation until we
8728  * unlock the page.
8729  */
btrfs_page_mkwrite(struct vm_area_struct * vma,struct vm_fault * vmf)8730 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
8731 {
8732 	struct page *page = vmf->page;
8733 	struct inode *inode = file_inode(vma->vm_file);
8734 	struct btrfs_root *root = BTRFS_I(inode)->root;
8735 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
8736 	struct btrfs_ordered_extent *ordered;
8737 	struct extent_state *cached_state = NULL;
8738 	char *kaddr;
8739 	unsigned long zero_start;
8740 	loff_t size;
8741 	int ret;
8742 	int reserved = 0;
8743 	u64 page_start;
8744 	u64 page_end;
8745 
8746 	sb_start_pagefault(inode->i_sb);
8747 	page_start = page_offset(page);
8748 	page_end = page_start + PAGE_CACHE_SIZE - 1;
8749 
8750 	ret = btrfs_delalloc_reserve_space(inode, page_start,
8751 					   PAGE_CACHE_SIZE);
8752 	if (!ret) {
8753 		ret = file_update_time(vma->vm_file);
8754 		reserved = 1;
8755 	}
8756 	if (ret) {
8757 		if (ret == -ENOMEM)
8758 			ret = VM_FAULT_OOM;
8759 		else /* -ENOSPC, -EIO, etc */
8760 			ret = VM_FAULT_SIGBUS;
8761 		if (reserved)
8762 			goto out;
8763 		goto out_noreserve;
8764 	}
8765 
8766 	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
8767 again:
8768 	lock_page(page);
8769 	size = i_size_read(inode);
8770 
8771 	if ((page->mapping != inode->i_mapping) ||
8772 	    (page_start >= size)) {
8773 		/* page got truncated out from underneath us */
8774 		goto out_unlock;
8775 	}
8776 	wait_on_page_writeback(page);
8777 
8778 	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
8779 	set_page_extent_mapped(page);
8780 
8781 	/*
8782 	 * we can't set the delalloc bits if there are pending ordered
8783 	 * extents.  Drop our locks and wait for them to finish
8784 	 */
8785 	ordered = btrfs_lookup_ordered_extent(inode, page_start);
8786 	if (ordered) {
8787 		unlock_extent_cached(io_tree, page_start, page_end,
8788 				     &cached_state, GFP_NOFS);
8789 		unlock_page(page);
8790 		btrfs_start_ordered_extent(inode, ordered, 1);
8791 		btrfs_put_ordered_extent(ordered);
8792 		goto again;
8793 	}
8794 
8795 	/*
8796 	 * XXX - page_mkwrite gets called every time the page is dirtied, even
8797 	 * if it was already dirty, so for space accounting reasons we need to
8798 	 * clear any delalloc bits for the range we are fixing to save.  There
8799 	 * is probably a better way to do this, but for now keep consistent with
8800 	 * prepare_pages in the normal write path.
8801 	 */
8802 	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
8803 			  EXTENT_DIRTY | EXTENT_DELALLOC |
8804 			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
8805 			  0, 0, &cached_state, GFP_NOFS);
8806 
8807 	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
8808 					&cached_state);
8809 	if (ret) {
8810 		unlock_extent_cached(io_tree, page_start, page_end,
8811 				     &cached_state, GFP_NOFS);
8812 		ret = VM_FAULT_SIGBUS;
8813 		goto out_unlock;
8814 	}
8815 	ret = 0;
8816 
8817 	/* page is wholly or partially inside EOF */
8818 	if (page_start + PAGE_CACHE_SIZE > size)
8819 		zero_start = size & ~PAGE_CACHE_MASK;
8820 	else
8821 		zero_start = PAGE_CACHE_SIZE;
8822 
8823 	if (zero_start != PAGE_CACHE_SIZE) {
8824 		kaddr = kmap(page);
8825 		memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
8826 		flush_dcache_page(page);
8827 		kunmap(page);
8828 	}
8829 	ClearPageChecked(page);
8830 	set_page_dirty(page);
8831 	SetPageUptodate(page);
8832 
8833 	BTRFS_I(inode)->last_trans = root->fs_info->generation;
8834 	BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
8835 	BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
8836 
8837 	unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
8838 
8839 out_unlock:
8840 	if (!ret) {
8841 		sb_end_pagefault(inode->i_sb);
8842 		return VM_FAULT_LOCKED;
8843 	}
8844 	unlock_page(page);
8845 out:
8846 	btrfs_delalloc_release_space(inode, page_start, PAGE_CACHE_SIZE);
8847 out_noreserve:
8848 	sb_end_pagefault(inode->i_sb);
8849 	return ret;
8850 }
8851 
btrfs_truncate(struct inode * inode)8852 static int btrfs_truncate(struct inode *inode)
8853 {
8854 	struct btrfs_root *root = BTRFS_I(inode)->root;
8855 	struct btrfs_block_rsv *rsv;
8856 	int ret = 0;
8857 	int err = 0;
8858 	struct btrfs_trans_handle *trans;
8859 	u64 mask = root->sectorsize - 1;
8860 	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
8861 
8862 	ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask),
8863 				       (u64)-1);
8864 	if (ret)
8865 		return ret;
8866 
8867 	/*
8868 	 * Yes ladies and gentelment, this is indeed ugly.  The fact is we have
8869 	 * 3 things going on here
8870 	 *
8871 	 * 1) We need to reserve space for our orphan item and the space to
8872 	 * delete our orphan item.  Lord knows we don't want to have a dangling
8873 	 * orphan item because we didn't reserve space to remove it.
8874 	 *
8875 	 * 2) We need to reserve space to update our inode.
8876 	 *
8877 	 * 3) We need to have something to cache all the space that is going to
8878 	 * be free'd up by the truncate operation, but also have some slack
8879 	 * space reserved in case it uses space during the truncate (thank you
8880 	 * very much snapshotting).
8881 	 *
8882 	 * And we need these to all be seperate.  The fact is we can use alot of
8883 	 * space doing the truncate, and we have no earthly idea how much space
8884 	 * we will use, so we need the truncate reservation to be seperate so it
8885 	 * doesn't end up using space reserved for updating the inode or
8886 	 * removing the orphan item.  We also need to be able to stop the
8887 	 * transaction and start a new one, which means we need to be able to
8888 	 * update the inode several times, and we have no idea of knowing how
8889 	 * many times that will be, so we can't just reserve 1 item for the
8890 	 * entirety of the opration, so that has to be done seperately as well.
8891 	 * Then there is the orphan item, which does indeed need to be held on
8892 	 * to for the whole operation, and we need nobody to touch this reserved
8893 	 * space except the orphan code.
8894 	 *
8895 	 * So that leaves us with
8896 	 *
8897 	 * 1) root->orphan_block_rsv - for the orphan deletion.
8898 	 * 2) rsv - for the truncate reservation, which we will steal from the
8899 	 * transaction reservation.
8900 	 * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
8901 	 * updating the inode.
8902 	 */
8903 	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
8904 	if (!rsv)
8905 		return -ENOMEM;
8906 	rsv->size = min_size;
8907 	rsv->failfast = 1;
8908 
8909 	/*
8910 	 * 1 for the truncate slack space
8911 	 * 1 for updating the inode.
8912 	 */
8913 	trans = btrfs_start_transaction(root, 2);
8914 	if (IS_ERR(trans)) {
8915 		err = PTR_ERR(trans);
8916 		goto out;
8917 	}
8918 
8919 	/* Migrate the slack space for the truncate to our reserve */
8920 	ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
8921 				      min_size);
8922 	BUG_ON(ret);
8923 
8924 	/*
8925 	 * So if we truncate and then write and fsync we normally would just
8926 	 * write the extents that changed, which is a problem if we need to
8927 	 * first truncate that entire inode.  So set this flag so we write out
8928 	 * all of the extents in the inode to the sync log so we're completely
8929 	 * safe.
8930 	 */
8931 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
8932 	trans->block_rsv = rsv;
8933 
8934 	while (1) {
8935 		ret = btrfs_truncate_inode_items(trans, root, inode,
8936 						 inode->i_size,
8937 						 BTRFS_EXTENT_DATA_KEY);
8938 		if (ret != -ENOSPC && ret != -EAGAIN) {
8939 			err = ret;
8940 			break;
8941 		}
8942 
8943 		trans->block_rsv = &root->fs_info->trans_block_rsv;
8944 		ret = btrfs_update_inode(trans, root, inode);
8945 		if (ret) {
8946 			err = ret;
8947 			break;
8948 		}
8949 
8950 		btrfs_end_transaction(trans, root);
8951 		btrfs_btree_balance_dirty(root);
8952 
8953 		trans = btrfs_start_transaction(root, 2);
8954 		if (IS_ERR(trans)) {
8955 			ret = err = PTR_ERR(trans);
8956 			trans = NULL;
8957 			break;
8958 		}
8959 
8960 		ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
8961 					      rsv, min_size);
8962 		BUG_ON(ret);	/* shouldn't happen */
8963 		trans->block_rsv = rsv;
8964 	}
8965 
8966 	if (ret == 0 && inode->i_nlink > 0) {
8967 		trans->block_rsv = root->orphan_block_rsv;
8968 		ret = btrfs_orphan_del(trans, inode);
8969 		if (ret)
8970 			err = ret;
8971 	}
8972 
8973 	if (trans) {
8974 		trans->block_rsv = &root->fs_info->trans_block_rsv;
8975 		ret = btrfs_update_inode(trans, root, inode);
8976 		if (ret && !err)
8977 			err = ret;
8978 
8979 		ret = btrfs_end_transaction(trans, root);
8980 		btrfs_btree_balance_dirty(root);
8981 	}
8982 
8983 out:
8984 	btrfs_free_block_rsv(root, rsv);
8985 
8986 	if (ret && !err)
8987 		err = ret;
8988 
8989 	return err;
8990 }
8991 
8992 /*
8993  * create a new subvolume directory/inode (helper for the ioctl).
8994  */
btrfs_create_subvol_root(struct btrfs_trans_handle * trans,struct btrfs_root * new_root,struct btrfs_root * parent_root,u64 new_dirid)8995 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
8996 			     struct btrfs_root *new_root,
8997 			     struct btrfs_root *parent_root,
8998 			     u64 new_dirid)
8999 {
9000 	struct inode *inode;
9001 	int err;
9002 	u64 index = 0;
9003 
9004 	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
9005 				new_dirid, new_dirid,
9006 				S_IFDIR | (~current_umask() & S_IRWXUGO),
9007 				&index);
9008 	if (IS_ERR(inode))
9009 		return PTR_ERR(inode);
9010 	inode->i_op = &btrfs_dir_inode_operations;
9011 	inode->i_fop = &btrfs_dir_file_operations;
9012 
9013 	set_nlink(inode, 1);
9014 	btrfs_i_size_write(inode, 0);
9015 	unlock_new_inode(inode);
9016 
9017 	err = btrfs_subvol_inherit_props(trans, new_root, parent_root);
9018 	if (err)
9019 		btrfs_err(new_root->fs_info,
9020 			  "error inheriting subvolume %llu properties: %d",
9021 			  new_root->root_key.objectid, err);
9022 
9023 	err = btrfs_update_inode(trans, new_root, inode);
9024 
9025 	iput(inode);
9026 	return err;
9027 }
9028 
btrfs_alloc_inode(struct super_block * sb)9029 struct inode *btrfs_alloc_inode(struct super_block *sb)
9030 {
9031 	struct btrfs_inode *ei;
9032 	struct inode *inode;
9033 
9034 	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
9035 	if (!ei)
9036 		return NULL;
9037 
9038 	ei->root = NULL;
9039 	ei->generation = 0;
9040 	ei->last_trans = 0;
9041 	ei->last_sub_trans = 0;
9042 	ei->logged_trans = 0;
9043 	ei->delalloc_bytes = 0;
9044 	ei->defrag_bytes = 0;
9045 	ei->disk_i_size = 0;
9046 	ei->flags = 0;
9047 	ei->csum_bytes = 0;
9048 	ei->index_cnt = (u64)-1;
9049 	ei->dir_index = 0;
9050 	ei->last_unlink_trans = 0;
9051 	ei->last_log_commit = 0;
9052 
9053 	spin_lock_init(&ei->lock);
9054 	ei->outstanding_extents = 0;
9055 	ei->reserved_extents = 0;
9056 
9057 	ei->runtime_flags = 0;
9058 	ei->force_compress = BTRFS_COMPRESS_NONE;
9059 
9060 	ei->delayed_node = NULL;
9061 
9062 	ei->i_otime.tv_sec = 0;
9063 	ei->i_otime.tv_nsec = 0;
9064 
9065 	inode = &ei->vfs_inode;
9066 	extent_map_tree_init(&ei->extent_tree);
9067 	extent_io_tree_init(&ei->io_tree, &inode->i_data);
9068 	extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
9069 	ei->io_tree.track_uptodate = 1;
9070 	ei->io_failure_tree.track_uptodate = 1;
9071 	atomic_set(&ei->sync_writers, 0);
9072 	mutex_init(&ei->log_mutex);
9073 	mutex_init(&ei->delalloc_mutex);
9074 	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
9075 	INIT_LIST_HEAD(&ei->delalloc_inodes);
9076 	RB_CLEAR_NODE(&ei->rb_node);
9077 
9078 	return inode;
9079 }
9080 
9081 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
btrfs_test_destroy_inode(struct inode * inode)9082 void btrfs_test_destroy_inode(struct inode *inode)
9083 {
9084 	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
9085 	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
9086 }
9087 #endif
9088 
btrfs_i_callback(struct rcu_head * head)9089 static void btrfs_i_callback(struct rcu_head *head)
9090 {
9091 	struct inode *inode = container_of(head, struct inode, i_rcu);
9092 	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
9093 }
9094 
btrfs_destroy_inode(struct inode * inode)9095 void btrfs_destroy_inode(struct inode *inode)
9096 {
9097 	struct btrfs_ordered_extent *ordered;
9098 	struct btrfs_root *root = BTRFS_I(inode)->root;
9099 
9100 	WARN_ON(!hlist_empty(&inode->i_dentry));
9101 	WARN_ON(inode->i_data.nrpages);
9102 	WARN_ON(BTRFS_I(inode)->outstanding_extents);
9103 	WARN_ON(BTRFS_I(inode)->reserved_extents);
9104 	WARN_ON(BTRFS_I(inode)->delalloc_bytes);
9105 	WARN_ON(BTRFS_I(inode)->csum_bytes);
9106 	WARN_ON(BTRFS_I(inode)->defrag_bytes);
9107 
9108 	/*
9109 	 * This can happen where we create an inode, but somebody else also
9110 	 * created the same inode and we need to destroy the one we already
9111 	 * created.
9112 	 */
9113 	if (!root)
9114 		goto free;
9115 
9116 	if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
9117 		     &BTRFS_I(inode)->runtime_flags)) {
9118 		btrfs_info(root->fs_info, "inode %llu still on the orphan list",
9119 			btrfs_ino(inode));
9120 		atomic_dec(&root->orphan_inodes);
9121 	}
9122 
9123 	while (1) {
9124 		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
9125 		if (!ordered)
9126 			break;
9127 		else {
9128 			btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup",
9129 				ordered->file_offset, ordered->len);
9130 			btrfs_remove_ordered_extent(inode, ordered);
9131 			btrfs_put_ordered_extent(ordered);
9132 			btrfs_put_ordered_extent(ordered);
9133 		}
9134 	}
9135 	btrfs_qgroup_check_reserved_leak(inode);
9136 	inode_tree_del(inode);
9137 	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
9138 free:
9139 	call_rcu(&inode->i_rcu, btrfs_i_callback);
9140 }
9141 
btrfs_drop_inode(struct inode * inode)9142 int btrfs_drop_inode(struct inode *inode)
9143 {
9144 	struct btrfs_root *root = BTRFS_I(inode)->root;
9145 
9146 	if (root == NULL)
9147 		return 1;
9148 
9149 	/* the snap/subvol tree is on deleting */
9150 	if (btrfs_root_refs(&root->root_item) == 0)
9151 		return 1;
9152 	else
9153 		return generic_drop_inode(inode);
9154 }
9155 
init_once(void * foo)9156 static void init_once(void *foo)
9157 {
9158 	struct btrfs_inode *ei = (struct btrfs_inode *) foo;
9159 
9160 	inode_init_once(&ei->vfs_inode);
9161 }
9162 
btrfs_destroy_cachep(void)9163 void btrfs_destroy_cachep(void)
9164 {
9165 	/*
9166 	 * Make sure all delayed rcu free inodes are flushed before we
9167 	 * destroy cache.
9168 	 */
9169 	rcu_barrier();
9170 	if (btrfs_inode_cachep)
9171 		kmem_cache_destroy(btrfs_inode_cachep);
9172 	if (btrfs_trans_handle_cachep)
9173 		kmem_cache_destroy(btrfs_trans_handle_cachep);
9174 	if (btrfs_transaction_cachep)
9175 		kmem_cache_destroy(btrfs_transaction_cachep);
9176 	if (btrfs_path_cachep)
9177 		kmem_cache_destroy(btrfs_path_cachep);
9178 	if (btrfs_free_space_cachep)
9179 		kmem_cache_destroy(btrfs_free_space_cachep);
9180 	if (btrfs_delalloc_work_cachep)
9181 		kmem_cache_destroy(btrfs_delalloc_work_cachep);
9182 }
9183 
btrfs_init_cachep(void)9184 int btrfs_init_cachep(void)
9185 {
9186 	btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
9187 			sizeof(struct btrfs_inode), 0,
9188 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
9189 	if (!btrfs_inode_cachep)
9190 		goto fail;
9191 
9192 	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
9193 			sizeof(struct btrfs_trans_handle), 0,
9194 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
9195 	if (!btrfs_trans_handle_cachep)
9196 		goto fail;
9197 
9198 	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
9199 			sizeof(struct btrfs_transaction), 0,
9200 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
9201 	if (!btrfs_transaction_cachep)
9202 		goto fail;
9203 
9204 	btrfs_path_cachep = kmem_cache_create("btrfs_path",
9205 			sizeof(struct btrfs_path), 0,
9206 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
9207 	if (!btrfs_path_cachep)
9208 		goto fail;
9209 
9210 	btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
9211 			sizeof(struct btrfs_free_space), 0,
9212 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
9213 	if (!btrfs_free_space_cachep)
9214 		goto fail;
9215 
9216 	btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
9217 			sizeof(struct btrfs_delalloc_work), 0,
9218 			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
9219 			NULL);
9220 	if (!btrfs_delalloc_work_cachep)
9221 		goto fail;
9222 
9223 	return 0;
9224 fail:
9225 	btrfs_destroy_cachep();
9226 	return -ENOMEM;
9227 }
9228 
btrfs_getattr(struct vfsmount * mnt,struct dentry * dentry,struct kstat * stat)9229 static int btrfs_getattr(struct vfsmount *mnt,
9230 			 struct dentry *dentry, struct kstat *stat)
9231 {
9232 	u64 delalloc_bytes;
9233 	struct inode *inode = d_inode(dentry);
9234 	u32 blocksize = inode->i_sb->s_blocksize;
9235 
9236 	generic_fillattr(inode, stat);
9237 	stat->dev = BTRFS_I(inode)->root->anon_dev;
9238 	stat->blksize = PAGE_CACHE_SIZE;
9239 
9240 	spin_lock(&BTRFS_I(inode)->lock);
9241 	delalloc_bytes = BTRFS_I(inode)->delalloc_bytes;
9242 	spin_unlock(&BTRFS_I(inode)->lock);
9243 	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
9244 			ALIGN(delalloc_bytes, blocksize)) >> 9;
9245 	return 0;
9246 }
9247 
btrfs_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry)9248 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
9249 			   struct inode *new_dir, struct dentry *new_dentry)
9250 {
9251 	struct btrfs_trans_handle *trans;
9252 	struct btrfs_root *root = BTRFS_I(old_dir)->root;
9253 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;
9254 	struct inode *new_inode = d_inode(new_dentry);
9255 	struct inode *old_inode = d_inode(old_dentry);
9256 	struct timespec ctime = CURRENT_TIME;
9257 	u64 index = 0;
9258 	u64 root_objectid;
9259 	int ret;
9260 	u64 old_ino = btrfs_ino(old_inode);
9261 
9262 	if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
9263 		return -EPERM;
9264 
9265 	/* we only allow rename subvolume link between subvolumes */
9266 	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
9267 		return -EXDEV;
9268 
9269 	if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
9270 	    (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
9271 		return -ENOTEMPTY;
9272 
9273 	if (S_ISDIR(old_inode->i_mode) && new_inode &&
9274 	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
9275 		return -ENOTEMPTY;
9276 
9277 
9278 	/* check for collisions, even if the  name isn't there */
9279 	ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino,
9280 			     new_dentry->d_name.name,
9281 			     new_dentry->d_name.len);
9282 
9283 	if (ret) {
9284 		if (ret == -EEXIST) {
9285 			/* we shouldn't get
9286 			 * eexist without a new_inode */
9287 			if (WARN_ON(!new_inode)) {
9288 				return ret;
9289 			}
9290 		} else {
9291 			/* maybe -EOVERFLOW */
9292 			return ret;
9293 		}
9294 	}
9295 	ret = 0;
9296 
9297 	/*
9298 	 * we're using rename to replace one file with another.  Start IO on it
9299 	 * now so  we don't add too much work to the end of the transaction
9300 	 */
9301 	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size)
9302 		filemap_flush(old_inode->i_mapping);
9303 
9304 	/* close the racy window with snapshot create/destroy ioctl */
9305 	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
9306 		down_read(&root->fs_info->subvol_sem);
9307 	/*
9308 	 * We want to reserve the absolute worst case amount of items.  So if
9309 	 * both inodes are subvols and we need to unlink them then that would
9310 	 * require 4 item modifications, but if they are both normal inodes it
9311 	 * would require 5 item modifications, so we'll assume their normal
9312 	 * inodes.  So 5 * 2 is 10, plus 1 for the new link, so 11 total items
9313 	 * should cover the worst case number of items we'll modify.
9314 	 */
9315 	trans = btrfs_start_transaction(root, 11);
9316 	if (IS_ERR(trans)) {
9317                 ret = PTR_ERR(trans);
9318                 goto out_notrans;
9319         }
9320 
9321 	if (dest != root)
9322 		btrfs_record_root_in_trans(trans, dest);
9323 
9324 	ret = btrfs_set_inode_index(new_dir, &index);
9325 	if (ret)
9326 		goto out_fail;
9327 
9328 	BTRFS_I(old_inode)->dir_index = 0ULL;
9329 	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
9330 		/* force full log commit if subvolume involved. */
9331 		btrfs_set_log_full_commit(root->fs_info, trans);
9332 	} else {
9333 		ret = btrfs_insert_inode_ref(trans, dest,
9334 					     new_dentry->d_name.name,
9335 					     new_dentry->d_name.len,
9336 					     old_ino,
9337 					     btrfs_ino(new_dir), index);
9338 		if (ret)
9339 			goto out_fail;
9340 		/*
9341 		 * this is an ugly little race, but the rename is required
9342 		 * to make sure that if we crash, the inode is either at the
9343 		 * old name or the new one.  pinning the log transaction lets
9344 		 * us make sure we don't allow a log commit to come in after
9345 		 * we unlink the name but before we add the new name back in.
9346 		 */
9347 		btrfs_pin_log_trans(root);
9348 	}
9349 
9350 	inode_inc_iversion(old_dir);
9351 	inode_inc_iversion(new_dir);
9352 	inode_inc_iversion(old_inode);
9353 	old_dir->i_ctime = old_dir->i_mtime = ctime;
9354 	new_dir->i_ctime = new_dir->i_mtime = ctime;
9355 	old_inode->i_ctime = ctime;
9356 
9357 	if (old_dentry->d_parent != new_dentry->d_parent)
9358 		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
9359 
9360 	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
9361 		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
9362 		ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
9363 					old_dentry->d_name.name,
9364 					old_dentry->d_name.len);
9365 	} else {
9366 		ret = __btrfs_unlink_inode(trans, root, old_dir,
9367 					d_inode(old_dentry),
9368 					old_dentry->d_name.name,
9369 					old_dentry->d_name.len);
9370 		if (!ret)
9371 			ret = btrfs_update_inode(trans, root, old_inode);
9372 	}
9373 	if (ret) {
9374 		btrfs_abort_transaction(trans, root, ret);
9375 		goto out_fail;
9376 	}
9377 
9378 	if (new_inode) {
9379 		inode_inc_iversion(new_inode);
9380 		new_inode->i_ctime = CURRENT_TIME;
9381 		if (unlikely(btrfs_ino(new_inode) ==
9382 			     BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
9383 			root_objectid = BTRFS_I(new_inode)->location.objectid;
9384 			ret = btrfs_unlink_subvol(trans, dest, new_dir,
9385 						root_objectid,
9386 						new_dentry->d_name.name,
9387 						new_dentry->d_name.len);
9388 			BUG_ON(new_inode->i_nlink == 0);
9389 		} else {
9390 			ret = btrfs_unlink_inode(trans, dest, new_dir,
9391 						 d_inode(new_dentry),
9392 						 new_dentry->d_name.name,
9393 						 new_dentry->d_name.len);
9394 		}
9395 		if (!ret && new_inode->i_nlink == 0)
9396 			ret = btrfs_orphan_add(trans, d_inode(new_dentry));
9397 		if (ret) {
9398 			btrfs_abort_transaction(trans, root, ret);
9399 			goto out_fail;
9400 		}
9401 	}
9402 
9403 	ret = btrfs_add_link(trans, new_dir, old_inode,
9404 			     new_dentry->d_name.name,
9405 			     new_dentry->d_name.len, 0, index);
9406 	if (ret) {
9407 		btrfs_abort_transaction(trans, root, ret);
9408 		goto out_fail;
9409 	}
9410 
9411 	if (old_inode->i_nlink == 1)
9412 		BTRFS_I(old_inode)->dir_index = index;
9413 
9414 	if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
9415 		struct dentry *parent = new_dentry->d_parent;
9416 		btrfs_log_new_name(trans, old_inode, old_dir, parent);
9417 		btrfs_end_log_trans(root);
9418 	}
9419 out_fail:
9420 	btrfs_end_transaction(trans, root);
9421 out_notrans:
9422 	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
9423 		up_read(&root->fs_info->subvol_sem);
9424 
9425 	return ret;
9426 }
9427 
btrfs_rename2(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)9428 static int btrfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
9429 			 struct inode *new_dir, struct dentry *new_dentry,
9430 			 unsigned int flags)
9431 {
9432 	if (flags & ~RENAME_NOREPLACE)
9433 		return -EINVAL;
9434 
9435 	return btrfs_rename(old_dir, old_dentry, new_dir, new_dentry);
9436 }
9437 
btrfs_run_delalloc_work(struct btrfs_work * work)9438 static void btrfs_run_delalloc_work(struct btrfs_work *work)
9439 {
9440 	struct btrfs_delalloc_work *delalloc_work;
9441 	struct inode *inode;
9442 
9443 	delalloc_work = container_of(work, struct btrfs_delalloc_work,
9444 				     work);
9445 	inode = delalloc_work->inode;
9446 	if (delalloc_work->wait) {
9447 		btrfs_wait_ordered_range(inode, 0, (u64)-1);
9448 	} else {
9449 		filemap_flush(inode->i_mapping);
9450 		if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
9451 			     &BTRFS_I(inode)->runtime_flags))
9452 			filemap_flush(inode->i_mapping);
9453 	}
9454 
9455 	if (delalloc_work->delay_iput)
9456 		btrfs_add_delayed_iput(inode);
9457 	else
9458 		iput(inode);
9459 	complete(&delalloc_work->completion);
9460 }
9461 
btrfs_alloc_delalloc_work(struct inode * inode,int wait,int delay_iput)9462 struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
9463 						    int wait, int delay_iput)
9464 {
9465 	struct btrfs_delalloc_work *work;
9466 
9467 	work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
9468 	if (!work)
9469 		return NULL;
9470 
9471 	init_completion(&work->completion);
9472 	INIT_LIST_HEAD(&work->list);
9473 	work->inode = inode;
9474 	work->wait = wait;
9475 	work->delay_iput = delay_iput;
9476 	WARN_ON_ONCE(!inode);
9477 	btrfs_init_work(&work->work, btrfs_flush_delalloc_helper,
9478 			btrfs_run_delalloc_work, NULL, NULL);
9479 
9480 	return work;
9481 }
9482 
btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work * work)9483 void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
9484 {
9485 	wait_for_completion(&work->completion);
9486 	kmem_cache_free(btrfs_delalloc_work_cachep, work);
9487 }
9488 
9489 /*
9490  * some fairly slow code that needs optimization. This walks the list
9491  * of all the inodes with pending delalloc and forces them to disk.
9492  */
__start_delalloc_inodes(struct btrfs_root * root,int delay_iput,int nr)9493 static int __start_delalloc_inodes(struct btrfs_root *root, int delay_iput,
9494 				   int nr)
9495 {
9496 	struct btrfs_inode *binode;
9497 	struct inode *inode;
9498 	struct btrfs_delalloc_work *work, *next;
9499 	struct list_head works;
9500 	struct list_head splice;
9501 	int ret = 0;
9502 
9503 	INIT_LIST_HEAD(&works);
9504 	INIT_LIST_HEAD(&splice);
9505 
9506 	mutex_lock(&root->delalloc_mutex);
9507 	spin_lock(&root->delalloc_lock);
9508 	list_splice_init(&root->delalloc_inodes, &splice);
9509 	while (!list_empty(&splice)) {
9510 		binode = list_entry(splice.next, struct btrfs_inode,
9511 				    delalloc_inodes);
9512 
9513 		list_move_tail(&binode->delalloc_inodes,
9514 			       &root->delalloc_inodes);
9515 		inode = igrab(&binode->vfs_inode);
9516 		if (!inode) {
9517 			cond_resched_lock(&root->delalloc_lock);
9518 			continue;
9519 		}
9520 		spin_unlock(&root->delalloc_lock);
9521 
9522 		work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
9523 		if (!work) {
9524 			if (delay_iput)
9525 				btrfs_add_delayed_iput(inode);
9526 			else
9527 				iput(inode);
9528 			ret = -ENOMEM;
9529 			goto out;
9530 		}
9531 		list_add_tail(&work->list, &works);
9532 		btrfs_queue_work(root->fs_info->flush_workers,
9533 				 &work->work);
9534 		ret++;
9535 		if (nr != -1 && ret >= nr)
9536 			goto out;
9537 		cond_resched();
9538 		spin_lock(&root->delalloc_lock);
9539 	}
9540 	spin_unlock(&root->delalloc_lock);
9541 
9542 out:
9543 	list_for_each_entry_safe(work, next, &works, list) {
9544 		list_del_init(&work->list);
9545 		btrfs_wait_and_free_delalloc_work(work);
9546 	}
9547 
9548 	if (!list_empty_careful(&splice)) {
9549 		spin_lock(&root->delalloc_lock);
9550 		list_splice_tail(&splice, &root->delalloc_inodes);
9551 		spin_unlock(&root->delalloc_lock);
9552 	}
9553 	mutex_unlock(&root->delalloc_mutex);
9554 	return ret;
9555 }
9556 
btrfs_start_delalloc_inodes(struct btrfs_root * root,int delay_iput)9557 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
9558 {
9559 	int ret;
9560 
9561 	if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
9562 		return -EROFS;
9563 
9564 	ret = __start_delalloc_inodes(root, delay_iput, -1);
9565 	if (ret > 0)
9566 		ret = 0;
9567 	/*
9568 	 * the filemap_flush will queue IO into the worker threads, but
9569 	 * we have to make sure the IO is actually started and that
9570 	 * ordered extents get created before we return
9571 	 */
9572 	atomic_inc(&root->fs_info->async_submit_draining);
9573 	while (atomic_read(&root->fs_info->nr_async_submits) ||
9574 	      atomic_read(&root->fs_info->async_delalloc_pages)) {
9575 		wait_event(root->fs_info->async_submit_wait,
9576 		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
9577 		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
9578 	}
9579 	atomic_dec(&root->fs_info->async_submit_draining);
9580 	return ret;
9581 }
9582 
btrfs_start_delalloc_roots(struct btrfs_fs_info * fs_info,int delay_iput,int nr)9583 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput,
9584 			       int nr)
9585 {
9586 	struct btrfs_root *root;
9587 	struct list_head splice;
9588 	int ret;
9589 
9590 	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
9591 		return -EROFS;
9592 
9593 	INIT_LIST_HEAD(&splice);
9594 
9595 	mutex_lock(&fs_info->delalloc_root_mutex);
9596 	spin_lock(&fs_info->delalloc_root_lock);
9597 	list_splice_init(&fs_info->delalloc_roots, &splice);
9598 	while (!list_empty(&splice) && nr) {
9599 		root = list_first_entry(&splice, struct btrfs_root,
9600 					delalloc_root);
9601 		root = btrfs_grab_fs_root(root);
9602 		BUG_ON(!root);
9603 		list_move_tail(&root->delalloc_root,
9604 			       &fs_info->delalloc_roots);
9605 		spin_unlock(&fs_info->delalloc_root_lock);
9606 
9607 		ret = __start_delalloc_inodes(root, delay_iput, nr);
9608 		btrfs_put_fs_root(root);
9609 		if (ret < 0)
9610 			goto out;
9611 
9612 		if (nr != -1) {
9613 			nr -= ret;
9614 			WARN_ON(nr < 0);
9615 		}
9616 		spin_lock(&fs_info->delalloc_root_lock);
9617 	}
9618 	spin_unlock(&fs_info->delalloc_root_lock);
9619 
9620 	ret = 0;
9621 	atomic_inc(&fs_info->async_submit_draining);
9622 	while (atomic_read(&fs_info->nr_async_submits) ||
9623 	      atomic_read(&fs_info->async_delalloc_pages)) {
9624 		wait_event(fs_info->async_submit_wait,
9625 		   (atomic_read(&fs_info->nr_async_submits) == 0 &&
9626 		    atomic_read(&fs_info->async_delalloc_pages) == 0));
9627 	}
9628 	atomic_dec(&fs_info->async_submit_draining);
9629 out:
9630 	if (!list_empty_careful(&splice)) {
9631 		spin_lock(&fs_info->delalloc_root_lock);
9632 		list_splice_tail(&splice, &fs_info->delalloc_roots);
9633 		spin_unlock(&fs_info->delalloc_root_lock);
9634 	}
9635 	mutex_unlock(&fs_info->delalloc_root_mutex);
9636 	return ret;
9637 }
9638 
btrfs_symlink(struct inode * dir,struct dentry * dentry,const char * symname)9639 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
9640 			 const char *symname)
9641 {
9642 	struct btrfs_trans_handle *trans;
9643 	struct btrfs_root *root = BTRFS_I(dir)->root;
9644 	struct btrfs_path *path;
9645 	struct btrfs_key key;
9646 	struct inode *inode = NULL;
9647 	int err;
9648 	int drop_inode = 0;
9649 	u64 objectid;
9650 	u64 index = 0;
9651 	int name_len;
9652 	int datasize;
9653 	unsigned long ptr;
9654 	struct btrfs_file_extent_item *ei;
9655 	struct extent_buffer *leaf;
9656 
9657 	name_len = strlen(symname);
9658 	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
9659 		return -ENAMETOOLONG;
9660 
9661 	/*
9662 	 * 2 items for inode item and ref
9663 	 * 2 items for dir items
9664 	 * 1 item for updating parent inode item
9665 	 * 1 item for the inline extent item
9666 	 * 1 item for xattr if selinux is on
9667 	 */
9668 	trans = btrfs_start_transaction(root, 7);
9669 	if (IS_ERR(trans))
9670 		return PTR_ERR(trans);
9671 
9672 	err = btrfs_find_free_ino(root, &objectid);
9673 	if (err)
9674 		goto out_unlock;
9675 
9676 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
9677 				dentry->d_name.len, btrfs_ino(dir), objectid,
9678 				S_IFLNK|S_IRWXUGO, &index);
9679 	if (IS_ERR(inode)) {
9680 		err = PTR_ERR(inode);
9681 		goto out_unlock;
9682 	}
9683 
9684 	/*
9685 	* If the active LSM wants to access the inode during
9686 	* d_instantiate it needs these. Smack checks to see
9687 	* if the filesystem supports xattrs by looking at the
9688 	* ops vector.
9689 	*/
9690 	inode->i_fop = &btrfs_file_operations;
9691 	inode->i_op = &btrfs_file_inode_operations;
9692 	inode->i_mapping->a_ops = &btrfs_aops;
9693 	BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
9694 
9695 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
9696 	if (err)
9697 		goto out_unlock_inode;
9698 
9699 	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
9700 	if (err)
9701 		goto out_unlock_inode;
9702 
9703 	path = btrfs_alloc_path();
9704 	if (!path) {
9705 		err = -ENOMEM;
9706 		goto out_unlock_inode;
9707 	}
9708 	key.objectid = btrfs_ino(inode);
9709 	key.offset = 0;
9710 	key.type = BTRFS_EXTENT_DATA_KEY;
9711 	datasize = btrfs_file_extent_calc_inline_size(name_len);
9712 	err = btrfs_insert_empty_item(trans, root, path, &key,
9713 				      datasize);
9714 	if (err) {
9715 		btrfs_free_path(path);
9716 		goto out_unlock_inode;
9717 	}
9718 	leaf = path->nodes[0];
9719 	ei = btrfs_item_ptr(leaf, path->slots[0],
9720 			    struct btrfs_file_extent_item);
9721 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
9722 	btrfs_set_file_extent_type(leaf, ei,
9723 				   BTRFS_FILE_EXTENT_INLINE);
9724 	btrfs_set_file_extent_encryption(leaf, ei, 0);
9725 	btrfs_set_file_extent_compression(leaf, ei, 0);
9726 	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
9727 	btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
9728 
9729 	ptr = btrfs_file_extent_inline_start(ei);
9730 	write_extent_buffer(leaf, symname, ptr, name_len);
9731 	btrfs_mark_buffer_dirty(leaf);
9732 	btrfs_free_path(path);
9733 
9734 	inode->i_op = &btrfs_symlink_inode_operations;
9735 	inode->i_mapping->a_ops = &btrfs_symlink_aops;
9736 	inode_set_bytes(inode, name_len);
9737 	btrfs_i_size_write(inode, name_len);
9738 	err = btrfs_update_inode(trans, root, inode);
9739 	if (err) {
9740 		drop_inode = 1;
9741 		goto out_unlock_inode;
9742 	}
9743 
9744 	unlock_new_inode(inode);
9745 	d_instantiate(dentry, inode);
9746 
9747 out_unlock:
9748 	btrfs_end_transaction(trans, root);
9749 	if (drop_inode) {
9750 		inode_dec_link_count(inode);
9751 		iput(inode);
9752 	}
9753 	btrfs_btree_balance_dirty(root);
9754 	return err;
9755 
9756 out_unlock_inode:
9757 	drop_inode = 1;
9758 	unlock_new_inode(inode);
9759 	goto out_unlock;
9760 }
9761 
__btrfs_prealloc_file_range(struct inode * inode,int mode,u64 start,u64 num_bytes,u64 min_size,loff_t actual_len,u64 * alloc_hint,struct btrfs_trans_handle * trans)9762 static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
9763 				       u64 start, u64 num_bytes, u64 min_size,
9764 				       loff_t actual_len, u64 *alloc_hint,
9765 				       struct btrfs_trans_handle *trans)
9766 {
9767 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
9768 	struct extent_map *em;
9769 	struct btrfs_root *root = BTRFS_I(inode)->root;
9770 	struct btrfs_key ins;
9771 	u64 cur_offset = start;
9772 	u64 i_size;
9773 	u64 cur_bytes;
9774 	u64 last_alloc = (u64)-1;
9775 	int ret = 0;
9776 	bool own_trans = true;
9777 
9778 	if (trans)
9779 		own_trans = false;
9780 	while (num_bytes > 0) {
9781 		if (own_trans) {
9782 			trans = btrfs_start_transaction(root, 3);
9783 			if (IS_ERR(trans)) {
9784 				ret = PTR_ERR(trans);
9785 				break;
9786 			}
9787 		}
9788 
9789 		cur_bytes = min(num_bytes, 256ULL * 1024 * 1024);
9790 		cur_bytes = max(cur_bytes, min_size);
9791 		/*
9792 		 * If we are severely fragmented we could end up with really
9793 		 * small allocations, so if the allocator is returning small
9794 		 * chunks lets make its job easier by only searching for those
9795 		 * sized chunks.
9796 		 */
9797 		cur_bytes = min(cur_bytes, last_alloc);
9798 		ret = btrfs_reserve_extent(root, cur_bytes, min_size, 0,
9799 					   *alloc_hint, &ins, 1, 0);
9800 		if (ret) {
9801 			if (own_trans)
9802 				btrfs_end_transaction(trans, root);
9803 			break;
9804 		}
9805 
9806 		last_alloc = ins.offset;
9807 		ret = insert_reserved_file_extent(trans, inode,
9808 						  cur_offset, ins.objectid,
9809 						  ins.offset, ins.offset,
9810 						  ins.offset, 0, 0, 0,
9811 						  BTRFS_FILE_EXTENT_PREALLOC);
9812 		if (ret) {
9813 			btrfs_free_reserved_extent(root, ins.objectid,
9814 						   ins.offset, 0);
9815 			btrfs_abort_transaction(trans, root, ret);
9816 			if (own_trans)
9817 				btrfs_end_transaction(trans, root);
9818 			break;
9819 		}
9820 
9821 		btrfs_drop_extent_cache(inode, cur_offset,
9822 					cur_offset + ins.offset -1, 0);
9823 
9824 		em = alloc_extent_map();
9825 		if (!em) {
9826 			set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
9827 				&BTRFS_I(inode)->runtime_flags);
9828 			goto next;
9829 		}
9830 
9831 		em->start = cur_offset;
9832 		em->orig_start = cur_offset;
9833 		em->len = ins.offset;
9834 		em->block_start = ins.objectid;
9835 		em->block_len = ins.offset;
9836 		em->orig_block_len = ins.offset;
9837 		em->ram_bytes = ins.offset;
9838 		em->bdev = root->fs_info->fs_devices->latest_bdev;
9839 		set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
9840 		em->generation = trans->transid;
9841 
9842 		while (1) {
9843 			write_lock(&em_tree->lock);
9844 			ret = add_extent_mapping(em_tree, em, 1);
9845 			write_unlock(&em_tree->lock);
9846 			if (ret != -EEXIST)
9847 				break;
9848 			btrfs_drop_extent_cache(inode, cur_offset,
9849 						cur_offset + ins.offset - 1,
9850 						0);
9851 		}
9852 		free_extent_map(em);
9853 next:
9854 		num_bytes -= ins.offset;
9855 		cur_offset += ins.offset;
9856 		*alloc_hint = ins.objectid + ins.offset;
9857 
9858 		inode_inc_iversion(inode);
9859 		inode->i_ctime = CURRENT_TIME;
9860 		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
9861 		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
9862 		    (actual_len > inode->i_size) &&
9863 		    (cur_offset > inode->i_size)) {
9864 			if (cur_offset > actual_len)
9865 				i_size = actual_len;
9866 			else
9867 				i_size = cur_offset;
9868 			i_size_write(inode, i_size);
9869 			btrfs_ordered_update_i_size(inode, i_size, NULL);
9870 		}
9871 
9872 		ret = btrfs_update_inode(trans, root, inode);
9873 
9874 		if (ret) {
9875 			btrfs_abort_transaction(trans, root, ret);
9876 			if (own_trans)
9877 				btrfs_end_transaction(trans, root);
9878 			break;
9879 		}
9880 
9881 		if (own_trans)
9882 			btrfs_end_transaction(trans, root);
9883 	}
9884 	return ret;
9885 }
9886 
btrfs_prealloc_file_range(struct inode * inode,int mode,u64 start,u64 num_bytes,u64 min_size,loff_t actual_len,u64 * alloc_hint)9887 int btrfs_prealloc_file_range(struct inode *inode, int mode,
9888 			      u64 start, u64 num_bytes, u64 min_size,
9889 			      loff_t actual_len, u64 *alloc_hint)
9890 {
9891 	return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
9892 					   min_size, actual_len, alloc_hint,
9893 					   NULL);
9894 }
9895 
btrfs_prealloc_file_range_trans(struct inode * inode,struct btrfs_trans_handle * trans,int mode,u64 start,u64 num_bytes,u64 min_size,loff_t actual_len,u64 * alloc_hint)9896 int btrfs_prealloc_file_range_trans(struct inode *inode,
9897 				    struct btrfs_trans_handle *trans, int mode,
9898 				    u64 start, u64 num_bytes, u64 min_size,
9899 				    loff_t actual_len, u64 *alloc_hint)
9900 {
9901 	return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
9902 					   min_size, actual_len, alloc_hint, trans);
9903 }
9904 
btrfs_set_page_dirty(struct page * page)9905 static int btrfs_set_page_dirty(struct page *page)
9906 {
9907 	return __set_page_dirty_nobuffers(page);
9908 }
9909 
btrfs_permission(struct inode * inode,int mask)9910 static int btrfs_permission(struct inode *inode, int mask)
9911 {
9912 	struct btrfs_root *root = BTRFS_I(inode)->root;
9913 	umode_t mode = inode->i_mode;
9914 
9915 	if (mask & MAY_WRITE &&
9916 	    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
9917 		if (btrfs_root_readonly(root))
9918 			return -EROFS;
9919 		if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)
9920 			return -EACCES;
9921 	}
9922 	return generic_permission(inode, mask);
9923 }
9924 
btrfs_tmpfile(struct inode * dir,struct dentry * dentry,umode_t mode)9925 static int btrfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
9926 {
9927 	struct btrfs_trans_handle *trans;
9928 	struct btrfs_root *root = BTRFS_I(dir)->root;
9929 	struct inode *inode = NULL;
9930 	u64 objectid;
9931 	u64 index;
9932 	int ret = 0;
9933 
9934 	/*
9935 	 * 5 units required for adding orphan entry
9936 	 */
9937 	trans = btrfs_start_transaction(root, 5);
9938 	if (IS_ERR(trans))
9939 		return PTR_ERR(trans);
9940 
9941 	ret = btrfs_find_free_ino(root, &objectid);
9942 	if (ret)
9943 		goto out;
9944 
9945 	inode = btrfs_new_inode(trans, root, dir, NULL, 0,
9946 				btrfs_ino(dir), objectid, mode, &index);
9947 	if (IS_ERR(inode)) {
9948 		ret = PTR_ERR(inode);
9949 		inode = NULL;
9950 		goto out;
9951 	}
9952 
9953 	inode->i_fop = &btrfs_file_operations;
9954 	inode->i_op = &btrfs_file_inode_operations;
9955 
9956 	inode->i_mapping->a_ops = &btrfs_aops;
9957 	BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
9958 
9959 	ret = btrfs_init_inode_security(trans, inode, dir, NULL);
9960 	if (ret)
9961 		goto out_inode;
9962 
9963 	ret = btrfs_update_inode(trans, root, inode);
9964 	if (ret)
9965 		goto out_inode;
9966 	ret = btrfs_orphan_add(trans, inode);
9967 	if (ret)
9968 		goto out_inode;
9969 
9970 	/*
9971 	 * We set number of links to 0 in btrfs_new_inode(), and here we set
9972 	 * it to 1 because d_tmpfile() will issue a warning if the count is 0,
9973 	 * through:
9974 	 *
9975 	 *    d_tmpfile() -> inode_dec_link_count() -> drop_nlink()
9976 	 */
9977 	set_nlink(inode, 1);
9978 	unlock_new_inode(inode);
9979 	d_tmpfile(dentry, inode);
9980 	mark_inode_dirty(inode);
9981 
9982 out:
9983 	btrfs_end_transaction(trans, root);
9984 	if (ret)
9985 		iput(inode);
9986 	btrfs_balance_delayed_items(root);
9987 	btrfs_btree_balance_dirty(root);
9988 	return ret;
9989 
9990 out_inode:
9991 	unlock_new_inode(inode);
9992 	goto out;
9993 
9994 }
9995 
9996 /* Inspired by filemap_check_errors() */
btrfs_inode_check_errors(struct inode * inode)9997 int btrfs_inode_check_errors(struct inode *inode)
9998 {
9999 	int ret = 0;
10000 
10001 	if (test_bit(AS_ENOSPC, &inode->i_mapping->flags) &&
10002 	    test_and_clear_bit(AS_ENOSPC, &inode->i_mapping->flags))
10003 		ret = -ENOSPC;
10004 	if (test_bit(AS_EIO, &inode->i_mapping->flags) &&
10005 	    test_and_clear_bit(AS_EIO, &inode->i_mapping->flags))
10006 		ret = -EIO;
10007 
10008 	return ret;
10009 }
10010 
10011 static const struct inode_operations btrfs_dir_inode_operations = {
10012 	.getattr	= btrfs_getattr,
10013 	.lookup		= btrfs_lookup,
10014 	.create		= btrfs_create,
10015 	.unlink		= btrfs_unlink,
10016 	.link		= btrfs_link,
10017 	.mkdir		= btrfs_mkdir,
10018 	.rmdir		= btrfs_rmdir,
10019 	.rename2	= btrfs_rename2,
10020 	.symlink	= btrfs_symlink,
10021 	.setattr	= btrfs_setattr,
10022 	.mknod		= btrfs_mknod,
10023 	.setxattr	= btrfs_setxattr,
10024 	.getxattr	= btrfs_getxattr,
10025 	.listxattr	= btrfs_listxattr,
10026 	.removexattr	= btrfs_removexattr,
10027 	.permission	= btrfs_permission,
10028 	.get_acl	= btrfs_get_acl,
10029 	.set_acl	= btrfs_set_acl,
10030 	.update_time	= btrfs_update_time,
10031 	.tmpfile        = btrfs_tmpfile,
10032 };
10033 static const struct inode_operations btrfs_dir_ro_inode_operations = {
10034 	.lookup		= btrfs_lookup,
10035 	.permission	= btrfs_permission,
10036 	.get_acl	= btrfs_get_acl,
10037 	.set_acl	= btrfs_set_acl,
10038 	.update_time	= btrfs_update_time,
10039 };
10040 
10041 static const struct file_operations btrfs_dir_file_operations = {
10042 	.llseek		= generic_file_llseek,
10043 	.read		= generic_read_dir,
10044 	.iterate	= btrfs_real_readdir,
10045 	.unlocked_ioctl	= btrfs_ioctl,
10046 #ifdef CONFIG_COMPAT
10047 	.compat_ioctl	= btrfs_ioctl,
10048 #endif
10049 	.release        = btrfs_release_file,
10050 	.fsync		= btrfs_sync_file,
10051 };
10052 
10053 static struct extent_io_ops btrfs_extent_io_ops = {
10054 	.fill_delalloc = run_delalloc_range,
10055 	.submit_bio_hook = btrfs_submit_bio_hook,
10056 	.merge_bio_hook = btrfs_merge_bio_hook,
10057 	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
10058 	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
10059 	.writepage_start_hook = btrfs_writepage_start_hook,
10060 	.set_bit_hook = btrfs_set_bit_hook,
10061 	.clear_bit_hook = btrfs_clear_bit_hook,
10062 	.merge_extent_hook = btrfs_merge_extent_hook,
10063 	.split_extent_hook = btrfs_split_extent_hook,
10064 };
10065 
10066 /*
10067  * btrfs doesn't support the bmap operation because swapfiles
10068  * use bmap to make a mapping of extents in the file.  They assume
10069  * these extents won't change over the life of the file and they
10070  * use the bmap result to do IO directly to the drive.
10071  *
10072  * the btrfs bmap call would return logical addresses that aren't
10073  * suitable for IO and they also will change frequently as COW
10074  * operations happen.  So, swapfile + btrfs == corruption.
10075  *
10076  * For now we're avoiding this by dropping bmap.
10077  */
10078 static const struct address_space_operations btrfs_aops = {
10079 	.readpage	= btrfs_readpage,
10080 	.writepage	= btrfs_writepage,
10081 	.writepages	= btrfs_writepages,
10082 	.readpages	= btrfs_readpages,
10083 	.direct_IO	= btrfs_direct_IO,
10084 	.invalidatepage = btrfs_invalidatepage,
10085 	.releasepage	= btrfs_releasepage,
10086 	.set_page_dirty	= btrfs_set_page_dirty,
10087 	.error_remove_page = generic_error_remove_page,
10088 };
10089 
10090 static const struct address_space_operations btrfs_symlink_aops = {
10091 	.readpage	= btrfs_readpage,
10092 	.writepage	= btrfs_writepage,
10093 	.invalidatepage = btrfs_invalidatepage,
10094 	.releasepage	= btrfs_releasepage,
10095 };
10096 
10097 static const struct inode_operations btrfs_file_inode_operations = {
10098 	.getattr	= btrfs_getattr,
10099 	.setattr	= btrfs_setattr,
10100 	.setxattr	= btrfs_setxattr,
10101 	.getxattr	= btrfs_getxattr,
10102 	.listxattr      = btrfs_listxattr,
10103 	.removexattr	= btrfs_removexattr,
10104 	.permission	= btrfs_permission,
10105 	.fiemap		= btrfs_fiemap,
10106 	.get_acl	= btrfs_get_acl,
10107 	.set_acl	= btrfs_set_acl,
10108 	.update_time	= btrfs_update_time,
10109 };
10110 static const struct inode_operations btrfs_special_inode_operations = {
10111 	.getattr	= btrfs_getattr,
10112 	.setattr	= btrfs_setattr,
10113 	.permission	= btrfs_permission,
10114 	.setxattr	= btrfs_setxattr,
10115 	.getxattr	= btrfs_getxattr,
10116 	.listxattr	= btrfs_listxattr,
10117 	.removexattr	= btrfs_removexattr,
10118 	.get_acl	= btrfs_get_acl,
10119 	.set_acl	= btrfs_set_acl,
10120 	.update_time	= btrfs_update_time,
10121 };
10122 static const struct inode_operations btrfs_symlink_inode_operations = {
10123 	.readlink	= generic_readlink,
10124 	.follow_link	= page_follow_link_light,
10125 	.put_link	= page_put_link,
10126 	.getattr	= btrfs_getattr,
10127 	.setattr	= btrfs_setattr,
10128 	.permission	= btrfs_permission,
10129 	.setxattr	= btrfs_setxattr,
10130 	.getxattr	= btrfs_getxattr,
10131 	.listxattr	= btrfs_listxattr,
10132 	.removexattr	= btrfs_removexattr,
10133 	.update_time	= btrfs_update_time,
10134 };
10135 
10136 const struct dentry_operations btrfs_dentry_operations = {
10137 	.d_delete	= btrfs_dentry_delete,
10138 	.d_release	= btrfs_dentry_release,
10139 };
10140