projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Btrfs: Remove debugging statements from the invalidatepage calls
[deliverable/linux.git] / fs / btrfs / inode.c
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19 #include <linux/bio.h>
20 #include <linux/buffer_head.h>
21 #include <linux/fs.h>
22 #include <linux/pagemap.h>
23 #include <linux/highmem.h>
24 #include <linux/time.h>
25 #include <linux/init.h>
26 #include <linux/string.h>
27 #include <linux/smp_lock.h>
28 #include <linux/backing-dev.h>
29 #include <linux/mpage.h>
30 #include <linux/swap.h>
31 #include <linux/writeback.h>
32 #include <linux/statfs.h>
33 #include <linux/compat.h>
34 #include <linux/bit_spinlock.h>
35 #include <linux/version.h>
36 #include <linux/xattr.h>
37 #include "ctree.h"
38 #include "disk-io.h"
39 #include "transaction.h"
40 #include "btrfs_inode.h"
41 #include "ioctl.h"
42 #include "print-tree.h"
43 #include "volumes.h"
44
45 struct btrfs_iget_args {
46 u64 ino;
47 struct btrfs_root *root;
48 };
49
50 static struct inode_operations btrfs_dir_inode_operations;
51 static struct inode_operations btrfs_symlink_inode_operations;
52 static struct inode_operations btrfs_dir_ro_inode_operations;
53 static struct inode_operations btrfs_special_inode_operations;
54 static struct inode_operations btrfs_file_inode_operations;
55 static struct address_space_operations btrfs_aops;
56 static struct address_space_operations btrfs_symlink_aops;
57 static struct file_operations btrfs_dir_file_operations;
58 static struct extent_io_ops btrfs_extent_io_ops;
59
60 static struct kmem_cache *btrfs_inode_cachep;
61 struct kmem_cache *btrfs_trans_handle_cachep;
62 struct kmem_cache *btrfs_transaction_cachep;
63 struct kmem_cache *btrfs_bit_radix_cachep;
64 struct kmem_cache *btrfs_path_cachep;
65
66 #define S_SHIFT 12
67 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
68 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
69 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
70 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
71 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
72 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
73 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
74 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
75 };
76
77 int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
78 int for_del)
79 {
80 u64 total = btrfs_super_total_bytes(&root->fs_info->super_copy);
81 u64 used = btrfs_super_bytes_used(&root->fs_info->super_copy);
82 u64 thresh;
83 int ret = 0;
84
85 if (for_del)
86 thresh = total * 90;
87 else
88 thresh = total * 85;
89
90 do_div(thresh, 100);
91
92 spin_lock(&root->fs_info->delalloc_lock);
93 if (used + root->fs_info->delalloc_bytes + num_required > thresh)
94 ret = -ENOSPC;
95 spin_unlock(&root->fs_info->delalloc_lock);
96 return ret;
97 }
98
99 static int cow_file_range(struct inode *inode, u64 start, u64 end)
100 {
101 struct btrfs_root *root = BTRFS_I(inode)->root;
102 struct btrfs_trans_handle *trans;
103 u64 alloc_hint = 0;
104 u64 num_bytes;
105 u64 cur_alloc_size;
106 u64 blocksize = root->sectorsize;
107 u64 orig_start = start;
108 u64 orig_num_bytes;
109 struct btrfs_key ins;
110 int ret;
111
112 trans = btrfs_start_transaction(root, 1);
113 BUG_ON(!trans);
114 btrfs_set_trans_block_group(trans, inode);
115
116 num_bytes = (end - start + blocksize) & ~(blocksize - 1);
117 num_bytes = max(blocksize, num_bytes);
118 ret = btrfs_drop_extents(trans, root, inode,
119 start, start + num_bytes, start, &alloc_hint);
120 orig_num_bytes = num_bytes;
121
122 if (alloc_hint == EXTENT_MAP_INLINE)
123 goto out;
124
125 BUG_ON(num_bytes > btrfs_super_total_bytes(&root->fs_info->super_copy));
126
127 while(num_bytes > 0) {
128 cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
129 ret = btrfs_alloc_extent(trans, root, cur_alloc_size,
130 root->sectorsize,
131 root->root_key.objectid,
132 trans->transid,
133 inode->i_ino, start, 0,
134 alloc_hint, (u64)-1, &ins, 1);
135 if (ret) {
136 WARN_ON(1);
137 goto out;
138 }
139 cur_alloc_size = ins.offset;
140 ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
141 start, ins.objectid, ins.offset,
142 ins.offset);
143 inode->i_blocks += ins.offset >> 9;
144 btrfs_check_file(root, inode);
145 if (num_bytes < cur_alloc_size) {
146 printk("num_bytes %Lu cur_alloc %Lu\n", num_bytes,
147 cur_alloc_size);
148 break;
149 }
150 num_bytes -= cur_alloc_size;
151 alloc_hint = ins.objectid + ins.offset;
152 start += cur_alloc_size;
153 }
154 btrfs_drop_extent_cache(inode, orig_start,
155 orig_start + orig_num_bytes - 1);
156 btrfs_add_ordered_inode(inode);
157 btrfs_update_inode(trans, root, inode);
158 out:
159 btrfs_end_transaction(trans, root);
160 return ret;
161 }
162
163 static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
164 {
165 u64 extent_start;
166 u64 extent_end;
167 u64 bytenr;
168 u64 cow_end;
169 u64 loops = 0;
170 u64 total_fs_bytes;
171 struct btrfs_root *root = BTRFS_I(inode)->root;
172 struct extent_buffer *leaf;
173 int found_type;
174 struct btrfs_path *path;
175 struct btrfs_file_extent_item *item;
176 int ret;
177 int err;
178 struct btrfs_key found_key;
179
180 total_fs_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
181 path = btrfs_alloc_path();
182 BUG_ON(!path);
183 again:
184 ret = btrfs_lookup_file_extent(NULL, root, path,
185 inode->i_ino, start, 0);
186 if (ret < 0) {
187 btrfs_free_path(path);
188 return ret;
189 }
190
191 cow_end = end;
192 if (ret != 0) {
193 if (path->slots[0] == 0)
194 goto not_found;
195 path->slots[0]--;
196 }
197
198 leaf = path->nodes[0];
199 item = btrfs_item_ptr(leaf, path->slots[0],
200 struct btrfs_file_extent_item);
201
202 /* are we inside the extent that was found? */
203 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
204 found_type = btrfs_key_type(&found_key);
205 if (found_key.objectid != inode->i_ino ||
206 found_type != BTRFS_EXTENT_DATA_KEY) {
207 goto not_found;
208 }
209
210 found_type = btrfs_file_extent_type(leaf, item);
211 extent_start = found_key.offset;
212 if (found_type == BTRFS_FILE_EXTENT_REG) {
213 u64 extent_num_bytes;
214
215 extent_num_bytes = btrfs_file_extent_num_bytes(leaf, item);
216 extent_end = extent_start + extent_num_bytes;
217 err = 0;
218
219 if (loops && start != extent_start)
220 goto not_found;
221
222 if (start < extent_start || start >= extent_end)
223 goto not_found;
224
225 cow_end = min(end, extent_end - 1);
226 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
227 if (bytenr == 0)
228 goto not_found;
229
230 /*
231 * we may be called by the resizer, make sure we're inside
232 * the limits of the FS
233 */
234 if (bytenr + extent_num_bytes > total_fs_bytes)
235 goto not_found;
236
237 if (btrfs_count_snapshots_in_path(root, path, bytenr) != 1) {
238 goto not_found;
239 }
240
241 start = extent_end;
242 } else {
243 goto not_found;
244 }
245 loop:
246 if (start > end) {
247 btrfs_free_path(path);
248 return 0;
249 }
250 btrfs_release_path(root, path);
251 loops++;
252 goto again;
253
254 not_found:
255 cow_file_range(inode, start, cow_end);
256 start = cow_end + 1;
257 goto loop;
258 }
259
260 static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
261 {
262 struct btrfs_root *root = BTRFS_I(inode)->root;
263 int ret;
264 mutex_lock(&root->fs_info->fs_mutex);
265 if (btrfs_test_opt(root, NODATACOW) ||
266 btrfs_test_flag(inode, NODATACOW))
267 ret = run_delalloc_nocow(inode, start, end);
268 else
269 ret = cow_file_range(inode, start, end);
270
271 mutex_unlock(&root->fs_info->fs_mutex);
272 return ret;
273 }
274
275 int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
276 unsigned long old, unsigned long bits)
277 {
278 if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
279 struct btrfs_root *root = BTRFS_I(inode)->root;
280 spin_lock(&root->fs_info->delalloc_lock);
281 BTRFS_I(inode)->delalloc_bytes += end - start + 1;
282 root->fs_info->delalloc_bytes += end - start + 1;
283 spin_unlock(&root->fs_info->delalloc_lock);
284 }
285 return 0;
286 }
287
288 int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
289 unsigned long old, unsigned long bits)
290 {
291 if ((old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
292 struct btrfs_root *root = BTRFS_I(inode)->root;
293 spin_lock(&root->fs_info->delalloc_lock);
294 if (end - start + 1 > root->fs_info->delalloc_bytes) {
295 printk("warning: delalloc account %Lu %Lu\n",
296 end - start + 1, root->fs_info->delalloc_bytes);
297 root->fs_info->delalloc_bytes = 0;
298 BTRFS_I(inode)->delalloc_bytes = 0;
299 } else {
300 root->fs_info->delalloc_bytes -= end - start + 1;
301 BTRFS_I(inode)->delalloc_bytes -= end - start + 1;
302 }
303 spin_unlock(&root->fs_info->delalloc_lock);
304 }
305 return 0;
306 }
307
308 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
309 size_t size, struct bio *bio)
310 {
311 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
312 struct btrfs_mapping_tree *map_tree;
313 u64 logical = bio->bi_sector << 9;
314 u64 length = 0;
315 u64 map_length;
316 struct bio_vec *bvec;
317 int i;
318 int ret;
319
320 bio_for_each_segment(bvec, bio, i) {
321 length += bvec->bv_len;
322 }
323 map_tree = &root->fs_info->mapping_tree;
324 map_length = length;
325 ret = btrfs_map_block(map_tree, READ, logical,
326 &map_length, NULL, 0);
327
328 if (map_length < length + size) {
329 return 1;
330 }
331 return 0;
332 }
333
334 int __btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
335 int mirror_num)
336 {
337 struct btrfs_root *root = BTRFS_I(inode)->root;
338 struct btrfs_trans_handle *trans;
339 int ret = 0;
340 char *sums = NULL;
341
342 ret = btrfs_csum_one_bio(root, bio, &sums);
343 BUG_ON(ret);
344
345 mutex_lock(&root->fs_info->fs_mutex);
346 trans = btrfs_start_transaction(root, 1);
347
348 btrfs_set_trans_block_group(trans, inode);
349 btrfs_csum_file_blocks(trans, root, inode, bio, sums);
350
351 ret = btrfs_end_transaction(trans, root);
352 BUG_ON(ret);
353 mutex_unlock(&root->fs_info->fs_mutex);
354
355 kfree(sums);
356
357 return btrfs_map_bio(root, rw, bio, mirror_num);
358 }
359
360 int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
361 int mirror_num)
362 {
363 struct btrfs_root *root = BTRFS_I(inode)->root;
364 int ret = 0;
365
366 if (!(rw & (1 << BIO_RW))) {
367 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
368 BUG_ON(ret);
369 goto mapit;
370 }
371
372 if (btrfs_test_opt(root, NODATASUM) ||
373 btrfs_test_flag(inode, NODATASUM)) {
374 goto mapit;
375 }
376
377 return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
378 inode, rw, bio, mirror_num,
379 __btrfs_submit_bio_hook);
380 mapit:
381 return btrfs_map_bio(root, rw, bio, mirror_num);
382 }
383
384 int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
385 {
386 int ret = 0;
387 struct inode *inode = page->mapping->host;
388 struct btrfs_root *root = BTRFS_I(inode)->root;
389 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
390 struct btrfs_csum_item *item;
391 struct btrfs_path *path = NULL;
392 u32 csum;
393
394 if (btrfs_test_opt(root, NODATASUM) ||
395 btrfs_test_flag(inode, NODATASUM))
396 return 0;
397
398 mutex_lock(&root->fs_info->fs_mutex);
399 path = btrfs_alloc_path();
400 item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
401 if (IS_ERR(item)) {
402 ret = PTR_ERR(item);
403 /* a csum that isn't present is a preallocated region. */
404 if (ret == -ENOENT || ret == -EFBIG)
405 ret = 0;
406 csum = 0;
407 printk("no csum found for inode %lu start %Lu\n", inode->i_ino, start);
408 goto out;
409 }
410 read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
411 BTRFS_CRC32_SIZE);
412 set_state_private(io_tree, start, csum);
413 out:
414 if (path)
415 btrfs_free_path(path);
416 mutex_unlock(&root->fs_info->fs_mutex);
417 return ret;
418 }
419
420 struct io_failure_record {
421 struct page *page;
422 u64 start;
423 u64 len;
424 u64 logical;
425 int last_mirror;
426 };
427
428 int btrfs_readpage_io_failed_hook(struct bio *failed_bio,
429 struct page *page, u64 start, u64 end,
430 struct extent_state *state)
431 {
432 struct io_failure_record *failrec = NULL;
433 u64 private;
434 struct extent_map *em;
435 struct inode *inode = page->mapping->host;
436 struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
437 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
438 struct bio *bio;
439 int num_copies;
440 int ret;
441 u64 logical;
442
443 ret = get_state_private(failure_tree, start, &private);
444 if (ret) {
445 failrec = kmalloc(sizeof(*failrec), GFP_NOFS);
446 if (!failrec)
447 return -ENOMEM;
448 failrec->start = start;
449 failrec->len = end - start + 1;
450 failrec->last_mirror = 0;
451
452 spin_lock(&em_tree->lock);
453 em = lookup_extent_mapping(em_tree, start, failrec->len);
454 if (em->start > start || em->start + em->len < start) {
455 free_extent_map(em);
456 em = NULL;
457 }
458 spin_unlock(&em_tree->lock);
459
460 if (!em || IS_ERR(em)) {
461 kfree(failrec);
462 return -EIO;
463 }
464 logical = start - em->start;
465 logical = em->block_start + logical;
466 failrec->logical = logical;
467 free_extent_map(em);
468 set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
469 EXTENT_DIRTY, GFP_NOFS);
470 set_state_private(failure_tree, start,
471 (u64)(unsigned long)failrec);
472 } else {
473 failrec = (struct io_failure_record *)(unsigned long)private;
474 }
475 num_copies = btrfs_num_copies(
476 &BTRFS_I(inode)->root->fs_info->mapping_tree,
477 failrec->logical, failrec->len);
478 failrec->last_mirror++;
479 if (!state) {
480 spin_lock_irq(&BTRFS_I(inode)->io_tree.lock);
481 state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
482 failrec->start,
483 EXTENT_LOCKED);
484 if (state && state->start != failrec->start)
485 state = NULL;
486 spin_unlock_irq(&BTRFS_I(inode)->io_tree.lock);
487 }
488 if (!state || failrec->last_mirror > num_copies) {
489 set_state_private(failure_tree, failrec->start, 0);
490 clear_extent_bits(failure_tree, failrec->start,
491 failrec->start + failrec->len - 1,
492 EXTENT_LOCKED | EXTENT_DIRTY, GFP_NOFS);
493 kfree(failrec);
494 return -EIO;
495 }
496 bio = bio_alloc(GFP_NOFS, 1);
497 bio->bi_private = state;
498 bio->bi_end_io = failed_bio->bi_end_io;
499 bio->bi_sector = failrec->logical >> 9;
500 bio->bi_bdev = failed_bio->bi_bdev;
501 bio_add_page(bio, page, failrec->len, start - page_offset(page));
502 btrfs_submit_bio_hook(inode, READ, bio, failrec->last_mirror);
503 return 0;
504 }
505
506 int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
507 struct extent_state *state)
508 {
509 size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
510 struct inode *inode = page->mapping->host;
511 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
512 char *kaddr;
513 u64 private = ~(u32)0;
514 int ret;
515 struct btrfs_root *root = BTRFS_I(inode)->root;
516 u32 csum = ~(u32)0;
517 unsigned long flags;
518
519 if (btrfs_test_opt(root, NODATASUM) ||
520 btrfs_test_flag(inode, NODATASUM))
521 return 0;
522 if (state && state->start == start) {
523 private = state->private;
524 ret = 0;
525 } else {
526 ret = get_state_private(io_tree, start, &private);
527 }
528 local_irq_save(flags);
529 kaddr = kmap_atomic(page, KM_IRQ0);
530 if (ret) {
531 goto zeroit;
532 }
533 csum = btrfs_csum_data(root, kaddr + offset, csum, end - start + 1);
534 btrfs_csum_final(csum, (char *)&csum);
535 if (csum != private) {
536 goto zeroit;
537 }
538 kunmap_atomic(kaddr, KM_IRQ0);
539 local_irq_restore(flags);
540
541 /* if the io failure tree for this inode is non-empty,
542 * check to see if we've recovered from a failed IO
543 */
544 private = 0;
545 if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
546 (u64)-1, 1, EXTENT_DIRTY)) {
547 u64 private_failure;
548 struct io_failure_record *failure;
549 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
550 start, &private_failure);
551 if (ret == 0) {
552 failure = (struct io_failure_record *)(unsigned long)
553 private_failure;
554 set_state_private(&BTRFS_I(inode)->io_failure_tree,
555 failure->start, 0);
556 clear_extent_bits(&BTRFS_I(inode)->io_failure_tree,
557 failure->start,
558 failure->start + failure->len - 1,
559 EXTENT_DIRTY | EXTENT_LOCKED,
560 GFP_NOFS);
561 kfree(failure);
562 }
563 }
564 return 0;
565
566 zeroit:
567 printk("btrfs csum failed ino %lu off %llu csum %u private %Lu\n",
568 page->mapping->host->i_ino, (unsigned long long)start, csum,
569 private);
570 memset(kaddr + offset, 1, end - start + 1);
571 flush_dcache_page(page);
572 kunmap_atomic(kaddr, KM_IRQ0);
573 local_irq_restore(flags);
574 if (private == 0)
575 return 0;
576 return -EIO;
577 }
578
579 void btrfs_read_locked_inode(struct inode *inode)
580 {
581 struct btrfs_path *path;
582 struct extent_buffer *leaf;
583 struct btrfs_inode_item *inode_item;
584 struct btrfs_timespec *tspec;
585 struct btrfs_root *root = BTRFS_I(inode)->root;
586 struct btrfs_key location;
587 u64 alloc_group_block;
588 u32 rdev;
589 int ret;
590
591 path = btrfs_alloc_path();
592 BUG_ON(!path);
593 mutex_lock(&root->fs_info->fs_mutex);
594 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
595
596 ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
597 if (ret)
598 goto make_bad;
599
600 leaf = path->nodes[0];
601 inode_item = btrfs_item_ptr(leaf, path->slots[0],
602 struct btrfs_inode_item);
603
604 inode->i_mode = btrfs_inode_mode(leaf, inode_item);
605 inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
606 inode->i_uid = btrfs_inode_uid(leaf, inode_item);
607 inode->i_gid = btrfs_inode_gid(leaf, inode_item);
608 inode->i_size = btrfs_inode_size(leaf, inode_item);
609
610 tspec = btrfs_inode_atime(inode_item);
611 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
612 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
613
614 tspec = btrfs_inode_mtime(inode_item);
615 inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
616 inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
617
618 tspec = btrfs_inode_ctime(inode_item);
619 inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
620 inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
621
622 inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
623 inode->i_generation = btrfs_inode_generation(leaf, inode_item);
624 inode->i_rdev = 0;
625 rdev = btrfs_inode_rdev(leaf, inode_item);
626
627 alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
628 BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
629 alloc_group_block);
630 BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
631 if (!BTRFS_I(inode)->block_group) {
632 BTRFS_I(inode)->block_group = btrfs_find_block_group(root,
633 NULL, 0,
634 BTRFS_BLOCK_GROUP_METADATA, 0);
635 }
636 btrfs_free_path(path);
637 inode_item = NULL;
638
639 mutex_unlock(&root->fs_info->fs_mutex);
640
641 switch (inode->i_mode & S_IFMT) {
642 case S_IFREG:
643 inode->i_mapping->a_ops = &btrfs_aops;
644 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
645 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
646 inode->i_fop = &btrfs_file_operations;
647 inode->i_op = &btrfs_file_inode_operations;
648 break;
649 case S_IFDIR:
650 inode->i_fop = &btrfs_dir_file_operations;
651 if (root == root->fs_info->tree_root)
652 inode->i_op = &btrfs_dir_ro_inode_operations;
653 else
654 inode->i_op = &btrfs_dir_inode_operations;
655 break;
656 case S_IFLNK:
657 inode->i_op = &btrfs_symlink_inode_operations;
658 inode->i_mapping->a_ops = &btrfs_symlink_aops;
659 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
660 break;
661 default:
662 init_special_inode(inode, inode->i_mode, rdev);
663 break;
664 }
665 return;
666
667 make_bad:
668 btrfs_release_path(root, path);
669 btrfs_free_path(path);
670 mutex_unlock(&root->fs_info->fs_mutex);
671 make_bad_inode(inode);
672 }
673
674 static void fill_inode_item(struct extent_buffer *leaf,
675 struct btrfs_inode_item *item,
676 struct inode *inode)
677 {
678 btrfs_set_inode_uid(leaf, item, inode->i_uid);
679 btrfs_set_inode_gid(leaf, item, inode->i_gid);
680 btrfs_set_inode_size(leaf, item, inode->i_size);
681 btrfs_set_inode_mode(leaf, item, inode->i_mode);
682 btrfs_set_inode_nlink(leaf, item, inode->i_nlink);
683
684 btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
685 inode->i_atime.tv_sec);
686 btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
687 inode->i_atime.tv_nsec);
688
689 btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
690 inode->i_mtime.tv_sec);
691 btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
692 inode->i_mtime.tv_nsec);
693
694 btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
695 inode->i_ctime.tv_sec);
696 btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
697 inode->i_ctime.tv_nsec);
698
699 btrfs_set_inode_nblocks(leaf, item, inode->i_blocks);
700 btrfs_set_inode_generation(leaf, item, inode->i_generation);
701 btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
702 btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
703 btrfs_set_inode_block_group(leaf, item,
704 BTRFS_I(inode)->block_group->key.objectid);
705 }
706
707 int btrfs_update_inode(struct btrfs_trans_handle *trans,
708 struct btrfs_root *root,
709 struct inode *inode)
710 {
711 struct btrfs_inode_item *inode_item;
712 struct btrfs_path *path;
713 struct extent_buffer *leaf;
714 int ret;
715
716 path = btrfs_alloc_path();
717 BUG_ON(!path);
718 ret = btrfs_lookup_inode(trans, root, path,
719 &BTRFS_I(inode)->location, 1);
720 if (ret) {
721 if (ret > 0)
722 ret = -ENOENT;
723 goto failed;
724 }
725
726 leaf = path->nodes[0];
727 inode_item = btrfs_item_ptr(leaf, path->slots[0],
728 struct btrfs_inode_item);
729
730 fill_inode_item(leaf, inode_item, inode);
731 btrfs_mark_buffer_dirty(leaf);
732 btrfs_set_inode_last_trans(trans, inode);
733 ret = 0;
734 failed:
735 btrfs_release_path(root, path);
736 btrfs_free_path(path);
737 return ret;
738 }
739
740
741 static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
742 struct btrfs_root *root,
743 struct inode *dir,
744 struct dentry *dentry)
745 {
746 struct btrfs_path *path;
747 const char *name = dentry->d_name.name;
748 int name_len = dentry->d_name.len;
749 int ret = 0;
750 struct extent_buffer *leaf;
751 struct btrfs_dir_item *di;
752 struct btrfs_key key;
753
754 path = btrfs_alloc_path();
755 if (!path) {
756 ret = -ENOMEM;
757 goto err;
758 }
759
760 di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
761 name, name_len, -1);
762 if (IS_ERR(di)) {
763 ret = PTR_ERR(di);
764 goto err;
765 }
766 if (!di) {
767 ret = -ENOENT;
768 goto err;
769 }
770 leaf = path->nodes[0];
771 btrfs_dir_item_key_to_cpu(leaf, di, &key);
772 ret = btrfs_delete_one_dir_name(trans, root, path, di);
773 if (ret)
774 goto err;
775 btrfs_release_path(root, path);
776
777 di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
778 key.objectid, name, name_len, -1);
779 if (IS_ERR(di)) {
780 ret = PTR_ERR(di);
781 goto err;
782 }
783 if (!di) {
784 ret = -ENOENT;
785 goto err;
786 }
787 ret = btrfs_delete_one_dir_name(trans, root, path, di);
788
789 dentry->d_inode->i_ctime = dir->i_ctime;
790 ret = btrfs_del_inode_ref(trans, root, name, name_len,
791 dentry->d_inode->i_ino,
792 dentry->d_parent->d_inode->i_ino);
793 if (ret) {
794 printk("failed to delete reference to %.*s, "
795 "inode %lu parent %lu\n", name_len, name,
796 dentry->d_inode->i_ino,
797 dentry->d_parent->d_inode->i_ino);
798 }
799 err:
800 btrfs_free_path(path);
801 if (!ret) {
802 dir->i_size -= name_len * 2;
803 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
804 btrfs_update_inode(trans, root, dir);
805 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
806 dentry->d_inode->i_nlink--;
807 #else
808 drop_nlink(dentry->d_inode);
809 #endif
810 ret = btrfs_update_inode(trans, root, dentry->d_inode);
811 dir->i_sb->s_dirt = 1;
812 }
813 return ret;
814 }
815
816 static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
817 {
818 struct btrfs_root *root;
819 struct btrfs_trans_handle *trans;
820 struct inode *inode = dentry->d_inode;
821 int ret;
822 unsigned long nr = 0;
823
824 root = BTRFS_I(dir)->root;
825 mutex_lock(&root->fs_info->fs_mutex);
826
827 ret = btrfs_check_free_space(root, 1, 1);
828 if (ret)
829 goto fail;
830
831 trans = btrfs_start_transaction(root, 1);
832
833 btrfs_set_trans_block_group(trans, dir);
834 ret = btrfs_unlink_trans(trans, root, dir, dentry);
835 nr = trans->blocks_used;
836
837 if (inode->i_nlink == 0) {
838 int found;
839 /* if the inode isn't linked anywhere,
840 * we don't need to worry about
841 * data=ordered
842 */
843 found = btrfs_del_ordered_inode(inode);
844 if (found == 1) {
845 atomic_dec(&inode->i_count);
846 }
847 }
848
849 btrfs_end_transaction(trans, root);
850 fail:
851 mutex_unlock(&root->fs_info->fs_mutex);
852 btrfs_btree_balance_dirty(root, nr);
853 btrfs_throttle(root);
854 return ret;
855 }
856
857 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
858 {
859 struct inode *inode = dentry->d_inode;
860 int err = 0;
861 int ret;
862 struct btrfs_root *root = BTRFS_I(dir)->root;
863 struct btrfs_trans_handle *trans;
864 unsigned long nr = 0;
865
866 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
867 return -ENOTEMPTY;
868
869 mutex_lock(&root->fs_info->fs_mutex);
870 ret = btrfs_check_free_space(root, 1, 1);
871 if (ret)
872 goto fail;
873
874 trans = btrfs_start_transaction(root, 1);
875 btrfs_set_trans_block_group(trans, dir);
876
877 /* now the directory is empty */
878 err = btrfs_unlink_trans(trans, root, dir, dentry);
879 if (!err) {
880 inode->i_size = 0;
881 }
882
883 nr = trans->blocks_used;
884 ret = btrfs_end_transaction(trans, root);
885 fail:
886 mutex_unlock(&root->fs_info->fs_mutex);
887 btrfs_btree_balance_dirty(root, nr);
888 btrfs_throttle(root);
889
890 if (ret && !err)
891 err = ret;
892 return err;
893 }
894
895 /*
896 * this can truncate away extent items, csum items and directory items.
897 * It starts at a high offset and removes keys until it can't find
898 * any higher than i_size.
899 *
900 * csum items that cross the new i_size are truncated to the new size
901 * as well.
902 */
903 static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
904 struct btrfs_root *root,
905 struct inode *inode,
906 u32 min_type)
907 {
908 int ret;
909 struct btrfs_path *path;
910 struct btrfs_key key;
911 struct btrfs_key found_key;
912 u32 found_type;
913 struct extent_buffer *leaf;
914 struct btrfs_file_extent_item *fi;
915 u64 extent_start = 0;
916 u64 extent_num_bytes = 0;
917 u64 item_end = 0;
918 u64 root_gen = 0;
919 u64 root_owner = 0;
920 int found_extent;
921 int del_item;
922 int pending_del_nr = 0;
923 int pending_del_slot = 0;
924 int extent_type = -1;
925 u64 mask = root->sectorsize - 1;
926
927 btrfs_drop_extent_cache(inode, inode->i_size & (~mask), (u64)-1);
928 path = btrfs_alloc_path();
929 path->reada = -1;
930 BUG_ON(!path);
931
932 /* FIXME, add redo link to tree so we don't leak on crash */
933 key.objectid = inode->i_ino;
934 key.offset = (u64)-1;
935 key.type = (u8)-1;
936
937 btrfs_init_path(path);
938 search_again:
939 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
940 if (ret < 0) {
941 goto error;
942 }
943 if (ret > 0) {
944 BUG_ON(path->slots[0] == 0);
945 path->slots[0]--;
946 }
947
948 while(1) {
949 fi = NULL;
950 leaf = path->nodes[0];
951 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
952 found_type = btrfs_key_type(&found_key);
953
954 if (found_key.objectid != inode->i_ino)
955 break;
956
957 if (found_type < min_type)
958 break;
959
960 item_end = found_key.offset;
961 if (found_type == BTRFS_EXTENT_DATA_KEY) {
962 fi = btrfs_item_ptr(leaf, path->slots[0],
963 struct btrfs_file_extent_item);
964 extent_type = btrfs_file_extent_type(leaf, fi);
965 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
966 item_end +=
967 btrfs_file_extent_num_bytes(leaf, fi);
968 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
969 struct btrfs_item *item = btrfs_item_nr(leaf,
970 path->slots[0]);
971 item_end += btrfs_file_extent_inline_len(leaf,
972 item);
973 }
974 item_end--;
975 }
976 if (found_type == BTRFS_CSUM_ITEM_KEY) {
977 ret = btrfs_csum_truncate(trans, root, path,
978 inode->i_size);
979 BUG_ON(ret);
980 }
981 if (item_end < inode->i_size) {
982 if (found_type == BTRFS_DIR_ITEM_KEY) {
983 found_type = BTRFS_INODE_ITEM_KEY;
984 } else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
985 found_type = BTRFS_CSUM_ITEM_KEY;
986 } else if (found_type == BTRFS_EXTENT_DATA_KEY) {
987 found_type = BTRFS_XATTR_ITEM_KEY;
988 } else if (found_type == BTRFS_XATTR_ITEM_KEY) {
989 found_type = BTRFS_INODE_REF_KEY;
990 } else if (found_type) {
991 found_type--;
992 } else {
993 break;
994 }
995 btrfs_set_key_type(&key, found_type);
996 goto next;
997 }
998 if (found_key.offset >= inode->i_size)
999 del_item = 1;
1000 else
1001 del_item = 0;
1002 found_extent = 0;
1003
1004 /* FIXME, shrink the extent if the ref count is only 1 */
1005 if (found_type != BTRFS_EXTENT_DATA_KEY)
1006 goto delete;
1007
1008 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
1009 u64 num_dec;
1010 extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
1011 if (!del_item) {
1012 u64 orig_num_bytes =
1013 btrfs_file_extent_num_bytes(leaf, fi);
1014 extent_num_bytes = inode->i_size -
1015 found_key.offset + root->sectorsize - 1;
1016 extent_num_bytes = extent_num_bytes &
1017 ~((u64)root->sectorsize - 1);
1018 btrfs_set_file_extent_num_bytes(leaf, fi,
1019 extent_num_bytes);
1020 num_dec = (orig_num_bytes -
1021 extent_num_bytes);
1022 if (extent_start != 0)
1023 dec_i_blocks(inode, num_dec);
1024 btrfs_mark_buffer_dirty(leaf);
1025 } else {
1026 extent_num_bytes =
1027 btrfs_file_extent_disk_num_bytes(leaf,
1028 fi);
1029 /* FIXME blocksize != 4096 */
1030 num_dec = btrfs_file_extent_num_bytes(leaf, fi);
1031 if (extent_start != 0) {
1032 found_extent = 1;
1033 dec_i_blocks(inode, num_dec);
1034 }
1035 root_gen = btrfs_header_generation(leaf);
1036 root_owner = btrfs_header_owner(leaf);
1037 }
1038 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1039 if (!del_item) {
1040 u32 newsize = inode->i_size - found_key.offset;
1041 dec_i_blocks(inode, item_end + 1 -
1042 found_key.offset - newsize);
1043 newsize =
1044 btrfs_file_extent_calc_inline_size(newsize);
1045 ret = btrfs_truncate_item(trans, root, path,
1046 newsize, 1);
1047 BUG_ON(ret);
1048 } else {
1049 dec_i_blocks(inode, item_end + 1 -
1050 found_key.offset);
1051 }
1052 }
1053 delete:
1054 if (del_item) {
1055 if (!pending_del_nr) {
1056 /* no pending yet, add ourselves */
1057 pending_del_slot = path->slots[0];
1058 pending_del_nr = 1;
1059 } else if (pending_del_nr &&
1060 path->slots[0] + 1 == pending_del_slot) {
1061 /* hop on the pending chunk */
1062 pending_del_nr++;
1063 pending_del_slot = path->slots[0];
1064 } else {
1065 printk("bad pending slot %d pending_del_nr %d pending_del_slot %d\n", path->slots[0], pending_del_nr, pending_del_slot);
1066 }
1067 } else {
1068 break;
1069 }
1070 if (found_extent) {
1071 ret = btrfs_free_extent(trans, root, extent_start,
1072 extent_num_bytes,
1073 root_owner,
1074 root_gen, inode->i_ino,
1075 found_key.offset, 0);
1076 BUG_ON(ret);
1077 }
1078 next:
1079 if (path->slots[0] == 0) {
1080 if (pending_del_nr)
1081 goto del_pending;
1082 btrfs_release_path(root, path);
1083 goto search_again;
1084 }
1085
1086 path->slots[0]--;
1087 if (pending_del_nr &&
1088 path->slots[0] + 1 != pending_del_slot) {
1089 struct btrfs_key debug;
1090 del_pending:
1091 btrfs_item_key_to_cpu(path->nodes[0], &debug,
1092 pending_del_slot);
1093 ret = btrfs_del_items(trans, root, path,
1094 pending_del_slot,
1095 pending_del_nr);
1096 BUG_ON(ret);
1097 pending_del_nr = 0;
1098 btrfs_release_path(root, path);
1099 goto search_again;
1100 }
1101 }
1102 ret = 0;
1103 error:
1104 if (pending_del_nr) {
1105 ret = btrfs_del_items(trans, root, path, pending_del_slot,
1106 pending_del_nr);
1107 }
1108 btrfs_release_path(root, path);
1109 btrfs_free_path(path);
1110 inode->i_sb->s_dirt = 1;
1111 return ret;
1112 }
1113
1114 static int btrfs_cow_one_page(struct inode *inode, struct page *page,
1115 size_t zero_start)
1116 {
1117 char *kaddr;
1118 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1119 u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
1120 u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
1121 int ret = 0;
1122
1123 WARN_ON(!PageLocked(page));
1124 set_page_extent_mapped(page);
1125
1126 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
1127 set_extent_delalloc(&BTRFS_I(inode)->io_tree, page_start,
1128 page_end, GFP_NOFS);
1129
1130 if (zero_start != PAGE_CACHE_SIZE) {
1131 kaddr = kmap(page);
1132 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
1133 flush_dcache_page(page);
1134 kunmap(page);
1135 }
1136 set_page_dirty(page);
1137 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
1138
1139 return ret;
1140 }
1141
1142 /*
1143 * taken from block_truncate_page, but does cow as it zeros out
1144 * any bytes left in the last page in the file.
1145 */
1146 static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
1147 {
1148 struct inode *inode = mapping->host;
1149 struct btrfs_root *root = BTRFS_I(inode)->root;
1150 u32 blocksize = root->sectorsize;
1151 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1152 unsigned offset = from & (PAGE_CACHE_SIZE-1);
1153 struct page *page;
1154 int ret = 0;
1155 u64 page_start;
1156
1157 if ((offset & (blocksize - 1)) == 0)
1158 goto out;
1159
1160 ret = -ENOMEM;
1161 page = grab_cache_page(mapping, index);
1162 if (!page)
1163 goto out;
1164 if (!PageUptodate(page)) {
1165 ret = btrfs_readpage(NULL, page);
1166 lock_page(page);
1167 if (!PageUptodate(page)) {
1168 ret = -EIO;
1169 goto out;
1170 }
1171 }
1172 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
1173
1174 ret = btrfs_cow_one_page(inode, page, offset);
1175
1176 unlock_page(page);
1177 page_cache_release(page);
1178 out:
1179 return ret;
1180 }
1181
1182 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
1183 {
1184 struct inode *inode = dentry->d_inode;
1185 int err;
1186
1187 err = inode_change_ok(inode, attr);
1188 if (err)
1189 return err;
1190
1191 if (S_ISREG(inode->i_mode) &&
1192 attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
1193 struct btrfs_trans_handle *trans;
1194 struct btrfs_root *root = BTRFS_I(inode)->root;
1195 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1196
1197 u64 mask = root->sectorsize - 1;
1198 u64 hole_start = (inode->i_size + mask) & ~mask;
1199 u64 block_end = (attr->ia_size + mask) & ~mask;
1200 u64 hole_size;
1201 u64 alloc_hint = 0;
1202
1203 if (attr->ia_size <= hole_start)
1204 goto out;
1205
1206 mutex_lock(&root->fs_info->fs_mutex);
1207 err = btrfs_check_free_space(root, 1, 0);
1208 mutex_unlock(&root->fs_info->fs_mutex);
1209 if (err)
1210 goto fail;
1211
1212 btrfs_truncate_page(inode->i_mapping, inode->i_size);
1213
1214 lock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
1215 hole_size = block_end - hole_start;
1216
1217 mutex_lock(&root->fs_info->fs_mutex);
1218 trans = btrfs_start_transaction(root, 1);
1219 btrfs_set_trans_block_group(trans, inode);
1220 err = btrfs_drop_extents(trans, root, inode,
1221 hole_start, block_end, hole_start,
1222 &alloc_hint);
1223
1224 if (alloc_hint != EXTENT_MAP_INLINE) {
1225 err = btrfs_insert_file_extent(trans, root,
1226 inode->i_ino,
1227 hole_start, 0, 0,
1228 hole_size);
1229 btrfs_drop_extent_cache(inode, hole_start,
1230 (u64)-1);
1231 btrfs_check_file(root, inode);
1232 }
1233 btrfs_end_transaction(trans, root);
1234 mutex_unlock(&root->fs_info->fs_mutex);
1235 unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
1236 if (err)
1237 return err;
1238 }
1239 out:
1240 err = inode_setattr(inode, attr);
1241 fail:
1242 return err;
1243 }
1244
1245 void btrfs_put_inode(struct inode *inode)
1246 {
1247 int ret;
1248
1249 if (!BTRFS_I(inode)->ordered_trans) {
1250 return;
1251 }
1252
1253 if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY) ||
1254 mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK))
1255 return;
1256
1257 ret = btrfs_del_ordered_inode(inode);
1258 if (ret == 1) {
1259 atomic_dec(&inode->i_count);
1260 }
1261 }
1262
1263 void btrfs_delete_inode(struct inode *inode)
1264 {
1265 struct btrfs_trans_handle *trans;
1266 struct btrfs_root *root = BTRFS_I(inode)->root;
1267 unsigned long nr;
1268 int ret;
1269
1270 truncate_inode_pages(&inode->i_data, 0);
1271 if (is_bad_inode(inode)) {
1272 goto no_delete;
1273 }
1274
1275 inode->i_size = 0;
1276 mutex_lock(&root->fs_info->fs_mutex);
1277 trans = btrfs_start_transaction(root, 1);
1278
1279 btrfs_set_trans_block_group(trans, inode);
1280 ret = btrfs_truncate_in_trans(trans, root, inode, 0);
1281 if (ret)
1282 goto no_delete_lock;
1283
1284 nr = trans->blocks_used;
1285 clear_inode(inode);
1286
1287 btrfs_end_transaction(trans, root);
1288 mutex_unlock(&root->fs_info->fs_mutex);
1289 btrfs_btree_balance_dirty(root, nr);
1290 btrfs_throttle(root);
1291 return;
1292
1293 no_delete_lock:
1294 nr = trans->blocks_used;
1295 btrfs_end_transaction(trans, root);
1296 mutex_unlock(&root->fs_info->fs_mutex);
1297 btrfs_btree_balance_dirty(root, nr);
1298 btrfs_throttle(root);
1299 no_delete:
1300 clear_inode(inode);
1301 }
1302
1303 /*
1304 * this returns the key found in the dir entry in the location pointer.
1305 * If no dir entries were found, location->objectid is 0.
1306 */
1307 static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
1308 struct btrfs_key *location)
1309 {
1310 const char *name = dentry->d_name.name;
1311 int namelen = dentry->d_name.len;
1312 struct btrfs_dir_item *di;
1313 struct btrfs_path *path;
1314 struct btrfs_root *root = BTRFS_I(dir)->root;
1315 int ret = 0;
1316
1317 if (namelen == 1 && strcmp(name, ".") == 0) {
1318 location->objectid = dir->i_ino;
1319 location->type = BTRFS_INODE_ITEM_KEY;
1320 location->offset = 0;
1321 return 0;
1322 }
1323 path = btrfs_alloc_path();
1324 BUG_ON(!path);
1325
1326 if (namelen == 2 && strcmp(name, "..") == 0) {
1327 struct btrfs_key key;
1328 struct extent_buffer *leaf;
1329 u32 nritems;
1330 int slot;
1331
1332 key.objectid = dir->i_ino;
1333 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
1334 key.offset = 0;
1335 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1336 BUG_ON(ret == 0);
1337 ret = 0;
1338
1339 leaf = path->nodes[0];
1340 slot = path->slots[0];
1341 nritems = btrfs_header_nritems(leaf);
1342 if (slot >= nritems)
1343 goto out_err;
1344
1345 btrfs_item_key_to_cpu(leaf, &key, slot);
1346 if (key.objectid != dir->i_ino ||
1347 key.type != BTRFS_INODE_REF_KEY) {
1348 goto out_err;
1349 }
1350 location->objectid = key.offset;
1351 location->type = BTRFS_INODE_ITEM_KEY;
1352 location->offset = 0;
1353 goto out;
1354 }
1355
1356 di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
1357 namelen, 0);
1358 if (IS_ERR(di))
1359 ret = PTR_ERR(di);
1360 if (!di || IS_ERR(di)) {
1361 goto out_err;
1362 }
1363 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
1364 out:
1365 btrfs_free_path(path);
1366 return ret;
1367 out_err:
1368 location->objectid = 0;
1369 goto out;
1370 }
1371
1372 /*
1373 * when we hit a tree root in a directory, the btrfs part of the inode
1374 * needs to be changed to reflect the root directory of the tree root. This
1375 * is kind of like crossing a mount point.
1376 */
1377 static int fixup_tree_root_location(struct btrfs_root *root,
1378 struct btrfs_key *location,
1379 struct btrfs_root **sub_root,
1380 struct dentry *dentry)
1381 {
1382 struct btrfs_path *path;
1383 struct btrfs_root_item *ri;
1384
1385 if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
1386 return 0;
1387 if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1388 return 0;
1389
1390 path = btrfs_alloc_path();
1391 BUG_ON(!path);
1392 mutex_lock(&root->fs_info->fs_mutex);
1393
1394 *sub_root = btrfs_read_fs_root(root->fs_info, location,
1395 dentry->d_name.name,
1396 dentry->d_name.len);
1397 if (IS_ERR(*sub_root))
1398 return PTR_ERR(*sub_root);
1399
1400 ri = &(*sub_root)->root_item;
1401 location->objectid = btrfs_root_dirid(ri);
1402 btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
1403 location->offset = 0;
1404
1405 btrfs_free_path(path);
1406 mutex_unlock(&root->fs_info->fs_mutex);
1407 return 0;
1408 }
1409
1410 static int btrfs_init_locked_inode(struct inode *inode, void *p)
1411 {
1412 struct btrfs_iget_args *args = p;
1413 inode->i_ino = args->ino;
1414 BTRFS_I(inode)->root = args->root;
1415 BTRFS_I(inode)->delalloc_bytes = 0;
1416 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1417 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1418 inode->i_mapping, GFP_NOFS);
1419 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1420 inode->i_mapping, GFP_NOFS);
1421 return 0;
1422 }
1423
1424 static int btrfs_find_actor(struct inode *inode, void *opaque)
1425 {
1426 struct btrfs_iget_args *args = opaque;
1427 return (args->ino == inode->i_ino &&
1428 args->root == BTRFS_I(inode)->root);
1429 }
1430
1431 struct inode *btrfs_ilookup(struct super_block *s, u64 objectid,
1432 u64 root_objectid)
1433 {
1434 struct btrfs_iget_args args;
1435 args.ino = objectid;
1436 args.root = btrfs_lookup_fs_root(btrfs_sb(s)->fs_info, root_objectid);
1437
1438 if (!args.root)
1439 return NULL;
1440
1441 return ilookup5(s, objectid, btrfs_find_actor, (void *)&args);
1442 }
1443
1444 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
1445 struct btrfs_root *root)
1446 {
1447 struct inode *inode;
1448 struct btrfs_iget_args args;
1449 args.ino = objectid;
1450 args.root = root;
1451
1452 inode = iget5_locked(s, objectid, btrfs_find_actor,
1453 btrfs_init_locked_inode,
1454 (void *)&args);
1455 return inode;
1456 }
1457
1458 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
1459 struct nameidata *nd)
1460 {
1461 struct inode * inode;
1462 struct btrfs_inode *bi = BTRFS_I(dir);
1463 struct btrfs_root *root = bi->root;
1464 struct btrfs_root *sub_root = root;
1465 struct btrfs_key location;
1466 int ret;
1467
1468 if (dentry->d_name.len > BTRFS_NAME_LEN)
1469 return ERR_PTR(-ENAMETOOLONG);
1470
1471 mutex_lock(&root->fs_info->fs_mutex);
1472 ret = btrfs_inode_by_name(dir, dentry, &location);
1473 mutex_unlock(&root->fs_info->fs_mutex);
1474
1475 if (ret < 0)
1476 return ERR_PTR(ret);
1477
1478 inode = NULL;
1479 if (location.objectid) {
1480 ret = fixup_tree_root_location(root, &location, &sub_root,
1481 dentry);
1482 if (ret < 0)
1483 return ERR_PTR(ret);
1484 if (ret > 0)
1485 return ERR_PTR(-ENOENT);
1486 inode = btrfs_iget_locked(dir->i_sb, location.objectid,
1487 sub_root);
1488 if (!inode)
1489 return ERR_PTR(-EACCES);
1490 if (inode->i_state & I_NEW) {
1491 /* the inode and parent dir are two different roots */
1492 if (sub_root != root) {
1493 igrab(inode);
1494 sub_root->inode = inode;
1495 }
1496 BTRFS_I(inode)->root = sub_root;
1497 memcpy(&BTRFS_I(inode)->location, &location,
1498 sizeof(location));
1499 btrfs_read_locked_inode(inode);
1500 unlock_new_inode(inode);
1501 }
1502 }
1503 return d_splice_alias(inode, dentry);
1504 }
1505
1506 static unsigned char btrfs_filetype_table[] = {
1507 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
1508 };
1509
1510 static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
1511 {
1512 struct inode *inode = filp->f_dentry->d_inode;
1513 struct btrfs_root *root = BTRFS_I(inode)->root;
1514 struct btrfs_item *item;
1515 struct btrfs_dir_item *di;
1516 struct btrfs_key key;
1517 struct btrfs_key found_key;
1518 struct btrfs_path *path;
1519 int ret;
1520 u32 nritems;
1521 struct extent_buffer *leaf;
1522 int slot;
1523 int advance;
1524 unsigned char d_type;
1525 int over = 0;
1526 u32 di_cur;
1527 u32 di_total;
1528 u32 di_len;
1529 int key_type = BTRFS_DIR_INDEX_KEY;
1530 char tmp_name[32];
1531 char *name_ptr;
1532 int name_len;
1533
1534 /* FIXME, use a real flag for deciding about the key type */
1535 if (root->fs_info->tree_root == root)
1536 key_type = BTRFS_DIR_ITEM_KEY;
1537
1538 /* special case for "." */
1539 if (filp->f_pos == 0) {
1540 over = filldir(dirent, ".", 1,
1541 1, inode->i_ino,
1542 DT_DIR);
1543 if (over)
1544 return 0;
1545 filp->f_pos = 1;
1546 }
1547
1548 mutex_lock(&root->fs_info->fs_mutex);
1549 key.objectid = inode->i_ino;
1550 path = btrfs_alloc_path();
1551 path->reada = 2;
1552
1553 /* special case for .., just use the back ref */
1554 if (filp->f_pos == 1) {
1555 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
1556 key.offset = 0;
1557 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1558 BUG_ON(ret == 0);
1559 leaf = path->nodes[0];
1560 slot = path->slots[0];
1561 nritems = btrfs_header_nritems(leaf);
1562 if (slot >= nritems) {
1563 btrfs_release_path(root, path);
1564 goto read_dir_items;
1565 }
1566 btrfs_item_key_to_cpu(leaf, &found_key, slot);
1567 btrfs_release_path(root, path);
1568 if (found_key.objectid != key.objectid ||
1569 found_key.type != BTRFS_INODE_REF_KEY)
1570 goto read_dir_items;
1571 over = filldir(dirent, "..", 2,
1572 2, found_key.offset, DT_DIR);
1573 if (over)
1574 goto nopos;
1575 filp->f_pos = 2;
1576 }
1577
1578 read_dir_items:
1579 btrfs_set_key_type(&key, key_type);
1580 key.offset = filp->f_pos;
1581
1582 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1583 if (ret < 0)
1584 goto err;
1585 advance = 0;
1586 while(1) {
1587 leaf = path->nodes[0];
1588 nritems = btrfs_header_nritems(leaf);
1589 slot = path->slots[0];
1590 if (advance || slot >= nritems) {
1591 if (slot >= nritems -1) {
1592 ret = btrfs_next_leaf(root, path);
1593 if (ret)
1594 break;
1595 leaf = path->nodes[0];
1596 nritems = btrfs_header_nritems(leaf);
1597 slot = path->slots[0];
1598 } else {
1599 slot++;
1600 path->slots[0]++;
1601 }
1602 }
1603 advance = 1;
1604 item = btrfs_item_nr(leaf, slot);
1605 btrfs_item_key_to_cpu(leaf, &found_key, slot);
1606
1607 if (found_key.objectid != key.objectid)
1608 break;
1609 if (btrfs_key_type(&found_key) != key_type)
1610 break;
1611 if (found_key.offset < filp->f_pos)
1612 continue;
1613
1614 filp->f_pos = found_key.offset;
1615 advance = 1;
1616 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
1617 di_cur = 0;
1618 di_total = btrfs_item_size(leaf, item);
1619 while(di_cur < di_total) {
1620 struct btrfs_key location;
1621
1622 name_len = btrfs_dir_name_len(leaf, di);
1623 if (name_len < 32) {
1624 name_ptr = tmp_name;
1625 } else {
1626 name_ptr = kmalloc(name_len, GFP_NOFS);
1627 BUG_ON(!name_ptr);
1628 }
1629 read_extent_buffer(leaf, name_ptr,
1630 (unsigned long)(di + 1), name_len);
1631
1632 d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
1633 btrfs_dir_item_key_to_cpu(leaf, di, &location);
1634 over = filldir(dirent, name_ptr, name_len,
1635 found_key.offset,
1636 location.objectid,
1637 d_type);
1638
1639 if (name_ptr != tmp_name)
1640 kfree(name_ptr);
1641
1642 if (over)
1643 goto nopos;
1644 di_len = btrfs_dir_name_len(leaf, di) +
1645 btrfs_dir_data_len(leaf, di) +sizeof(*di);
1646 di_cur += di_len;
1647 di = (struct btrfs_dir_item *)((char *)di + di_len);
1648 }
1649 }
1650 if (key_type == BTRFS_DIR_INDEX_KEY)
1651 filp->f_pos = INT_LIMIT(typeof(filp->f_pos));
1652 else
1653 filp->f_pos++;
1654 nopos:
1655 ret = 0;
1656 err:
1657 btrfs_release_path(root, path);
1658 btrfs_free_path(path);
1659 mutex_unlock(&root->fs_info->fs_mutex);
1660 return ret;
1661 }
1662
1663 int btrfs_write_inode(struct inode *inode, int wait)
1664 {
1665 struct btrfs_root *root = BTRFS_I(inode)->root;
1666 struct btrfs_trans_handle *trans;
1667 int ret = 0;
1668
1669 if (wait) {
1670 mutex_lock(&root->fs_info->fs_mutex);
1671 trans = btrfs_start_transaction(root, 1);
1672 btrfs_set_trans_block_group(trans, inode);
1673 ret = btrfs_commit_transaction(trans, root);
1674 mutex_unlock(&root->fs_info->fs_mutex);
1675 }
1676 return ret;
1677 }
1678
1679 /*
1680 * This is somewhat expensive, updating the tree every time the
1681 * inode changes. But, it is most likely to find the inode in cache.
1682 * FIXME, needs more benchmarking...there are no reasons other than performance
1683 * to keep or drop this code.
1684 */
1685 void btrfs_dirty_inode(struct inode *inode)
1686 {
1687 struct btrfs_root *root = BTRFS_I(inode)->root;
1688 struct btrfs_trans_handle *trans;
1689
1690 mutex_lock(&root->fs_info->fs_mutex);
1691 trans = btrfs_start_transaction(root, 1);
1692 btrfs_set_trans_block_group(trans, inode);
1693 btrfs_update_inode(trans, root, inode);
1694 btrfs_end_transaction(trans, root);
1695 mutex_unlock(&root->fs_info->fs_mutex);
1696 }
1697
1698 static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
1699 struct btrfs_root *root,
1700 const char *name, int name_len,
1701 u64 ref_objectid,
1702 u64 objectid,
1703 struct btrfs_block_group_cache *group,
1704 int mode)
1705 {
1706 struct inode *inode;
1707 struct btrfs_inode_item *inode_item;
1708 struct btrfs_block_group_cache *new_inode_group;
1709 struct btrfs_key *location;
1710 struct btrfs_path *path;
1711 struct btrfs_inode_ref *ref;
1712 struct btrfs_key key[2];
1713 u32 sizes[2];
1714 unsigned long ptr;
1715 int ret;
1716 int owner;
1717
1718 path = btrfs_alloc_path();
1719 BUG_ON(!path);
1720
1721 inode = new_inode(root->fs_info->sb);
1722 if (!inode)
1723 return ERR_PTR(-ENOMEM);
1724
1725 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1726 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1727 inode->i_mapping, GFP_NOFS);
1728 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1729 inode->i_mapping, GFP_NOFS);
1730 BTRFS_I(inode)->delalloc_bytes = 0;
1731 BTRFS_I(inode)->root = root;
1732
1733 if (mode & S_IFDIR)
1734 owner = 0;
1735 else
1736 owner = 1;
1737 new_inode_group = btrfs_find_block_group(root, group, 0,
1738 BTRFS_BLOCK_GROUP_METADATA, owner);
1739 if (!new_inode_group) {
1740 printk("find_block group failed\n");
1741 new_inode_group = group;
1742 }
1743 BTRFS_I(inode)->block_group = new_inode_group;
1744 BTRFS_I(inode)->flags = 0;
1745
1746 key[0].objectid = objectid;
1747 btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
1748 key[0].offset = 0;
1749
1750 key[1].objectid = objectid;
1751 btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
1752 key[1].offset = ref_objectid;
1753
1754 sizes[0] = sizeof(struct btrfs_inode_item);
1755 sizes[1] = name_len + sizeof(*ref);
1756
1757 ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
1758 if (ret != 0)
1759 goto fail;
1760
1761 if (objectid > root->highest_inode)
1762 root->highest_inode = objectid;
1763
1764 inode->i_uid = current->fsuid;
1765 inode->i_gid = current->fsgid;
1766 inode->i_mode = mode;
1767 inode->i_ino = objectid;
1768 inode->i_blocks = 0;
1769 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1770 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1771 struct btrfs_inode_item);
1772 fill_inode_item(path->nodes[0], inode_item, inode);
1773
1774 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
1775 struct btrfs_inode_ref);
1776 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
1777 ptr = (unsigned long)(ref + 1);
1778 write_extent_buffer(path->nodes[0], name, ptr, name_len);
1779
1780 btrfs_mark_buffer_dirty(path->nodes[0]);
1781 btrfs_free_path(path);
1782
1783 location = &BTRFS_I(inode)->location;
1784 location->objectid = objectid;
1785 location->offset = 0;
1786 btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
1787
1788 insert_inode_hash(inode);
1789 return inode;
1790 fail:
1791 btrfs_free_path(path);
1792 return ERR_PTR(ret);
1793 }
1794
1795 static inline u8 btrfs_inode_type(struct inode *inode)
1796 {
1797 return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
1798 }
1799
1800 static int btrfs_add_link(struct btrfs_trans_handle *trans,
1801 struct dentry *dentry, struct inode *inode,
1802 int add_backref)
1803 {
1804 int ret;
1805 struct btrfs_key key;
1806 struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
1807 struct inode *parent_inode;
1808
1809 key.objectid = inode->i_ino;
1810 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
1811 key.offset = 0;
1812
1813 ret = btrfs_insert_dir_item(trans, root,
1814 dentry->d_name.name, dentry->d_name.len,
1815 dentry->d_parent->d_inode->i_ino,
1816 &key, btrfs_inode_type(inode));
1817 if (ret == 0) {
1818 if (add_backref) {
1819 ret = btrfs_insert_inode_ref(trans, root,
1820 dentry->d_name.name,
1821 dentry->d_name.len,
1822 inode->i_ino,
1823 dentry->d_parent->d_inode->i_ino);
1824 }
1825 parent_inode = dentry->d_parent->d_inode;
1826 parent_inode->i_size += dentry->d_name.len * 2;
1827 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
1828 ret = btrfs_update_inode(trans, root,
1829 dentry->d_parent->d_inode);
1830 }
1831 return ret;
1832 }
1833
1834 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
1835 struct dentry *dentry, struct inode *inode,
1836 int backref)
1837 {
1838 int err = btrfs_add_link(trans, dentry, inode, backref);
1839 if (!err) {
1840 d_instantiate(dentry, inode);
1841 return 0;
1842 }
1843 if (err > 0)
1844 err = -EEXIST;
1845 return err;
1846 }
1847
1848 static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
1849 int mode, dev_t rdev)
1850 {
1851 struct btrfs_trans_handle *trans;
1852 struct btrfs_root *root = BTRFS_I(dir)->root;
1853 struct inode *inode = NULL;
1854 int err;
1855 int drop_inode = 0;
1856 u64 objectid;
1857 unsigned long nr = 0;
1858
1859 if (!new_valid_dev(rdev))
1860 return -EINVAL;
1861
1862 mutex_lock(&root->fs_info->fs_mutex);
1863 err = btrfs_check_free_space(root, 1, 0);
1864 if (err)
1865 goto fail;
1866
1867 trans = btrfs_start_transaction(root, 1);
1868 btrfs_set_trans_block_group(trans, dir);
1869
1870 err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
1871 if (err) {
1872 err = -ENOSPC;
1873 goto out_unlock;
1874 }
1875
1876 inode = btrfs_new_inode(trans, root, dentry->d_name.name,
1877 dentry->d_name.len,
1878 dentry->d_parent->d_inode->i_ino, objectid,
1879 BTRFS_I(dir)->block_group, mode);
1880 err = PTR_ERR(inode);
1881 if (IS_ERR(inode))
1882 goto out_unlock;
1883
1884 btrfs_set_trans_block_group(trans, inode);
1885 err = btrfs_add_nondir(trans, dentry, inode, 0);
1886 if (err)
1887 drop_inode = 1;
1888 else {
1889 inode->i_op = &btrfs_special_inode_operations;
1890 init_special_inode(inode, inode->i_mode, rdev);
1891 btrfs_update_inode(trans, root, inode);
1892 }
1893 dir->i_sb->s_dirt = 1;
1894 btrfs_update_inode_block_group(trans, inode);
1895 btrfs_update_inode_block_group(trans, dir);
1896 out_unlock:
1897 nr = trans->blocks_used;
1898 btrfs_end_transaction(trans, root);
1899 fail:
1900 mutex_unlock(&root->fs_info->fs_mutex);
1901
1902 if (drop_inode) {
1903 inode_dec_link_count(inode);
1904 iput(inode);
1905 }
1906 btrfs_btree_balance_dirty(root, nr);
1907 btrfs_throttle(root);
1908 return err;
1909 }
1910
1911 static int btrfs_create(struct inode *dir, struct dentry *dentry,
1912 int mode, struct nameidata *nd)
1913 {
1914 struct btrfs_trans_handle *trans;
1915 struct btrfs_root *root = BTRFS_I(dir)->root;
1916 struct inode *inode = NULL;
1917 int err;
1918 int drop_inode = 0;
1919 unsigned long nr = 0;
1920 u64 objectid;
1921
1922 mutex_lock(&root->fs_info->fs_mutex);
1923 err = btrfs_check_free_space(root, 1, 0);
1924 if (err)
1925 goto fail;
1926 trans = btrfs_start_transaction(root, 1);
1927 btrfs_set_trans_block_group(trans, dir);
1928
1929 err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
1930 if (err) {
1931 err = -ENOSPC;
1932 goto out_unlock;
1933 }
1934
1935 inode = btrfs_new_inode(trans, root, dentry->d_name.name,
1936 dentry->d_name.len,
1937 dentry->d_parent->d_inode->i_ino,
1938 objectid, BTRFS_I(dir)->block_group, mode);
1939 err = PTR_ERR(inode);
1940 if (IS_ERR(inode))
1941 goto out_unlock;
1942
1943 btrfs_set_trans_block_group(trans, inode);
1944 err = btrfs_add_nondir(trans, dentry, inode, 0);
1945 if (err)
1946 drop_inode = 1;
1947 else {
1948 inode->i_mapping->a_ops = &btrfs_aops;
1949 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
1950 inode->i_fop = &btrfs_file_operations;
1951 inode->i_op = &btrfs_file_inode_operations;
1952 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
1953 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
1954 inode->i_mapping, GFP_NOFS);
1955 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
1956 inode->i_mapping, GFP_NOFS);
1957 BTRFS_I(inode)->delalloc_bytes = 0;
1958 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
1959 }
1960 dir->i_sb->s_dirt = 1;
1961 btrfs_update_inode_block_group(trans, inode);
1962 btrfs_update_inode_block_group(trans, dir);
1963 out_unlock:
1964 nr = trans->blocks_used;
1965 btrfs_end_transaction(trans, root);
1966 fail:
1967 mutex_unlock(&root->fs_info->fs_mutex);
1968
1969 if (drop_inode) {
1970 inode_dec_link_count(inode);
1971 iput(inode);
1972 }
1973 btrfs_btree_balance_dirty(root, nr);
1974 btrfs_throttle(root);
1975 return err;
1976 }
1977
1978 static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
1979 struct dentry *dentry)
1980 {
1981 struct btrfs_trans_handle *trans;
1982 struct btrfs_root *root = BTRFS_I(dir)->root;
1983 struct inode *inode = old_dentry->d_inode;
1984 unsigned long nr = 0;
1985 int err;
1986 int drop_inode = 0;
1987
1988 if (inode->i_nlink == 0)
1989 return -ENOENT;
1990
1991 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
1992 inode->i_nlink++;
1993 #else
1994 inc_nlink(inode);
1995 #endif
1996 mutex_lock(&root->fs_info->fs_mutex);
1997 err = btrfs_check_free_space(root, 1, 0);
1998 if (err)
1999 goto fail;
2000 trans = btrfs_start_transaction(root, 1);
2001
2002 btrfs_set_trans_block_group(trans, dir);
2003 atomic_inc(&inode->i_count);
2004 err = btrfs_add_nondir(trans, dentry, inode, 1);
2005
2006 if (err)
2007 drop_inode = 1;
2008
2009 dir->i_sb->s_dirt = 1;
2010 btrfs_update_inode_block_group(trans, dir);
2011 err = btrfs_update_inode(trans, root, inode);
2012
2013 if (err)
2014 drop_inode = 1;
2015
2016 nr = trans->blocks_used;
2017 btrfs_end_transaction(trans, root);
2018 fail:
2019 mutex_unlock(&root->fs_info->fs_mutex);
2020
2021 if (drop_inode) {
2022 inode_dec_link_count(inode);
2023 iput(inode);
2024 }
2025 btrfs_btree_balance_dirty(root, nr);
2026 btrfs_throttle(root);
2027 return err;
2028 }
2029
2030 static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2031 {
2032 struct inode *inode;
2033 struct btrfs_trans_handle *trans;
2034 struct btrfs_root *root = BTRFS_I(dir)->root;
2035 int err = 0;
2036 int drop_on_err = 0;
2037 u64 objectid;
2038 unsigned long nr = 1;
2039
2040 mutex_lock(&root->fs_info->fs_mutex);
2041 err = btrfs_check_free_space(root, 1, 0);
2042 if (err)
2043 goto out_unlock;
2044
2045 trans = btrfs_start_transaction(root, 1);
2046 btrfs_set_trans_block_group(trans, dir);
2047
2048 if (IS_ERR(trans)) {
2049 err = PTR_ERR(trans);
2050 goto out_unlock;
2051 }
2052
2053 err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
2054 if (err) {
2055 err = -ENOSPC;
2056 goto out_unlock;
2057 }
2058
2059 inode = btrfs_new_inode(trans, root, dentry->d_name.name,
2060 dentry->d_name.len,
2061 dentry->d_parent->d_inode->i_ino, objectid,
2062 BTRFS_I(dir)->block_group, S_IFDIR | mode);
2063 if (IS_ERR(inode)) {
2064 err = PTR_ERR(inode);
2065 goto out_fail;
2066 }
2067
2068 drop_on_err = 1;
2069 inode->i_op = &btrfs_dir_inode_operations;
2070 inode->i_fop = &btrfs_dir_file_operations;
2071 btrfs_set_trans_block_group(trans, inode);
2072
2073 inode->i_size = 0;
2074 err = btrfs_update_inode(trans, root, inode);
2075 if (err)
2076 goto out_fail;
2077
2078 err = btrfs_add_link(trans, dentry, inode, 0);
2079 if (err)
2080 goto out_fail;
2081
2082 d_instantiate(dentry, inode);
2083 drop_on_err = 0;
2084 dir->i_sb->s_dirt = 1;
2085 btrfs_update_inode_block_group(trans, inode);
2086 btrfs_update_inode_block_group(trans, dir);
2087
2088 out_fail:
2089 nr = trans->blocks_used;
2090 btrfs_end_transaction(trans, root);
2091
2092 out_unlock:
2093 mutex_unlock(&root->fs_info->fs_mutex);
2094 if (drop_on_err)
2095 iput(inode);
2096 btrfs_btree_balance_dirty(root, nr);
2097 btrfs_throttle(root);
2098 return err;
2099 }
2100
2101 static int merge_extent_mapping(struct extent_map_tree *em_tree,
2102 struct extent_map *existing,
2103 struct extent_map *em)
2104 {
2105 u64 start_diff;
2106 u64 new_end;
2107 int ret = 0;
2108 int real_blocks = existing->block_start < EXTENT_MAP_LAST_BYTE;
2109
2110 if (real_blocks && em->block_start >= EXTENT_MAP_LAST_BYTE)
2111 goto invalid;
2112
2113 if (!real_blocks && em->block_start != existing->block_start)
2114 goto invalid;
2115
2116 new_end = max(existing->start + existing->len, em->start + em->len);
2117
2118 if (existing->start >= em->start) {
2119 if (em->start + em->len < existing->start)
2120 goto invalid;
2121
2122 start_diff = existing->start - em->start;
2123 if (real_blocks && em->block_start + start_diff !=
2124 existing->block_start)
2125 goto invalid;
2126
2127 em->len = new_end - em->start;
2128
2129 remove_extent_mapping(em_tree, existing);
2130 /* free for the tree */
2131 free_extent_map(existing);
2132 ret = add_extent_mapping(em_tree, em);
2133
2134 } else if (em->start > existing->start) {
2135
2136 if (existing->start + existing->len < em->start)
2137 goto invalid;
2138
2139 start_diff = em->start - existing->start;
2140 if (real_blocks && existing->block_start + start_diff !=
2141 em->block_start)
2142 goto invalid;
2143
2144 remove_extent_mapping(em_tree, existing);
2145 em->block_start = existing->block_start;
2146 em->start = existing->start;
2147 em->len = new_end - existing->start;
2148 free_extent_map(existing);
2149
2150 ret = add_extent_mapping(em_tree, em);
2151 } else {
2152 goto invalid;
2153 }
2154 return ret;
2155
2156 invalid:
2157 printk("invalid extent map merge [%Lu %Lu %Lu] [%Lu %Lu %Lu]\n",
2158 existing->start, existing->len, existing->block_start,
2159 em->start, em->len, em->block_start);
2160 return -EIO;
2161 }
2162
2163 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
2164 size_t pg_offset, u64 start, u64 len,
2165 int create)
2166 {
2167 int ret;
2168 int err = 0;
2169 u64 bytenr;
2170 u64 extent_start = 0;
2171 u64 extent_end = 0;
2172 u64 objectid = inode->i_ino;
2173 u32 found_type;
2174 struct btrfs_path *path;
2175 struct btrfs_root *root = BTRFS_I(inode)->root;
2176 struct btrfs_file_extent_item *item;
2177 struct extent_buffer *leaf;
2178 struct btrfs_key found_key;
2179 struct extent_map *em = NULL;
2180 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
2181 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2182 struct btrfs_trans_handle *trans = NULL;
2183
2184 path = btrfs_alloc_path();
2185 BUG_ON(!path);
2186 mutex_lock(&root->fs_info->fs_mutex);
2187
2188 again:
2189 spin_lock(&em_tree->lock);
2190 em = lookup_extent_mapping(em_tree, start, len);
2191 spin_unlock(&em_tree->lock);
2192
2193 if (em) {
2194 if (em->start > start) {
2195 printk("get_extent lookup [%Lu %Lu] em [%Lu %Lu]\n",
2196 start, len, em->start, em->len);
2197 WARN_ON(1);
2198 }
2199 if (em->block_start == EXTENT_MAP_INLINE && page)
2200 free_extent_map(em);
2201 else
2202 goto out;
2203 }
2204 em = alloc_extent_map(GFP_NOFS);
2205 if (!em) {
2206 err = -ENOMEM;
2207 goto out;
2208 }
2209
2210 em->start = EXTENT_MAP_HOLE;
2211 em->len = (u64)-1;
2212 em->bdev = inode->i_sb->s_bdev;
2213 ret = btrfs_lookup_file_extent(trans, root, path,
2214 objectid, start, trans != NULL);
2215 if (ret < 0) {
2216 err = ret;
2217 goto out;
2218 }
2219
2220 if (ret != 0) {
2221 if (path->slots[0] == 0)
2222 goto not_found;
2223 path->slots[0]--;
2224 }
2225
2226 leaf = path->nodes[0];
2227 item = btrfs_item_ptr(leaf, path->slots[0],
2228 struct btrfs_file_extent_item);
2229 /* are we inside the extent that was found? */
2230 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2231 found_type = btrfs_key_type(&found_key);
2232 if (found_key.objectid != objectid ||
2233 found_type != BTRFS_EXTENT_DATA_KEY) {
2234 goto not_found;
2235 }
2236
2237 found_type = btrfs_file_extent_type(leaf, item);
2238 extent_start = found_key.offset;
2239 if (found_type == BTRFS_FILE_EXTENT_REG) {
2240 extent_end = extent_start +
2241 btrfs_file_extent_num_bytes(leaf, item);
2242 err = 0;
2243 if (start < extent_start || start >= extent_end) {
2244 em->start = start;
2245 if (start < extent_start) {
2246 if (start + len <= extent_start)
2247 goto not_found;
2248 em->len = extent_end - extent_start;
2249 } else {
2250 em->len = len;
2251 }
2252 goto not_found_em;
2253 }
2254 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
2255 if (bytenr == 0) {
2256 em->start = extent_start;
2257 em->len = extent_end - extent_start;
2258 em->block_start = EXTENT_MAP_HOLE;
2259 goto insert;
2260 }
2261 bytenr += btrfs_file_extent_offset(leaf, item);
2262 em->block_start = bytenr;
2263 em->start = extent_start;
2264 em->len = extent_end - extent_start;
2265 goto insert;
2266 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
2267 u64 page_start;
2268 unsigned long ptr;
2269 char *map;
2270 size_t size;
2271 size_t extent_offset;
2272 size_t copy_size;
2273
2274 size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
2275 path->slots[0]));
2276 extent_end = (extent_start + size + root->sectorsize - 1) &
2277 ~((u64)root->sectorsize - 1);
2278 if (start < extent_start || start >= extent_end) {
2279 em->start = start;
2280 if (start < extent_start) {
2281 if (start + len <= extent_start)
2282 goto not_found;
2283 em->len = extent_end - extent_start;
2284 } else {
2285 em->len = len;
2286 }
2287 goto not_found_em;
2288 }
2289 em->block_start = EXTENT_MAP_INLINE;
2290
2291 if (!page) {
2292 em->start = extent_start;
2293 em->len = size;
2294 goto out;
2295 }
2296
2297 page_start = page_offset(page) + pg_offset;
2298 extent_offset = page_start - extent_start;
2299 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
2300 size - extent_offset);
2301 em->start = extent_start + extent_offset;
2302 em->len = (copy_size + root->sectorsize - 1) &
2303 ~((u64)root->sectorsize - 1);
2304 map = kmap(page);
2305 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
2306 if (create == 0 && !PageUptodate(page)) {
2307 read_extent_buffer(leaf, map + pg_offset, ptr,
2308 copy_size);
2309 flush_dcache_page(page);
2310 } else if (create && PageUptodate(page)) {
2311 if (!trans) {
2312 kunmap(page);
2313 free_extent_map(em);
2314 em = NULL;
2315 btrfs_release_path(root, path);
2316 trans = btrfs_start_transaction(root, 1);
2317 goto again;
2318 }
2319 write_extent_buffer(leaf, map + pg_offset, ptr,
2320 copy_size);
2321 btrfs_mark_buffer_dirty(leaf);
2322 }
2323 kunmap(page);
2324 set_extent_uptodate(io_tree, em->start,
2325 extent_map_end(em) - 1, GFP_NOFS);
2326 goto insert;
2327 } else {
2328 printk("unkknown found_type %d\n", found_type);
2329 WARN_ON(1);
2330 }
2331 not_found:
2332 em->start = start;
2333 em->len = len;
2334 not_found_em:
2335 em->block_start = EXTENT_MAP_HOLE;
2336 insert:
2337 btrfs_release_path(root, path);
2338 if (em->start > start || extent_map_end(em) <= start) {
2339 printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->len, start, len);
2340 err = -EIO;
2341 goto out;
2342 }
2343
2344 err = 0;
2345 spin_lock(&em_tree->lock);
2346 ret = add_extent_mapping(em_tree, em);
2347
2348 /* it is possible that someone inserted the extent into the tree
2349 * while we had the lock dropped. It is also possible that
2350 * an overlapping map exists in the tree
2351 */
2352 if (ret == -EEXIST) {
2353 struct extent_map *existing;
2354 existing = lookup_extent_mapping(em_tree, start, len);
2355 if (!existing) {
2356 existing = lookup_extent_mapping(em_tree, em->start,
2357 em->len);
2358 if (existing) {
2359 err = merge_extent_mapping(em_tree, existing,
2360 em);
2361 free_extent_map(existing);
2362 if (err) {
2363 free_extent_map(em);
2364 em = NULL;
2365 }
2366 } else {
2367 err = -EIO;
2368 printk("failing to insert %Lu %Lu\n",
2369 start, len);
2370 free_extent_map(em);
2371 em = NULL;
2372 }
2373 } else {
2374 free_extent_map(em);
2375 em = existing;
2376 }
2377 }
2378 spin_unlock(&em_tree->lock);
2379 out:
2380 btrfs_free_path(path);
2381 if (trans) {
2382 ret = btrfs_end_transaction(trans, root);
2383 if (!err)
2384 err = ret;
2385 }
2386 mutex_unlock(&root->fs_info->fs_mutex);
2387 if (err) {
2388 free_extent_map(em);
2389 WARN_ON(1);
2390 return ERR_PTR(err);
2391 }
2392 return em;
2393 }
2394
2395 static int btrfs_get_block(struct inode *inode, sector_t iblock,
2396 struct buffer_head *bh_result, int create)
2397 {
2398 struct extent_map *em;
2399 u64 start = (u64)iblock << inode->i_blkbits;
2400 struct btrfs_multi_bio *multi = NULL;
2401 struct btrfs_root *root = BTRFS_I(inode)->root;
2402 u64 len;
2403 u64 logical;
2404 u64 map_length;
2405 int ret = 0;
2406
2407 em = btrfs_get_extent(inode, NULL, 0, start, bh_result->b_size, 0);
2408
2409 if (!em || IS_ERR(em))
2410 goto out;
2411
2412 if (em->start > start || em->start + em->len <= start)
2413 goto out;
2414
2415 if (em->block_start == EXTENT_MAP_INLINE) {
2416 ret = -EINVAL;
2417 goto out;
2418 }
2419
2420 if (em->block_start == EXTENT_MAP_HOLE ||
2421 em->block_start == EXTENT_MAP_DELALLOC) {
2422 goto out;
2423 }
2424
2425 len = em->start + em->len - start;
2426 len = min_t(u64, len, INT_LIMIT(typeof(bh_result->b_size)));
2427
2428 logical = start - em->start;
2429 logical = em->block_start + logical;
2430
2431 map_length = len;
2432 ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
2433 logical, &map_length, &multi, 0);
2434 BUG_ON(ret);
2435 bh_result->b_blocknr = multi->stripes[0].physical >> inode->i_blkbits;
2436 bh_result->b_size = min(map_length, len);
2437 bh_result->b_bdev = multi->stripes[0].dev->bdev;
2438 set_buffer_mapped(bh_result);
2439 kfree(multi);
2440 out:
2441 free_extent_map(em);
2442 return ret;
2443 }
2444
2445 static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
2446 const struct iovec *iov, loff_t offset,
2447 unsigned long nr_segs)
2448 {
2449 struct file *file = iocb->ki_filp;
2450 struct inode *inode = file->f_mapping->host;
2451
2452 if (rw == WRITE)
2453 return -EINVAL;
2454
2455 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2456 offset, nr_segs, btrfs_get_block, NULL);
2457 }
2458
2459 static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
2460 {
2461 return extent_bmap(mapping, iblock, btrfs_get_extent);
2462 }
2463
2464 int btrfs_readpage(struct file *file, struct page *page)
2465 {
2466 struct extent_io_tree *tree;
2467 tree = &BTRFS_I(page->mapping->host)->io_tree;
2468 return extent_read_full_page(tree, page, btrfs_get_extent);
2469 }
2470
2471 static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
2472 {
2473 struct extent_io_tree *tree;
2474
2475
2476 if (current->flags & PF_MEMALLOC) {
2477 redirty_page_for_writepage(wbc, page);
2478 unlock_page(page);
2479 return 0;
2480 }
2481 tree = &BTRFS_I(page->mapping->host)->io_tree;
2482 return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
2483 }
2484
2485 static int btrfs_writepages(struct address_space *mapping,
2486 struct writeback_control *wbc)
2487 {
2488 struct extent_io_tree *tree;
2489 tree = &BTRFS_I(mapping->host)->io_tree;
2490 return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
2491 }
2492
2493 static int
2494 btrfs_readpages(struct file *file, struct address_space *mapping,
2495 struct list_head *pages, unsigned nr_pages)
2496 {
2497 struct extent_io_tree *tree;
2498 tree = &BTRFS_I(mapping->host)->io_tree;
2499 return extent_readpages(tree, mapping, pages, nr_pages,
2500 btrfs_get_extent);
2501 }
2502
2503 static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
2504 {
2505 struct extent_io_tree *tree;
2506 struct extent_map_tree *map;
2507 int ret;
2508
2509 tree = &BTRFS_I(page->mapping->host)->io_tree;
2510 map = &BTRFS_I(page->mapping->host)->extent_tree;
2511 ret = try_release_extent_mapping(map, tree, page, gfp_flags);
2512 if (ret == 1) {
2513 invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
2514 ClearPagePrivate(page);
2515 set_page_private(page, 0);
2516 page_cache_release(page);
2517 }
2518 return ret;
2519 }
2520
2521 static void btrfs_invalidatepage(struct page *page, unsigned long offset)
2522 {
2523 struct extent_io_tree *tree;
2524
2525 tree = &BTRFS_I(page->mapping->host)->io_tree;
2526 extent_invalidatepage(tree, page, offset);
2527 btrfs_releasepage(page, GFP_NOFS);
2528 if (PagePrivate(page)) {
2529 invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
2530 ClearPagePrivate(page);
2531 set_page_private(page, 0);
2532 page_cache_release(page);
2533 }
2534 }
2535
2536 /*
2537 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
2538 * called from a page fault handler when a page is first dirtied. Hence we must
2539 * be careful to check for EOF conditions here. We set the page up correctly
2540 * for a written page which means we get ENOSPC checking when writing into
2541 * holes and correct delalloc and unwritten extent mapping on filesystems that
2542 * support these features.
2543 *
2544 * We are not allowed to take the i_mutex here so we have to play games to
2545 * protect against truncate races as the page could now be beyond EOF. Because
2546 * vmtruncate() writes the inode size before removing pages, once we have the
2547 * page lock we can determine safely if the page is beyond EOF. If it is not
2548 * beyond EOF, then the page is guaranteed safe against truncation until we
2549 * unlock the page.
2550 */
2551 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
2552 {
2553 struct inode *inode = fdentry(vma->vm_file)->d_inode;
2554 struct btrfs_root *root = BTRFS_I(inode)->root;
2555 unsigned long end;
2556 loff_t size;
2557 int ret;
2558 u64 page_start;
2559
2560 mutex_lock(&root->fs_info->fs_mutex);
2561 ret = btrfs_check_free_space(root, PAGE_CACHE_SIZE, 0);
2562 mutex_unlock(&root->fs_info->fs_mutex);
2563 if (ret)
2564 goto out;
2565
2566 ret = -EINVAL;
2567
2568 lock_page(page);
2569 wait_on_page_writeback(page);
2570 size = i_size_read(inode);
2571 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2572
2573 if ((page->mapping != inode->i_mapping) ||
2574 (page_start > size)) {
2575 /* page got truncated out from underneath us */
2576 goto out_unlock;
2577 }
2578
2579 /* page is wholly or partially inside EOF */
2580 if (page_start + PAGE_CACHE_SIZE > size)
2581 end = size & ~PAGE_CACHE_MASK;
2582 else
2583 end = PAGE_CACHE_SIZE;
2584
2585 ret = btrfs_cow_one_page(inode, page, end);
2586
2587 out_unlock:
2588 unlock_page(page);
2589 out:
2590 return ret;
2591 }
2592
2593 static void btrfs_truncate(struct inode *inode)
2594 {
2595 struct btrfs_root *root = BTRFS_I(inode)->root;
2596 int ret;
2597 struct btrfs_trans_handle *trans;
2598 unsigned long nr;
2599
2600 if (!S_ISREG(inode->i_mode))
2601 return;
2602 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2603 return;
2604
2605 btrfs_truncate_page(inode->i_mapping, inode->i_size);
2606
2607 mutex_lock(&root->fs_info->fs_mutex);
2608 trans = btrfs_start_transaction(root, 1);
2609 btrfs_set_trans_block_group(trans, inode);
2610
2611 /* FIXME, add redo link to tree so we don't leak on crash */
2612 ret = btrfs_truncate_in_trans(trans, root, inode,
2613 BTRFS_EXTENT_DATA_KEY);
2614 btrfs_update_inode(trans, root, inode);
2615 nr = trans->blocks_used;
2616
2617 ret = btrfs_end_transaction(trans, root);
2618 BUG_ON(ret);
2619 mutex_unlock(&root->fs_info->fs_mutex);
2620 btrfs_btree_balance_dirty(root, nr);
2621 btrfs_throttle(root);
2622 }
2623
2624 static int noinline create_subvol(struct btrfs_root *root, char *name,
2625 int namelen)
2626 {
2627 struct btrfs_trans_handle *trans;
2628 struct btrfs_key key;
2629 struct btrfs_root_item root_item;
2630 struct btrfs_inode_item *inode_item;
2631 struct extent_buffer *leaf;
2632 struct btrfs_root *new_root = root;
2633 struct inode *inode;
2634 struct inode *dir;
2635 int ret;
2636 int err;
2637 u64 objectid;
2638 u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
2639 unsigned long nr = 1;
2640
2641 mutex_lock(&root->fs_info->fs_mutex);
2642 ret = btrfs_check_free_space(root, 1, 0);
2643 if (ret)
2644 goto fail_commit;
2645
2646 trans = btrfs_start_transaction(root, 1);
2647 BUG_ON(!trans);
2648
2649 ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
2650 0, &objectid);
2651 if (ret)
2652 goto fail;
2653
2654 leaf = __btrfs_alloc_free_block(trans, root, root->leafsize,
2655 objectid, trans->transid, 0, 0,
2656 0, 0);
2657 if (IS_ERR(leaf))
2658 return PTR_ERR(leaf);
2659
2660 btrfs_set_header_nritems(leaf, 0);
2661 btrfs_set_header_level(leaf, 0);
2662 btrfs_set_header_bytenr(leaf, leaf->start);
2663 btrfs_set_header_generation(leaf, trans->transid);
2664 btrfs_set_header_owner(leaf, objectid);
2665
2666 write_extent_buffer(leaf, root->fs_info->fsid,
2667 (unsigned long)btrfs_header_fsid(leaf),
2668 BTRFS_FSID_SIZE);
2669 btrfs_mark_buffer_dirty(leaf);
2670
2671 inode_item = &root_item.inode;
2672 memset(inode_item, 0, sizeof(*inode_item));
2673 inode_item->generation = cpu_to_le64(1);
2674 inode_item->size = cpu_to_le64(3);
2675 inode_item->nlink = cpu_to_le32(1);
2676 inode_item->nblocks = cpu_to_le64(1);
2677 inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
2678
2679 btrfs_set_root_bytenr(&root_item, leaf->start);
2680 btrfs_set_root_level(&root_item, 0);
2681 btrfs_set_root_refs(&root_item, 1);
2682 btrfs_set_root_used(&root_item, 0);
2683
2684 memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress));
2685 root_item.drop_level = 0;
2686
2687 free_extent_buffer(leaf);
2688 leaf = NULL;
2689
2690 btrfs_set_root_dirid(&root_item, new_dirid);
2691
2692 key.objectid = objectid;
2693 key.offset = 1;
2694 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
2695 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
2696 &root_item);
2697 if (ret)
2698 goto fail;
2699
2700 /*
2701 * insert the directory item
2702 */
2703 key.offset = (u64)-1;
2704 dir = root->fs_info->sb->s_root->d_inode;
2705 ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
2706 name, namelen, dir->i_ino, &key,
2707 BTRFS_FT_DIR);
2708 if (ret)
2709 goto fail;
2710
2711 ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
2712 name, namelen, objectid,
2713 root->fs_info->sb->s_root->d_inode->i_ino);
2714 if (ret)
2715 goto fail;
2716
2717 ret = btrfs_commit_transaction(trans, root);
2718 if (ret)
2719 goto fail_commit;
2720
2721 new_root = btrfs_read_fs_root(root->fs_info, &key, name, namelen);
2722 BUG_ON(!new_root);
2723
2724 trans = btrfs_start_transaction(new_root, 1);
2725 BUG_ON(!trans);
2726
2727 inode = btrfs_new_inode(trans, new_root, "..", 2, new_dirid,
2728 new_dirid,
2729 BTRFS_I(dir)->block_group, S_IFDIR | 0700);
2730 if (IS_ERR(inode))
2731 goto fail;
2732 inode->i_op = &btrfs_dir_inode_operations;
2733 inode->i_fop = &btrfs_dir_file_operations;
2734 new_root->inode = inode;
2735
2736 ret = btrfs_insert_inode_ref(trans, new_root, "..", 2, new_dirid,
2737 new_dirid);
2738 inode->i_nlink = 1;
2739 inode->i_size = 0;
2740 ret = btrfs_update_inode(trans, new_root, inode);
2741 if (ret)
2742 goto fail;
2743 fail:
2744 nr = trans->blocks_used;
2745 err = btrfs_commit_transaction(trans, new_root);
2746 if (err && !ret)
2747 ret = err;
2748 fail_commit:
2749 mutex_unlock(&root->fs_info->fs_mutex);
2750 btrfs_btree_balance_dirty(root, nr);
2751 btrfs_throttle(root);
2752 return ret;
2753 }
2754
2755 static int create_snapshot(struct btrfs_root *root, char *name, int namelen)
2756 {
2757 struct btrfs_pending_snapshot *pending_snapshot;
2758 struct btrfs_trans_handle *trans;
2759 int ret;
2760 int err;
2761 unsigned long nr = 0;
2762
2763 if (!root->ref_cows)
2764 return -EINVAL;
2765
2766 mutex_lock(&root->fs_info->fs_mutex);
2767 ret = btrfs_check_free_space(root, 1, 0);
2768 if (ret)
2769 goto fail_unlock;
2770
2771 pending_snapshot = kmalloc(sizeof(*pending_snapshot), GFP_NOFS);
2772 if (!pending_snapshot) {
2773 ret = -ENOMEM;
2774 goto fail_unlock;
2775 }
2776 pending_snapshot->name = kmalloc(namelen + 1, GFP_NOFS);
2777 if (!pending_snapshot->name) {
2778 ret = -ENOMEM;
2779 kfree(pending_snapshot);
2780 goto fail_unlock;
2781 }
2782 memcpy(pending_snapshot->name, name, namelen);
2783 pending_snapshot->name[namelen] = '\0';
2784 trans = btrfs_start_transaction(root, 1);
2785 BUG_ON(!trans);
2786 pending_snapshot->root = root;
2787 list_add(&pending_snapshot->list,
2788 &trans->transaction->pending_snapshots);
2789 ret = btrfs_update_inode(trans, root, root->inode);
2790 err = btrfs_commit_transaction(trans, root);
2791
2792 fail_unlock:
2793 mutex_unlock(&root->fs_info->fs_mutex);
2794 btrfs_btree_balance_dirty(root, nr);
2795 btrfs_throttle(root);
2796 return ret;
2797 }
2798
2799 unsigned long btrfs_force_ra(struct address_space *mapping,
2800 struct file_ra_state *ra, struct file *file,
2801 pgoff_t offset, pgoff_t last_index)
2802 {
2803 pgoff_t req_size;
2804
2805 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
2806 req_size = last_index - offset + 1;
2807 offset = page_cache_readahead(mapping, ra, file, offset, req_size);
2808 return offset;
2809 #else
2810 req_size = min(last_index - offset + 1, (pgoff_t)128);
2811 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
2812 return offset + req_size;
2813 #endif
2814 }
2815
2816 int btrfs_defrag_file(struct file *file) {
2817 struct inode *inode = fdentry(file)->d_inode;
2818 struct btrfs_root *root = BTRFS_I(inode)->root;
2819 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2820 struct page *page;
2821 unsigned long last_index;
2822 unsigned long ra_index = 0;
2823 u64 page_start;
2824 u64 page_end;
2825 unsigned long i;
2826 int ret;
2827
2828 mutex_lock(&root->fs_info->fs_mutex);
2829 ret = btrfs_check_free_space(root, inode->i_size, 0);
2830 mutex_unlock(&root->fs_info->fs_mutex);
2831 if (ret)
2832 return -ENOSPC;
2833
2834 mutex_lock(&inode->i_mutex);
2835 last_index = inode->i_size >> PAGE_CACHE_SHIFT;
2836 for (i = 0; i <= last_index; i++) {
2837 if (i == ra_index) {
2838 ra_index = btrfs_force_ra(inode->i_mapping,
2839 &file->f_ra,
2840 file, ra_index, last_index);
2841 }
2842 page = grab_cache_page(inode->i_mapping, i);
2843 if (!page)
2844 goto out_unlock;
2845 if (!PageUptodate(page)) {
2846 btrfs_readpage(NULL, page);
2847 lock_page(page);
2848 if (!PageUptodate(page)) {
2849 unlock_page(page);
2850 page_cache_release(page);
2851 goto out_unlock;
2852 }
2853 }
2854 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2855 page_end = page_start + PAGE_CACHE_SIZE - 1;
2856
2857 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
2858 set_extent_delalloc(io_tree, page_start,
2859 page_end, GFP_NOFS);
2860
2861 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
2862 set_page_dirty(page);
2863 unlock_page(page);
2864 page_cache_release(page);
2865 balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
2866 }
2867
2868 out_unlock:
2869 mutex_unlock(&inode->i_mutex);
2870 return 0;
2871 }
2872
2873 static int btrfs_ioctl_resize(struct btrfs_root *root, void __user *arg)
2874 {
2875 u64 new_size;
2876 u64 old_size;
2877 struct btrfs_ioctl_vol_args *vol_args;
2878 struct btrfs_trans_handle *trans;
2879 char *sizestr;
2880 int ret = 0;
2881 int namelen;
2882 int mod = 0;
2883
2884 vol_args = kmalloc(sizeof(*vol_args), GFP_NOFS);
2885
2886 if (!vol_args)
2887 return -ENOMEM;
2888
2889 if (copy_from_user(vol_args, arg, sizeof(*vol_args))) {
2890 ret = -EFAULT;
2891 goto out;
2892 }
2893 namelen = strlen(vol_args->name);
2894 if (namelen > BTRFS_VOL_NAME_MAX) {
2895 ret = -EINVAL;
2896 goto out;
2897 }
2898
2899 sizestr = vol_args->name;
2900 if (!strcmp(sizestr, "max"))
2901 new_size = root->fs_info->sb->s_bdev->bd_inode->i_size;
2902 else {
2903 if (sizestr[0] == '-') {
2904 mod = -1;
2905 sizestr++;
2906 } else if (sizestr[0] == '+') {
2907 mod = 1;
2908 sizestr++;
2909 }
2910 new_size = btrfs_parse_size(sizestr);
2911 if (new_size == 0) {
2912 ret = -EINVAL;
2913 goto out;
2914 }
2915 }
2916
2917 mutex_lock(&root->fs_info->fs_mutex);
2918 old_size = btrfs_super_total_bytes(&root->fs_info->super_copy);
2919
2920 if (mod < 0) {
2921 if (new_size > old_size) {
2922 ret = -EINVAL;
2923 goto out_unlock;
2924 }
2925 new_size = old_size - new_size;
2926 } else if (mod > 0) {
2927 new_size = old_size + new_size;
2928 }
2929
2930 if (new_size < 256 * 1024 * 1024) {
2931 ret = -EINVAL;
2932 goto out_unlock;
2933 }
2934 if (new_size > root->fs_info->sb->s_bdev->bd_inode->i_size) {
2935 ret = -EFBIG;
2936 goto out_unlock;
2937 }
2938
2939 do_div(new_size, root->sectorsize);
2940 new_size *= root->sectorsize;
2941
2942 printk("new size is %Lu\n", new_size);
2943 if (new_size > old_size) {
2944 trans = btrfs_start_transaction(root, 1);
2945 ret = btrfs_grow_extent_tree(trans, root, new_size);
2946 btrfs_commit_transaction(trans, root);
2947 } else {
2948 ret = btrfs_shrink_extent_tree(root, new_size);
2949 }
2950
2951 out_unlock:
2952 mutex_unlock(&root->fs_info->fs_mutex);
2953 out:
2954 kfree(vol_args);
2955 return ret;
2956 }
2957
2958 static int noinline btrfs_ioctl_snap_create(struct btrfs_root *root,
2959 void __user *arg)
2960 {
2961 struct btrfs_ioctl_vol_args *vol_args;
2962 struct btrfs_dir_item *di;
2963 struct btrfs_path *path;
2964 u64 root_dirid;
2965 int namelen;
2966 int ret;
2967
2968 vol_args = kmalloc(sizeof(*vol_args), GFP_NOFS);
2969
2970 if (!vol_args)
2971 return -ENOMEM;
2972
2973 if (copy_from_user(vol_args, arg, sizeof(*vol_args))) {
2974 ret = -EFAULT;
2975 goto out;
2976 }
2977
2978 namelen = strlen(vol_args->name);
2979 if (namelen > BTRFS_VOL_NAME_MAX) {
2980 ret = -EINVAL;
2981 goto out;
2982 }
2983 if (strchr(vol_args->name, '/')) {
2984 ret = -EINVAL;
2985 goto out;
2986 }
2987
2988 path = btrfs_alloc_path();
2989 if (!path) {
2990 ret = -ENOMEM;
2991 goto out;
2992 }
2993
2994 root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
2995 mutex_lock(&root->fs_info->fs_mutex);
2996 di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
2997 path, root_dirid,
2998 vol_args->name, namelen, 0);
2999 mutex_unlock(&root->fs_info->fs_mutex);
3000 btrfs_free_path(path);
3001
3002 if (di && !IS_ERR(di)) {
3003 ret = -EEXIST;
3004 goto out;
3005 }
3006
3007 if (IS_ERR(di)) {
3008 ret = PTR_ERR(di);
3009 goto out;
3010 }
3011
3012 if (root == root->fs_info->tree_root)
3013 ret = create_subvol(root, vol_args->name, namelen);
3014 else
3015 ret = create_snapshot(root, vol_args->name, namelen);
3016 out:
3017 kfree(vol_args);
3018 return ret;
3019 }
3020
3021 static int btrfs_ioctl_defrag(struct file *file)
3022 {
3023 struct inode *inode = fdentry(file)->d_inode;
3024 struct btrfs_root *root = BTRFS_I(inode)->root;
3025
3026 switch (inode->i_mode & S_IFMT) {
3027 case S_IFDIR:
3028 mutex_lock(&root->fs_info->fs_mutex);
3029 btrfs_defrag_root(root, 0);
3030 btrfs_defrag_root(root->fs_info->extent_root, 0);
3031 mutex_unlock(&root->fs_info->fs_mutex);
3032 break;
3033 case S_IFREG:
3034 btrfs_defrag_file(file);
3035 break;
3036 }
3037
3038 return 0;
3039 }
3040
3041 long btrfs_ioctl(struct file *file, unsigned int
3042 cmd, unsigned long arg)
3043 {
3044 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
3045
3046 switch (cmd) {
3047 case BTRFS_IOC_SNAP_CREATE:
3048 return btrfs_ioctl_snap_create(root, (void __user *)arg);
3049 case BTRFS_IOC_DEFRAG:
3050 return btrfs_ioctl_defrag(file);
3051 case BTRFS_IOC_RESIZE:
3052 return btrfs_ioctl_resize(root, (void __user *)arg);
3053 }
3054
3055 return -ENOTTY;
3056 }
3057
3058 /*
3059 * Called inside transaction, so use GFP_NOFS
3060 */
3061 struct inode *btrfs_alloc_inode(struct super_block *sb)
3062 {
3063 struct btrfs_inode *ei;
3064
3065 ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
3066 if (!ei)
3067 return NULL;
3068 ei->last_trans = 0;
3069 ei->ordered_trans = 0;
3070 return &ei->vfs_inode;
3071 }
3072
3073 void btrfs_destroy_inode(struct inode *inode)
3074 {
3075 WARN_ON(!list_empty(&inode->i_dentry));
3076 WARN_ON(inode->i_data.nrpages);
3077
3078 btrfs_drop_extent_cache(inode, 0, (u64)-1);
3079 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
3080 }
3081
3082 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
3083 static void init_once(struct kmem_cache * cachep, void *foo)
3084 #else
3085 static void init_once(void * foo, struct kmem_cache * cachep,
3086 unsigned long flags)
3087 #endif
3088 {
3089 struct btrfs_inode *ei = (struct btrfs_inode *) foo;
3090
3091 inode_init_once(&ei->vfs_inode);
3092 }
3093
3094 void btrfs_destroy_cachep(void)
3095 {
3096 if (btrfs_inode_cachep)
3097 kmem_cache_destroy(btrfs_inode_cachep);
3098 if (btrfs_trans_handle_cachep)
3099 kmem_cache_destroy(btrfs_trans_handle_cachep);
3100 if (btrfs_transaction_cachep)
3101 kmem_cache_destroy(btrfs_transaction_cachep);
3102 if (btrfs_bit_radix_cachep)
3103 kmem_cache_destroy(btrfs_bit_radix_cachep);
3104 if (btrfs_path_cachep)
3105 kmem_cache_destroy(btrfs_path_cachep);
3106 }
3107
3108 struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
3109 unsigned long extra_flags,
3110 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
3111 void (*ctor)(struct kmem_cache *, void *)
3112 #else
3113 void (*ctor)(void *, struct kmem_cache *,
3114 unsigned long)
3115 #endif
3116 )
3117 {
3118 return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
3119 SLAB_MEM_SPREAD | extra_flags), ctor
3120 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
3121 ,NULL
3122 #endif
3123 );
3124 }
3125
3126 int btrfs_init_cachep(void)
3127 {
3128 btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
3129 sizeof(struct btrfs_inode),
3130 0, init_once);
3131 if (!btrfs_inode_cachep)
3132 goto fail;
3133 btrfs_trans_handle_cachep =
3134 btrfs_cache_create("btrfs_trans_handle_cache",
3135 sizeof(struct btrfs_trans_handle),
3136 0, NULL);
3137 if (!btrfs_trans_handle_cachep)
3138 goto fail;
3139 btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
3140 sizeof(struct btrfs_transaction),
3141 0, NULL);
3142 if (!btrfs_transaction_cachep)
3143 goto fail;
3144 btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
3145 sizeof(struct btrfs_path),
3146 0, NULL);
3147 if (!btrfs_path_cachep)
3148 goto fail;
3149 btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
3150 SLAB_DESTROY_BY_RCU, NULL);
3151 if (!btrfs_bit_radix_cachep)
3152 goto fail;
3153 return 0;
3154 fail:
3155 btrfs_destroy_cachep();
3156 return -ENOMEM;
3157 }
3158
3159 static int btrfs_getattr(struct vfsmount *mnt,
3160 struct dentry *dentry, struct kstat *stat)
3161 {
3162 struct inode *inode = dentry->d_inode;
3163 generic_fillattr(inode, stat);
3164 stat->blksize = PAGE_CACHE_SIZE;
3165 stat->blocks = inode->i_blocks + (BTRFS_I(inode)->delalloc_bytes >> 9);
3166 return 0;
3167 }
3168
3169 static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
3170 struct inode * new_dir,struct dentry *new_dentry)
3171 {
3172 struct btrfs_trans_handle *trans;
3173 struct btrfs_root *root = BTRFS_I(old_dir)->root;
3174 struct inode *new_inode = new_dentry->d_inode;
3175 struct inode *old_inode = old_dentry->d_inode;
3176 struct timespec ctime = CURRENT_TIME;
3177 struct btrfs_path *path;
3178 int ret;
3179
3180 if (S_ISDIR(old_inode->i_mode) && new_inode &&
3181 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
3182 return -ENOTEMPTY;
3183 }
3184
3185 mutex_lock(&root->fs_info->fs_mutex);
3186 ret = btrfs_check_free_space(root, 1, 0);
3187 if (ret)
3188 goto out_unlock;
3189
3190 trans = btrfs_start_transaction(root, 1);
3191
3192 btrfs_set_trans_block_group(trans, new_dir);
3193 path = btrfs_alloc_path();
3194 if (!path) {
3195 ret = -ENOMEM;
3196 goto out_fail;
3197 }
3198
3199 old_dentry->d_inode->i_nlink++;
3200 old_dir->i_ctime = old_dir->i_mtime = ctime;
3201 new_dir->i_ctime = new_dir->i_mtime = ctime;
3202 old_inode->i_ctime = ctime;
3203
3204 ret = btrfs_unlink_trans(trans, root, old_dir, old_dentry);
3205 if (ret)
3206 goto out_fail;
3207
3208 if (new_inode) {
3209 new_inode->i_ctime = CURRENT_TIME;
3210 ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
3211 if (ret)
3212 goto out_fail;
3213 }
3214 ret = btrfs_add_link(trans, new_dentry, old_inode, 1);
3215 if (ret)
3216 goto out_fail;
3217
3218 out_fail:
3219 btrfs_free_path(path);
3220 btrfs_end_transaction(trans, root);
3221 out_unlock:
3222 mutex_unlock(&root->fs_info->fs_mutex);
3223 return ret;
3224 }
3225
3226 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
3227 const char *symname)
3228 {
3229 struct btrfs_trans_handle *trans;
3230 struct btrfs_root *root = BTRFS_I(dir)->root;
3231 struct btrfs_path *path;
3232 struct btrfs_key key;
3233 struct inode *inode = NULL;
3234 int err;
3235 int drop_inode = 0;
3236 u64 objectid;
3237 int name_len;
3238 int datasize;
3239 unsigned long ptr;
3240 struct btrfs_file_extent_item *ei;
3241 struct extent_buffer *leaf;
3242 unsigned long nr = 0;
3243
3244 name_len = strlen(symname) + 1;
3245 if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
3246 return -ENAMETOOLONG;
3247
3248 mutex_lock(&root->fs_info->fs_mutex);
3249 err = btrfs_check_free_space(root, 1, 0);
3250 if (err)
3251 goto out_fail;
3252
3253 trans = btrfs_start_transaction(root, 1);
3254 btrfs_set_trans_block_group(trans, dir);
3255
3256 err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
3257 if (err) {
3258 err = -ENOSPC;
3259 goto out_unlock;
3260 }
3261
3262 inode = btrfs_new_inode(trans, root, dentry->d_name.name,
3263 dentry->d_name.len,
3264 dentry->d_parent->d_inode->i_ino, objectid,
3265 BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO);
3266 err = PTR_ERR(inode);
3267 if (IS_ERR(inode))
3268 goto out_unlock;
3269
3270 btrfs_set_trans_block_group(trans, inode);
3271 err = btrfs_add_nondir(trans, dentry, inode, 0);
3272 if (err)
3273 drop_inode = 1;
3274 else {
3275 inode->i_mapping->a_ops = &btrfs_aops;
3276 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3277 inode->i_fop = &btrfs_file_operations;
3278 inode->i_op = &btrfs_file_inode_operations;
3279 extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
3280 extent_io_tree_init(&BTRFS_I(inode)->io_tree,
3281 inode->i_mapping, GFP_NOFS);
3282 extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
3283 inode->i_mapping, GFP_NOFS);
3284 BTRFS_I(inode)->delalloc_bytes = 0;
3285 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
3286 }
3287 dir->i_sb->s_dirt = 1;
3288 btrfs_update_inode_block_group(trans, inode);
3289 btrfs_update_inode_block_group(trans, dir);
3290 if (drop_inode)
3291 goto out_unlock;
3292
3293 path = btrfs_alloc_path();
3294 BUG_ON(!path);
3295 key.objectid = inode->i_ino;
3296 key.offset = 0;
3297 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
3298 datasize = btrfs_file_extent_calc_inline_size(name_len);
3299 err = btrfs_insert_empty_item(trans, root, path, &key,
3300 datasize);
3301 if (err) {
3302 drop_inode = 1;
3303 goto out_unlock;
3304 }
3305 leaf = path->nodes[0];
3306 ei = btrfs_item_ptr(leaf, path->slots[0],
3307 struct btrfs_file_extent_item);
3308 btrfs_set_file_extent_generation(leaf, ei, trans->transid);
3309 btrfs_set_file_extent_type(leaf, ei,
3310 BTRFS_FILE_EXTENT_INLINE);
3311 ptr = btrfs_file_extent_inline_start(ei);
3312 write_extent_buffer(leaf, symname, ptr, name_len);
3313 btrfs_mark_buffer_dirty(leaf);
3314 btrfs_free_path(path);
3315
3316 inode->i_op = &btrfs_symlink_inode_operations;
3317 inode->i_mapping->a_ops = &btrfs_symlink_aops;
3318 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3319 inode->i_size = name_len - 1;
3320 err = btrfs_update_inode(trans, root, inode);
3321 if (err)
3322 drop_inode = 1;
3323
3324 out_unlock:
3325 nr = trans->blocks_used;
3326 btrfs_end_transaction(trans, root);
3327 out_fail:
3328 mutex_unlock(&root->fs_info->fs_mutex);
3329 if (drop_inode) {
3330 inode_dec_link_count(inode);
3331 iput(inode);
3332 }
3333 btrfs_btree_balance_dirty(root, nr);
3334 btrfs_throttle(root);
3335 return err;
3336 }
3337
3338 static int btrfs_permission(struct inode *inode, int mask,
3339 struct nameidata *nd)
3340 {
3341 if (btrfs_test_flag(inode, READONLY) && (mask & MAY_WRITE))
3342 return -EACCES;
3343 return generic_permission(inode, mask, NULL);
3344 }
3345
3346 static struct inode_operations btrfs_dir_inode_operations = {
3347 .lookup = btrfs_lookup,
3348 .create = btrfs_create,
3349 .unlink = btrfs_unlink,
3350 .link = btrfs_link,
3351 .mkdir = btrfs_mkdir,
3352 .rmdir = btrfs_rmdir,
3353 .rename = btrfs_rename,
3354 .symlink = btrfs_symlink,
3355 .setattr = btrfs_setattr,
3356 .mknod = btrfs_mknod,
3357 .setxattr = generic_setxattr,
3358 .getxattr = generic_getxattr,
3359 .listxattr = btrfs_listxattr,
3360 .removexattr = generic_removexattr,
3361 .permission = btrfs_permission,
3362 };
3363 static struct inode_operations btrfs_dir_ro_inode_operations = {
3364 .lookup = btrfs_lookup,
3365 .permission = btrfs_permission,
3366 };
3367 static struct file_operations btrfs_dir_file_operations = {
3368 .llseek = generic_file_llseek,
3369 .read = generic_read_dir,
3370 .readdir = btrfs_readdir,
3371 .unlocked_ioctl = btrfs_ioctl,
3372 #ifdef CONFIG_COMPAT
3373 .compat_ioctl = btrfs_ioctl,
3374 #endif
3375 };
3376
3377 static struct extent_io_ops btrfs_extent_io_ops = {
3378 .fill_delalloc = run_delalloc_range,
3379 .submit_bio_hook = btrfs_submit_bio_hook,
3380 .merge_bio_hook = btrfs_merge_bio_hook,
3381 .readpage_io_hook = btrfs_readpage_io_hook,
3382 .readpage_end_io_hook = btrfs_readpage_end_io_hook,
3383 .readpage_io_failed_hook = btrfs_readpage_io_failed_hook,
3384 .set_bit_hook = btrfs_set_bit_hook,
3385 .clear_bit_hook = btrfs_clear_bit_hook,
3386 };
3387
3388 static struct address_space_operations btrfs_aops = {
3389 .readpage = btrfs_readpage,
3390 .writepage = btrfs_writepage,
3391 .writepages = btrfs_writepages,
3392 .readpages = btrfs_readpages,
3393 .sync_page = block_sync_page,
3394 .bmap = btrfs_bmap,
3395 .direct_IO = btrfs_direct_IO,
3396 .invalidatepage = btrfs_invalidatepage,
3397 .releasepage = btrfs_releasepage,
3398 .set_page_dirty = __set_page_dirty_nobuffers,
3399 };
3400
3401 static struct address_space_operations btrfs_symlink_aops = {
3402 .readpage = btrfs_readpage,
3403 .writepage = btrfs_writepage,
3404 .invalidatepage = btrfs_invalidatepage,
3405 .releasepage = btrfs_releasepage,
3406 };
3407
3408 static struct inode_operations btrfs_file_inode_operations = {
3409 .truncate = btrfs_truncate,
3410 .getattr = btrfs_getattr,
3411 .setattr = btrfs_setattr,
3412 .setxattr = generic_setxattr,
3413 .getxattr = generic_getxattr,
3414 .listxattr = btrfs_listxattr,
3415 .removexattr = generic_removexattr,
3416 .permission = btrfs_permission,
3417 };
3418 static struct inode_operations btrfs_special_inode_operations = {
3419 .getattr = btrfs_getattr,
3420 .setattr = btrfs_setattr,
3421 .permission = btrfs_permission,
3422 };
3423 static struct inode_operations btrfs_symlink_inode_operations = {
3424 .readlink = generic_readlink,
3425 .follow_link = page_follow_link_light,
3426 .put_link = page_put_link,
3427 .permission = btrfs_permission,
3428 };
Linux kernel - Deliverables
This page took 0.170906 seconds and 6 git commands to generate.