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
);
32 btrfs_init_path(&path
);
33 mutex_lock(&root
->fs_info
->fs_mutex
);
35 ret
= btrfs_lookup_inode(NULL
, root
, &path
, inode
->i_ino
, 0);
37 btrfs_release_path(root
, &path
);
38 mutex_unlock(&root
->fs_info
->fs_mutex
);
39 make_bad_inode(inode
);
42 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
44 struct btrfs_inode_item
);
46 inode
->i_mode
= btrfs_inode_mode(inode_item
);
47 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
48 inode
->i_uid
= btrfs_inode_uid(inode_item
);
49 inode
->i_gid
= btrfs_inode_gid(inode_item
);
50 inode
->i_size
= btrfs_inode_size(inode_item
);
51 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
52 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
53 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
54 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
55 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
56 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
57 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
58 inode
->i_generation
= btrfs_inode_generation(inode_item
);
59 btrfs_release_path(root
, &path
);
60 mutex_unlock(&root
->fs_info
->fs_mutex
);
61 switch (inode
->i_mode
& S_IFMT
) {
64 init_special_inode(inode
, inode
->i_mode
,
65 btrfs_inode_rdev(inode_item
));
69 inode
->i_mapping
->a_ops
= &btrfs_aops
;
70 inode
->i_fop
= &btrfs_file_operations
;
71 inode
->i_op
= &btrfs_file_inode_operations
;
74 inode
->i_op
= &btrfs_dir_inode_operations
;
75 inode
->i_fop
= &btrfs_dir_file_operations
;
78 // inode->i_op = &page_symlink_inode_operations;
84 static int btrfs_unlink_trans(struct btrfs_trans_handle
*trans
,
85 struct btrfs_root
*root
,
87 struct dentry
*dentry
)
89 struct btrfs_path path
;
90 const char *name
= dentry
->d_name
.name
;
91 int name_len
= dentry
->d_name
.len
;
94 struct btrfs_dir_item
*di
;
96 btrfs_init_path(&path
);
97 ret
= btrfs_lookup_dir_item(trans
, root
, &path
, dir
->i_ino
,
105 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
106 struct btrfs_dir_item
);
107 objectid
= btrfs_dir_objectid(di
);
109 ret
= btrfs_del_item(trans
, root
, &path
);
111 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
113 btrfs_release_path(root
, &path
);
115 inode_dec_link_count(dentry
->d_inode
);
119 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
121 struct btrfs_root
*root
;
122 struct btrfs_trans_handle
*trans
;
125 root
= btrfs_sb(dir
->i_sb
);
126 mutex_lock(&root
->fs_info
->fs_mutex
);
127 trans
= btrfs_start_transaction(root
, 1);
128 ret
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
129 btrfs_end_transaction(trans
, root
);
130 mutex_unlock(&root
->fs_info
->fs_mutex
);
134 static int btrfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
136 struct inode
*inode
= dentry
->d_inode
;
139 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
140 struct btrfs_path path
;
141 struct btrfs_key key
;
142 struct btrfs_trans_handle
*trans
;
143 struct btrfs_disk_key
*found_key
;
144 struct btrfs_leaf
*leaf
;
146 btrfs_init_path(&path
);
147 mutex_lock(&root
->fs_info
->fs_mutex
);
148 trans
= btrfs_start_transaction(root
, 1);
149 key
.objectid
= inode
->i_ino
;
150 key
.offset
= (u64
)-1;
152 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
153 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
160 BUG_ON(path
.slots
[0] == 0);
162 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
163 found_key
= &leaf
->items
[path
.slots
[0]].key
;
164 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
) {
168 if (btrfs_disk_key_type(found_key
) != BTRFS_DIR_ITEM_KEY
||
169 btrfs_disk_key_offset(found_key
) != 2) {
173 ret
= btrfs_del_item(trans
, root
, &path
);
175 btrfs_release_path(root
, &path
);
177 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
186 ret
= btrfs_del_item(trans
, root
, &path
);
191 btrfs_release_path(root
, &path
);
193 /* now the directory is empty */
194 err
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
199 mutex_unlock(&root
->fs_info
->fs_mutex
);
200 ret
= btrfs_end_transaction(trans
, root
);
206 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
207 struct btrfs_root
*root
,
210 u64 objectid
= inode
->i_ino
;
211 struct btrfs_path path
;
212 struct btrfs_inode_map_item
*map
;
213 struct btrfs_key stat_data_key
;
216 btrfs_init_path(&path
);
217 ret
= btrfs_lookup_inode_map(trans
, root
, &path
, objectid
, -1);
221 btrfs_release_path(root
, &path
);
224 map
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
225 struct btrfs_inode_map_item
);
226 btrfs_disk_key_to_cpu(&stat_data_key
, &map
->key
);
227 ret
= btrfs_del_item(trans
, root
->fs_info
->inode_root
, &path
);
229 btrfs_release_path(root
, &path
);
230 btrfs_init_path(&path
);
232 ret
= btrfs_lookup_inode(trans
, root
, &path
, objectid
, -1);
234 ret
= btrfs_del_item(trans
, root
, &path
);
236 btrfs_release_path(root
, &path
);
241 static int btrfs_truncate_in_trans(struct btrfs_trans_handle
*trans
,
242 struct btrfs_root
*root
,
246 struct btrfs_path path
;
247 struct btrfs_key key
;
248 struct btrfs_disk_key
*found_key
;
249 struct btrfs_leaf
*leaf
;
250 struct btrfs_file_extent_item
*fi
;
252 u64 extent_num_blocks
;
254 /* FIXME, add redo link to tree so we don't leak on crash */
255 key
.objectid
= inode
->i_ino
;
256 key
.offset
= (u64
)-1;
258 btrfs_set_key_type(&key
, BTRFS_EXTENT_DATA_KEY
);
260 btrfs_init_path(&path
);
261 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
263 btrfs_release_path(root
, &path
);
267 BUG_ON(path
.slots
[0] == 0);
270 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
271 found_key
= &leaf
->items
[path
.slots
[0]].key
;
272 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
)
274 if (btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
)
276 if (btrfs_disk_key_offset(found_key
) < inode
->i_size
)
278 fi
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
280 struct btrfs_file_extent_item
);
281 extent_start
= btrfs_file_extent_disk_blocknr(fi
);
282 extent_num_blocks
= btrfs_file_extent_disk_num_blocks(fi
);
283 key
.offset
= btrfs_disk_key_offset(found_key
) - 1;
284 ret
= btrfs_del_item(trans
, root
, &path
);
286 inode
->i_blocks
-= btrfs_file_extent_num_blocks(fi
) >> 9;
287 btrfs_release_path(root
, &path
);
288 ret
= btrfs_free_extent(trans
, root
, extent_start
,
289 extent_num_blocks
, 0);
291 if (key
.offset
+ 1 == 0)
294 btrfs_release_path(root
, &path
);
300 static void btrfs_delete_inode(struct inode
*inode
)
302 struct btrfs_trans_handle
*trans
;
303 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
306 truncate_inode_pages(&inode
->i_data
, 0);
307 if (is_bad_inode(inode
)) {
311 mutex_lock(&root
->fs_info
->fs_mutex
);
312 trans
= btrfs_start_transaction(root
, 1);
313 if (S_ISREG(inode
->i_mode
)) {
314 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
317 btrfs_free_inode(trans
, root
, inode
);
318 btrfs_end_transaction(trans
, root
);
319 mutex_unlock(&root
->fs_info
->fs_mutex
);
325 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
328 const char *name
= dentry
->d_name
.name
;
329 int namelen
= dentry
->d_name
.len
;
330 struct btrfs_dir_item
*di
;
331 struct btrfs_path path
;
332 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
335 btrfs_init_path(&path
);
336 ret
= btrfs_lookup_dir_item(NULL
, root
, &path
, dir
->i_ino
, name
,
338 if (ret
|| !btrfs_match_dir_item_name(root
, &path
, name
, namelen
)) {
342 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
343 struct btrfs_dir_item
);
344 *ino
= btrfs_dir_objectid(di
);
346 btrfs_release_path(root
, &path
);
350 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
351 struct nameidata
*nd
)
353 struct inode
* inode
;
357 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
358 return ERR_PTR(-ENAMETOOLONG
);
360 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
365 inode
= iget(dir
->i_sb
, ino
);
367 return ERR_PTR(-EACCES
);
369 return d_splice_alias(inode
, dentry
);
372 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
374 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
375 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
376 struct btrfs_item
*item
;
377 struct btrfs_dir_item
*di
;
378 struct btrfs_key key
;
379 struct btrfs_path path
;
382 struct btrfs_leaf
*leaf
;
385 unsigned char d_type
= DT_UNKNOWN
;
388 key
.objectid
= inode
->i_ino
;
390 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
391 key
.offset
= filp
->f_pos
;
392 btrfs_init_path(&path
);
393 ret
= btrfs_search_slot(NULL
, root
, &key
, &path
, 0, 0);
399 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
400 nritems
= btrfs_header_nritems(&leaf
->header
);
401 slot
= path
.slots
[0];
402 if (advance
|| slot
>= nritems
) {
403 if (slot
>= nritems
-1) {
404 ret
= btrfs_next_leaf(root
, &path
);
407 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
408 nritems
= btrfs_header_nritems(&leaf
->header
);
409 slot
= path
.slots
[0];
416 item
= leaf
->items
+ slot
;
417 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
419 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_ITEM_KEY
)
421 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
425 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
426 over
= filldir(dirent
, (const char *)(di
+ 1),
427 btrfs_dir_name_len(di
),
428 btrfs_disk_key_offset(&item
->key
),
429 btrfs_dir_objectid(di
), d_type
);
431 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
434 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
) + 1;
438 btrfs_release_path(root
, &path
);
442 static void btrfs_put_super (struct super_block
* sb
)
444 struct btrfs_root
*root
= btrfs_sb(sb
);
447 ret
= close_ctree(root
);
449 printk("close ctree returns %d\n", ret
);
451 sb
->s_fs_info
= NULL
;
454 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
456 struct inode
* inode
;
457 struct dentry
* root_dentry
;
458 struct btrfs_super_block
*disk_super
;
459 struct buffer_head
*bh
;
460 struct btrfs_root
*root
;
462 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
463 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
464 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
465 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
466 sb
->s_op
= &btrfs_super_ops
;
469 bh
= sb_bread(sb
, BTRFS_SUPER_INFO_OFFSET
/ sb
->s_blocksize
);
471 printk("btrfs: unable to read on disk super\n");
474 disk_super
= (struct btrfs_super_block
*)bh
->b_data
;
475 root
= open_ctree(sb
, bh
, disk_super
);
478 printk("btrfs: open_ctree failed\n");
481 sb
->s_fs_info
= root
;
482 disk_super
= root
->fs_info
->disk_super
;
483 printk("read in super total blocks %Lu root %Lu\n",
484 btrfs_super_total_blocks(disk_super
),
485 btrfs_super_root_dir(disk_super
));
487 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
490 if (inode
->i_state
& I_NEW
) {
491 btrfs_read_locked_inode(inode
);
492 unlock_new_inode(inode
);
495 root_dentry
= d_alloc_root(inode
);
500 sb
->s_root
= root_dentry
;
505 static void fill_inode_item(struct btrfs_inode_item
*item
,
508 btrfs_set_inode_uid(item
, inode
->i_uid
);
509 btrfs_set_inode_gid(item
, inode
->i_gid
);
510 btrfs_set_inode_size(item
, inode
->i_size
);
511 btrfs_set_inode_mode(item
, inode
->i_mode
);
512 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
513 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
514 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
515 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
516 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
517 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
518 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
519 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
520 btrfs_set_inode_generation(item
, inode
->i_generation
);
523 static int btrfs_update_inode(struct btrfs_trans_handle
*trans
,
524 struct btrfs_root
*root
,
527 struct btrfs_inode_item
*inode_item
;
528 struct btrfs_path path
;
531 btrfs_init_path(&path
);
533 ret
= btrfs_lookup_inode(trans
, root
, &path
, inode
->i_ino
, 1);
540 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
542 struct btrfs_inode_item
);
544 fill_inode_item(inode_item
, inode
);
545 mark_buffer_dirty(path
.nodes
[0]);
547 btrfs_release_path(root
, &path
);
551 static int btrfs_write_inode(struct inode
*inode
, int wait
)
553 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
554 struct btrfs_trans_handle
*trans
;
557 mutex_lock(&root
->fs_info
->fs_mutex
);
558 trans
= btrfs_start_transaction(root
, 1);
559 ret
= btrfs_update_inode(trans
, root
, inode
);
561 btrfs_commit_transaction(trans
, root
);
563 btrfs_end_transaction(trans
, root
);
564 mutex_unlock(&root
->fs_info
->fs_mutex
);
568 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
569 struct inode
*dir
, int mode
)
572 struct btrfs_inode_item inode_item
;
573 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
574 struct btrfs_key key
;
578 inode
= new_inode(dir
->i_sb
);
580 return ERR_PTR(-ENOMEM
);
582 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
585 inode
->i_uid
= current
->fsuid
;
586 inode
->i_gid
= current
->fsgid
;
587 inode
->i_mode
= mode
;
588 inode
->i_ino
= objectid
;
590 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
591 fill_inode_item(&inode_item
, inode
);
593 key
.objectid
= objectid
;
596 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
597 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
600 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
603 insert_inode_hash(inode
);
607 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
608 struct dentry
*dentry
, struct inode
*inode
)
611 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
612 dentry
->d_name
.name
, dentry
->d_name
.len
,
613 dentry
->d_parent
->d_inode
->i_ino
,
616 dentry
->d_parent
->d_inode
->i_size
+= dentry
->d_name
.len
;
617 ret
= btrfs_update_inode(trans
, btrfs_sb(inode
->i_sb
),
618 dentry
->d_parent
->d_inode
);
624 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
625 struct dentry
*dentry
, struct inode
*inode
)
627 int err
= btrfs_add_link(trans
, dentry
, inode
);
629 d_instantiate(dentry
, inode
);
635 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
636 int mode
, struct nameidata
*nd
)
638 struct btrfs_trans_handle
*trans
;
639 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
644 mutex_lock(&root
->fs_info
->fs_mutex
);
645 trans
= btrfs_start_transaction(root
, 1);
646 inode
= btrfs_new_inode(trans
, dir
, mode
);
647 err
= PTR_ERR(inode
);
650 // FIXME mark the inode dirty
651 err
= btrfs_add_nondir(trans
, dentry
, inode
);
655 inode
->i_mapping
->a_ops
= &btrfs_aops
;
656 inode
->i_fop
= &btrfs_file_operations
;
657 inode
->i_op
= &btrfs_file_inode_operations
;
659 dir
->i_sb
->s_dirt
= 1;
660 btrfs_end_transaction(trans
, root
);
662 mutex_unlock(&root
->fs_info
->fs_mutex
);
664 inode_dec_link_count(inode
);
670 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
671 struct inode
*inode
, struct inode
*dir
)
673 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
679 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, inode
->i_ino
,
683 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, inode
->i_ino
,
688 ret
= btrfs_update_inode(trans
, root
, inode
);
693 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
696 struct btrfs_trans_handle
*trans
;
697 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
701 mutex_lock(&root
->fs_info
->fs_mutex
);
702 trans
= btrfs_start_transaction(root
, 1);
704 err
= PTR_ERR(trans
);
707 inode
= btrfs_new_inode(trans
, dir
, S_IFDIR
| mode
);
709 err
= PTR_ERR(inode
);
713 inode
->i_op
= &btrfs_dir_inode_operations
;
714 inode
->i_fop
= &btrfs_dir_file_operations
;
716 err
= btrfs_make_empty_dir(trans
, inode
, dir
);
719 err
= btrfs_add_link(trans
, dentry
, inode
);
722 d_instantiate(dentry
, inode
);
726 btrfs_end_transaction(trans
, root
);
728 mutex_unlock(&root
->fs_info
->fs_mutex
);
734 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
736 struct btrfs_trans_handle
*trans
;
737 struct btrfs_root
*root
;
743 filemap_flush(root
->fs_info
->btree_inode
->i_mapping
);
746 filemap_write_and_wait(root
->fs_info
->btree_inode
->i_mapping
);
748 mutex_lock(&root
->fs_info
->fs_mutex
);
749 trans
= btrfs_start_transaction(root
, 1);
750 ret
= btrfs_commit_transaction(trans
, root
);
753 printk("btrfs sync_fs\n");
754 mutex_unlock(&root
->fs_info
->fs_mutex
);
758 static int btrfs_get_block(struct inode
*inode
, sector_t iblock
,
759 struct buffer_head
*result
, int create
)
764 u64 extent_start
= 0;
766 u64 objectid
= inode
->i_ino
;
767 struct btrfs_path path
;
768 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
769 struct btrfs_trans_handle
*trans
= NULL
;
770 struct btrfs_file_extent_item
*item
;
771 struct btrfs_leaf
*leaf
;
772 struct btrfs_disk_key
*found_key
;
774 btrfs_init_path(&path
);
775 mutex_lock(&root
->fs_info
->fs_mutex
);
777 trans
= btrfs_start_transaction(root
, 1);
780 ret
= btrfs_lookup_file_extent(trans
, root
, &path
,
782 iblock
<< inode
->i_blkbits
, 0);
784 btrfs_release_path(root
, &path
);
790 if (path
.slots
[0] == 0) {
791 btrfs_release_path(root
, &path
);
797 item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
798 struct btrfs_file_extent_item
);
799 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
800 blocknr
= btrfs_file_extent_disk_blocknr(item
);
801 blocknr
+= btrfs_file_extent_offset(item
);
803 /* exact match found, use it */
806 map_bh(result
, inode
->i_sb
, blocknr
);
807 btrfs_release_path(root
, &path
);
811 /* are we inside the extent that was found? */
812 found_key
= &leaf
->items
[path
.slots
[0]].key
;
813 if (btrfs_disk_key_objectid(found_key
) != objectid
||
814 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
) {
817 btrfs_release_path(root
, &path
);
821 extent_start
= btrfs_disk_key_offset(&leaf
->items
[path
.slots
[0]].key
);
822 extent_start
= extent_start
>> inode
->i_blkbits
;
823 extent_start
+= btrfs_file_extent_offset(item
);
824 extent_end
= extent_start
+ btrfs_file_extent_num_blocks(item
);
825 btrfs_release_path(root
, &path
);
826 if (iblock
>= extent_start
&& iblock
< extent_end
) {
828 map_bh(result
, inode
->i_sb
, blocknr
+ iblock
- extent_start
);
832 /* ok, create a new extent */
837 ret
= btrfs_alloc_file_extent(trans
, root
, objectid
,
838 iblock
<< inode
->i_blkbits
,
839 1, extent_end
, &blocknr
);
844 inode
->i_blocks
+= inode
->i_sb
->s_blocksize
>> 9;
845 set_buffer_new(result
);
846 map_bh(result
, inode
->i_sb
, blocknr
);
850 btrfs_end_transaction(trans
, root
);
851 mutex_unlock(&root
->fs_info
->fs_mutex
);
855 static int btrfs_prepare_write(struct file
*file
, struct page
*page
,
856 unsigned from
, unsigned to
)
858 return nobh_prepare_write(page
, from
, to
, btrfs_get_block
);
861 static void btrfs_write_super(struct super_block
*sb
)
863 btrfs_sync_fs(sb
, 1);
866 static int btrfs_readpage(struct file
*file
, struct page
*page
)
868 return mpage_readpage(page
, btrfs_get_block
);
871 static int btrfs_readpages(struct file
*file
, struct address_space
*mapping
,
872 struct list_head
*pages
, unsigned nr_pages
)
874 return mpage_readpages(mapping
, pages
, nr_pages
, btrfs_get_block
);
877 static int btrfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
879 return nobh_writepage(page
, btrfs_get_block
, wbc
);
882 static void btrfs_truncate(struct inode
*inode
)
884 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
886 struct btrfs_trans_handle
*trans
;
888 if (!S_ISREG(inode
->i_mode
))
890 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
893 nobh_truncate_page(inode
->i_mapping
, inode
->i_size
);
895 /* FIXME, add redo link to tree so we don't leak on crash */
896 mutex_lock(&root
->fs_info
->fs_mutex
);
897 trans
= btrfs_start_transaction(root
, 1);
898 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
900 ret
= btrfs_end_transaction(trans
, root
);
902 mutex_unlock(&root
->fs_info
->fs_mutex
);
903 mark_inode_dirty(inode
);
906 static int btrfs_get_sb(struct file_system_type
*fs_type
,
907 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
909 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
910 btrfs_fill_super
, mnt
);
913 static struct file_system_type btrfs_fs_type
= {
914 .owner
= THIS_MODULE
,
916 .get_sb
= btrfs_get_sb
,
917 .kill_sb
= kill_block_super
,
918 .fs_flags
= FS_REQUIRES_DEV
,
921 static struct super_operations btrfs_super_ops
= {
922 .statfs
= simple_statfs
,
923 .delete_inode
= btrfs_delete_inode
,
924 .put_super
= btrfs_put_super
,
925 .read_inode
= btrfs_read_locked_inode
,
926 .write_super
= btrfs_write_super
,
927 .sync_fs
= btrfs_sync_fs
,
928 .write_inode
= btrfs_write_inode
,
931 static struct inode_operations btrfs_dir_inode_operations
= {
932 .lookup
= btrfs_lookup
,
933 .create
= btrfs_create
,
934 .unlink
= btrfs_unlink
,
935 .mkdir
= btrfs_mkdir
,
936 .rmdir
= btrfs_rmdir
,
939 static struct file_operations btrfs_dir_file_operations
= {
940 .llseek
= generic_file_llseek
,
941 .read
= generic_read_dir
,
942 .readdir
= btrfs_readdir
,
945 static struct address_space_operations btrfs_aops
= {
946 .readpage
= btrfs_readpage
,
947 .readpages
= btrfs_readpages
,
948 .writepage
= btrfs_writepage
,
949 .sync_page
= block_sync_page
,
950 .prepare_write
= btrfs_prepare_write
,
951 .commit_write
= nobh_commit_write
,
954 static struct inode_operations btrfs_file_inode_operations
= {
955 .truncate
= btrfs_truncate
,
958 static struct file_operations btrfs_file_operations
= {
959 .llseek
= generic_file_llseek
,
960 .read
= do_sync_read
,
961 .write
= do_sync_write
,
962 .aio_read
= generic_file_aio_read
,
963 .aio_write
= generic_file_aio_write
,
964 .mmap
= generic_file_mmap
,
965 .open
= generic_file_open
,
966 .sendfile
= generic_file_sendfile
,
967 .splice_read
= generic_file_splice_read
,
968 .splice_write
= generic_file_splice_write
,
971 static int __init
init_btrfs_fs(void)
973 printk("btrfs loaded!\n");
974 return register_filesystem(&btrfs_fs_type
);
977 static void __exit
exit_btrfs_fs(void)
979 unregister_filesystem(&btrfs_fs_type
);
980 printk("btrfs unloaded\n");
983 module_init(init_btrfs_fs
)
984 module_exit(exit_btrfs_fs
)
986 MODULE_LICENSE("GPL");