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"
19 #define BTRFS_SUPER_MAGIC 0x9123682E
21 static struct inode_operations btrfs_dir_inode_operations
;
22 static struct super_operations btrfs_super_ops
;
23 static struct file_operations btrfs_dir_file_operations
;
24 static struct inode_operations btrfs_file_inode_operations
;
25 static struct address_space_operations btrfs_aops
;
26 static struct file_operations btrfs_file_operations
;
28 static int check_inode(struct inode
*inode
)
30 struct btrfs_inode
*ei
= BTRFS_I(inode
);
31 WARN_ON(ei
->magic
!= 0xDEADBEEF);
32 WARN_ON(ei
->magic2
!= 0xDEADBEAF);
36 static void btrfs_read_locked_inode(struct inode
*inode
)
38 struct btrfs_path
*path
;
39 struct btrfs_inode_item
*inode_item
;
40 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
43 path
= btrfs_alloc_path();
45 btrfs_init_path(path
);
46 mutex_lock(&root
->fs_info
->fs_mutex
);
49 ret
= btrfs_lookup_inode(NULL
, root
, path
, inode
->i_ino
, 0);
51 btrfs_release_path(root
, path
);
52 btrfs_free_path(path
);
53 mutex_unlock(&root
->fs_info
->fs_mutex
);
54 make_bad_inode(inode
);
58 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
60 struct btrfs_inode_item
);
62 inode
->i_mode
= btrfs_inode_mode(inode_item
);
63 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
64 inode
->i_uid
= btrfs_inode_uid(inode_item
);
65 inode
->i_gid
= btrfs_inode_gid(inode_item
);
66 inode
->i_size
= btrfs_inode_size(inode_item
);
67 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
68 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
69 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
70 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
71 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
72 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
73 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
74 inode
->i_generation
= btrfs_inode_generation(inode_item
);
76 btrfs_release_path(root
, path
);
77 btrfs_free_path(path
);
80 mutex_unlock(&root
->fs_info
->fs_mutex
);
82 switch (inode
->i_mode
& S_IFMT
) {
85 init_special_inode(inode
, inode
->i_mode
,
86 btrfs_inode_rdev(inode_item
));
90 inode
->i_mapping
->a_ops
= &btrfs_aops
;
91 inode
->i_fop
= &btrfs_file_operations
;
92 inode
->i_op
= &btrfs_file_inode_operations
;
95 inode
->i_op
= &btrfs_dir_inode_operations
;
96 inode
->i_fop
= &btrfs_dir_file_operations
;
99 // inode->i_op = &page_symlink_inode_operations;
106 static int btrfs_unlink_trans(struct btrfs_trans_handle
*trans
,
107 struct btrfs_root
*root
,
109 struct dentry
*dentry
)
111 struct btrfs_path
*path
;
112 const char *name
= dentry
->d_name
.name
;
113 int name_len
= dentry
->d_name
.len
;
116 struct btrfs_dir_item
*di
;
118 path
= btrfs_alloc_path();
120 btrfs_init_path(path
);
121 ret
= btrfs_lookup_dir_item(trans
, root
, path
, dir
->i_ino
,
129 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
130 struct btrfs_dir_item
);
131 objectid
= btrfs_dir_objectid(di
);
133 ret
= btrfs_del_item(trans
, root
, path
);
136 btrfs_release_path(root
, path
);
137 ret
= btrfs_lookup_dir_index_item(trans
, root
, path
, dir
->i_ino
,
140 ret
= btrfs_del_item(trans
, root
, path
);
142 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
144 btrfs_release_path(root
, path
);
145 btrfs_free_path(path
);
147 inode_dec_link_count(dentry
->d_inode
);
148 dir
->i_size
-= name_len
* 2;
149 mark_inode_dirty(dir
);
154 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
156 struct btrfs_root
*root
;
157 struct btrfs_trans_handle
*trans
;
160 root
= btrfs_sb(dir
->i_sb
);
161 mutex_lock(&root
->fs_info
->fs_mutex
);
162 trans
= btrfs_start_transaction(root
, 1);
163 ret
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
164 btrfs_end_transaction(trans
, root
);
165 mutex_unlock(&root
->fs_info
->fs_mutex
);
169 static int btrfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
171 struct inode
*inode
= dentry
->d_inode
;
174 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
175 struct btrfs_path
*path
;
176 struct btrfs_key key
;
177 struct btrfs_trans_handle
*trans
;
178 struct btrfs_key found_key
;
180 struct btrfs_leaf
*leaf
;
181 char *goodnames
= "..";
183 path
= btrfs_alloc_path();
185 btrfs_init_path(path
);
186 mutex_lock(&root
->fs_info
->fs_mutex
);
187 trans
= btrfs_start_transaction(root
, 1);
188 key
.objectid
= inode
->i_ino
;
189 key
.offset
= (u64
)-1;
192 ret
= btrfs_search_slot(trans
, root
, &key
, path
, -1, 1);
198 if (path
->slots
[0] == 0) {
203 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
204 btrfs_disk_key_to_cpu(&found_key
,
205 &leaf
->items
[path
->slots
[0]].key
);
206 found_type
= btrfs_key_type(&found_key
);
207 if (found_key
.objectid
!= inode
->i_ino
) {
211 if ((found_type
!= BTRFS_DIR_ITEM_KEY
&&
212 found_type
!= BTRFS_DIR_INDEX_KEY
) ||
213 (!btrfs_match_dir_item_name(root
, path
, goodnames
, 2) &&
214 !btrfs_match_dir_item_name(root
, path
, goodnames
, 1))) {
218 ret
= btrfs_del_item(trans
, root
, path
);
221 if (found_type
== BTRFS_DIR_ITEM_KEY
&& found_key
.offset
== 1)
223 btrfs_release_path(root
, path
);
226 btrfs_release_path(root
, path
);
228 /* now the directory is empty */
229 err
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
234 btrfs_release_path(root
, path
);
235 btrfs_free_path(path
);
236 mutex_unlock(&root
->fs_info
->fs_mutex
);
237 ret
= btrfs_end_transaction(trans
, root
);
243 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
244 struct btrfs_root
*root
,
247 u64 objectid
= inode
->i_ino
;
248 struct btrfs_path
*path
;
249 struct btrfs_inode_map_item
*map
;
250 struct btrfs_key stat_data_key
;
255 path
= btrfs_alloc_path();
257 btrfs_init_path(path
);
258 ret
= btrfs_lookup_inode_map(trans
, root
, path
, objectid
, -1);
264 map
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
265 struct btrfs_inode_map_item
);
266 btrfs_disk_key_to_cpu(&stat_data_key
, &map
->key
);
267 ret
= btrfs_del_item(trans
, root
->fs_info
->inode_root
, path
);
269 btrfs_release_path(root
, path
);
271 ret
= btrfs_lookup_inode(trans
, root
, path
, objectid
, -1);
273 ret
= btrfs_del_item(trans
, root
, path
);
276 btrfs_release_path(root
, path
);
277 btrfs_free_path(path
);
281 static int btrfs_truncate_in_trans(struct btrfs_trans_handle
*trans
,
282 struct btrfs_root
*root
,
286 struct btrfs_path
*path
;
287 struct btrfs_key key
;
288 struct btrfs_disk_key
*found_key
;
289 struct btrfs_leaf
*leaf
;
290 struct btrfs_file_extent_item
*fi
= NULL
;
291 u64 extent_start
= 0;
292 u64 extent_num_blocks
= 0;
295 path
= btrfs_alloc_path();
297 /* FIXME, add redo link to tree so we don't leak on crash */
298 key
.objectid
= inode
->i_ino
;
299 key
.offset
= (u64
)-1;
302 * use BTRFS_CSUM_ITEM_KEY because it is larger than inline keys
305 btrfs_set_key_type(&key
, BTRFS_CSUM_ITEM_KEY
);
307 btrfs_init_path(path
);
308 ret
= btrfs_search_slot(trans
, root
, &key
, path
, -1, 1);
313 BUG_ON(path
->slots
[0] == 0);
316 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
317 found_key
= &leaf
->items
[path
->slots
[0]].key
;
318 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
)
320 if (btrfs_disk_key_type(found_key
) != BTRFS_CSUM_ITEM_KEY
&&
321 btrfs_disk_key_type(found_key
) != BTRFS_INLINE_DATA_KEY
&&
322 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
)
324 if (btrfs_disk_key_offset(found_key
) < inode
->i_size
)
326 if (btrfs_disk_key_type(found_key
) == BTRFS_EXTENT_DATA_KEY
) {
327 fi
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
329 struct btrfs_file_extent_item
);
330 extent_start
= btrfs_file_extent_disk_blocknr(fi
);
332 btrfs_file_extent_disk_num_blocks(fi
);
334 btrfs_file_extent_num_blocks(fi
) >> 9;
339 ret
= btrfs_del_item(trans
, root
, path
);
341 btrfs_release_path(root
, path
);
343 ret
= btrfs_free_extent(trans
, root
, extent_start
,
344 extent_num_blocks
, 0);
350 btrfs_release_path(root
, path
);
351 btrfs_free_path(path
);
355 static void btrfs_delete_inode(struct inode
*inode
)
357 struct btrfs_trans_handle
*trans
;
358 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
361 truncate_inode_pages(&inode
->i_data
, 0);
362 if (is_bad_inode(inode
)) {
366 mutex_lock(&root
->fs_info
->fs_mutex
);
367 trans
= btrfs_start_transaction(root
, 1);
368 if (S_ISREG(inode
->i_mode
)) {
369 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
372 btrfs_free_inode(trans
, root
, inode
);
373 btrfs_end_transaction(trans
, root
);
374 mutex_unlock(&root
->fs_info
->fs_mutex
);
380 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
383 const char *name
= dentry
->d_name
.name
;
384 int namelen
= dentry
->d_name
.len
;
385 struct btrfs_dir_item
*di
;
386 struct btrfs_path
*path
;
387 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
390 path
= btrfs_alloc_path();
392 btrfs_init_path(path
);
393 ret
= btrfs_lookup_dir_item(NULL
, root
, path
, dir
->i_ino
, name
,
395 if (ret
|| !btrfs_match_dir_item_name(root
, path
, name
, namelen
)) {
400 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
401 struct btrfs_dir_item
);
402 *ino
= btrfs_dir_objectid(di
);
404 btrfs_release_path(root
, path
);
405 btrfs_free_path(path
);
410 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
411 struct nameidata
*nd
)
413 struct inode
* inode
;
414 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
418 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
419 return ERR_PTR(-ENAMETOOLONG
);
420 mutex_lock(&root
->fs_info
->fs_mutex
);
421 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
422 mutex_unlock(&root
->fs_info
->fs_mutex
);
427 inode
= iget(dir
->i_sb
, ino
);
429 return ERR_PTR(-EACCES
);
433 return d_splice_alias(inode
, dentry
);
436 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
438 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
439 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
440 struct btrfs_item
*item
;
441 struct btrfs_dir_item
*di
;
442 struct btrfs_key key
;
443 struct btrfs_path
*path
;
446 struct btrfs_leaf
*leaf
;
449 unsigned char d_type
= DT_UNKNOWN
;
452 mutex_lock(&root
->fs_info
->fs_mutex
);
453 key
.objectid
= inode
->i_ino
;
455 btrfs_set_key_type(&key
, BTRFS_DIR_INDEX_KEY
);
456 key
.offset
= filp
->f_pos
;
457 path
= btrfs_alloc_path();
458 btrfs_init_path(path
);
459 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
465 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
466 nritems
= btrfs_header_nritems(&leaf
->header
);
467 slot
= path
->slots
[0];
468 if (advance
|| slot
>= nritems
) {
469 if (slot
>= nritems
-1) {
470 ret
= btrfs_next_leaf(root
, path
);
473 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
474 nritems
= btrfs_header_nritems(&leaf
->header
);
475 slot
= path
->slots
[0];
482 item
= leaf
->items
+ slot
;
483 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
485 if (btrfs_disk_key_offset(&item
->key
) >
486 root
->fs_info
->highest_inode
) {
487 printk("stopping at highest inode %Lu\n", root
->fs_info
->highest_inode
);
490 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_INDEX_KEY
)
492 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
494 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
496 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
497 over
= filldir(dirent
, (const char *)(di
+ 1),
498 btrfs_dir_name_len(di
),
499 btrfs_disk_key_offset(&item
->key
),
500 btrfs_dir_objectid(di
), d_type
);
508 btrfs_release_path(root
, path
);
509 btrfs_free_path(path
);
510 mutex_unlock(&root
->fs_info
->fs_mutex
);
514 static void btrfs_put_super (struct super_block
* sb
)
516 struct btrfs_root
*root
= btrfs_sb(sb
);
519 ret
= close_ctree(root
);
521 printk("close ctree returns %d\n", ret
);
523 sb
->s_fs_info
= NULL
;
526 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
528 struct inode
* inode
;
529 struct dentry
* root_dentry
;
530 struct btrfs_super_block
*disk_super
;
531 struct btrfs_root
*root
;
533 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
534 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
535 sb
->s_op
= &btrfs_super_ops
;
538 root
= open_ctree(sb
);
541 printk("btrfs: open_ctree failed\n");
544 sb
->s_fs_info
= root
;
545 disk_super
= root
->fs_info
->disk_super
;
546 printk("read in super total blocks %Lu root %Lu\n",
547 btrfs_super_total_blocks(disk_super
),
548 btrfs_super_root_dir(disk_super
));
550 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
553 if (inode
->i_state
& I_NEW
) {
554 btrfs_read_locked_inode(inode
);
555 unlock_new_inode(inode
);
558 root_dentry
= d_alloc_root(inode
);
563 sb
->s_root
= root_dentry
;
568 static void fill_inode_item(struct btrfs_inode_item
*item
,
571 btrfs_set_inode_uid(item
, inode
->i_uid
);
572 btrfs_set_inode_gid(item
, inode
->i_gid
);
573 btrfs_set_inode_size(item
, inode
->i_size
);
574 btrfs_set_inode_mode(item
, inode
->i_mode
);
575 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
576 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
577 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
578 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
579 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
580 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
581 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
582 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
583 btrfs_set_inode_generation(item
, inode
->i_generation
);
587 static int btrfs_update_inode(struct btrfs_trans_handle
*trans
,
588 struct btrfs_root
*root
,
591 struct btrfs_inode_item
*inode_item
;
592 struct btrfs_path
*path
;
595 path
= btrfs_alloc_path();
597 btrfs_init_path(path
);
599 ret
= btrfs_lookup_inode(trans
, root
, path
, inode
->i_ino
, 1);
606 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
608 struct btrfs_inode_item
);
610 fill_inode_item(inode_item
, inode
);
611 btrfs_mark_buffer_dirty(path
->nodes
[0]);
613 btrfs_release_path(root
, path
);
614 btrfs_free_path(path
);
619 static int btrfs_write_inode(struct inode
*inode
, int wait
)
621 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
622 struct btrfs_trans_handle
*trans
;
625 mutex_lock(&root
->fs_info
->fs_mutex
);
626 trans
= btrfs_start_transaction(root
, 1);
627 ret
= btrfs_update_inode(trans
, root
, inode
);
629 btrfs_commit_transaction(trans
, root
);
631 btrfs_end_transaction(trans
, root
);
632 mutex_unlock(&root
->fs_info
->fs_mutex
);
637 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
638 struct inode
*dir
, int mode
)
641 struct btrfs_inode_item inode_item
;
642 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
643 struct btrfs_key key
;
647 inode
= new_inode(dir
->i_sb
);
649 return ERR_PTR(-ENOMEM
);
652 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
655 inode
->i_uid
= current
->fsuid
;
656 inode
->i_gid
= current
->fsgid
;
657 inode
->i_mode
= mode
;
658 inode
->i_ino
= objectid
;
660 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
661 fill_inode_item(&inode_item
, inode
);
663 key
.objectid
= objectid
;
666 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
667 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
670 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
673 insert_inode_hash(inode
);
679 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
680 struct dentry
*dentry
, struct inode
*inode
)
683 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
684 dentry
->d_name
.name
, dentry
->d_name
.len
,
685 dentry
->d_parent
->d_inode
->i_ino
,
688 dentry
->d_parent
->d_inode
->i_size
+= dentry
->d_name
.len
* 2;
689 ret
= btrfs_update_inode(trans
, btrfs_sb(inode
->i_sb
),
690 dentry
->d_parent
->d_inode
);
693 check_inode(dentry
->d_parent
->d_inode
);
697 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
698 struct dentry
*dentry
, struct inode
*inode
)
700 int err
= btrfs_add_link(trans
, dentry
, inode
);
702 d_instantiate(dentry
, inode
);
711 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
712 int mode
, struct nameidata
*nd
)
714 struct btrfs_trans_handle
*trans
;
715 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
720 mutex_lock(&root
->fs_info
->fs_mutex
);
721 trans
= btrfs_start_transaction(root
, 1);
722 inode
= btrfs_new_inode(trans
, dir
, mode
);
723 err
= PTR_ERR(inode
);
726 // FIXME mark the inode dirty
727 err
= btrfs_add_nondir(trans
, dentry
, inode
);
731 inode
->i_mapping
->a_ops
= &btrfs_aops
;
732 inode
->i_fop
= &btrfs_file_operations
;
733 inode
->i_op
= &btrfs_file_inode_operations
;
735 dir
->i_sb
->s_dirt
= 1;
737 btrfs_end_transaction(trans
, root
);
738 mutex_unlock(&root
->fs_info
->fs_mutex
);
743 inode_dec_link_count(inode
);
749 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
750 struct inode
*inode
, struct inode
*dir
)
752 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
758 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, inode
->i_ino
,
762 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, inode
->i_ino
,
767 ret
= btrfs_update_inode(trans
, root
, inode
);
772 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
775 struct btrfs_trans_handle
*trans
;
776 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
780 mutex_lock(&root
->fs_info
->fs_mutex
);
781 trans
= btrfs_start_transaction(root
, 1);
783 err
= PTR_ERR(trans
);
786 inode
= btrfs_new_inode(trans
, dir
, S_IFDIR
| mode
);
788 err
= PTR_ERR(inode
);
792 inode
->i_op
= &btrfs_dir_inode_operations
;
793 inode
->i_fop
= &btrfs_dir_file_operations
;
795 err
= btrfs_make_empty_dir(trans
, inode
, dir
);
798 err
= btrfs_add_link(trans
, dentry
, inode
);
801 d_instantiate(dentry
, inode
);
805 btrfs_end_transaction(trans
, root
);
807 mutex_unlock(&root
->fs_info
->fs_mutex
);
813 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
815 struct btrfs_trans_handle
*trans
;
816 struct btrfs_root
*root
;
822 filemap_flush(root
->fs_info
->btree_inode
->i_mapping
);
825 filemap_write_and_wait(root
->fs_info
->btree_inode
->i_mapping
);
826 mutex_lock(&root
->fs_info
->fs_mutex
);
827 trans
= btrfs_start_transaction(root
, 1);
828 ret
= btrfs_commit_transaction(trans
, root
);
831 printk("btrfs sync_fs\n");
832 mutex_unlock(&root
->fs_info
->fs_mutex
);
837 static int btrfs_get_block_inline(struct inode
*inode
, sector_t iblock
,
838 struct buffer_head
*result
, int create
)
840 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
841 struct btrfs_path
*path
;
842 struct btrfs_key key
;
843 struct btrfs_leaf
*leaf
;
844 int num_bytes
= result
->b_size
;
854 path
= btrfs_alloc_path();
861 pos
= iblock
<< inode
->i_blkbits
;
862 key
.objectid
= inode
->i_ino
;
864 btrfs_set_key_type(&key
, BTRFS_INLINE_DATA_KEY
);
865 ptr
= kmap(result
->b_page
);
867 ptr
+= (pos
& (PAGE_CACHE_SIZE
-1));
870 ret
= btrfs_search_slot(NULL
, root
, &key
, path
, 0, 0);
878 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
879 item_size
= btrfs_item_size(leaf
->items
+ path
->slots
[0]);
880 copy_size
= min(num_bytes
, item_size
);
881 data_ptr
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
882 WARN_ON(safe_ptr
+ PAGE_CACHE_SIZE
< ptr
+ copy_size
);
883 memcpy(ptr
, data_ptr
, copy_size
);
885 num_bytes
-= copy_size
;
886 WARN_ON(num_bytes
< 0);
888 btrfs_release_path(root
, path
);
889 if (num_bytes
!= 0) {
890 if (pos
>= i_size_read(inode
))
891 memset(ptr
, 0, num_bytes
);
895 set_buffer_uptodate(result
);
896 map_bh(result
, inode
->i_sb
, 0);
899 btrfs_free_path(path
);
900 kunmap(result
->b_page
);
905 static int btrfs_get_block_lock(struct inode
*inode
, sector_t iblock
,
906 struct buffer_head
*result
, int create
)
911 u64 extent_start
= 0;
913 u64 objectid
= inode
->i_ino
;
914 struct btrfs_path
*path
;
915 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
916 struct btrfs_trans_handle
*trans
= NULL
;
917 struct btrfs_file_extent_item
*item
;
918 struct btrfs_leaf
*leaf
;
919 struct btrfs_disk_key
*found_key
;
921 path
= btrfs_alloc_path();
923 btrfs_init_path(path
);
925 trans
= btrfs_start_transaction(root
, 1);
927 ret
= btrfs_lookup_file_extent(trans
, root
, path
,
929 iblock
<< inode
->i_blkbits
, 0);
936 if (path
->slots
[0] == 0) {
937 btrfs_release_path(root
, path
);
943 item
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]), path
->slots
[0],
944 struct btrfs_file_extent_item
);
945 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
946 blocknr
= btrfs_file_extent_disk_blocknr(item
);
947 blocknr
+= btrfs_file_extent_offset(item
);
949 /* exact match found, use it */
952 map_bh(result
, inode
->i_sb
, blocknr
);
956 /* are we inside the extent that was found? */
957 found_key
= &leaf
->items
[path
->slots
[0]].key
;
958 if (btrfs_disk_key_objectid(found_key
) != objectid
||
959 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
) {
962 btrfs_release_path(root
, path
);
966 extent_start
= btrfs_disk_key_offset(&leaf
->items
[path
->slots
[0]].key
);
967 extent_start
= extent_start
>> inode
->i_blkbits
;
968 extent_start
+= btrfs_file_extent_offset(item
);
969 extent_end
= extent_start
+ btrfs_file_extent_num_blocks(item
);
970 if (iblock
>= extent_start
&& iblock
< extent_end
) {
972 map_bh(result
, inode
->i_sb
, blocknr
+ iblock
- extent_start
);
976 /* ok, create a new extent */
981 ret
= btrfs_alloc_file_extent(trans
, root
, objectid
,
982 iblock
<< inode
->i_blkbits
,
983 1, extent_end
, &blocknr
);
988 inode
->i_blocks
+= inode
->i_sb
->s_blocksize
>> 9;
989 set_buffer_new(result
);
990 map_bh(result
, inode
->i_sb
, blocknr
);
993 btrfs_release_path(root
, path
);
994 btrfs_free_path(path
);
996 btrfs_end_transaction(trans
, root
);
1000 static int btrfs_get_block(struct inode
*inode
, sector_t iblock
,
1001 struct buffer_head
*result
, int create
)
1004 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
1005 mutex_lock(&root
->fs_info
->fs_mutex
);
1006 err
= btrfs_get_block_lock(inode
, iblock
, result
, create
);
1007 // err = btrfs_get_block_inline(inode, iblock, result, create);
1008 mutex_unlock(&root
->fs_info
->fs_mutex
);
1012 static int btrfs_prepare_write(struct file
*file
, struct page
*page
,
1013 unsigned from
, unsigned to
)
1015 return nobh_prepare_write(page
, from
, to
, btrfs_get_block
);
1017 static int btrfs_commit_write(struct file
*file
, struct page
*page
,
1018 unsigned from
, unsigned to
)
1020 return nobh_commit_write(file
, page
, from
, to
);
1023 static void btrfs_write_super(struct super_block
*sb
)
1025 btrfs_sync_fs(sb
, 1);
1028 static int btrfs_readpage(struct file
*file
, struct page
*page
)
1030 return mpage_readpage(page
, btrfs_get_block
);
1033 static int btrfs_readpages(struct file
*file
, struct address_space
*mapping
,
1034 struct list_head
*pages
, unsigned nr_pages
)
1036 return mpage_readpages(mapping
, pages
, nr_pages
, btrfs_get_block
);
1039 static int btrfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1041 return nobh_writepage(page
, btrfs_get_block
, wbc
);
1044 static void btrfs_truncate(struct inode
*inode
)
1046 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
1048 struct btrfs_trans_handle
*trans
;
1050 if (!S_ISREG(inode
->i_mode
))
1052 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
1055 nobh_truncate_page(inode
->i_mapping
, inode
->i_size
);
1057 /* FIXME, add redo link to tree so we don't leak on crash */
1058 mutex_lock(&root
->fs_info
->fs_mutex
);
1059 trans
= btrfs_start_transaction(root
, 1);
1060 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
1062 ret
= btrfs_end_transaction(trans
, root
);
1064 mutex_unlock(&root
->fs_info
->fs_mutex
);
1065 mark_inode_dirty(inode
);
1068 static int btrfs_copy_from_user(loff_t pos
, int num_pages
, int write_bytes
,
1069 struct page
**prepared_pages
,
1070 const char __user
* buf
)
1072 long page_fault
= 0;
1074 int offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1076 for (i
= 0; i
< num_pages
&& write_bytes
> 0; i
++, offset
= 0) {
1077 size_t count
= min_t(size_t,
1078 PAGE_CACHE_SIZE
- offset
, write_bytes
);
1079 struct page
*page
= prepared_pages
[i
];
1080 fault_in_pages_readable(buf
, count
);
1082 /* Copy data from userspace to the current page */
1084 page_fault
= __copy_from_user(page_address(page
) + offset
,
1086 /* Flush processor's dcache for this page */
1087 flush_dcache_page(page
);
1090 write_bytes
-= count
;
1095 return page_fault
? -EFAULT
: 0;
1098 static void btrfs_drop_pages(struct page
**pages
, size_t num_pages
)
1101 for (i
= 0; i
< num_pages
; i
++) {
1104 unlock_page(pages
[i
]);
1105 mark_page_accessed(pages
[i
]);
1106 page_cache_release(pages
[i
]);
1109 static int dirty_and_release_pages(struct btrfs_trans_handle
*trans
,
1110 struct btrfs_root
*root
,
1112 struct page
**pages
,
1122 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1124 for (i
= 0; i
< num_pages
; i
++) {
1125 offset
= pos
& (PAGE_CACHE_SIZE
-1);
1126 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
1127 /* FIXME, one block at a time */
1129 mutex_lock(&root
->fs_info
->fs_mutex
);
1130 trans
= btrfs_start_transaction(root
, 1);
1131 btrfs_csum_file_block(trans
, root
, inode
->i_ino
,
1132 pages
[i
]->index
<< PAGE_CACHE_SHIFT
,
1133 kmap(pages
[i
]), PAGE_CACHE_SIZE
);
1135 SetPageChecked(pages
[i
]);
1136 ret
= btrfs_end_transaction(trans
, root
);
1138 mutex_unlock(&root
->fs_info
->fs_mutex
);
1140 ret
= nobh_commit_write(file
, pages
[i
], offset
,
1141 offset
+ this_write
);
1147 WARN_ON(this_write
> write_bytes
);
1148 write_bytes
-= this_write
;
1154 static int prepare_pages(struct btrfs_trans_handle
*trans
,
1155 struct btrfs_root
*root
,
1157 struct page
**pages
,
1163 unsigned long index
= pos
>> PAGE_CACHE_SHIFT
;
1164 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1169 loff_t isize
= i_size_read(inode
);
1171 memset(pages
, 0, num_pages
* sizeof(struct page
*));
1173 for (i
= 0; i
< num_pages
; i
++) {
1174 pages
[i
] = grab_cache_page(inode
->i_mapping
, index
+ i
);
1177 goto failed_release
;
1179 offset
= pos
& (PAGE_CACHE_SIZE
-1);
1180 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
1181 ret
= nobh_prepare_write(pages
[i
], offset
,
1182 offset
+ this_write
,
1187 goto failed_truncate
;
1189 WARN_ON(this_write
> write_bytes
);
1190 write_bytes
-= this_write
;
1195 btrfs_drop_pages(pages
, num_pages
);
1199 btrfs_drop_pages(pages
, num_pages
);
1201 vmtruncate(inode
, isize
);
1205 static ssize_t
btrfs_file_write(struct file
*file
, const char __user
*buf
,
1206 size_t count
, loff_t
*ppos
)
1209 size_t num_written
= 0;
1212 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1213 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
1214 struct page
*pages
[1];
1216 if (file
->f_flags
& O_DIRECT
)
1220 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
1221 current
->backing_dev_info
= inode
->i_mapping
->backing_dev_info
;
1222 err
= generic_write_checks(file
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
1227 err
= remove_suid(file
->f_path
.dentry
);
1230 file_update_time(file
);
1231 mutex_lock(&inode
->i_mutex
);
1233 size_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1234 size_t write_bytes
= min(count
, PAGE_CACHE_SIZE
- offset
);
1235 size_t num_pages
= (write_bytes
+ PAGE_CACHE_SIZE
- 1) >>
1237 ret
= prepare_pages(NULL
, root
, file
, pages
, num_pages
,
1240 ret
= btrfs_copy_from_user(pos
, num_pages
,
1241 write_bytes
, pages
, buf
);
1244 ret
= dirty_and_release_pages(NULL
, root
, file
, pages
,
1245 num_pages
, pos
, write_bytes
);
1247 btrfs_drop_pages(pages
, num_pages
);
1250 count
-= write_bytes
;
1252 num_written
+= write_bytes
;
1254 balance_dirty_pages_ratelimited(inode
->i_mapping
);
1257 mutex_unlock(&inode
->i_mutex
);
1260 current
->backing_dev_info
= NULL
;
1261 return num_written
? num_written
: err
;
1265 static ssize_t
inline_one_page(struct btrfs_root
*root
, struct inode
*inode
,
1266 struct page
*page
, loff_t pos
,
1267 size_t offset
, size_t write_bytes
)
1269 struct btrfs_path
*path
;
1270 struct btrfs_trans_handle
*trans
;
1271 struct btrfs_key key
;
1272 struct btrfs_leaf
*leaf
;
1273 struct btrfs_key found_key
;
1275 size_t copy_size
= 0;
1278 size_t num_written
= 0;
1280 path
= btrfs_alloc_path();
1282 mutex_lock(&root
->fs_info
->fs_mutex
);
1283 trans
= btrfs_start_transaction(root
, 1);
1284 key
.objectid
= inode
->i_ino
;
1286 btrfs_set_key_type(&key
, BTRFS_INLINE_DATA_KEY
);
1290 ret
= btrfs_search_slot(trans
, root
, &key
, path
, 0, 1);
1296 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1297 btrfs_disk_key_to_cpu(&found_key
,
1298 &leaf
->items
[path
->slots
[0]].key
);
1299 copy_size
= btrfs_item_size(leaf
->items
+ path
->slots
[0]);
1300 dst
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
1301 copy_size
= min(write_bytes
, copy_size
);
1304 int slot
= path
->slots
[0];
1308 // FIXME find max key
1309 leaf
= btrfs_buffer_leaf(path
->nodes
[0]);
1310 btrfs_disk_key_to_cpu(&found_key
,
1311 &leaf
->items
[slot
].key
);
1312 if (found_key
.objectid
!= inode
->i_ino
)
1314 if (btrfs_key_type(&found_key
) != BTRFS_INLINE_DATA_KEY
)
1316 copy_size
= btrfs_item_size(leaf
->items
+ slot
);
1317 if (found_key
.offset
+ copy_size
<= pos
)
1319 dst
= btrfs_item_ptr(leaf
, path
->slots
[0], char);
1320 dst
+= pos
- found_key
.offset
;
1321 copy_size
= copy_size
- (pos
- found_key
.offset
);
1322 BUG_ON(copy_size
< 0);
1323 copy_size
= min(write_bytes
, copy_size
);
1324 WARN_ON(copy_size
== 0);
1328 btrfs_release_path(root
, path
);
1329 copy_size
= min(write_bytes
,
1330 (size_t)BTRFS_LEAF_DATA_SIZE(root
) -
1331 sizeof(struct btrfs_item
) * 4);
1332 ret
= btrfs_insert_empty_item(trans
, root
, path
, &key
, copy_size
);
1334 dst
= btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
1335 path
->slots
[0], char);
1337 WARN_ON(copy_size
== 0);
1338 WARN_ON(dst
+ copy_size
>
1339 btrfs_item_ptr(btrfs_buffer_leaf(path
->nodes
[0]),
1340 path
->slots
[0], char) +
1341 btrfs_item_size(btrfs_buffer_leaf(path
->nodes
[0])->items
+
1343 btrfs_memcpy(root
, path
->nodes
[0]->b_data
, dst
,
1344 page_address(page
) + offset
, copy_size
);
1345 mark_buffer_dirty(path
->nodes
[0]);
1346 btrfs_release_path(root
, path
);
1348 offset
+= copy_size
;
1349 num_written
+= copy_size
;
1350 write_bytes
-= copy_size
;
1354 btrfs_free_path(path
);
1355 ret
= btrfs_end_transaction(trans
, root
);
1357 mutex_unlock(&root
->fs_info
->fs_mutex
);
1358 return num_written
? num_written
: err
;
1361 static ssize_t
btrfs_file_inline_write(struct file
*file
,
1362 const char __user
*buf
,
1363 size_t count
, loff_t
*ppos
)
1366 size_t num_written
= 0;
1369 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1370 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
1371 unsigned long page_index
;
1373 if (file
->f_flags
& O_DIRECT
)
1377 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
1378 current
->backing_dev_info
= inode
->i_mapping
->backing_dev_info
;
1379 err
= generic_write_checks(file
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
1384 err
= remove_suid(file
->f_path
.dentry
);
1387 file_update_time(file
);
1388 mutex_lock(&inode
->i_mutex
);
1390 size_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1391 size_t write_bytes
= min(count
, PAGE_CACHE_SIZE
- offset
);
1394 page_index
= pos
>> PAGE_CACHE_SHIFT
;
1395 page
= grab_cache_page(inode
->i_mapping
, page_index
);
1396 if (!PageUptodate(page
)) {
1397 ret
= mpage_readpage(page
, btrfs_get_block
);
1401 ret
= btrfs_copy_from_user(pos
, 1,
1402 write_bytes
, &page
, buf
);
1404 write_bytes
= inline_one_page(root
, inode
, page
, pos
,
1405 offset
, write_bytes
);
1406 SetPageUptodate(page
);
1407 if (write_bytes
> 0 && pos
+ write_bytes
> inode
->i_size
) {
1408 i_size_write(inode
, pos
+ write_bytes
);
1409 mark_inode_dirty(inode
);
1411 page_cache_release(page
);
1413 if (write_bytes
< 0)
1416 count
-= write_bytes
;
1418 num_written
+= write_bytes
;
1420 balance_dirty_pages_ratelimited(inode
->i_mapping
);
1424 mutex_unlock(&inode
->i_mutex
);
1427 current
->backing_dev_info
= NULL
;
1428 return num_written
? num_written
: err
;
1432 static int btrfs_read_actor(read_descriptor_t
*desc
, struct page
*page
,
1433 unsigned long offset
, unsigned long size
)
1436 unsigned long left
, count
= desc
->count
;
1441 if (!PageChecked(page
)) {
1442 /* FIXME, do it per block */
1443 struct btrfs_root
*root
= btrfs_sb(page
->mapping
->host
->i_sb
);
1444 int ret
= btrfs_csum_verify_file_block(root
,
1445 page
->mapping
->host
->i_ino
,
1446 page
->index
<< PAGE_CACHE_SHIFT
,
1447 kmap(page
), PAGE_CACHE_SIZE
);
1449 printk("failed to verify ino %lu page %lu\n",
1450 page
->mapping
->host
->i_ino
,
1452 memset(page_address(page
), 0, PAGE_CACHE_SIZE
);
1454 SetPageChecked(page
);
1458 * Faults on the destination of a read are common, so do it before
1461 if (!fault_in_pages_writeable(desc
->arg
.buf
, size
)) {
1462 kaddr
= kmap_atomic(page
, KM_USER0
);
1463 left
= __copy_to_user_inatomic(desc
->arg
.buf
,
1464 kaddr
+ offset
, size
);
1465 kunmap_atomic(kaddr
, KM_USER0
);
1470 /* Do it the slow way */
1472 left
= __copy_to_user(desc
->arg
.buf
, kaddr
+ offset
, size
);
1477 desc
->error
= -EFAULT
;
1480 desc
->count
= count
- size
;
1481 desc
->written
+= size
;
1482 desc
->arg
.buf
+= size
;
1487 * btrfs_file_aio_read - filesystem read routine
1488 * @iocb: kernel I/O control block
1489 * @iov: io vector request
1490 * @nr_segs: number of segments in the iovec
1491 * @pos: current file position
1493 static ssize_t
btrfs_file_aio_read(struct kiocb
*iocb
, const struct iovec
*iov
,
1494 unsigned long nr_segs
, loff_t pos
)
1496 struct file
*filp
= iocb
->ki_filp
;
1500 loff_t
*ppos
= &iocb
->ki_pos
;
1503 for (seg
= 0; seg
< nr_segs
; seg
++) {
1504 const struct iovec
*iv
= &iov
[seg
];
1507 * If any segment has a negative length, or the cumulative
1508 * length ever wraps negative then return -EINVAL.
1510 count
+= iv
->iov_len
;
1511 if (unlikely((ssize_t
)(count
|iv
->iov_len
) < 0))
1513 if (access_ok(VERIFY_WRITE
, iv
->iov_base
, iv
->iov_len
))
1518 count
-= iv
->iov_len
; /* This segment is no good */
1523 for (seg
= 0; seg
< nr_segs
; seg
++) {
1524 read_descriptor_t desc
;
1527 desc
.arg
.buf
= iov
[seg
].iov_base
;
1528 desc
.count
= iov
[seg
].iov_len
;
1529 if (desc
.count
== 0)
1532 do_generic_file_read(filp
, ppos
, &desc
,
1534 retval
+= desc
.written
;
1536 retval
= retval
?: desc
.error
;
1544 static struct kmem_cache
*btrfs_inode_cachep
;
1545 struct kmem_cache
*btrfs_trans_handle_cachep
;
1546 struct kmem_cache
*btrfs_transaction_cachep
;
1547 struct kmem_cache
*btrfs_bit_radix_cachep
;
1548 struct kmem_cache
*btrfs_path_cachep
;
1551 * Called inside transaction, so use GFP_NOFS
1553 static struct inode
*btrfs_alloc_inode(struct super_block
*sb
)
1555 struct btrfs_inode
*ei
;
1557 ei
= kmem_cache_alloc(btrfs_inode_cachep
, GFP_NOFS
);
1560 ei
->magic
= 0xDEADBEEF;
1561 ei
->magic2
= 0xDEADBEAF;
1562 return &ei
->vfs_inode
;
1565 static void btrfs_destroy_inode(struct inode
*inode
)
1567 struct btrfs_inode
*ei
= BTRFS_I(inode
);
1568 WARN_ON(ei
->magic
!= 0xDEADBEEF);
1569 WARN_ON(ei
->magic2
!= 0xDEADBEAF);
1570 WARN_ON(!list_empty(&inode
->i_dentry
));
1571 WARN_ON(inode
->i_data
.nrpages
);
1575 kmem_cache_free(btrfs_inode_cachep
, BTRFS_I(inode
));
1578 static void init_once(void * foo
, struct kmem_cache
* cachep
,
1579 unsigned long flags
)
1581 struct btrfs_inode
*ei
= (struct btrfs_inode
*) foo
;
1583 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
1584 SLAB_CTOR_CONSTRUCTOR
) {
1585 inode_init_once(&ei
->vfs_inode
);
1589 static int init_inodecache(void)
1591 btrfs_inode_cachep
= kmem_cache_create("btrfs_inode_cache",
1592 sizeof(struct btrfs_inode
),
1593 0, (SLAB_RECLAIM_ACCOUNT
|
1596 btrfs_trans_handle_cachep
= kmem_cache_create("btrfs_trans_handle_cache",
1597 sizeof(struct btrfs_trans_handle
),
1598 0, (SLAB_RECLAIM_ACCOUNT
|
1601 btrfs_transaction_cachep
= kmem_cache_create("btrfs_transaction_cache",
1602 sizeof(struct btrfs_transaction
),
1603 0, (SLAB_RECLAIM_ACCOUNT
|
1606 btrfs_path_cachep
= kmem_cache_create("btrfs_path_cache",
1607 sizeof(struct btrfs_transaction
),
1608 0, (SLAB_RECLAIM_ACCOUNT
|
1611 btrfs_bit_radix_cachep
= kmem_cache_create("btrfs_radix",
1613 0, (SLAB_RECLAIM_ACCOUNT
|
1615 SLAB_DESTROY_BY_RCU
),
1617 if (btrfs_inode_cachep
== NULL
|| btrfs_trans_handle_cachep
== NULL
||
1618 btrfs_transaction_cachep
== NULL
|| btrfs_bit_radix_cachep
== NULL
)
1623 static void destroy_inodecache(void)
1625 kmem_cache_destroy(btrfs_inode_cachep
);
1626 kmem_cache_destroy(btrfs_trans_handle_cachep
);
1627 kmem_cache_destroy(btrfs_transaction_cachep
);
1628 kmem_cache_destroy(btrfs_bit_radix_cachep
);
1629 kmem_cache_destroy(btrfs_path_cachep
);
1632 static int btrfs_get_sb(struct file_system_type
*fs_type
,
1633 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1635 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
1636 btrfs_fill_super
, mnt
);
1639 static struct file_system_type btrfs_fs_type
= {
1640 .owner
= THIS_MODULE
,
1642 .get_sb
= btrfs_get_sb
,
1643 .kill_sb
= kill_block_super
,
1644 .fs_flags
= FS_REQUIRES_DEV
,
1647 static struct super_operations btrfs_super_ops
= {
1648 .statfs
= simple_statfs
,
1649 .delete_inode
= btrfs_delete_inode
,
1650 .put_super
= btrfs_put_super
,
1651 .read_inode
= btrfs_read_locked_inode
,
1652 .write_super
= btrfs_write_super
,
1653 .sync_fs
= btrfs_sync_fs
,
1654 .write_inode
= btrfs_write_inode
,
1655 .alloc_inode
= btrfs_alloc_inode
,
1656 .destroy_inode
= btrfs_destroy_inode
,
1659 static struct inode_operations btrfs_dir_inode_operations
= {
1660 .lookup
= btrfs_lookup
,
1661 .create
= btrfs_create
,
1662 .unlink
= btrfs_unlink
,
1663 .mkdir
= btrfs_mkdir
,
1664 .rmdir
= btrfs_rmdir
,
1667 static struct file_operations btrfs_dir_file_operations
= {
1668 .llseek
= generic_file_llseek
,
1669 .read
= generic_read_dir
,
1670 .readdir
= btrfs_readdir
,
1673 static struct address_space_operations btrfs_aops
= {
1674 .readpage
= btrfs_readpage
,
1675 .readpages
= btrfs_readpages
,
1676 .writepage
= btrfs_writepage
,
1677 .sync_page
= block_sync_page
,
1678 .prepare_write
= btrfs_prepare_write
,
1679 .commit_write
= btrfs_commit_write
,
1682 static struct inode_operations btrfs_file_inode_operations
= {
1683 .truncate
= btrfs_truncate
,
1686 static struct file_operations btrfs_file_operations
= {
1687 .llseek
= generic_file_llseek
,
1688 .read
= do_sync_read
,
1689 .aio_read
= btrfs_file_aio_read
,
1690 .write
= btrfs_file_write
,
1691 .mmap
= generic_file_mmap
,
1692 .open
= generic_file_open
,
1695 static int __init
init_btrfs_fs(void)
1698 printk("btrfs loaded!\n");
1699 err
= init_inodecache();
1702 return register_filesystem(&btrfs_fs_type
);
1705 static void __exit
exit_btrfs_fs(void)
1707 destroy_inodecache();
1708 unregister_filesystem(&btrfs_fs_type
);
1709 printk("btrfs unloaded\n");
1712 module_init(init_btrfs_fs
)
1713 module_exit(exit_btrfs_fs
)
1715 MODULE_LICENSE("GPL");