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
;
22 /* some random number */
24 static struct super_operations ramfs_ops
;
26 static struct backing_dev_info ramfs_backing_dev_info
= {
27 .ra_pages
= 0, /* No readahead */
28 .capabilities
= BDI_CAP_NO_ACCT_DIRTY
| BDI_CAP_NO_WRITEBACK
|
29 BDI_CAP_MAP_DIRECT
| BDI_CAP_MAP_COPY
|
30 BDI_CAP_READ_MAP
| BDI_CAP_WRITE_MAP
| BDI_CAP_EXEC_MAP
,
33 struct inode
*ramfs_get_inode(struct super_block
*sb
, int mode
, dev_t dev
)
35 struct inode
* inode
= new_inode(sb
);
39 inode
->i_uid
= current
->fsuid
;
40 inode
->i_gid
= current
->fsgid
;
42 inode
->i_mapping
->a_ops
= &ramfs_aops
;
43 inode
->i_mapping
->backing_dev_info
= &ramfs_backing_dev_info
;
44 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
45 switch (mode
& S_IFMT
) {
47 init_special_inode(inode
, mode
, dev
);
50 inode
->i_op
= &ramfs_file_inode_operations
;
51 inode
->i_fop
= &ramfs_file_operations
;
54 inode
->i_op
= &ramfs_dir_inode_operations
;
55 inode
->i_fop
= &simple_dir_operations
;
57 /* directory inodes start off with i_nlink == 2 (for "." entry) */
61 inode
->i_op
= &page_symlink_inode_operations
;
69 * File creation. Allocate an inode, and we're done..
73 ramfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t dev
)
75 struct inode
* inode
= ramfs_get_inode(dir
->i_sb
, mode
, dev
);
79 if (dir
->i_mode
& S_ISGID
) {
80 inode
->i_gid
= dir
->i_gid
;
82 inode
->i_mode
|= S_ISGID
;
84 d_instantiate(dentry
, inode
);
85 dget(dentry
); /* Extra count - pin the dentry in core */
87 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
92 static int ramfs_mkdir(struct inode
* dir
, struct dentry
* dentry
, int mode
)
94 int retval
= ramfs_mknod(dir
, dentry
, mode
| S_IFDIR
, 0);
100 static int ramfs_create(struct inode
*dir
, struct dentry
*dentry
, int mode
, struct nameidata
*nd
)
102 return ramfs_mknod(dir
, dentry
, mode
| S_IFREG
, 0);
105 static int ramfs_symlink(struct inode
* dir
, struct dentry
*dentry
, const char * symname
)
110 inode
= ramfs_get_inode(dir
->i_sb
, S_IFLNK
|S_IRWXUGO
, 0);
112 int l
= strlen(symname
)+1;
113 error
= page_symlink(inode
, symname
, l
);
115 if (dir
->i_mode
& S_ISGID
)
116 inode
->i_gid
= dir
->i_gid
;
117 d_instantiate(dentry
, inode
);
119 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
126 static struct inode_operations ramfs_dir_inode_operations
= {
127 .create
= ramfs_create
,
128 .lookup
= simple_lookup
,
130 .unlink
= simple_unlink
,
131 .symlink
= ramfs_symlink
,
132 .mkdir
= ramfs_mkdir
,
133 .rmdir
= simple_rmdir
,
134 .mknod
= ramfs_mknod
,
135 .rename
= simple_rename
,
139 static void btrfs_read_locked_inode(struct inode
*inode
)
141 struct btrfs_path path
;
142 struct btrfs_inode_item
*inode_item
;
143 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
145 btrfs_init_path(&path
);
146 ret
= btrfs_lookup_inode(NULL
, root
, &path
, inode
->i_ino
, 0);
148 make_bad_inode(inode
);
151 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
153 struct btrfs_inode_item
);
155 inode
->i_mode
= btrfs_inode_mode(inode_item
);
156 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
157 inode
->i_uid
= btrfs_inode_uid(inode_item
);
158 inode
->i_gid
= btrfs_inode_gid(inode_item
);
159 inode
->i_size
= btrfs_inode_size(inode_item
);
160 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
161 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
162 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
163 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
164 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
165 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
166 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
167 inode
->i_generation
= btrfs_inode_generation(inode_item
);
168 btrfs_release_path(root
, &path
);
169 switch (inode
->i_mode
& S_IFMT
) {
172 init_special_inode(inode
, inode
->i_mode
,
173 btrfs_inode_rdev(inode_item
));
179 inode
->i_op
= &btrfs_dir_inode_operations
;
180 inode
->i_fop
= &btrfs_dir_file_operations
;
183 // inode->i_op = &page_symlink_inode_operations;
189 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
192 const char *name
= dentry
->d_name
.name
;
193 int namelen
= dentry
->d_name
.len
;
194 struct btrfs_dir_item
*di
;
195 struct btrfs_path path
;
196 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
199 btrfs_init_path(&path
);
200 ret
= btrfs_lookup_dir_item(NULL
, root
, &path
, dir
->i_ino
, name
,
206 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
207 struct btrfs_dir_item
);
208 *ino
= btrfs_dir_objectid(di
);
210 btrfs_release_path(root
, &path
);
214 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
215 struct nameidata
*nd
)
217 struct inode
* inode
;
221 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
222 return ERR_PTR(-ENAMETOOLONG
);
224 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
229 inode
= iget(dir
->i_sb
, ino
);
231 return ERR_PTR(-EACCES
);
233 return d_splice_alias(inode
, dentry
);
236 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
238 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
239 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
240 struct btrfs_item
*item
;
241 struct btrfs_dir_item
*di
;
242 struct btrfs_key key
;
243 struct btrfs_path path
;
246 struct btrfs_leaf
*leaf
;
249 unsigned char d_type
= DT_UNKNOWN
;
252 key
.objectid
= inode
->i_ino
;
254 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
255 key
.offset
= filp
->f_pos
;
256 btrfs_init_path(&path
);
257 ret
= btrfs_search_slot(NULL
, root
, &key
, &path
, 0, 0);
261 advance
= filp
->f_pos
> 0 && ret
!= 0;
263 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
264 nritems
= btrfs_header_nritems(&leaf
->header
);
265 slot
= path
.slots
[0];
267 if (slot
== nritems
-1) {
268 ret
= btrfs_next_leaf(root
, &path
);
271 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
272 nritems
= btrfs_header_nritems(&leaf
->header
);
273 slot
= path
.slots
[0];
280 item
= leaf
->items
+ slot
;
281 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
283 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_ITEM_KEY
)
285 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
286 over
= filldir(dirent
, (const char *)(di
+ 1),
287 btrfs_dir_name_len(di
),
288 btrfs_disk_key_offset(&item
->key
),
289 btrfs_dir_objectid(di
), d_type
);
292 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
) + 1;
296 btrfs_release_path(root
, &path
);
300 static void btrfs_put_super (struct super_block
* sb
)
302 struct btrfs_root
*root
= btrfs_sb(sb
);
305 ret
= close_ctree(root
);
307 printk("close ctree returns %d\n", ret
);
309 sb
->s_fs_info
= NULL
;
312 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
314 struct inode
* inode
;
315 struct dentry
* root_dentry
;
316 struct btrfs_super_block
*disk_super
;
317 struct buffer_head
*bh
;
318 struct btrfs_root
*root
;
320 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
321 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
322 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
323 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
324 sb
->s_op
= &btrfs_super_ops
;
327 bh
= sb_bread(sb
, BTRFS_SUPER_INFO_OFFSET
/ sb
->s_blocksize
);
329 printk("btrfs: unable to read on disk super\n");
332 disk_super
= (struct btrfs_super_block
*)bh
->b_data
;
333 root
= open_ctree(sb
, bh
, disk_super
);
334 sb
->s_fs_info
= root
;
336 printk("btrfs: open_ctree failed\n");
339 printk("read in super total blocks %Lu root %Lu\n",
340 btrfs_super_total_blocks(disk_super
),
341 btrfs_super_root_dir(disk_super
));
343 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
346 if (inode
->i_state
& I_NEW
) {
347 btrfs_read_locked_inode(inode
);
348 unlock_new_inode(inode
);
351 root_dentry
= d_alloc_root(inode
);
356 sb
->s_root
= root_dentry
;
361 static void fill_inode_item(struct btrfs_inode_item
*item
,
364 btrfs_set_inode_uid(item
, inode
->i_uid
);
365 btrfs_set_inode_gid(item
, inode
->i_gid
);
366 btrfs_set_inode_size(item
, inode
->i_size
);
367 btrfs_set_inode_mode(item
, inode
->i_mode
);
368 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
369 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
370 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
371 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
372 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
373 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
374 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
375 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
376 btrfs_set_inode_generation(item
, inode
->i_generation
);
379 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
380 struct inode
*dir
, int mode
)
383 struct btrfs_inode_item inode_item
;
384 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
385 struct btrfs_key key
;
389 inode
= new_inode(dir
->i_sb
);
391 return ERR_PTR(-ENOMEM
);
393 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
396 inode
->i_uid
= current
->fsuid
;
397 inode
->i_gid
= current
->fsgid
;
398 inode
->i_mode
= mode
;
399 inode
->i_ino
= objectid
;
401 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
402 fill_inode_item(&inode_item
, inode
);
405 key
.objectid
= objectid
;
408 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
409 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
412 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
415 insert_inode_hash(inode
);
416 // FIXME mark_inode_dirty(inode)
420 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
421 struct dentry
*dentry
, struct inode
*inode
)
424 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
425 dentry
->d_name
.name
, dentry
->d_name
.len
,
426 dentry
->d_parent
->d_inode
->i_ino
,
432 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
433 struct dentry
*dentry
, struct inode
*inode
)
435 int err
= btrfs_add_link(trans
, dentry
, inode
);
437 d_instantiate(dentry
, inode
);
440 inode_dec_link_count(inode
);
445 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
446 int mode
, struct nameidata
*nd
)
448 struct btrfs_trans_handle
*trans
;
449 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
453 trans
= btrfs_start_transaction(root
, 1);
454 inode
= btrfs_new_inode(trans
, dir
, mode
);
455 err
= PTR_ERR(inode
);
458 // FIXME mark the inode dirty
459 err
= btrfs_add_nondir(trans
, dentry
, inode
);
460 dir
->i_sb
->s_dirt
= 1;
461 btrfs_end_transaction(trans
, root
);
465 static void btrfs_write_super(struct super_block
*sb
)
468 printk("btrfs write_super!\n");
471 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
473 struct btrfs_trans_handle
*trans
;
474 struct btrfs_root
*root
;
478 trans
= btrfs_start_transaction(root
, 1);
479 ret
= btrfs_commit_transaction(trans
, root
);
482 printk("btrfs sync_fs\n");
486 static int btrfs_get_sb(struct file_system_type
*fs_type
,
487 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
489 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
490 btrfs_fill_super
, mnt
);
493 static struct file_system_type btrfs_fs_type
= {
494 .owner
= THIS_MODULE
,
496 .get_sb
= btrfs_get_sb
,
497 .kill_sb
= kill_block_super
,
498 .fs_flags
= FS_REQUIRES_DEV
,
501 static struct super_operations btrfs_super_ops
= {
502 .statfs
= simple_statfs
,
503 .drop_inode
= generic_delete_inode
,
504 .put_super
= btrfs_put_super
,
505 .read_inode
= btrfs_read_locked_inode
,
506 .write_super
= btrfs_write_super
,
507 .sync_fs
= btrfs_sync_fs
,
510 static struct inode_operations btrfs_dir_inode_operations
= {
511 .lookup
= btrfs_lookup
,
512 .create
= btrfs_create
,
515 static struct file_operations btrfs_dir_file_operations
= {
516 .llseek
= generic_file_llseek
,
517 .read
= generic_read_dir
,
518 .readdir
= btrfs_readdir
,
522 static int __init
init_btrfs_fs(void)
524 printk("btrfs loaded!\n");
525 return register_filesystem(&btrfs_fs_type
);
528 static void __exit
exit_btrfs_fs(void)
530 unregister_filesystem(&btrfs_fs_type
);
531 printk("btrfs unloaded\n");
534 module_init(init_btrfs_fs
)
535 module_exit(exit_btrfs_fs
)
537 MODULE_LICENSE("GPL");