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