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>
14 #include "transaction.h"
16 #define BTRFS_SUPER_MAGIC 0x9123682E
18 static struct inode_operations btrfs_dir_inode_operations
;
19 static struct super_operations btrfs_super_ops
;
20 static struct file_operations btrfs_dir_file_operations
;
21 static struct inode_operations btrfs_file_inode_operations
;
22 static struct address_space_operations btrfs_aops
;
23 static struct file_operations btrfs_file_operations
;
25 static void btrfs_read_locked_inode(struct inode
*inode
)
27 struct btrfs_path path
;
28 struct btrfs_inode_item
*inode_item
;
29 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
31 btrfs_init_path(&path
);
32 ret
= btrfs_lookup_inode(NULL
, root
, &path
, inode
->i_ino
, 0);
34 make_bad_inode(inode
);
35 btrfs_release_path(root
, &path
);
38 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
40 struct btrfs_inode_item
);
42 inode
->i_mode
= btrfs_inode_mode(inode_item
);
43 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
44 inode
->i_uid
= btrfs_inode_uid(inode_item
);
45 inode
->i_gid
= btrfs_inode_gid(inode_item
);
46 inode
->i_size
= btrfs_inode_size(inode_item
);
47 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
48 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
49 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
50 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
51 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
52 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
53 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
54 inode
->i_generation
= btrfs_inode_generation(inode_item
);
55 btrfs_release_path(root
, &path
);
56 switch (inode
->i_mode
& S_IFMT
) {
59 init_special_inode(inode
, inode
->i_mode
,
60 btrfs_inode_rdev(inode_item
));
64 inode
->i_mapping
->a_ops
= &btrfs_aops
;
65 inode
->i_fop
= &btrfs_file_operations
;
66 inode
->i_op
= &btrfs_file_inode_operations
;
69 inode
->i_op
= &btrfs_dir_inode_operations
;
70 inode
->i_fop
= &btrfs_dir_file_operations
;
73 // inode->i_op = &page_symlink_inode_operations;
79 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
81 struct btrfs_path path
;
82 struct btrfs_root
*root
;
83 struct btrfs_trans_handle
*trans
;
84 const char *name
= dentry
->d_name
.name
;
85 int name_len
= dentry
->d_name
.len
;
88 struct btrfs_dir_item
*di
;
90 btrfs_init_path(&path
);
91 root
= btrfs_sb(dir
->i_sb
);
92 mutex_lock(&root
->fs_info
->fs_mutex
);
93 trans
= btrfs_start_transaction(root
, 1);
95 ret
= btrfs_lookup_dir_item(trans
, root
, &path
, dir
->i_ino
,
103 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
104 struct btrfs_dir_item
);
105 objectid
= btrfs_dir_objectid(di
);
107 ret
= btrfs_del_item(trans
, root
, &path
);
109 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
111 btrfs_release_path(root
, &path
);
112 btrfs_end_transaction(trans
, root
);
113 mutex_unlock(&root
->fs_info
->fs_mutex
);
115 inode_dec_link_count(dentry
->d_inode
);
119 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
120 struct btrfs_root
*root
,
123 u64 objectid
= inode
->i_ino
;
124 struct btrfs_path path
;
125 struct btrfs_inode_map_item
*map
;
126 struct btrfs_key stat_data_key
;
129 btrfs_init_path(&path
);
130 ret
= btrfs_lookup_inode_map(trans
, root
, &path
, objectid
, -1);
134 btrfs_release_path(root
, &path
);
137 map
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
138 struct btrfs_inode_map_item
);
139 btrfs_disk_key_to_cpu(&stat_data_key
, &map
->key
);
140 ret
= btrfs_del_item(trans
, root
->fs_info
->inode_root
, &path
);
142 btrfs_release_path(root
, &path
);
143 btrfs_init_path(&path
);
145 ret
= btrfs_lookup_inode(trans
, root
, &path
, objectid
, -1);
147 ret
= btrfs_del_item(trans
, root
, &path
);
149 btrfs_release_path(root
, &path
);
154 static void btrfs_delete_inode(struct inode
*inode
)
156 struct btrfs_trans_handle
*trans
;
157 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
158 truncate_inode_pages(&inode
->i_data
, 0);
159 if (is_bad_inode(inode
)) {
166 mutex_lock(&root
->fs_info
->fs_mutex
);
167 trans
= btrfs_start_transaction(root
, 1);
168 btrfs_free_inode(trans
, root
, inode
);
169 btrfs_end_transaction(trans
, root
);
170 mutex_unlock(&root
->fs_info
->fs_mutex
);
177 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
180 const char *name
= dentry
->d_name
.name
;
181 int namelen
= dentry
->d_name
.len
;
182 struct btrfs_dir_item
*di
;
183 struct btrfs_path path
;
184 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
187 btrfs_init_path(&path
);
188 ret
= btrfs_lookup_dir_item(NULL
, root
, &path
, dir
->i_ino
, name
,
190 if (ret
|| !btrfs_match_dir_item_name(root
, &path
, name
, namelen
)) {
194 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
195 struct btrfs_dir_item
);
196 *ino
= btrfs_dir_objectid(di
);
198 btrfs_release_path(root
, &path
);
202 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
203 struct nameidata
*nd
)
205 struct inode
* inode
;
209 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
210 return ERR_PTR(-ENAMETOOLONG
);
212 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
217 inode
= iget(dir
->i_sb
, ino
);
219 return ERR_PTR(-EACCES
);
221 return d_splice_alias(inode
, dentry
);
224 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
226 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
227 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
228 struct btrfs_item
*item
;
229 struct btrfs_dir_item
*di
;
230 struct btrfs_key key
;
231 struct btrfs_path path
;
234 struct btrfs_leaf
*leaf
;
237 unsigned char d_type
= DT_UNKNOWN
;
240 key
.objectid
= inode
->i_ino
;
242 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
243 key
.offset
= filp
->f_pos
;
244 btrfs_init_path(&path
);
245 ret
= btrfs_search_slot(NULL
, root
, &key
, &path
, 0, 0);
251 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
252 nritems
= btrfs_header_nritems(&leaf
->header
);
253 slot
= path
.slots
[0];
254 if (advance
|| slot
>= nritems
) {
255 if (slot
>= nritems
-1) {
256 ret
= btrfs_next_leaf(root
, &path
);
259 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
260 nritems
= btrfs_header_nritems(&leaf
->header
);
261 slot
= path
.slots
[0];
268 item
= leaf
->items
+ slot
;
269 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
271 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_ITEM_KEY
)
273 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
277 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
278 over
= filldir(dirent
, (const char *)(di
+ 1),
279 btrfs_dir_name_len(di
),
280 btrfs_disk_key_offset(&item
->key
),
281 btrfs_dir_objectid(di
), d_type
);
283 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
286 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
) + 1;
290 btrfs_release_path(root
, &path
);
294 static void btrfs_put_super (struct super_block
* sb
)
296 struct btrfs_root
*root
= btrfs_sb(sb
);
299 ret
= close_ctree(root
);
301 printk("close ctree returns %d\n", ret
);
303 sb
->s_fs_info
= NULL
;
306 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
308 struct inode
* inode
;
309 struct dentry
* root_dentry
;
310 struct btrfs_super_block
*disk_super
;
311 struct buffer_head
*bh
;
312 struct btrfs_root
*root
;
314 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
315 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
316 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
317 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
318 sb
->s_op
= &btrfs_super_ops
;
321 bh
= sb_bread(sb
, BTRFS_SUPER_INFO_OFFSET
/ sb
->s_blocksize
);
323 printk("btrfs: unable to read on disk super\n");
326 disk_super
= (struct btrfs_super_block
*)bh
->b_data
;
327 root
= open_ctree(sb
, bh
, disk_super
);
328 sb
->s_fs_info
= root
;
330 printk("btrfs: open_ctree failed\n");
333 printk("read in super total blocks %Lu root %Lu\n",
334 btrfs_super_total_blocks(disk_super
),
335 btrfs_super_root_dir(disk_super
));
337 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
340 if (inode
->i_state
& I_NEW
) {
341 btrfs_read_locked_inode(inode
);
342 unlock_new_inode(inode
);
345 root_dentry
= d_alloc_root(inode
);
350 sb
->s_root
= root_dentry
;
355 static void fill_inode_item(struct btrfs_inode_item
*item
,
358 btrfs_set_inode_uid(item
, inode
->i_uid
);
359 btrfs_set_inode_gid(item
, inode
->i_gid
);
360 btrfs_set_inode_size(item
, inode
->i_size
);
361 btrfs_set_inode_mode(item
, inode
->i_mode
);
362 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
363 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
364 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
365 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
366 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
367 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
368 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
369 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
370 btrfs_set_inode_generation(item
, inode
->i_generation
);
373 static int btrfs_update_inode(struct btrfs_trans_handle
*trans
,
374 struct btrfs_root
*root
,
377 struct btrfs_inode_item
*inode_item
;
378 struct btrfs_path path
;
381 btrfs_init_path(&path
);
383 ret
= btrfs_lookup_inode(trans
, root
, &path
, inode
->i_ino
, 1);
390 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
392 struct btrfs_inode_item
);
394 fill_inode_item(inode_item
, inode
);
395 mark_buffer_dirty(path
.nodes
[0]);
397 btrfs_release_path(root
, &path
);
401 static int btrfs_write_inode(struct inode
*inode
, int wait
)
403 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
404 struct btrfs_trans_handle
*trans
;
407 mutex_lock(&root
->fs_info
->fs_mutex
);
408 trans
= btrfs_start_transaction(root
, 1);
409 ret
= btrfs_update_inode(trans
, root
, inode
);
411 btrfs_commit_transaction(trans
, root
);
413 btrfs_end_transaction(trans
, root
);
414 mutex_unlock(&root
->fs_info
->fs_mutex
);
418 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
419 struct inode
*dir
, int mode
)
422 struct btrfs_inode_item inode_item
;
423 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
424 struct btrfs_key key
;
428 inode
= new_inode(dir
->i_sb
);
430 return ERR_PTR(-ENOMEM
);
432 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
435 inode
->i_uid
= current
->fsuid
;
436 inode
->i_gid
= current
->fsgid
;
437 inode
->i_mode
= mode
;
438 inode
->i_ino
= objectid
;
440 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
441 fill_inode_item(&inode_item
, inode
);
443 key
.objectid
= objectid
;
446 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
447 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
450 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
453 insert_inode_hash(inode
);
457 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
458 struct dentry
*dentry
, struct inode
*inode
)
461 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
462 dentry
->d_name
.name
, dentry
->d_name
.len
,
463 dentry
->d_parent
->d_inode
->i_ino
,
466 dentry
->d_parent
->d_inode
->i_size
+= dentry
->d_name
.len
;
467 ret
= btrfs_update_inode(trans
, btrfs_sb(inode
->i_sb
),
468 dentry
->d_parent
->d_inode
);
474 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
475 struct dentry
*dentry
, struct inode
*inode
)
477 int err
= btrfs_add_link(trans
, dentry
, inode
);
479 d_instantiate(dentry
, inode
);
485 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
486 int mode
, struct nameidata
*nd
)
488 struct btrfs_trans_handle
*trans
;
489 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
494 mutex_lock(&root
->fs_info
->fs_mutex
);
495 trans
= btrfs_start_transaction(root
, 1);
496 inode
= btrfs_new_inode(trans
, dir
, mode
);
497 err
= PTR_ERR(inode
);
500 // FIXME mark the inode dirty
501 err
= btrfs_add_nondir(trans
, dentry
, inode
);
505 inode
->i_mapping
->a_ops
= &btrfs_aops
;
506 inode
->i_fop
= &btrfs_file_operations
;
507 inode
->i_op
= &btrfs_file_inode_operations
;
509 dir
->i_sb
->s_dirt
= 1;
510 btrfs_end_transaction(trans
, root
);
512 mutex_unlock(&root
->fs_info
->fs_mutex
);
514 inode_dec_link_count(inode
);
520 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
521 struct inode
*inode
, struct inode
*dir
)
523 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
529 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, inode
->i_ino
,
533 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, inode
->i_ino
,
538 ret
= btrfs_update_inode(trans
, root
, inode
);
543 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
546 struct btrfs_trans_handle
*trans
;
547 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
551 mutex_lock(&root
->fs_info
->fs_mutex
);
552 trans
= btrfs_start_transaction(root
, 1);
554 err
= PTR_ERR(trans
);
557 inode
= btrfs_new_inode(trans
, dir
, S_IFDIR
| mode
);
559 err
= PTR_ERR(inode
);
563 inode
->i_op
= &btrfs_dir_inode_operations
;
564 inode
->i_fop
= &btrfs_dir_file_operations
;
566 err
= btrfs_make_empty_dir(trans
, inode
, dir
);
569 err
= btrfs_add_link(trans
, dentry
, inode
);
572 d_instantiate(dentry
, inode
);
576 btrfs_end_transaction(trans
, root
);
578 mutex_unlock(&root
->fs_info
->fs_mutex
);
584 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
586 struct btrfs_trans_handle
*trans
;
587 struct btrfs_root
*root
;
592 filemap_flush(sb
->s_bdev
->bd_inode
->i_mapping
);
595 filemap_write_and_wait(sb
->s_bdev
->bd_inode
->i_mapping
);
598 mutex_lock(&root
->fs_info
->fs_mutex
);
599 trans
= btrfs_start_transaction(root
, 1);
600 ret
= btrfs_commit_transaction(trans
, root
);
603 printk("btrfs sync_fs\n");
604 mutex_unlock(&root
->fs_info
->fs_mutex
);
608 static int btrfs_get_block(struct inode
*inode
, sector_t iblock
,
609 struct buffer_head
*result
, int create
)
614 u64 extent_start
= 0;
616 u64 objectid
= inode
->i_ino
;
617 struct btrfs_path path
;
618 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
619 struct btrfs_trans_handle
*trans
= NULL
;
620 struct btrfs_file_extent_item
*item
;
621 struct btrfs_leaf
*leaf
;
622 struct btrfs_disk_key
*found_key
;
624 btrfs_init_path(&path
);
625 mutex_lock(&root
->fs_info
->fs_mutex
);
627 trans
= btrfs_start_transaction(root
, 1);
630 ret
= btrfs_lookup_file_extent(trans
, root
, &path
,
631 inode
->i_ino
, iblock
, 1, 0);
633 btrfs_release_path(root
, &path
);
639 if (path
.slots
[0] == 0) {
640 btrfs_release_path(root
, &path
);
646 item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
647 struct btrfs_file_extent_item
);
648 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
649 blocknr
= btrfs_file_extent_disk_blocknr(item
);
650 blocknr
+= btrfs_file_extent_offset(item
);
652 /* exact match found, use it */
655 map_bh(result
, inode
->i_sb
, blocknr
);
656 btrfs_release_path(root
, &path
);
660 /* are we inside the extent that was found? */
661 found_key
= &leaf
->items
[path
.slots
[0]].key
;
662 if (btrfs_disk_key_objectid(found_key
) != objectid
||
663 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
) {
666 btrfs_release_path(root
, &path
);
670 extent_start
= btrfs_disk_key_offset(&leaf
->items
[path
.slots
[0]].key
);
671 extent_start
+= btrfs_file_extent_offset(item
);
672 extent_end
= extent_start
+ btrfs_file_extent_num_blocks(item
);
673 btrfs_release_path(root
, &path
);
674 if (iblock
>= extent_start
&& iblock
< extent_end
) {
676 map_bh(result
, inode
->i_sb
, blocknr
+ iblock
- extent_start
);
680 /* ok, create a new extent */
685 ret
= btrfs_alloc_file_extent(trans
, root
, objectid
, iblock
,
686 1, extent_end
, &blocknr
);
691 map_bh(result
, inode
->i_sb
, blocknr
);
695 btrfs_end_transaction(trans
, root
);
696 mutex_unlock(&root
->fs_info
->fs_mutex
);
700 static int btrfs_prepare_write(struct file
*file
, struct page
*page
,
701 unsigned from
, unsigned to
)
703 return nobh_prepare_write(page
, from
, to
, btrfs_get_block
);
706 static void btrfs_write_super(struct super_block
*sb
)
708 btrfs_sync_fs(sb
, 1);
711 static int btrfs_readpage(struct file
*file
, struct page
*page
)
713 return mpage_readpage(page
, btrfs_get_block
);
716 static int btrfs_readpages(struct file
*file
, struct address_space
*mapping
,
717 struct list_head
*pages
, unsigned nr_pages
)
719 return mpage_readpages(mapping
, pages
, nr_pages
, btrfs_get_block
);
722 static int btrfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
724 return nobh_writepage(page
, btrfs_get_block
, wbc
);
727 static int btrfs_get_sb(struct file_system_type
*fs_type
,
728 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
730 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
731 btrfs_fill_super
, mnt
);
734 static struct file_system_type btrfs_fs_type
= {
735 .owner
= THIS_MODULE
,
737 .get_sb
= btrfs_get_sb
,
738 .kill_sb
= kill_block_super
,
739 .fs_flags
= FS_REQUIRES_DEV
,
742 static struct super_operations btrfs_super_ops
= {
743 .statfs
= simple_statfs
,
744 .delete_inode
= btrfs_delete_inode
,
745 .put_super
= btrfs_put_super
,
746 .read_inode
= btrfs_read_locked_inode
,
747 .write_super
= btrfs_write_super
,
748 .sync_fs
= btrfs_sync_fs
,
749 .write_inode
= btrfs_write_inode
,
752 static struct inode_operations btrfs_dir_inode_operations
= {
753 .lookup
= btrfs_lookup
,
754 .create
= btrfs_create
,
755 .unlink
= btrfs_unlink
,
756 .mkdir
= btrfs_mkdir
,
759 static struct file_operations btrfs_dir_file_operations
= {
760 .llseek
= generic_file_llseek
,
761 .read
= generic_read_dir
,
762 .readdir
= btrfs_readdir
,
765 static struct address_space_operations btrfs_aops
= {
766 .readpage
= btrfs_readpage
,
767 .readpages
= btrfs_readpages
,
768 .writepage
= btrfs_writepage
,
769 .sync_page
= block_sync_page
,
770 .prepare_write
= btrfs_prepare_write
,
771 .commit_write
= nobh_commit_write
,
774 static struct inode_operations btrfs_file_inode_operations
= {
778 static struct file_operations btrfs_file_operations
= {
779 .llseek
= generic_file_llseek
,
780 .read
= do_sync_read
,
781 .write
= do_sync_write
,
782 .aio_read
= generic_file_aio_read
,
783 .aio_write
= generic_file_aio_write
,
784 .mmap
= generic_file_mmap
,
785 .open
= generic_file_open
,
786 .sendfile
= generic_file_sendfile
,
787 .splice_read
= generic_file_splice_read
,
788 .splice_write
= generic_file_splice_write
,
791 static int __init
init_btrfs_fs(void)
793 printk("btrfs loaded!\n");
794 return register_filesystem(&btrfs_fs_type
);
797 static void __exit
exit_btrfs_fs(void)
799 unregister_filesystem(&btrfs_fs_type
);
800 printk("btrfs unloaded\n");
803 module_init(init_btrfs_fs
)
804 module_exit(exit_btrfs_fs
)
806 MODULE_LICENSE("GPL");