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