1 #include <linux/module.h>
2 #include <linux/buffer_head.h>
4 #include <linux/pagemap.h>
5 #include <linux/highmem.h>
6 #include <linux/time.h>
7 #include <linux/init.h>
8 #include <linux/string.h>
9 #include <linux/smp_lock.h>
10 #include <linux/backing-dev.h>
11 #include <linux/mpage.h>
12 #include <linux/swap.h>
13 #include <linux/writeback.h>
16 #include "transaction.h"
17 #include "btrfs_inode.h"
20 void btrfs_fsinfo_release(struct kobject
*obj
)
22 struct btrfs_fs_info
*fsinfo
= container_of(obj
,
23 struct btrfs_fs_info
, kobj
);
27 struct kobj_type btrfs_fsinfo_ktype
= {
28 .release
= btrfs_fsinfo_release
,
31 struct btrfs_iget_args
{
33 struct btrfs_root
*root
;
36 decl_subsys(btrfs
, &btrfs_fsinfo_ktype
, NULL
);
38 #define BTRFS_SUPER_MAGIC 0x9123682E
40 static struct inode_operations btrfs_dir_inode_operations
;
41 static struct inode_operations btrfs_dir_ro_inode_operations
;
42 static struct super_operations btrfs_super_ops
;
43 static struct file_operations btrfs_dir_file_operations
;
44 static struct inode_operations btrfs_file_inode_operations
;
45 static struct address_space_operations btrfs_aops
;
46 static struct file_operations btrfs_file_operations
;
48 static void btrfs_read_locked_inode(struct inode
*inode
)
50 struct btrfs_path
*path
;
51 struct btrfs_inode_item
*inode_item
;
52 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
53 struct btrfs_key location
;
56 path
= btrfs_alloc_path();
58 btrfs_init_path(path
);
59 mutex_lock(&root
->fs_info
->fs_mutex
);
61 memcpy(&location
, &BTRFS_I(inode
)->location
, sizeof(location
));
62 ret
= btrfs_lookup_inode(NULL
, root
, path
, &location
, 0);
64 btrfs_free_path(path
);
67 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
69 struct btrfs_inode_item
);
71 inode
->i_mode
= btrfs_inode_mode(inode_item
);
72 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
73 inode
->i_uid
= btrfs_inode_uid(inode_item
);
74 inode
->i_gid
= btrfs_inode_gid(inode_item
);
75 inode
->i_size
= btrfs_inode_size(inode_item
);
76 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
77 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
78 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
79 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
80 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
81 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
82 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
83 inode
->i_generation
= btrfs_inode_generation(inode_item
);
85 btrfs_free_path(path
);
88 mutex_unlock(&root
->fs_info
->fs_mutex
);
90 switch (inode
->i_mode
& S_IFMT
) {
93 init_special_inode(inode
, inode
->i_mode
,
94 btrfs_inode_rdev(inode_item
));
98 inode
->i_mapping
->a_ops
= &btrfs_aops
;
99 inode
->i_fop
= &btrfs_file_operations
;
100 inode
->i_op
= &btrfs_file_inode_operations
;
103 inode
->i_fop
= &btrfs_dir_file_operations
;
104 if (root
== root
->fs_info
->tree_root
)
105 inode
->i_op
= &btrfs_dir_ro_inode_operations
;
107 inode
->i_op
= &btrfs_dir_inode_operations
;
110 // inode->i_op = &page_symlink_inode_operations;
116 btrfs_release_path(root
, path
);
117 btrfs_free_path(path
);
118 mutex_unlock(&root
->fs_info
->fs_mutex
);
119 make_bad_inode(inode
);
122 static int btrfs_unlink_trans(struct btrfs_trans_handle
*trans
,
123 struct btrfs_root
*root
,
125 struct dentry
*dentry
)
127 struct btrfs_path
*path
;
128 const char *name
= dentry
->d_name
.name
;
129 int name_len
= dentry
->d_name
.len
;
132 struct btrfs_dir_item
*di
;
134 path
= btrfs_alloc_path();
136 btrfs_init_path(path
);
137 ret
= btrfs_lookup_dir_item(trans
, root
, path
, dir
->i_ino
,
145 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
146 struct btrfs_dir_item
);
147 objectid
= btrfs_disk_key_objectid(&di
->location
);
149 ret
= btrfs_del_item(trans
, root
, path
);
152 btrfs_release_path(root
, path
);
153 ret
= btrfs_lookup_dir_index_item(trans
, root
, path
, dir
->i_ino
,
156 ret
= btrfs_del_item(trans
, root
, path
);
158 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
160 btrfs_release_path(root
, path
);
161 btrfs_free_path(path
);
163 inode_dec_link_count(dentry
->d_inode
);
164 dir
->i_size
-= name_len
* 2;
165 mark_inode_dirty(dir
);
170 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
172 struct btrfs_root
*root
;
173 struct btrfs_trans_handle
*trans
;
176 root
= BTRFS_I(dir
)->root
;
177 mutex_lock(&root
->fs_info
->fs_mutex
);
178 trans
= btrfs_start_transaction(root
, 1);
179 ret
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
180 btrfs_end_transaction(trans
, root
);
181 mutex_unlock(&root
->fs_info
->fs_mutex
);
185 static int btrfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
187 struct inode
*inode
= dentry
->d_inode
;
190 struct btrfs_root
*root
= BTRFS_I(dir
)->root
;
191 struct btrfs_path
*path
;
192 struct btrfs_key key
;
193 struct btrfs_trans_handle
*trans
;
194 struct btrfs_key found_key
;
196 struct btrfs_leaf
*leaf
;
197 char *goodnames
= "..";
199 path
= btrfs_alloc_path();
201 btrfs_init_path(path
);
202 mutex_lock(&root
->fs_info
->fs_mutex
);
203 trans
= btrfs_start_transaction(root
, 1);
204 key
.objectid
= inode
->i_ino
;
205 key
.offset
= (u64
)-1;
208 ret
= btrfs_search_slot(trans
, root
, &key
, path
, -1, 1);
214 if (path
->slots
[0] == 0) {
219 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
220 btrfs_disk_key_to_cpu(&found_key
,
221 &leaf
->items
[path
->slots
[0]].key
);
222 found_type
= btrfs_key_type(&found_key
);
223 if (found_key
.objectid
!= inode
->i_ino
) {
227 if ((found_type
!= BTRFS_DIR_ITEM_KEY
&&
228 found_type
!= BTRFS_DIR_INDEX_KEY
) ||
229 (!btrfs_match_dir_item_name(root
, path
, goodnames
, 2) &&
230 !btrfs_match_dir_item_name(root
, path
, goodnames
, 1))) {
234 ret
= btrfs_del_item(trans
, root
, path
);
237 if (found_type
== BTRFS_DIR_ITEM_KEY
&& found_key
.offset
== 1)
239 btrfs_release_path(root
, path
);
242 btrfs_release_path(root
, path
);
244 /* now the directory is empty */
245 err
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
250 btrfs_release_path(root
, path
);
251 btrfs_free_path(path
);
252 mutex_unlock(&root
->fs_info
->fs_mutex
);
253 ret
= btrfs_end_transaction(trans
, root
);
259 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
260 struct btrfs_root
*root
,
263 struct btrfs_path
*path
;
268 path
= btrfs_alloc_path();
270 btrfs_init_path(path
);
271 ret
= btrfs_lookup_inode(trans
, root
, path
,
272 &BTRFS_I(inode
)->location
, -1);
274 ret
= btrfs_del_item(trans
, root
, path
);
276 btrfs_free_path(path
);
280 static int btrfs_truncate_in_trans(struct btrfs_trans_handle
*trans
,
281 struct btrfs_root
*root
,
285 struct btrfs_path
*path
;
286 struct btrfs_key key
;
287 struct btrfs_disk_key
*found_key
;
288 struct btrfs_leaf
*leaf
;
289 struct btrfs_file_extent_item
*fi
= NULL
;
290 u64 extent_start
= 0;
291 u64 extent_num_blocks
= 0;
294 path
= btrfs_alloc_path();
296 /* FIXME, add redo link to tree so we don't leak on crash */
297 key
.objectid
= inode
->i_ino
;
298 key
.offset
= (u64
)-1;
301 * use BTRFS_CSUM_ITEM_KEY because it is larger than inline keys
304 btrfs_set_key_type(&key
, BTRFS_CSUM_ITEM_KEY
);
306 btrfs_init_path(path
);
307 ret
= btrfs_search_slot(trans
, root
, &key
, path
, -1, 1);
312 BUG_ON(path
->slots
[0] == 0);
315 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
316 found_key
= &leaf
->items
[path
->slots
[0]].key
;
317 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
)
319 if (btrfs_disk_key_type(found_key
) != BTRFS_CSUM_ITEM_KEY
&&
320 btrfs_disk_key_type(found_key
) != BTRFS_INLINE_DATA_KEY
&&
321 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
)
323 if (btrfs_disk_key_offset(found_key
) < inode
->i_size
)
325 if (btrfs_disk_key_type(found_key
) == BTRFS_EXTENT_DATA_KEY
) {
326 fi
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
328 struct btrfs_file_extent_item
);
329 extent_start
= btrfs_file_extent_disk_blocknr(fi
);
331 btrfs_file_extent_disk_num_blocks(fi
);
333 btrfs_file_extent_num_blocks(fi
) >> 9;
338 ret
= btrfs_del_item(trans
, root
, path
);
340 btrfs_release_path(root
, path
);
342 ret
= btrfs_free_extent(trans
, root
, extent_start
,
343 extent_num_blocks
, 0);
349 btrfs_release_path(root
, path
);
350 btrfs_free_path(path
);
354 static void btrfs_delete_inode(struct inode
*inode
)
356 struct btrfs_trans_handle
*trans
;
357 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
360 truncate_inode_pages(&inode
->i_data
, 0);
361 if (is_bad_inode(inode
)) {
365 mutex_lock(&root
->fs_info
->fs_mutex
);
366 trans
= btrfs_start_transaction(root
, 1);
367 if (S_ISREG(inode
->i_mode
)) {
368 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
371 btrfs_free_inode(trans
, root
, inode
);
372 btrfs_end_transaction(trans
, root
);
373 mutex_unlock(&root
->fs_info
->fs_mutex
);
379 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
380 struct btrfs_key
*location
)
382 const char *name
= dentry
->d_name
.name
;
383 int namelen
= dentry
->d_name
.len
;
384 struct btrfs_dir_item
*di
;
385 struct btrfs_path
*path
;
386 struct btrfs_root
*root
= BTRFS_I(dir
)->root
;
389 path
= btrfs_alloc_path();
391 btrfs_init_path(path
);
392 ret
= btrfs_lookup_dir_item(NULL
, root
, path
, dir
->i_ino
, name
,
394 if (ret
|| !btrfs_match_dir_item_name(root
, path
, name
, namelen
)) {
395 location
->objectid
= 0;
399 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
400 struct btrfs_dir_item
);
401 btrfs_disk_key_to_cpu(location
, &di
->location
);
403 btrfs_release_path(root
, path
);
404 btrfs_free_path(path
);
408 int fixup_tree_root_location(struct btrfs_root
*root
,
409 struct btrfs_key
*location
,
410 struct btrfs_root
**sub_root
)
412 struct btrfs_path
*path
;
413 struct btrfs_root_item
*ri
;
415 if (btrfs_key_type(location
) != BTRFS_ROOT_ITEM_KEY
)
417 if (location
->objectid
== BTRFS_ROOT_TREE_OBJECTID
)
420 path
= btrfs_alloc_path();
422 mutex_lock(&root
->fs_info
->fs_mutex
);
424 *sub_root
= btrfs_read_fs_root(root
->fs_info
, location
);
425 if (IS_ERR(*sub_root
))
426 return PTR_ERR(*sub_root
);
428 ri
= &(*sub_root
)->root_item
;
429 location
->objectid
= btrfs_root_dirid(ri
);
431 btrfs_set_key_type(location
, BTRFS_INODE_ITEM_KEY
);
432 location
->offset
= 0;
434 btrfs_free_path(path
);
435 mutex_unlock(&root
->fs_info
->fs_mutex
);
439 int btrfs_init_locked_inode(struct inode
*inode
, void *p
)
441 struct btrfs_iget_args
*args
= p
;
442 inode
->i_ino
= args
->ino
;
443 BTRFS_I(inode
)->root
= args
->root
;
447 int btrfs_find_actor(struct inode
*inode
, void *opaque
)
449 struct btrfs_iget_args
*args
= opaque
;
450 return (args
->ino
== inode
->i_ino
&&
451 args
->root
== BTRFS_I(inode
)->root
);
454 struct inode
*btrfs_iget_locked(struct super_block
*s
, u64 objectid
,
455 struct btrfs_root
*root
)
458 struct btrfs_iget_args args
;
462 inode
= iget5_locked(s
, objectid
, btrfs_find_actor
,
463 btrfs_init_locked_inode
,
468 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
469 struct nameidata
*nd
)
471 struct inode
* inode
;
472 struct btrfs_inode
*bi
= BTRFS_I(dir
);
473 struct btrfs_root
*root
= bi
->root
;
474 struct btrfs_root
*sub_root
= root
;
475 struct btrfs_key location
;
478 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
479 return ERR_PTR(-ENAMETOOLONG
);
480 mutex_lock(&root
->fs_info
->fs_mutex
);
481 ret
= btrfs_inode_by_name(dir
, dentry
, &location
);
482 mutex_unlock(&root
->fs_info
->fs_mutex
);
486 if (location
.objectid
) {
487 ret
= fixup_tree_root_location(root
, &location
, &sub_root
);
491 return ERR_PTR(-ENOENT
);
492 inode
= btrfs_iget_locked(dir
->i_sb
, location
.objectid
,
495 return ERR_PTR(-EACCES
);
496 if (inode
->i_state
& I_NEW
) {
497 if (sub_root
!= root
) {
498 printk("adding new root for inode %lu root %p (found %p)\n", inode
->i_ino
, sub_root
, BTRFS_I(inode
)->root
);
500 sub_root
->inode
= inode
;
502 BTRFS_I(inode
)->root
= sub_root
;
503 memcpy(&BTRFS_I(inode
)->location
, &location
,
505 btrfs_read_locked_inode(inode
);
506 unlock_new_inode(inode
);
509 return d_splice_alias(inode
, dentry
);
512 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
514 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
515 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
516 struct btrfs_item
*item
;
517 struct btrfs_dir_item
*di
;
518 struct btrfs_key key
;
519 struct btrfs_path
*path
;
522 struct btrfs_leaf
*leaf
;
525 unsigned char d_type
= DT_UNKNOWN
;
527 int key_type
= BTRFS_DIR_INDEX_KEY
;
529 /* FIXME, use a real flag for deciding about the key type */
530 if (root
->fs_info
->tree_root
== root
)
531 key_type
= BTRFS_DIR_ITEM_KEY
;
532 mutex_lock(&root
->fs_info
->fs_mutex
);
533 key
.objectid
= inode
->i_ino
;
535 btrfs_set_key_type(&key
, key_type
);
536 key
.offset
= filp
->f_pos
;
537 path
= btrfs_alloc_path();
538 btrfs_init_path(path
);
539 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
544 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
545 nritems
= btrfs_header_nritems(&leaf
->header
);
546 slot
= path
->slots
[0];
547 if (advance
|| slot
>= nritems
) {
548 if (slot
>= nritems
-1) {
549 ret
= btrfs_next_leaf(root
, path
);
552 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
553 nritems
= btrfs_header_nritems(&leaf
->header
);
554 slot
= path
->slots
[0];
561 item
= leaf
->items
+ slot
;
562 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
564 if (key_type
== BTRFS_DIR_INDEX_KEY
&&
565 btrfs_disk_key_offset(&item
->key
) > root
->highest_inode
)
567 if (btrfs_disk_key_type(&item
->key
) != key_type
)
569 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
571 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
573 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
574 over
= filldir(dirent
, (const char *)(di
+ 1),
575 btrfs_dir_name_len(di
),
576 btrfs_disk_key_offset(&item
->key
),
577 btrfs_disk_key_objectid(&di
->location
), d_type
);
585 btrfs_release_path(root
, path
);
586 btrfs_free_path(path
);
587 mutex_unlock(&root
->fs_info
->fs_mutex
);
591 static void btrfs_put_super (struct super_block
* sb
)
593 struct btrfs_root
*root
= btrfs_sb(sb
);
596 ret
= close_ctree(root
);
598 printk("close ctree returns %d\n", ret
);
600 sb
->s_fs_info
= NULL
;
603 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
605 struct inode
* inode
;
606 struct dentry
* root_dentry
;
607 struct btrfs_super_block
*disk_super
;
608 struct btrfs_root
*tree_root
;
609 struct btrfs_inode
*bi
;
611 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
612 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
613 sb
->s_op
= &btrfs_super_ops
;
616 tree_root
= open_ctree(sb
);
619 printk("btrfs: open_ctree failed\n");
622 sb
->s_fs_info
= tree_root
;
623 disk_super
= tree_root
->fs_info
->disk_super
;
624 printk("read in super total blocks %Lu root %Lu\n",
625 btrfs_super_total_blocks(disk_super
),
626 btrfs_super_root_dir(disk_super
));
628 inode
= btrfs_iget_locked(sb
, btrfs_super_root_dir(disk_super
),
631 bi
->location
.objectid
= inode
->i_ino
;
632 bi
->location
.offset
= 0;
633 bi
->location
.flags
= 0;
634 bi
->root
= tree_root
;
635 btrfs_set_key_type(&bi
->location
, BTRFS_INODE_ITEM_KEY
);
639 if (inode
->i_state
& I_NEW
) {
640 btrfs_read_locked_inode(inode
);
641 unlock_new_inode(inode
);
644 root_dentry
= d_alloc_root(inode
);
649 sb
->s_root
= root_dentry
;
654 static void fill_inode_item(struct btrfs_inode_item
*item
,
657 btrfs_set_inode_uid(item
, inode
->i_uid
);
658 btrfs_set_inode_gid(item
, inode
->i_gid
);
659 btrfs_set_inode_size(item
, inode
->i_size
);
660 btrfs_set_inode_mode(item
, inode
->i_mode
);
661 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
662 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
663 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
664 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
665 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
666 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
667 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
668 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
669 btrfs_set_inode_generation(item
, inode
->i_generation
);
672 static int btrfs_update_inode(struct btrfs_trans_handle
*trans
,
673 struct btrfs_root
*root
,
676 struct btrfs_inode_item
*inode_item
;
677 struct btrfs_path
*path
;
680 path
= btrfs_alloc_path();
682 btrfs_init_path(path
);
683 ret
= btrfs_lookup_inode(trans
, root
, path
,
684 &BTRFS_I(inode
)->location
, 1);
691 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
693 struct btrfs_inode_item
);
695 fill_inode_item(inode_item
, inode
);
696 btrfs_mark_buffer_dirty(path
->nodes
[0]);
699 btrfs_release_path(root
, path
);
700 btrfs_free_path(path
);
704 static int btrfs_write_inode(struct inode
*inode
, int wait
)
706 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
707 struct btrfs_trans_handle
*trans
;
710 mutex_lock(&root
->fs_info
->fs_mutex
);
711 trans
= btrfs_start_transaction(root
, 1);
712 ret
= btrfs_update_inode(trans
, root
, inode
);
714 btrfs_commit_transaction(trans
, root
);
716 btrfs_end_transaction(trans
, root
);
717 mutex_unlock(&root
->fs_info
->fs_mutex
);
721 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
722 struct btrfs_root
*root
,
723 u64 objectid
, int mode
)
726 struct btrfs_inode_item inode_item
;
727 struct btrfs_key
*location
;
730 inode
= new_inode(root
->fs_info
->sb
);
732 return ERR_PTR(-ENOMEM
);
734 BTRFS_I(inode
)->root
= root
;
736 inode
->i_uid
= current
->fsuid
;
737 inode
->i_gid
= current
->fsgid
;
738 inode
->i_mode
= mode
;
739 inode
->i_ino
= objectid
;
741 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
742 fill_inode_item(&inode_item
, inode
);
743 location
= &BTRFS_I(inode
)->location
;
744 location
->objectid
= objectid
;
746 location
->offset
= 0;
747 btrfs_set_key_type(location
, BTRFS_INODE_ITEM_KEY
);
749 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
752 insert_inode_hash(inode
);
756 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
757 struct dentry
*dentry
, struct inode
*inode
)
760 struct btrfs_key key
;
761 struct btrfs_root
*root
= BTRFS_I(dentry
->d_parent
->d_inode
)->root
;
762 key
.objectid
= inode
->i_ino
;
764 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
767 ret
= btrfs_insert_dir_item(trans
, root
,
768 dentry
->d_name
.name
, dentry
->d_name
.len
,
769 dentry
->d_parent
->d_inode
->i_ino
,
772 dentry
->d_parent
->d_inode
->i_size
+= dentry
->d_name
.len
* 2;
773 ret
= btrfs_update_inode(trans
, root
,
774 dentry
->d_parent
->d_inode
);
779 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
780 struct dentry
*dentry
, struct inode
*inode
)
782 int err
= btrfs_add_link(trans
, dentry
, inode
);
784 d_instantiate(dentry
, inode
);
792 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
793 int mode
, struct nameidata
*nd
)
795 struct btrfs_trans_handle
*trans
;
796 struct btrfs_root
*root
= BTRFS_I(dir
)->root
;
802 mutex_lock(&root
->fs_info
->fs_mutex
);
803 trans
= btrfs_start_transaction(root
, 1);
805 err
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
811 inode
= btrfs_new_inode(trans
, root
, objectid
, mode
);
812 err
= PTR_ERR(inode
);
815 // FIXME mark the inode dirty
816 err
= btrfs_add_nondir(trans
, dentry
, inode
);
820 inode
->i_mapping
->a_ops
= &btrfs_aops
;
821 inode
->i_fop
= &btrfs_file_operations
;
822 inode
->i_op
= &btrfs_file_inode_operations
;
824 dir
->i_sb
->s_dirt
= 1;
826 btrfs_end_transaction(trans
, root
);
827 mutex_unlock(&root
->fs_info
->fs_mutex
);
830 inode_dec_link_count(inode
);
836 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
837 struct btrfs_root
*root
,
838 u64 objectid
, u64 dirid
)
842 struct btrfs_key key
;
847 key
.objectid
= objectid
;
850 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
852 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, objectid
,
856 key
.objectid
= dirid
;
857 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, objectid
,
865 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
868 struct btrfs_trans_handle
*trans
;
869 struct btrfs_root
*root
= BTRFS_I(dir
)->root
;
874 mutex_lock(&root
->fs_info
->fs_mutex
);
875 trans
= btrfs_start_transaction(root
, 1);
877 err
= PTR_ERR(trans
);
881 err
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
887 inode
= btrfs_new_inode(trans
, root
, objectid
, S_IFDIR
| mode
);
889 err
= PTR_ERR(inode
);
893 inode
->i_op
= &btrfs_dir_inode_operations
;
894 inode
->i_fop
= &btrfs_dir_file_operations
;
896 err
= btrfs_make_empty_dir(trans
, root
, inode
->i_ino
, dir
->i_ino
);
901 err
= btrfs_update_inode(trans
, root
, inode
);
904 err
= btrfs_add_link(trans
, dentry
, inode
);
907 d_instantiate(dentry
, inode
);
911 btrfs_end_transaction(trans
, root
);
913 mutex_unlock(&root
->fs_info
->fs_mutex
);
919 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
921 struct btrfs_trans_handle
*trans
;
922 struct btrfs_root
*root
;
928 filemap_flush(root
->fs_info
->btree_inode
->i_mapping
);
931 filemap_write_and_wait(root
->fs_info
->btree_inode
->i_mapping
);
932 mutex_lock(&root
->fs_info
->fs_mutex
);
933 trans
= btrfs_start_transaction(root
, 1);
934 ret
= btrfs_commit_transaction(trans
, root
);
937 printk("btrfs sync_fs\n");
938 mutex_unlock(&root
->fs_info
->fs_mutex
);
943 static int btrfs_get_block_inline(struct inode
*inode
, sector_t iblock
,
944 struct buffer_head
*result
, int create
)
946 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
947 struct btrfs_path
*path
;
948 struct btrfs_key key
;
949 struct btrfs_leaf
*leaf
;
950 int num_bytes
= result
->b_size
;
960 path
= btrfs_alloc_path();
967 pos
= iblock
<< inode
->i_blkbits
;
968 key
.objectid
= inode
->i_ino
;
970 btrfs_set_key_type(&key
, BTRFS_INLINE_DATA_KEY
);
971 ptr
= kmap(result
->b_page
);
973 ptr
+= (pos
& (PAGE_CACHE_SIZE
-1));
976 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
984 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
985 item_size
= btrfs_item_size(leaf
->items
+ path
->slots
[0]);
986 copy_size
= min(num_bytes
, item_size
);
987 data_ptr
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
988 WARN_ON(safe_ptr
+ PAGE_CACHE_SIZE
< ptr
+ copy_size
);
989 memcpy(ptr
, data_ptr
, copy_size
);
991 num_bytes
-= copy_size
;
992 WARN_ON(num_bytes
< 0);
994 btrfs_release_path(root
, path
);
995 if (num_bytes
!= 0) {
996 if (pos
>= i_size_read(inode
))
997 memset(ptr
, 0, num_bytes
);
1001 set_buffer_uptodate(result
);
1002 map_bh(result
, inode
->i_sb
, 0);
1005 btrfs_free_path(path
);
1006 kunmap(result
->b_page
);
1011 static int btrfs_get_block_lock(struct inode
*inode
, sector_t iblock
,
1012 struct buffer_head
*result
, int create
)
1017 u64 extent_start
= 0;
1019 u64 objectid
= inode
->i_ino
;
1020 struct btrfs_path
*path
;
1021 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1022 struct btrfs_trans_handle
*trans
= NULL
;
1023 struct btrfs_file_extent_item
*item
;
1024 struct btrfs_leaf
*leaf
;
1025 struct btrfs_disk_key
*found_key
;
1027 path
= btrfs_alloc_path();
1029 btrfs_init_path(path
);
1031 trans
= btrfs_start_transaction(root
, 1);
1035 ret
= btrfs_lookup_file_extent(trans
, root
, path
,
1037 iblock
<< inode
->i_blkbits
, create
);
1044 if (path
->slots
[0] == 0) {
1045 btrfs_release_path(root
, path
);
1051 item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
1052 struct btrfs_file_extent_item
);
1053 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1054 blocknr
= btrfs_file_extent_disk_blocknr(item
);
1055 blocknr
+= btrfs_file_extent_offset(item
);
1057 /* exact match found, use it, FIXME, deal with extents
1058 * other than the page size
1060 if (0 && ret
== 0) {
1063 btrfs_file_extent_generation(item
) != trans
->transid
) {
1064 struct btrfs_key ins
;
1065 ret
= btrfs_alloc_extent(trans
, root
, 1,
1066 blocknr
, (u64
)-1, &ins
);
1068 btrfs_set_file_extent_disk_blocknr(item
, ins
.objectid
);
1069 mark_buffer_dirty(path
->nodes
[0]);
1070 ret
= btrfs_free_extent(trans
, root
,
1073 blocknr
= ins
.objectid
;
1076 btrfs_map_bh_to_logical(root
, result
, blocknr
);
1080 /* are we inside the extent that was found? */
1081 found_key
= &leaf
->items
[path
->slots
[0]].key
;
1082 if (btrfs_disk_key_objectid(found_key
) != objectid
||
1083 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
) {
1086 btrfs_release_path(root
, path
);
1090 extent_start
= btrfs_disk_key_offset(&leaf
->items
[path
->slots
[0]].key
);
1091 extent_start
= extent_start
>> inode
->i_blkbits
;
1092 extent_end
= extent_start
+ btrfs_file_extent_num_blocks(item
);
1093 if (iblock
>= extent_start
&& iblock
< extent_end
) {
1095 btrfs_map_bh_to_logical(root
, result
, blocknr
+ iblock
-
1100 /* ok, create a new extent */
1106 ret
= btrfs_alloc_file_extent(trans
, root
, objectid
,
1107 iblock
<< inode
->i_blkbits
,
1108 1, extent_end
, &blocknr
);
1113 inode
->i_blocks
+= inode
->i_sb
->s_blocksize
>> 9;
1114 set_buffer_new(result
);
1115 map_bh(result
, inode
->i_sb
, blocknr
);
1117 btrfs_map_bh_to_logical(root
, result
, blocknr
);
1120 btrfs_release_path(root
, path
);
1121 btrfs_free_path(path
);
1122 printk("mapping iblock %lu to %lu\n", iblock
, result
->b_blocknr
);
1124 btrfs_end_transaction(trans
, root
);
1128 static int btrfs_get_block(struct inode
*inode
, sector_t iblock
,
1129 struct buffer_head
*result
, int create
)
1132 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1133 mutex_lock(&root
->fs_info
->fs_mutex
);
1134 err
= btrfs_get_block_lock(inode
, iblock
, result
, create
);
1135 // err = btrfs_get_block_inline(inode, iblock, result, create);
1136 mutex_unlock(&root
->fs_info
->fs_mutex
);
1140 static int btrfs_prepare_write(struct file
*file
, struct page
*page
,
1141 unsigned from
, unsigned to
)
1143 return nobh_prepare_write(page
, from
, to
, btrfs_get_block
);
1145 static int btrfs_commit_write(struct file
*file
, struct page
*page
,
1146 unsigned from
, unsigned to
)
1148 return nobh_commit_write(file
, page
, from
, to
);
1151 static void btrfs_write_super(struct super_block
*sb
)
1153 btrfs_sync_fs(sb
, 1);
1156 static int btrfs_readpage(struct file
*file
, struct page
*page
)
1158 return mpage_readpage(page
, btrfs_get_block
);
1161 static int btrfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1163 return nobh_writepage(page
, btrfs_get_block
, wbc
);
1166 static void btrfs_truncate(struct inode
*inode
)
1168 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1170 struct btrfs_trans_handle
*trans
;
1172 if (!S_ISREG(inode
->i_mode
))
1174 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1177 nobh_truncate_page(inode
->i_mapping
, inode
->i_size
);
1179 /* FIXME, add redo link to tree so we don't leak on crash */
1180 mutex_lock(&root
->fs_info
->fs_mutex
);
1181 trans
= btrfs_start_transaction(root
, 1);
1182 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
1184 ret
= btrfs_end_transaction(trans
, root
);
1186 mutex_unlock(&root
->fs_info
->fs_mutex
);
1187 mark_inode_dirty(inode
);
1190 static int btrfs_copy_from_user(loff_t pos
, int num_pages
, int write_bytes
,
1191 struct page
**prepared_pages
,
1192 const char __user
* buf
)
1194 long page_fault
= 0;
1196 int offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1198 for (i
= 0; i
< num_pages
&& write_bytes
> 0; i
++, offset
= 0) {
1199 size_t count
= min_t(size_t,
1200 PAGE_CACHE_SIZE
- offset
, write_bytes
);
1201 struct page
*page
= prepared_pages
[i
];
1202 fault_in_pages_readable(buf
, count
);
1204 /* Copy data from userspace to the current page */
1206 page_fault
= __copy_from_user(page_address(page
) + offset
,
1208 /* Flush processor's dcache for this page */
1209 flush_dcache_page(page
);
1212 write_bytes
-= count
;
1217 return page_fault
? -EFAULT
: 0;
1220 static void btrfs_drop_pages(struct page
**pages
, size_t num_pages
)
1223 for (i
= 0; i
< num_pages
; i
++) {
1226 unlock_page(pages
[i
]);
1227 mark_page_accessed(pages
[i
]);
1228 page_cache_release(pages
[i
]);
1231 static int dirty_and_release_pages(struct btrfs_trans_handle
*trans
,
1232 struct btrfs_root
*root
,
1234 struct page
**pages
,
1245 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1247 for (i
= 0; i
< num_pages
; i
++) {
1248 offset
= pos
& (PAGE_CACHE_SIZE
-1);
1249 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
1250 /* FIXME, one block at a time */
1252 mutex_lock(&root
->fs_info
->fs_mutex
);
1253 trans
= btrfs_start_transaction(root
, 1);
1254 btrfs_csum_file_block(trans
, root
, inode
->i_ino
,
1255 pages
[i
]->index
<< PAGE_CACHE_SHIFT
,
1257 kmap(pages
[i
]), PAGE_CACHE_SIZE
);
1259 SetPageChecked(pages
[i
]);
1260 ret
= btrfs_end_transaction(trans
, root
);
1262 mutex_unlock(&root
->fs_info
->fs_mutex
);
1264 ret
= nobh_commit_write(file
, pages
[i
], offset
,
1265 offset
+ this_write
);
1271 WARN_ON(this_write
> write_bytes
);
1272 write_bytes
-= this_write
;
1278 static int drop_csums(struct btrfs_trans_handle
*trans
,
1279 struct btrfs_root
*root
,
1280 struct inode
*inode
,
1283 struct btrfs_path
*path
;
1284 struct btrfs_leaf
*leaf
;
1285 struct btrfs_key key
;
1287 struct btrfs_csum_item
*item
;
1288 char *old_block
= NULL
;
1295 path
= btrfs_alloc_path();
1299 item
= btrfs_lookup_csum(trans
, root
, path
,
1300 inode
->i_ino
, cur
, 1);
1302 cur
+= root
->blocksize
;
1305 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1306 slot
= path
->slots
[0];
1307 btrfs_disk_key_to_cpu(&key
, &leaf
->items
[slot
].key
);
1308 item_size
= btrfs_item_size(leaf
->items
+ slot
);
1309 num_csums
= item_size
/ sizeof(struct btrfs_csum_item
);
1310 found_end
= key
.offset
+ (num_csums
<< inode
->i_blkbits
);
1313 if (found_end
> end
) {
1315 old_block
= kmalloc(root
->blocksize
, GFP_NOFS
);
1316 src
= btrfs_item_ptr(leaf
, slot
, char);
1317 memcpy(old_block
, src
, item_size
);
1319 if (key
.offset
< start
) {
1320 u64 new_size
= (start
- key
.offset
) >>
1322 new_size
*= sizeof(struct btrfs_csum_item
);
1323 ret
= btrfs_truncate_item(trans
, root
, path
, new_size
);
1326 btrfs_del_item(trans
, root
, path
);
1328 btrfs_release_path(root
, path
);
1329 if (found_end
> end
) {
1334 num_csums
= (found_end
- end
) >> inode
->i_blkbits
;
1335 new_size
= num_csums
* sizeof(struct btrfs_csum_item
);
1337 ret
= btrfs_insert_empty_item(trans
, root
, path
,
1340 dst
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
1341 path
->slots
[0], char);
1342 memcpy(dst
, old_block
+ item_size
- new_size
,
1344 item
= (struct btrfs_csum_item
*)dst
;
1345 for (i
= 0; i
< num_csums
; i
++) {
1346 btrfs_set_csum_extent_offset(item
, end
);
1349 mark_buffer_dirty(path
->nodes
[0]);
1354 btrfs_free_path(path
);
1358 static int drop_extents(struct btrfs_trans_handle
*trans
,
1359 struct btrfs_root
*root
,
1360 struct inode
*inode
,
1364 struct btrfs_key key
;
1365 struct btrfs_leaf
*leaf
;
1367 struct btrfs_file_extent_item
*extent
;
1370 struct btrfs_file_extent_item old
;
1371 struct btrfs_path
*path
;
1372 u64 search_start
= start
;
1375 path
= btrfs_alloc_path();
1379 printk("drop extent inode %lu start %Lu end %Lu\n", inode
->i_ino
, start
, end
);
1380 ret
= btrfs_lookup_file_extent(trans
, root
, path
, inode
->i_ino
,
1383 printk("lookup failed\n");
1389 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1390 slot
= path
->slots
[0];
1391 btrfs_disk_key_to_cpu(&key
, &leaf
->items
[slot
].key
);
1393 printk("found key %Lu %Lu %u\n", key
.objectid
, key
.offset
, key
.flags
);
1395 extent
= btrfs_item_ptr(leaf
, slot
,
1396 struct btrfs_file_extent_item
);
1397 extent_end
= key
.offset
+
1398 (btrfs_file_extent_num_blocks(extent
) <<
1400 printk("extent end is %Lu\n", extent_end
);
1401 if (key
.offset
>= end
|| key
.objectid
!= inode
->i_ino
) {
1405 if (btrfs_key_type(&key
) != BTRFS_EXTENT_DATA_KEY
)
1408 if (end
< extent_end
&& end
>= key
.offset
) {
1409 memcpy(&old
, extent
, sizeof(old
));
1410 ret
= btrfs_inc_extent_ref(trans
, root
,
1411 btrfs_file_extent_disk_blocknr(&old
),
1412 btrfs_file_extent_disk_num_blocks(&old
));
1417 if (start
> key
.offset
) {
1419 /* truncate existing extent */
1421 WARN_ON(start
& (root
->blocksize
- 1));
1422 new_num
= (start
- key
.offset
) >> inode
->i_blkbits
;
1423 printk("truncating existing extent, was %Lu ", btrfs_file_extent_num_blocks(extent
));
1424 btrfs_set_file_extent_num_blocks(extent
, new_num
);
1425 printk("now %Lu\n", btrfs_file_extent_num_blocks(extent
));
1427 mark_buffer_dirty(path
->nodes
[0]);
1431 u64 disk_num_blocks
;
1432 printk("del old\n");
1433 disk_blocknr
= btrfs_file_extent_disk_blocknr(extent
);
1435 btrfs_file_extent_disk_num_blocks(extent
);
1436 search_start
= key
.offset
+
1437 (btrfs_file_extent_num_blocks(extent
) <<
1439 ret
= btrfs_del_item(trans
, root
, path
);
1441 btrfs_release_path(root
, path
);
1443 ret
= btrfs_free_extent(trans
, root
, disk_blocknr
,
1444 disk_num_blocks
, 0);
1447 if (!bookend
&& search_start
>= end
) {
1455 /* create bookend */
1456 struct btrfs_key ins
;
1457 printk("bookend! extent end %Lu\n", extent_end
);
1458 ins
.objectid
= inode
->i_ino
;
1461 btrfs_set_key_type(&ins
, BTRFS_EXTENT_DATA_KEY
);
1463 btrfs_release_path(root
, path
);
1464 ret
= drop_csums(trans
, root
, inode
, start
, end
);
1466 ret
= btrfs_insert_empty_item(trans
, root
, path
, &ins
,
1469 extent
= btrfs_item_ptr(
1470 btrfs_buffer_leaf(path
->nodes
[0]),
1472 struct btrfs_file_extent_item
);
1473 btrfs_set_file_extent_disk_blocknr(extent
,
1474 btrfs_file_extent_disk_blocknr(&old
));
1475 btrfs_set_file_extent_disk_num_blocks(extent
,
1476 btrfs_file_extent_disk_num_blocks(&old
));
1478 btrfs_set_file_extent_offset(extent
,
1479 btrfs_file_extent_offset(&old
) +
1480 ((end
- key
.offset
) >> inode
->i_blkbits
));
1481 WARN_ON(btrfs_file_extent_num_blocks(&old
) <
1482 (end
- key
.offset
) >> inode
->i_blkbits
);
1483 btrfs_set_file_extent_num_blocks(extent
,
1484 btrfs_file_extent_num_blocks(&old
) -
1485 ((end
- key
.offset
) >> inode
->i_blkbits
));
1487 btrfs_set_file_extent_generation(extent
,
1488 btrfs_file_extent_generation(&old
));
1489 printk("new bookend at offset %Lu, file_extent_offset %Lu, file_extent_num_blocks %Lu\n", end
, btrfs_file_extent_offset(extent
), btrfs_file_extent_num_blocks(extent
));
1490 btrfs_mark_buffer_dirty(path
->nodes
[0]);
1495 if (slot
>= btrfs_header_nritems(&leaf
->header
) - 1) {
1496 ret
= btrfs_next_leaf(root
, path
);
1507 ret
= drop_csums(trans
, root
, inode
, start
, end
);
1511 btrfs_free_path(path
);
1515 static int prepare_pages(struct btrfs_root
*root
,
1517 struct page
**pages
,
1520 unsigned long first_index
,
1521 unsigned long last_index
,
1523 u64 alloc_extent_start
)
1526 unsigned long index
= pos
>> PAGE_CACHE_SHIFT
;
1527 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1531 struct buffer_head
*bh
;
1532 struct buffer_head
*head
;
1533 loff_t isize
= i_size_read(inode
);
1535 memset(pages
, 0, num_pages
* sizeof(struct page
*));
1537 for (i
= 0; i
< num_pages
; i
++) {
1538 pages
[i
] = grab_cache_page(inode
->i_mapping
, index
+ i
);
1541 goto failed_release
;
1543 offset
= pos
& (PAGE_CACHE_SIZE
-1);
1544 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
1546 if ((pages
[i
]->index
== first_index
||
1547 pages
[i
]->index
== last_index
) && pos
< isize
&&
1548 !PageUptodate(pages
[i
])) {
1549 ret
= mpage_readpage(pages
[i
], btrfs_get_block
);
1551 lock_page(pages
[i
]);
1554 create_empty_buffers(pages
[i
], root
->fs_info
->sb
->s_blocksize
,
1555 (1 << BH_Uptodate
));
1556 head
= page_buffers(pages
[i
]);
1559 printk("mapping page %lu to block %Lu\n", pages
[i
]->index
, alloc_extent_start
);
1560 err
= btrfs_map_bh_to_logical(root
, bh
,
1561 alloc_extent_start
);
1564 goto failed_truncate
;
1565 bh
= bh
->b_this_page
;
1566 alloc_extent_start
++;
1567 } while (bh
!= head
);
1569 WARN_ON(this_write
> write_bytes
);
1570 write_bytes
-= this_write
;
1575 btrfs_drop_pages(pages
, num_pages
);
1579 btrfs_drop_pages(pages
, num_pages
);
1581 vmtruncate(inode
, isize
);
1585 static ssize_t
btrfs_file_write(struct file
*file
, const char __user
*buf
,
1586 size_t count
, loff_t
*ppos
)
1589 size_t num_written
= 0;
1592 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1593 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1594 struct page
*pages
[8];
1595 unsigned long first_index
;
1596 unsigned long last_index
;
1599 u64 alloc_extent_start
;
1600 u64 orig_extent_start
;
1601 struct btrfs_trans_handle
*trans
;
1602 struct btrfs_key ins
;
1604 if (file
->f_flags
& O_DIRECT
)
1608 start_pos
= pos
& ~(root
->blocksize
- 1);
1610 if (start_pos
!= pos
)
1612 num_blocks
= (count
+ pos
- start_pos
+ root
->blocksize
- 1) >>
1615 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
1616 current
->backing_dev_info
= inode
->i_mapping
->backing_dev_info
;
1617 err
= generic_write_checks(file
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
1622 err
= remove_suid(file
->f_path
.dentry
);
1625 file_update_time(file
);
1626 mutex_lock(&inode
->i_mutex
);
1627 first_index
= pos
>> PAGE_CACHE_SHIFT
;
1628 last_index
= (pos
+ count
) >> PAGE_CACHE_SHIFT
;
1630 mutex_lock(&root
->fs_info
->fs_mutex
);
1631 trans
= btrfs_start_transaction(root
, 1);
1634 mutex_unlock(&root
->fs_info
->fs_mutex
);
1637 if (start_pos
< inode
->i_size
) {
1638 ret
= drop_extents(trans
, root
, inode
,
1640 (pos
+ count
+ root
->blocksize
-1) &
1641 ~(root
->blocksize
- 1));
1643 orig_extent_start
= start_pos
;
1644 ret
= btrfs_alloc_extent(trans
, root
, num_blocks
, 1,
1647 ret
= btrfs_insert_file_extent(trans
, root
, inode
->i_ino
,
1648 start_pos
, ins
.objectid
, ins
.offset
);
1650 alloc_extent_start
= ins
.objectid
;
1651 ret
= btrfs_end_transaction(trans
, root
);
1652 mutex_unlock(&root
->fs_info
->fs_mutex
);
1655 size_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1656 size_t write_bytes
= min(count
, PAGE_CACHE_SIZE
- offset
);
1657 size_t num_pages
= (write_bytes
+ PAGE_CACHE_SIZE
- 1) >>
1659 printk("num_pages is %lu\n", num_pages
);
1661 memset(pages
, 0, sizeof(pages
));
1662 ret
= prepare_pages(root
, file
, pages
, num_pages
,
1663 pos
, first_index
, last_index
,
1664 write_bytes
, alloc_extent_start
);
1667 /* FIXME blocks != pagesize */
1668 alloc_extent_start
+= num_pages
;
1669 ret
= btrfs_copy_from_user(pos
, num_pages
,
1670 write_bytes
, pages
, buf
);
1673 printk("2num_pages is %lu\n", num_pages
);
1674 ret
= dirty_and_release_pages(NULL
, root
, file
, pages
,
1675 num_pages
, orig_extent_start
,
1678 btrfs_drop_pages(pages
, num_pages
);
1681 count
-= write_bytes
;
1683 num_written
+= write_bytes
;
1685 balance_dirty_pages_ratelimited(inode
->i_mapping
);
1689 mutex_unlock(&inode
->i_mutex
);
1692 current
->backing_dev_info
= NULL
;
1693 return num_written
? num_written
: err
;
1697 static ssize_t
inline_one_page(struct btrfs_root
*root
, struct inode
*inode
,
1698 struct page
*page
, loff_t pos
,
1699 size_t offset
, size_t write_bytes
)
1701 struct btrfs_path
*path
;
1702 struct btrfs_trans_handle
*trans
;
1703 struct btrfs_key key
;
1704 struct btrfs_leaf
*leaf
;
1705 struct btrfs_key found_key
;
1707 size_t copy_size
= 0;
1710 size_t num_written
= 0;
1712 path
= btrfs_alloc_path();
1714 mutex_lock(&root
->fs_info
->fs_mutex
);
1715 trans
= btrfs_start_transaction(root
, 1);
1716 key
.objectid
= inode
->i_ino
;
1718 btrfs_set_key_type(&key
, BTRFS_INLINE_DATA_KEY
);
1722 ret
= btrfs_search_slot(trans
, root
, &key
, path
, 0, 1);
1728 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1729 btrfs_disk_key_to_cpu(&found_key
,
1730 &leaf
->items
[path
->slots
[0]].key
);
1731 copy_size
= btrfs_item_size(leaf
->items
+ path
->slots
[0]);
1732 dst
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
1733 copy_size
= min(write_bytes
, copy_size
);
1736 int slot
= path
->slots
[0];
1740 // FIXME find max key
1741 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1742 btrfs_disk_key_to_cpu(&found_key
,
1743 &leaf
->items
[slot
].key
);
1744 if (found_key
.objectid
!= inode
->i_ino
)
1746 if (btrfs_key_type(&found_key
) != BTRFS_INLINE_DATA_KEY
)
1748 copy_size
= btrfs_item_size(leaf
->items
+ slot
);
1749 if (found_key
.offset
+ copy_size
<= pos
)
1751 dst
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
1752 dst
+= pos
- found_key
.offset
;
1753 copy_size
= copy_size
- (pos
- found_key
.offset
);
1754 BUG_ON(copy_size
< 0);
1755 copy_size
= min(write_bytes
, copy_size
);
1756 WARN_ON(copy_size
== 0);
1760 btrfs_release_path(root
, path
);
1761 copy_size
= min(write_bytes
,
1762 (size_t)BTRFS_LEAF_DATA_SIZE(root
) -
1763 sizeof(struct btrfs_item
) * 4);
1764 ret
= btrfs_insert_empty_item(trans
, root
, path
, &key
, copy_size
);
1766 dst
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
1767 path
->slots
[0], char);
1769 WARN_ON(copy_size
== 0);
1770 WARN_ON(dst
+ copy_size
>
1771 btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
1772 path
->slots
[0], char) +
1773 btrfs_item_size(btrfs_buffer_leaf(path
->nodes
[0])->items
+
1775 btrfs_memcpy(root
, path
->nodes
[0]->b_data
, dst
,
1776 page_address(page
) + offset
, copy_size
);
1777 mark_buffer_dirty(path
->nodes
[0]);
1778 btrfs_release_path(root
, path
);
1780 offset
+= copy_size
;
1781 num_written
+= copy_size
;
1782 write_bytes
-= copy_size
;
1786 btrfs_free_path(path
);
1787 ret
= btrfs_end_transaction(trans
, root
);
1789 mutex_unlock(&root
->fs_info
->fs_mutex
);
1790 return num_written
? num_written
: err
;
1793 static ssize_t
btrfs_file_inline_write(struct file
*file
,
1794 const char __user
*buf
,
1795 size_t count
, loff_t
*ppos
)
1798 size_t num_written
= 0;
1801 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1802 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1803 unsigned long page_index
;
1805 if (file
->f_flags
& O_DIRECT
)
1809 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
1810 current
->backing_dev_info
= inode
->i_mapping
->backing_dev_info
;
1811 err
= generic_write_checks(file
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
1816 err
= remove_suid(file
->f_path
.dentry
);
1819 file_update_time(file
);
1820 mutex_lock(&inode
->i_mutex
);
1822 size_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1823 size_t write_bytes
= min(count
, PAGE_CACHE_SIZE
- offset
);
1826 page_index
= pos
>> PAGE_CACHE_SHIFT
;
1827 page
= grab_cache_page(inode
->i_mapping
, page_index
);
1828 if (!PageUptodate(page
)) {
1829 ret
= mpage_readpage(page
, btrfs_get_block
);
1833 ret
= btrfs_copy_from_user(pos
, 1,
1834 write_bytes
, &page
, buf
);
1836 write_bytes
= inline_one_page(root
, inode
, page
, pos
,
1837 offset
, write_bytes
);
1838 SetPageUptodate(page
);
1839 if (write_bytes
> 0 && pos
+ write_bytes
> inode
->i_size
) {
1840 i_size_write(inode
, pos
+ write_bytes
);
1841 mark_inode_dirty(inode
);
1843 page_cache_release(page
);
1845 if (write_bytes
< 0)
1848 count
-= write_bytes
;
1850 num_written
+= write_bytes
;
1852 balance_dirty_pages_ratelimited(inode
->i_mapping
);
1856 mutex_unlock(&inode
->i_mutex
);
1859 current
->backing_dev_info
= NULL
;
1860 return num_written
? num_written
: err
;
1864 static int btrfs_read_actor(read_descriptor_t
*desc
, struct page
*page
,
1865 unsigned long offset
, unsigned long size
)
1868 unsigned long left
, count
= desc
->count
;
1869 struct inode
*inode
= page
->mapping
->host
;
1874 if (!PageChecked(page
)) {
1875 /* FIXME, do it per block */
1876 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
1877 int ret
= btrfs_csum_verify_file_block(root
,
1878 page
->mapping
->host
->i_ino
,
1879 page
->index
<< PAGE_CACHE_SHIFT
,
1880 kmap(page
), PAGE_CACHE_SIZE
);
1882 printk("failed to verify ino %lu page %lu\n",
1883 page
->mapping
->host
->i_ino
,
1885 memset(page_address(page
), 0, PAGE_CACHE_SIZE
);
1887 SetPageChecked(page
);
1891 * Faults on the destination of a read are common, so do it before
1894 if (!fault_in_pages_writeable(desc
->arg
.buf
, size
)) {
1895 kaddr
= kmap_atomic(page
, KM_USER0
);
1896 left
= __copy_to_user_inatomic(desc
->arg
.buf
,
1897 kaddr
+ offset
, size
);
1898 kunmap_atomic(kaddr
, KM_USER0
);
1903 /* Do it the slow way */
1905 left
= __copy_to_user(desc
->arg
.buf
, kaddr
+ offset
, size
);
1910 desc
->error
= -EFAULT
;
1913 desc
->count
= count
- size
;
1914 desc
->written
+= size
;
1915 desc
->arg
.buf
+= size
;
1920 * btrfs_file_aio_read - filesystem read routine
1921 * @iocb: kernel I/O control block
1922 * @iov: io vector request
1923 * @nr_segs: number of segments in the iovec
1924 * @pos: current file position
1926 static ssize_t
btrfs_file_aio_read(struct kiocb
*iocb
, const struct iovec
*iov
,
1927 unsigned long nr_segs
, loff_t pos
)
1929 struct file
*filp
= iocb
->ki_filp
;
1933 loff_t
*ppos
= &iocb
->ki_pos
;
1936 for (seg
= 0; seg
< nr_segs
; seg
++) {
1937 const struct iovec
*iv
= &iov
[seg
];
1940 * If any segment has a negative length, or the cumulative
1941 * length ever wraps negative then return -EINVAL.
1943 count
+= iv
->iov_len
;
1944 if (unlikely((ssize_t
)(count
|iv
->iov_len
) < 0))
1946 if (access_ok(VERIFY_WRITE
, iv
->iov_base
, iv
->iov_len
))
1951 count
-= iv
->iov_len
; /* This segment is no good */
1956 for (seg
= 0; seg
< nr_segs
; seg
++) {
1957 read_descriptor_t desc
;
1960 desc
.arg
.buf
= iov
[seg
].iov_base
;
1961 desc
.count
= iov
[seg
].iov_len
;
1962 if (desc
.count
== 0)
1965 do_generic_file_read(filp
, ppos
, &desc
,
1967 retval
+= desc
.written
;
1969 retval
= retval
?: desc
.error
;
1977 static int create_subvol(struct btrfs_root
*root
, char *name
, int namelen
)
1979 struct btrfs_trans_handle
*trans
;
1980 struct btrfs_key key
;
1981 struct btrfs_root_item root_item
;
1982 struct btrfs_inode_item
*inode_item
;
1983 struct buffer_head
*subvol
;
1984 struct btrfs_leaf
*leaf
;
1985 struct btrfs_root
*new_root
;
1986 struct inode
*inode
;
1989 u64 new_dirid
= BTRFS_FIRST_FREE_OBJECTID
;
1991 mutex_lock(&root
->fs_info
->fs_mutex
);
1992 trans
= btrfs_start_transaction(root
, 1);
1995 subvol
= btrfs_alloc_free_block(trans
, root
);
1996 leaf
= btrfs_buffer_leaf(subvol
);
1997 btrfs_set_header_nritems(&leaf
->header
, 0);
1998 btrfs_set_header_level(&leaf
->header
, 0);
1999 btrfs_set_header_blocknr(&leaf
->header
, bh_blocknr(subvol
));
2000 btrfs_set_header_generation(&leaf
->header
, trans
->transid
);
2001 memcpy(leaf
->header
.fsid
, root
->fs_info
->disk_super
->fsid
,
2002 sizeof(leaf
->header
.fsid
));
2004 inode_item
= &root_item
.inode
;
2005 memset(inode_item
, 0, sizeof(*inode_item
));
2006 btrfs_set_inode_generation(inode_item
, 1);
2007 btrfs_set_inode_size(inode_item
, 3);
2008 btrfs_set_inode_nlink(inode_item
, 1);
2009 btrfs_set_inode_nblocks(inode_item
, 1);
2010 btrfs_set_inode_mode(inode_item
, S_IFDIR
| 0755);
2012 btrfs_set_root_blocknr(&root_item
, bh_blocknr(subvol
));
2013 btrfs_set_root_refs(&root_item
, 1);
2015 mark_buffer_dirty(subvol
);
2019 ret
= btrfs_find_free_objectid(trans
, root
->fs_info
->tree_root
,
2023 btrfs_set_root_dirid(&root_item
, new_dirid
);
2025 key
.objectid
= objectid
;
2028 btrfs_set_key_type(&key
, BTRFS_ROOT_ITEM_KEY
);
2029 ret
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
, &key
,
2034 * insert the directory item
2036 key
.offset
= (u64
)-1;
2037 ret
= btrfs_insert_dir_item(trans
, root
->fs_info
->tree_root
,
2039 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
,
2043 ret
= btrfs_commit_transaction(trans
, root
);
2046 new_root
= btrfs_read_fs_root(root
->fs_info
, &key
);
2049 trans
= btrfs_start_transaction(new_root
, 1);
2052 inode
= btrfs_new_inode(trans
, new_root
, new_dirid
, S_IFDIR
| 0700);
2053 inode
->i_op
= &btrfs_dir_inode_operations
;
2054 inode
->i_fop
= &btrfs_dir_file_operations
;
2056 ret
= btrfs_make_empty_dir(trans
, new_root
, new_dirid
, new_dirid
);
2061 ret
= btrfs_update_inode(trans
, new_root
, inode
);
2064 ret
= btrfs_commit_transaction(trans
, new_root
);
2069 mutex_unlock(&root
->fs_info
->fs_mutex
);
2073 static int create_snapshot(struct btrfs_root
*root
, char *name
, int namelen
)
2075 struct btrfs_trans_handle
*trans
;
2076 struct btrfs_key key
;
2077 struct btrfs_root_item new_root_item
;
2081 if (!root
->ref_cows
)
2084 mutex_lock(&root
->fs_info
->fs_mutex
);
2085 trans
= btrfs_start_transaction(root
, 1);
2088 ret
= btrfs_update_inode(trans
, root
, root
->inode
);
2091 ret
= btrfs_find_free_objectid(trans
, root
->fs_info
->tree_root
,
2095 memcpy(&new_root_item
, &root
->root_item
,
2096 sizeof(new_root_item
));
2098 key
.objectid
= objectid
;
2101 btrfs_set_key_type(&key
, BTRFS_ROOT_ITEM_KEY
);
2102 btrfs_set_root_blocknr(&new_root_item
, bh_blocknr(root
->node
));
2104 ret
= btrfs_insert_root(trans
, root
->fs_info
->tree_root
, &key
,
2109 * insert the directory item
2111 key
.offset
= (u64
)-1;
2112 ret
= btrfs_insert_dir_item(trans
, root
->fs_info
->tree_root
,
2114 root
->fs_info
->sb
->s_root
->d_inode
->i_ino
,
2119 ret
= btrfs_inc_root_ref(trans
, root
);
2122 ret
= btrfs_commit_transaction(trans
, root
);
2124 mutex_unlock(&root
->fs_info
->fs_mutex
);
2128 static int add_disk(struct btrfs_root
*root
, char *name
, int namelen
)
2130 struct block_device
*bdev
;
2131 struct btrfs_path
*path
;
2132 struct super_block
*sb
= root
->fs_info
->sb
;
2133 struct btrfs_root
*dev_root
= root
->fs_info
->dev_root
;
2134 struct btrfs_trans_handle
*trans
;
2135 struct btrfs_device_item
*dev_item
;
2136 struct btrfs_key key
;
2143 printk("adding disk %s\n", name
);
2144 path
= btrfs_alloc_path();
2147 num_blocks
= btrfs_super_total_blocks(root
->fs_info
->disk_super
);
2148 bdev
= open_bdev_excl(name
, O_RDWR
, sb
);
2150 ret
= PTR_ERR(bdev
);
2151 printk("open bdev excl failed ret %d\n", ret
);
2154 set_blocksize(bdev
, sb
->s_blocksize
);
2155 new_blocks
= bdev
->bd_inode
->i_size
>> sb
->s_blocksize_bits
;
2156 key
.objectid
= num_blocks
;
2157 key
.offset
= new_blocks
;
2159 btrfs_set_key_type(&key
, BTRFS_DEV_ITEM_KEY
);
2161 mutex_lock(&dev_root
->fs_info
->fs_mutex
);
2162 trans
= btrfs_start_transaction(dev_root
, 1);
2163 item_size
= sizeof(*dev_item
) + namelen
;
2164 printk("insert empty on %Lu %Lu %u size %d\n", num_blocks
, new_blocks
, key
.flags
, item_size
);
2165 ret
= btrfs_insert_empty_item(trans
, dev_root
, path
, &key
, item_size
);
2167 printk("insert failed %d\n", ret
);
2168 close_bdev_excl(bdev
);
2173 dev_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
2174 path
->slots
[0], struct btrfs_device_item
);
2175 btrfs_set_device_pathlen(dev_item
, namelen
);
2176 memcpy(dev_item
+ 1, name
, namelen
);
2178 device_id
= btrfs_super_last_device_id(root
->fs_info
->disk_super
) + 1;
2179 btrfs_set_super_last_device_id(root
->fs_info
->disk_super
, device_id
);
2180 btrfs_set_device_id(dev_item
, device_id
);
2181 mark_buffer_dirty(path
->nodes
[0]);
2183 ret
= btrfs_insert_dev_radix(root
, bdev
, device_id
, num_blocks
,
2187 btrfs_set_super_total_blocks(root
->fs_info
->disk_super
,
2188 num_blocks
+ new_blocks
);
2189 i_size_write(root
->fs_info
->btree_inode
,
2190 (num_blocks
+ new_blocks
) <<
2191 root
->fs_info
->btree_inode
->i_blkbits
);
2195 ret
= btrfs_commit_transaction(trans
, dev_root
);
2197 mutex_unlock(&root
->fs_info
->fs_mutex
);
2199 btrfs_free_path(path
);
2204 static int btrfs_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int
2205 cmd
, unsigned long arg
)
2207 struct btrfs_root
*root
= BTRFS_I(inode
)->root
;
2208 struct btrfs_ioctl_vol_args vol_args
;
2211 struct btrfs_path
*path
;
2215 case BTRFS_IOC_SNAP_CREATE
:
2216 if (copy_from_user(&vol_args
,
2217 (struct btrfs_ioctl_vol_args __user
*)arg
,
2220 namelen
= strlen(vol_args
.name
);
2221 if (namelen
> BTRFS_VOL_NAME_MAX
)
2223 path
= btrfs_alloc_path();
2226 root_dirid
= root
->fs_info
->sb
->s_root
->d_inode
->i_ino
,
2227 mutex_lock(&root
->fs_info
->fs_mutex
);
2228 ret
= btrfs_lookup_dir_item(NULL
, root
->fs_info
->tree_root
,
2230 vol_args
.name
, namelen
, 0);
2231 mutex_unlock(&root
->fs_info
->fs_mutex
);
2232 btrfs_free_path(path
);
2236 if (root
== root
->fs_info
->tree_root
)
2237 ret
= create_subvol(root
, vol_args
.name
, namelen
);
2239 ret
= create_snapshot(root
, vol_args
.name
, namelen
);
2242 case BTRFS_IOC_ADD_DISK
:
2243 if (copy_from_user(&vol_args
,
2244 (struct btrfs_ioctl_vol_args __user
*)arg
,
2247 namelen
= strlen(vol_args
.name
);
2248 if (namelen
> BTRFS_VOL_NAME_MAX
)
2250 vol_args
.name
[namelen
] = '\0';
2251 ret
= add_disk(root
, vol_args
.name
, namelen
);
2259 static struct kmem_cache
*btrfs_inode_cachep
;
2260 struct kmem_cache
*btrfs_trans_handle_cachep
;
2261 struct kmem_cache
*btrfs_transaction_cachep
;
2262 struct kmem_cache
*btrfs_bit_radix_cachep
;
2263 struct kmem_cache
*btrfs_path_cachep
;
2266 * Called inside transaction, so use GFP_NOFS
2268 static struct inode
*btrfs_alloc_inode(struct super_block
*sb
)
2270 struct btrfs_inode
*ei
;
2272 ei
= kmem_cache_alloc(btrfs_inode_cachep
, GFP_NOFS
);
2275 return &ei
->vfs_inode
;
2278 static void btrfs_destroy_inode(struct inode
*inode
)
2280 WARN_ON(!list_empty(&inode
->i_dentry
));
2281 WARN_ON(inode
->i_data
.nrpages
);
2283 kmem_cache_free(btrfs_inode_cachep
, BTRFS_I(inode
));
2286 static void init_once(void * foo
, struct kmem_cache
* cachep
,
2287 unsigned long flags
)
2289 struct btrfs_inode
*ei
= (struct btrfs_inode
*) foo
;
2291 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
2292 SLAB_CTOR_CONSTRUCTOR
) {
2293 inode_init_once(&ei
->vfs_inode
);
2297 static int init_inodecache(void)
2299 btrfs_inode_cachep
= kmem_cache_create("btrfs_inode_cache",
2300 sizeof(struct btrfs_inode
),
2301 0, (SLAB_RECLAIM_ACCOUNT
|
2304 btrfs_trans_handle_cachep
= kmem_cache_create("btrfs_trans_handle_cache",
2305 sizeof(struct btrfs_trans_handle
),
2306 0, (SLAB_RECLAIM_ACCOUNT
|
2309 btrfs_transaction_cachep
= kmem_cache_create("btrfs_transaction_cache",
2310 sizeof(struct btrfs_transaction
),
2311 0, (SLAB_RECLAIM_ACCOUNT
|
2314 btrfs_path_cachep
= kmem_cache_create("btrfs_path_cache",
2315 sizeof(struct btrfs_transaction
),
2316 0, (SLAB_RECLAIM_ACCOUNT
|
2319 btrfs_bit_radix_cachep
= kmem_cache_create("btrfs_radix",
2321 0, (SLAB_RECLAIM_ACCOUNT
|
2323 SLAB_DESTROY_BY_RCU
),
2325 if (btrfs_inode_cachep
== NULL
|| btrfs_trans_handle_cachep
== NULL
||
2326 btrfs_transaction_cachep
== NULL
|| btrfs_bit_radix_cachep
== NULL
)
2331 static void destroy_inodecache(void)
2333 kmem_cache_destroy(btrfs_inode_cachep
);
2334 kmem_cache_destroy(btrfs_trans_handle_cachep
);
2335 kmem_cache_destroy(btrfs_transaction_cachep
);
2336 kmem_cache_destroy(btrfs_bit_radix_cachep
);
2337 kmem_cache_destroy(btrfs_path_cachep
);
2340 static int btrfs_get_sb(struct file_system_type
*fs_type
,
2341 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
2343 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
2344 btrfs_fill_super
, mnt
);
2347 static struct file_system_type btrfs_fs_type
= {
2348 .owner
= THIS_MODULE
,
2350 .get_sb
= btrfs_get_sb
,
2351 .kill_sb
= kill_block_super
,
2352 .fs_flags
= FS_REQUIRES_DEV
,
2355 static struct super_operations btrfs_super_ops
= {
2356 .statfs
= simple_statfs
,
2357 .delete_inode
= btrfs_delete_inode
,
2358 .put_super
= btrfs_put_super
,
2359 .read_inode
= btrfs_read_locked_inode
,
2360 .write_super
= btrfs_write_super
,
2361 .sync_fs
= btrfs_sync_fs
,
2362 .write_inode
= btrfs_write_inode
,
2363 .alloc_inode
= btrfs_alloc_inode
,
2364 .destroy_inode
= btrfs_destroy_inode
,
2367 static struct inode_operations btrfs_dir_inode_operations
= {
2368 .lookup
= btrfs_lookup
,
2369 .create
= btrfs_create
,
2370 .unlink
= btrfs_unlink
,
2371 .mkdir
= btrfs_mkdir
,
2372 .rmdir
= btrfs_rmdir
,
2375 static struct inode_operations btrfs_dir_ro_inode_operations
= {
2376 .lookup
= btrfs_lookup
,
2379 static struct file_operations btrfs_dir_file_operations
= {
2380 .llseek
= generic_file_llseek
,
2381 .read
= generic_read_dir
,
2382 .readdir
= btrfs_readdir
,
2383 .ioctl
= btrfs_ioctl
,
2386 static struct address_space_operations btrfs_aops
= {
2387 .readpage
= btrfs_readpage
,
2388 .writepage
= btrfs_writepage
,
2389 .sync_page
= block_sync_page
,
2390 .prepare_write
= btrfs_prepare_write
,
2391 .commit_write
= btrfs_commit_write
,
2394 static struct inode_operations btrfs_file_inode_operations
= {
2395 .truncate
= btrfs_truncate
,
2398 static struct file_operations btrfs_file_operations
= {
2399 .llseek
= generic_file_llseek
,
2400 .read
= do_sync_read
,
2401 .aio_read
= btrfs_file_aio_read
,
2402 .write
= btrfs_file_write
,
2403 .mmap
= generic_file_mmap
,
2404 .open
= generic_file_open
,
2405 .ioctl
= btrfs_ioctl
,
2408 static int __init
init_btrfs_fs(void)
2411 printk("btrfs loaded!\n");
2412 err
= init_inodecache();
2415 kset_set_kset_s(&btrfs_subsys
, fs_subsys
);
2416 err
= subsystem_register(&btrfs_subsys
);
2419 return register_filesystem(&btrfs_fs_type
);
2421 destroy_inodecache();
2425 static void __exit
exit_btrfs_fs(void)
2427 destroy_inodecache();
2428 unregister_filesystem(&btrfs_fs_type
);
2429 subsystem_unregister(&btrfs_subsys
);
2430 printk("btrfs unloaded\n");
2433 module_init(init_btrfs_fs
)
2434 module_exit(exit_btrfs_fs
)
2436 MODULE_LICENSE("GPL");