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>
13 #include "transaction.h"
15 #define BTRFS_SUPER_MAGIC 0x9123682E
17 static struct inode_operations btrfs_dir_inode_operations
;
18 static struct super_operations btrfs_super_ops
;
19 static struct file_operations btrfs_dir_file_operations
;
21 static void btrfs_read_locked_inode(struct inode
*inode
)
23 struct btrfs_path path
;
24 struct btrfs_inode_item
*inode_item
;
25 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
27 btrfs_init_path(&path
);
28 ret
= btrfs_lookup_inode(NULL
, root
, &path
, inode
->i_ino
, 0);
30 make_bad_inode(inode
);
31 btrfs_release_path(root
, &path
);
34 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
36 struct btrfs_inode_item
);
38 inode
->i_mode
= btrfs_inode_mode(inode_item
);
39 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
40 inode
->i_uid
= btrfs_inode_uid(inode_item
);
41 inode
->i_gid
= btrfs_inode_gid(inode_item
);
42 inode
->i_size
= btrfs_inode_size(inode_item
);
43 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
44 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
45 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
46 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
47 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
48 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
49 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
50 inode
->i_generation
= btrfs_inode_generation(inode_item
);
51 btrfs_release_path(root
, &path
);
52 switch (inode
->i_mode
& S_IFMT
) {
55 init_special_inode(inode
, inode
->i_mode
,
56 btrfs_inode_rdev(inode_item
));
62 inode
->i_op
= &btrfs_dir_inode_operations
;
63 inode
->i_fop
= &btrfs_dir_file_operations
;
66 // inode->i_op = &page_symlink_inode_operations;
72 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
74 struct btrfs_path path
;
75 struct btrfs_root
*root
;
76 struct btrfs_trans_handle
*trans
;
77 const char *name
= dentry
->d_name
.name
;
78 int name_len
= dentry
->d_name
.len
;
81 struct btrfs_dir_item
*di
;
83 btrfs_init_path(&path
);
84 root
= btrfs_sb(dir
->i_sb
);
85 mutex_lock(&root
->fs_info
->fs_mutex
);
86 trans
= btrfs_start_transaction(root
, 1);
88 ret
= btrfs_lookup_dir_item(trans
, root
, &path
, dir
->i_ino
,
96 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
97 struct btrfs_dir_item
);
98 objectid
= btrfs_dir_objectid(di
);
100 ret
= btrfs_del_item(trans
, root
, &path
);
102 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
104 btrfs_release_path(root
, &path
);
105 btrfs_end_transaction(trans
, root
);
106 mutex_unlock(&root
->fs_info
->fs_mutex
);
108 inode_dec_link_count(dentry
->d_inode
);
112 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
113 struct btrfs_root
*root
,
116 u64 objectid
= inode
->i_ino
;
117 struct btrfs_path path
;
118 struct btrfs_inode_map_item
*map
;
119 struct btrfs_key stat_data_key
;
122 btrfs_init_path(&path
);
123 ret
= btrfs_lookup_inode_map(trans
, root
, &path
, objectid
, -1);
127 btrfs_release_path(root
, &path
);
130 map
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
131 struct btrfs_inode_map_item
);
132 btrfs_disk_key_to_cpu(&stat_data_key
, &map
->key
);
133 ret
= btrfs_del_item(trans
, root
->fs_info
->inode_root
, &path
);
135 btrfs_release_path(root
, &path
);
136 btrfs_init_path(&path
);
138 ret
= btrfs_lookup_inode(trans
, root
, &path
, objectid
, -1);
140 ret
= btrfs_del_item(trans
, root
, &path
);
142 btrfs_release_path(root
, &path
);
147 static void btrfs_delete_inode(struct inode
*inode
)
149 struct btrfs_trans_handle
*trans
;
150 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
151 truncate_inode_pages(&inode
->i_data
, 0);
152 if (is_bad_inode(inode
)) {
159 mutex_lock(&root
->fs_info
->fs_mutex
);
160 trans
= btrfs_start_transaction(root
, 1);
161 btrfs_free_inode(trans
, root
, inode
);
162 btrfs_end_transaction(trans
, root
);
163 mutex_unlock(&root
->fs_info
->fs_mutex
);
170 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
173 const char *name
= dentry
->d_name
.name
;
174 int namelen
= dentry
->d_name
.len
;
175 struct btrfs_dir_item
*di
;
176 struct btrfs_path path
;
177 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
180 btrfs_init_path(&path
);
181 ret
= btrfs_lookup_dir_item(NULL
, root
, &path
, dir
->i_ino
, name
,
183 if (ret
|| !btrfs_match_dir_item_name(root
, &path
, name
, namelen
)) {
187 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
188 struct btrfs_dir_item
);
189 *ino
= btrfs_dir_objectid(di
);
191 btrfs_release_path(root
, &path
);
195 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
196 struct nameidata
*nd
)
198 struct inode
* inode
;
202 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
203 return ERR_PTR(-ENAMETOOLONG
);
205 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
210 inode
= iget(dir
->i_sb
, ino
);
212 return ERR_PTR(-EACCES
);
214 return d_splice_alias(inode
, dentry
);
217 static void reada_leaves(struct btrfs_root
*root
, struct btrfs_path
*path
)
219 struct buffer_head
*bh
;
220 struct btrfs_node
*node
;
230 node
= btrfs_buffer_node(path
->nodes
[1]);
231 slot
= path
->slots
[1];
232 objectid
= btrfs_disk_key_objectid(&node
->ptrs
[slot
].key
);
233 nritems
= btrfs_header_nritems(&node
->header
);
234 for (i
= slot
; i
< nritems
; i
++) {
235 item_objectid
= btrfs_disk_key_objectid(&node
->ptrs
[i
].key
);
236 if (item_objectid
!= objectid
)
238 blocknr
= btrfs_node_blockptr(node
, i
);
239 bh
= sb_getblk(root
->fs_info
->sb
, blocknr
);
240 ll_rw_block(READ
, 1, &bh
);
245 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
247 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
248 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
249 struct btrfs_item
*item
;
250 struct btrfs_dir_item
*di
;
251 struct btrfs_key key
;
252 struct btrfs_path path
;
255 struct btrfs_leaf
*leaf
;
258 unsigned char d_type
= DT_UNKNOWN
;
261 key
.objectid
= inode
->i_ino
;
263 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
264 key
.offset
= filp
->f_pos
;
265 btrfs_init_path(&path
);
266 ret
= btrfs_search_slot(NULL
, root
, &key
, &path
, 0, 0);
271 reada_leaves(root
, &path
);
273 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
274 nritems
= btrfs_header_nritems(&leaf
->header
);
275 slot
= path
.slots
[0];
277 if (slot
== nritems
-1) {
278 ret
= btrfs_next_leaf(root
, &path
);
281 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
282 nritems
= btrfs_header_nritems(&leaf
->header
);
283 slot
= path
.slots
[0];
284 if (path
.nodes
[1] && path
.slots
[1] == 0)
285 reada_leaves(root
, &path
);
292 item
= leaf
->items
+ slot
;
293 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
295 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_ITEM_KEY
)
297 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
299 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
300 over
= filldir(dirent
, (const char *)(di
+ 1),
301 btrfs_dir_name_len(di
),
302 btrfs_disk_key_offset(&item
->key
),
303 btrfs_dir_objectid(di
), d_type
);
305 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
308 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
) + 1;
312 btrfs_release_path(root
, &path
);
316 static void btrfs_put_super (struct super_block
* sb
)
318 struct btrfs_root
*root
= btrfs_sb(sb
);
321 ret
= close_ctree(root
);
323 printk("close ctree returns %d\n", ret
);
325 sb
->s_fs_info
= NULL
;
328 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
330 struct inode
* inode
;
331 struct dentry
* root_dentry
;
332 struct btrfs_super_block
*disk_super
;
333 struct buffer_head
*bh
;
334 struct btrfs_root
*root
;
336 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
337 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
338 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
339 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
340 sb
->s_op
= &btrfs_super_ops
;
343 bh
= sb_bread(sb
, BTRFS_SUPER_INFO_OFFSET
/ sb
->s_blocksize
);
345 printk("btrfs: unable to read on disk super\n");
348 disk_super
= (struct btrfs_super_block
*)bh
->b_data
;
349 root
= open_ctree(sb
, bh
, disk_super
);
350 sb
->s_fs_info
= root
;
352 printk("btrfs: open_ctree failed\n");
355 printk("read in super total blocks %Lu root %Lu\n",
356 btrfs_super_total_blocks(disk_super
),
357 btrfs_super_root_dir(disk_super
));
359 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
362 if (inode
->i_state
& I_NEW
) {
363 btrfs_read_locked_inode(inode
);
364 unlock_new_inode(inode
);
367 root_dentry
= d_alloc_root(inode
);
372 sb
->s_root
= root_dentry
;
377 static void fill_inode_item(struct btrfs_inode_item
*item
,
380 btrfs_set_inode_uid(item
, inode
->i_uid
);
381 btrfs_set_inode_gid(item
, inode
->i_gid
);
382 btrfs_set_inode_size(item
, inode
->i_size
);
383 btrfs_set_inode_mode(item
, inode
->i_mode
);
384 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
385 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
386 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
387 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
388 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
389 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
390 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
391 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
392 btrfs_set_inode_generation(item
, inode
->i_generation
);
395 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
396 struct inode
*dir
, int mode
)
399 struct btrfs_inode_item inode_item
;
400 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
401 struct btrfs_key key
;
405 inode
= new_inode(dir
->i_sb
);
407 return ERR_PTR(-ENOMEM
);
409 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
412 inode
->i_uid
= current
->fsuid
;
413 inode
->i_gid
= current
->fsgid
;
414 inode
->i_mode
= mode
;
415 inode
->i_ino
= objectid
;
417 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
418 /* FIXME do this on link */
421 fill_inode_item(&inode_item
, inode
);
423 key
.objectid
= objectid
;
426 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
427 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
430 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
433 insert_inode_hash(inode
);
434 // FIXME mark_inode_dirty(inode)
438 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
439 struct dentry
*dentry
, struct inode
*inode
)
442 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
443 dentry
->d_name
.name
, dentry
->d_name
.len
,
444 dentry
->d_parent
->d_inode
->i_ino
,
449 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
450 struct dentry
*dentry
, struct inode
*inode
)
452 int err
= btrfs_add_link(trans
, dentry
, inode
);
454 d_instantiate(dentry
, inode
);
460 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
461 int mode
, struct nameidata
*nd
)
463 struct btrfs_trans_handle
*trans
;
464 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
469 mutex_lock(&root
->fs_info
->fs_mutex
);
470 trans
= btrfs_start_transaction(root
, 1);
471 inode
= btrfs_new_inode(trans
, dir
, mode
);
472 err
= PTR_ERR(inode
);
475 // FIXME mark the inode dirty
476 err
= btrfs_add_nondir(trans
, dentry
, inode
);
479 dir
->i_sb
->s_dirt
= 1;
480 btrfs_end_transaction(trans
, root
);
482 mutex_unlock(&root
->fs_info
->fs_mutex
);
484 inode_dec_link_count(inode
);
490 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
491 struct inode
*inode
, struct inode
*dir
)
493 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
499 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, inode
->i_ino
,
503 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, inode
->i_ino
,
509 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
512 struct btrfs_trans_handle
*trans
;
513 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
517 mutex_lock(&root
->fs_info
->fs_mutex
);
518 trans
= btrfs_start_transaction(root
, 1);
520 err
= PTR_ERR(trans
);
523 inode
= btrfs_new_inode(trans
, dir
, S_IFDIR
| mode
);
525 err
= PTR_ERR(inode
);
529 inode
->i_op
= &btrfs_dir_inode_operations
;
530 inode
->i_fop
= &btrfs_dir_file_operations
;
532 err
= btrfs_make_empty_dir(trans
, inode
, dir
);
535 err
= btrfs_add_link(trans
, dentry
, inode
);
538 d_instantiate(dentry
, inode
);
539 mark_inode_dirty(inode
);
543 btrfs_end_transaction(trans
, root
);
545 mutex_unlock(&root
->fs_info
->fs_mutex
);
551 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
553 struct btrfs_trans_handle
*trans
;
554 struct btrfs_root
*root
;
559 filemap_flush(sb
->s_bdev
->bd_inode
->i_mapping
);
562 filemap_write_and_wait(sb
->s_bdev
->bd_inode
->i_mapping
);
565 mutex_lock(&root
->fs_info
->fs_mutex
);
566 trans
= btrfs_start_transaction(root
, 1);
567 ret
= btrfs_commit_transaction(trans
, root
);
570 printk("btrfs sync_fs\n");
571 mutex_unlock(&root
->fs_info
->fs_mutex
);
575 static void btrfs_write_super(struct super_block
*sb
)
577 btrfs_sync_fs(sb
, 1);
581 static int btrfs_get_sb(struct file_system_type
*fs_type
,
582 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
584 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
585 btrfs_fill_super
, mnt
);
588 static struct file_system_type btrfs_fs_type
= {
589 .owner
= THIS_MODULE
,
591 .get_sb
= btrfs_get_sb
,
592 .kill_sb
= kill_block_super
,
593 .fs_flags
= FS_REQUIRES_DEV
,
596 static struct super_operations btrfs_super_ops
= {
597 .statfs
= simple_statfs
,
598 .delete_inode
= btrfs_delete_inode
,
599 .put_super
= btrfs_put_super
,
600 .read_inode
= btrfs_read_locked_inode
,
601 .write_super
= btrfs_write_super
,
602 .sync_fs
= btrfs_sync_fs
,
605 static struct inode_operations btrfs_dir_inode_operations
= {
606 .lookup
= btrfs_lookup
,
607 .create
= btrfs_create
,
608 .unlink
= btrfs_unlink
,
609 .mkdir
= btrfs_mkdir
,
612 static struct file_operations btrfs_dir_file_operations
= {
613 .llseek
= generic_file_llseek
,
614 .read
= generic_read_dir
,
615 .readdir
= btrfs_readdir
,
619 static int __init
init_btrfs_fs(void)
621 printk("btrfs loaded!\n");
622 return register_filesystem(&btrfs_fs_type
);
625 static void __exit
exit_btrfs_fs(void)
627 unregister_filesystem(&btrfs_fs_type
);
628 printk("btrfs unloaded\n");
631 module_init(init_btrfs_fs
)
632 module_exit(exit_btrfs_fs
)
634 MODULE_LICENSE("GPL");