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"
18 #define BTRFS_SUPER_MAGIC 0x9123682E
20 static struct inode_operations btrfs_dir_inode_operations
;
21 static struct super_operations btrfs_super_ops
;
22 static struct file_operations btrfs_dir_file_operations
;
23 static struct inode_operations btrfs_file_inode_operations
;
24 static struct address_space_operations btrfs_aops
;
25 static struct file_operations btrfs_file_operations
;
27 static void btrfs_read_locked_inode(struct inode
*inode
)
29 struct btrfs_path path
;
30 struct btrfs_inode_item
*inode_item
;
31 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
34 btrfs_init_path(&path
);
35 mutex_lock(&root
->fs_info
->fs_mutex
);
37 ret
= btrfs_lookup_inode(NULL
, root
, &path
, inode
->i_ino
, 0);
39 btrfs_release_path(root
, &path
);
40 mutex_unlock(&root
->fs_info
->fs_mutex
);
41 make_bad_inode(inode
);
44 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
46 struct btrfs_inode_item
);
48 inode
->i_mode
= btrfs_inode_mode(inode_item
);
49 inode
->i_nlink
= btrfs_inode_nlink(inode_item
);
50 inode
->i_uid
= btrfs_inode_uid(inode_item
);
51 inode
->i_gid
= btrfs_inode_gid(inode_item
);
52 inode
->i_size
= btrfs_inode_size(inode_item
);
53 inode
->i_atime
.tv_sec
= btrfs_timespec_sec(&inode_item
->atime
);
54 inode
->i_atime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->atime
);
55 inode
->i_mtime
.tv_sec
= btrfs_timespec_sec(&inode_item
->mtime
);
56 inode
->i_mtime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->mtime
);
57 inode
->i_ctime
.tv_sec
= btrfs_timespec_sec(&inode_item
->ctime
);
58 inode
->i_ctime
.tv_nsec
= btrfs_timespec_nsec(&inode_item
->ctime
);
59 inode
->i_blocks
= btrfs_inode_nblocks(inode_item
);
60 inode
->i_generation
= btrfs_inode_generation(inode_item
);
61 btrfs_release_path(root
, &path
);
62 mutex_unlock(&root
->fs_info
->fs_mutex
);
63 switch (inode
->i_mode
& S_IFMT
) {
66 init_special_inode(inode
, inode
->i_mode
,
67 btrfs_inode_rdev(inode_item
));
71 inode
->i_mapping
->a_ops
= &btrfs_aops
;
72 inode
->i_fop
= &btrfs_file_operations
;
73 inode
->i_op
= &btrfs_file_inode_operations
;
76 inode
->i_op
= &btrfs_dir_inode_operations
;
77 inode
->i_fop
= &btrfs_dir_file_operations
;
80 // inode->i_op = &page_symlink_inode_operations;
86 static int btrfs_unlink_trans(struct btrfs_trans_handle
*trans
,
87 struct btrfs_root
*root
,
89 struct dentry
*dentry
)
91 struct btrfs_path path
;
92 const char *name
= dentry
->d_name
.name
;
93 int name_len
= dentry
->d_name
.len
;
96 struct btrfs_dir_item
*di
;
98 btrfs_init_path(&path
);
99 ret
= btrfs_lookup_dir_item(trans
, root
, &path
, dir
->i_ino
,
107 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
108 struct btrfs_dir_item
);
109 objectid
= btrfs_dir_objectid(di
);
111 ret
= btrfs_del_item(trans
, root
, &path
);
113 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
115 btrfs_release_path(root
, &path
);
117 inode_dec_link_count(dentry
->d_inode
);
121 static int btrfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
123 struct btrfs_root
*root
;
124 struct btrfs_trans_handle
*trans
;
127 root
= btrfs_sb(dir
->i_sb
);
128 mutex_lock(&root
->fs_info
->fs_mutex
);
129 trans
= btrfs_start_transaction(root
, 1);
130 ret
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
131 btrfs_end_transaction(trans
, root
);
132 mutex_unlock(&root
->fs_info
->fs_mutex
);
136 static int btrfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
138 struct inode
*inode
= dentry
->d_inode
;
141 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
142 struct btrfs_path path
;
143 struct btrfs_key key
;
144 struct btrfs_trans_handle
*trans
;
145 struct btrfs_disk_key
*found_key
;
146 struct btrfs_leaf
*leaf
;
148 btrfs_init_path(&path
);
149 mutex_lock(&root
->fs_info
->fs_mutex
);
150 trans
= btrfs_start_transaction(root
, 1);
151 key
.objectid
= inode
->i_ino
;
152 key
.offset
= (u64
)-1;
154 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
155 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
162 BUG_ON(path
.slots
[0] == 0);
164 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
165 found_key
= &leaf
->items
[path
.slots
[0]].key
;
166 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
) {
170 if (btrfs_disk_key_type(found_key
) != BTRFS_DIR_ITEM_KEY
||
171 btrfs_disk_key_offset(found_key
) != 2) {
175 ret
= btrfs_del_item(trans
, root
, &path
);
177 btrfs_release_path(root
, &path
);
179 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
188 ret
= btrfs_del_item(trans
, root
, &path
);
193 btrfs_release_path(root
, &path
);
195 /* now the directory is empty */
196 err
= btrfs_unlink_trans(trans
, root
, dir
, dentry
);
201 mutex_unlock(&root
->fs_info
->fs_mutex
);
202 ret
= btrfs_end_transaction(trans
, root
);
208 static int btrfs_free_inode(struct btrfs_trans_handle
*trans
,
209 struct btrfs_root
*root
,
212 u64 objectid
= inode
->i_ino
;
213 struct btrfs_path path
;
214 struct btrfs_inode_map_item
*map
;
215 struct btrfs_key stat_data_key
;
218 btrfs_init_path(&path
);
219 ret
= btrfs_lookup_inode_map(trans
, root
, &path
, objectid
, -1);
223 btrfs_release_path(root
, &path
);
226 map
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
227 struct btrfs_inode_map_item
);
228 btrfs_disk_key_to_cpu(&stat_data_key
, &map
->key
);
229 ret
= btrfs_del_item(trans
, root
->fs_info
->inode_root
, &path
);
231 btrfs_release_path(root
, &path
);
232 btrfs_init_path(&path
);
234 ret
= btrfs_lookup_inode(trans
, root
, &path
, objectid
, -1);
236 ret
= btrfs_del_item(trans
, root
, &path
);
238 btrfs_release_path(root
, &path
);
243 static int btrfs_truncate_in_trans(struct btrfs_trans_handle
*trans
,
244 struct btrfs_root
*root
,
248 struct btrfs_path path
;
249 struct btrfs_key key
;
250 struct btrfs_disk_key
*found_key
;
251 struct btrfs_leaf
*leaf
;
252 struct btrfs_file_extent_item
*fi
= NULL
;
253 u64 extent_start
= 0;
254 u64 extent_num_blocks
= 0;
257 /* FIXME, add redo link to tree so we don't leak on crash */
258 key
.objectid
= inode
->i_ino
;
259 key
.offset
= (u64
)-1;
261 btrfs_set_key_type(&key
, BTRFS_CSUM_ITEM_KEY
);
263 btrfs_init_path(&path
);
264 ret
= btrfs_search_slot(trans
, root
, &key
, &path
, -1, 1);
266 btrfs_release_path(root
, &path
);
270 BUG_ON(path
.slots
[0] == 0);
273 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
274 found_key
= &leaf
->items
[path
.slots
[0]].key
;
275 if (btrfs_disk_key_objectid(found_key
) != inode
->i_ino
)
277 if (btrfs_disk_key_type(found_key
) != BTRFS_CSUM_ITEM_KEY
&&
278 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
)
280 if (btrfs_disk_key_offset(found_key
) < inode
->i_size
)
282 if (btrfs_disk_key_type(found_key
) == BTRFS_EXTENT_DATA_KEY
) {
283 fi
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
285 struct btrfs_file_extent_item
);
286 extent_start
= btrfs_file_extent_disk_blocknr(fi
);
288 btrfs_file_extent_disk_num_blocks(fi
);
290 btrfs_file_extent_num_blocks(fi
) >> 9;
295 ret
= btrfs_del_item(trans
, root
, &path
);
297 btrfs_release_path(root
, &path
);
299 ret
= btrfs_free_extent(trans
, root
, extent_start
,
300 extent_num_blocks
, 0);
304 btrfs_release_path(root
, &path
);
310 static void btrfs_delete_inode(struct inode
*inode
)
312 struct btrfs_trans_handle
*trans
;
313 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
316 truncate_inode_pages(&inode
->i_data
, 0);
317 if (is_bad_inode(inode
)) {
321 mutex_lock(&root
->fs_info
->fs_mutex
);
322 trans
= btrfs_start_transaction(root
, 1);
323 if (S_ISREG(inode
->i_mode
)) {
324 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
327 btrfs_free_inode(trans
, root
, inode
);
328 btrfs_end_transaction(trans
, root
);
329 mutex_unlock(&root
->fs_info
->fs_mutex
);
335 static int btrfs_inode_by_name(struct inode
*dir
, struct dentry
*dentry
,
338 const char *name
= dentry
->d_name
.name
;
339 int namelen
= dentry
->d_name
.len
;
340 struct btrfs_dir_item
*di
;
341 struct btrfs_path path
;
342 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
345 btrfs_init_path(&path
);
346 ret
= btrfs_lookup_dir_item(NULL
, root
, &path
, dir
->i_ino
, name
,
348 if (ret
|| !btrfs_match_dir_item_name(root
, &path
, name
, namelen
)) {
352 di
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
353 struct btrfs_dir_item
);
354 *ino
= btrfs_dir_objectid(di
);
356 btrfs_release_path(root
, &path
);
360 static struct dentry
*btrfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
361 struct nameidata
*nd
)
363 struct inode
* inode
;
364 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
368 if (dentry
->d_name
.len
> BTRFS_NAME_LEN
)
369 return ERR_PTR(-ENAMETOOLONG
);
371 mutex_lock(&root
->fs_info
->fs_mutex
);
372 ret
= btrfs_inode_by_name(dir
, dentry
, &ino
);
373 mutex_unlock(&root
->fs_info
->fs_mutex
);
378 inode
= iget(dir
->i_sb
, ino
);
380 return ERR_PTR(-EACCES
);
382 return d_splice_alias(inode
, dentry
);
385 static int btrfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
387 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
388 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
389 struct btrfs_item
*item
;
390 struct btrfs_dir_item
*di
;
391 struct btrfs_key key
;
392 struct btrfs_path path
;
395 struct btrfs_leaf
*leaf
;
398 unsigned char d_type
= DT_UNKNOWN
;
401 mutex_lock(&root
->fs_info
->fs_mutex
);
402 key
.objectid
= inode
->i_ino
;
404 btrfs_set_key_type(&key
, BTRFS_DIR_ITEM_KEY
);
405 key
.offset
= filp
->f_pos
;
406 btrfs_init_path(&path
);
407 ret
= btrfs_search_slot(NULL
, root
, &key
, &path
, 0, 0);
413 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
414 nritems
= btrfs_header_nritems(&leaf
->header
);
415 slot
= path
.slots
[0];
416 if (advance
|| slot
>= nritems
) {
417 if (slot
>= nritems
-1) {
418 ret
= btrfs_next_leaf(root
, &path
);
421 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
422 nritems
= btrfs_header_nritems(&leaf
->header
);
423 slot
= path
.slots
[0];
430 item
= leaf
->items
+ slot
;
431 if (btrfs_disk_key_objectid(&item
->key
) != key
.objectid
)
433 if (btrfs_disk_key_type(&item
->key
) != BTRFS_DIR_ITEM_KEY
)
435 if (btrfs_disk_key_offset(&item
->key
) < filp
->f_pos
)
439 di
= btrfs_item_ptr(leaf
, slot
, struct btrfs_dir_item
);
440 over
= filldir(dirent
, (const char *)(di
+ 1),
441 btrfs_dir_name_len(di
),
442 btrfs_disk_key_offset(&item
->key
),
443 btrfs_dir_objectid(di
), d_type
);
445 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
);
448 filp
->f_pos
= btrfs_disk_key_offset(&item
->key
) + 1;
452 btrfs_release_path(root
, &path
);
453 mutex_unlock(&root
->fs_info
->fs_mutex
);
457 static void btrfs_put_super (struct super_block
* sb
)
459 struct btrfs_root
*root
= btrfs_sb(sb
);
462 ret
= close_ctree(root
);
464 printk("close ctree returns %d\n", ret
);
466 sb
->s_fs_info
= NULL
;
469 static int btrfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
471 struct inode
* inode
;
472 struct dentry
* root_dentry
;
473 struct btrfs_super_block
*disk_super
;
474 struct buffer_head
*bh
;
475 struct btrfs_root
*root
;
477 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
478 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
479 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
480 sb
->s_magic
= BTRFS_SUPER_MAGIC
;
481 sb
->s_op
= &btrfs_super_ops
;
484 bh
= sb_bread(sb
, BTRFS_SUPER_INFO_OFFSET
/ sb
->s_blocksize
);
486 printk("btrfs: unable to read on disk super\n");
489 disk_super
= (struct btrfs_super_block
*)bh
->b_data
;
490 root
= open_ctree(sb
, bh
, disk_super
);
493 printk("btrfs: open_ctree failed\n");
496 sb
->s_fs_info
= root
;
497 disk_super
= root
->fs_info
->disk_super
;
498 printk("read in super total blocks %Lu root %Lu\n",
499 btrfs_super_total_blocks(disk_super
),
500 btrfs_super_root_dir(disk_super
));
502 inode
= iget_locked(sb
, btrfs_super_root_dir(disk_super
));
505 if (inode
->i_state
& I_NEW
) {
506 btrfs_read_locked_inode(inode
);
507 unlock_new_inode(inode
);
510 root_dentry
= d_alloc_root(inode
);
515 sb
->s_root
= root_dentry
;
520 static void fill_inode_item(struct btrfs_inode_item
*item
,
523 btrfs_set_inode_uid(item
, inode
->i_uid
);
524 btrfs_set_inode_gid(item
, inode
->i_gid
);
525 btrfs_set_inode_size(item
, inode
->i_size
);
526 btrfs_set_inode_mode(item
, inode
->i_mode
);
527 btrfs_set_inode_nlink(item
, inode
->i_nlink
);
528 btrfs_set_timespec_sec(&item
->atime
, inode
->i_atime
.tv_sec
);
529 btrfs_set_timespec_nsec(&item
->atime
, inode
->i_atime
.tv_nsec
);
530 btrfs_set_timespec_sec(&item
->mtime
, inode
->i_mtime
.tv_sec
);
531 btrfs_set_timespec_nsec(&item
->mtime
, inode
->i_mtime
.tv_nsec
);
532 btrfs_set_timespec_sec(&item
->ctime
, inode
->i_ctime
.tv_sec
);
533 btrfs_set_timespec_nsec(&item
->ctime
, inode
->i_ctime
.tv_nsec
);
534 btrfs_set_inode_nblocks(item
, inode
->i_blocks
);
535 btrfs_set_inode_generation(item
, inode
->i_generation
);
538 static int btrfs_update_inode(struct btrfs_trans_handle
*trans
,
539 struct btrfs_root
*root
,
542 struct btrfs_inode_item
*inode_item
;
543 struct btrfs_path path
;
546 btrfs_init_path(&path
);
548 ret
= btrfs_lookup_inode(trans
, root
, &path
, inode
->i_ino
, 1);
555 inode_item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]),
557 struct btrfs_inode_item
);
559 fill_inode_item(inode_item
, inode
);
560 mark_buffer_dirty(path
.nodes
[0]);
562 btrfs_release_path(root
, &path
);
566 static int btrfs_write_inode(struct inode
*inode
, int wait
)
568 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
569 struct btrfs_trans_handle
*trans
;
572 mutex_lock(&root
->fs_info
->fs_mutex
);
573 trans
= btrfs_start_transaction(root
, 1);
574 ret
= btrfs_update_inode(trans
, root
, inode
);
576 btrfs_commit_transaction(trans
, root
);
578 btrfs_end_transaction(trans
, root
);
579 mutex_unlock(&root
->fs_info
->fs_mutex
);
583 static struct inode
*btrfs_new_inode(struct btrfs_trans_handle
*trans
,
584 struct inode
*dir
, int mode
)
587 struct btrfs_inode_item inode_item
;
588 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
589 struct btrfs_key key
;
593 inode
= new_inode(dir
->i_sb
);
595 return ERR_PTR(-ENOMEM
);
597 ret
= btrfs_find_free_objectid(trans
, root
, dir
->i_ino
, &objectid
);
600 inode
->i_uid
= current
->fsuid
;
601 inode
->i_gid
= current
->fsgid
;
602 inode
->i_mode
= mode
;
603 inode
->i_ino
= objectid
;
605 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
606 fill_inode_item(&inode_item
, inode
);
608 key
.objectid
= objectid
;
611 btrfs_set_key_type(&key
, BTRFS_INODE_ITEM_KEY
);
612 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &key
);
615 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
618 insert_inode_hash(inode
);
622 static int btrfs_add_link(struct btrfs_trans_handle
*trans
,
623 struct dentry
*dentry
, struct inode
*inode
)
626 ret
= btrfs_insert_dir_item(trans
, btrfs_sb(inode
->i_sb
),
627 dentry
->d_name
.name
, dentry
->d_name
.len
,
628 dentry
->d_parent
->d_inode
->i_ino
,
631 dentry
->d_parent
->d_inode
->i_size
+= dentry
->d_name
.len
;
632 ret
= btrfs_update_inode(trans
, btrfs_sb(inode
->i_sb
),
633 dentry
->d_parent
->d_inode
);
639 static int btrfs_add_nondir(struct btrfs_trans_handle
*trans
,
640 struct dentry
*dentry
, struct inode
*inode
)
642 int err
= btrfs_add_link(trans
, dentry
, inode
);
644 d_instantiate(dentry
, inode
);
650 static int btrfs_create(struct inode
*dir
, struct dentry
*dentry
,
651 int mode
, struct nameidata
*nd
)
653 struct btrfs_trans_handle
*trans
;
654 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
659 mutex_lock(&root
->fs_info
->fs_mutex
);
660 trans
= btrfs_start_transaction(root
, 1);
661 inode
= btrfs_new_inode(trans
, dir
, mode
);
662 err
= PTR_ERR(inode
);
665 // FIXME mark the inode dirty
666 err
= btrfs_add_nondir(trans
, dentry
, inode
);
670 inode
->i_mapping
->a_ops
= &btrfs_aops
;
671 inode
->i_fop
= &btrfs_file_operations
;
672 inode
->i_op
= &btrfs_file_inode_operations
;
674 dir
->i_sb
->s_dirt
= 1;
676 btrfs_end_transaction(trans
, root
);
677 mutex_unlock(&root
->fs_info
->fs_mutex
);
679 inode_dec_link_count(inode
);
685 static int btrfs_make_empty_dir(struct btrfs_trans_handle
*trans
,
686 struct inode
*inode
, struct inode
*dir
)
688 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
694 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, inode
->i_ino
,
698 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, inode
->i_ino
,
703 ret
= btrfs_update_inode(trans
, root
, inode
);
708 static int btrfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
711 struct btrfs_trans_handle
*trans
;
712 struct btrfs_root
*root
= btrfs_sb(dir
->i_sb
);
716 mutex_lock(&root
->fs_info
->fs_mutex
);
717 trans
= btrfs_start_transaction(root
, 1);
719 err
= PTR_ERR(trans
);
722 inode
= btrfs_new_inode(trans
, dir
, S_IFDIR
| mode
);
724 err
= PTR_ERR(inode
);
728 inode
->i_op
= &btrfs_dir_inode_operations
;
729 inode
->i_fop
= &btrfs_dir_file_operations
;
731 err
= btrfs_make_empty_dir(trans
, inode
, dir
);
734 err
= btrfs_add_link(trans
, dentry
, inode
);
737 d_instantiate(dentry
, inode
);
741 btrfs_end_transaction(trans
, root
);
743 mutex_unlock(&root
->fs_info
->fs_mutex
);
749 static int btrfs_sync_fs(struct super_block
*sb
, int wait
)
751 struct btrfs_trans_handle
*trans
;
752 struct btrfs_root
*root
;
758 filemap_flush(root
->fs_info
->btree_inode
->i_mapping
);
761 filemap_write_and_wait(root
->fs_info
->btree_inode
->i_mapping
);
763 mutex_lock(&root
->fs_info
->fs_mutex
);
764 trans
= btrfs_start_transaction(root
, 1);
765 ret
= btrfs_commit_transaction(trans
, root
);
768 printk("btrfs sync_fs\n");
769 mutex_unlock(&root
->fs_info
->fs_mutex
);
773 static int btrfs_get_block_lock(struct inode
*inode
, sector_t iblock
,
774 struct buffer_head
*result
, int create
)
779 u64 extent_start
= 0;
781 u64 objectid
= inode
->i_ino
;
782 struct btrfs_path path
;
783 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
784 struct btrfs_trans_handle
*trans
= NULL
;
785 struct btrfs_file_extent_item
*item
;
786 struct btrfs_leaf
*leaf
;
787 struct btrfs_disk_key
*found_key
;
789 btrfs_init_path(&path
);
791 trans
= btrfs_start_transaction(root
, 1);
794 ret
= btrfs_lookup_file_extent(trans
, root
, &path
,
796 iblock
<< inode
->i_blkbits
, 0);
798 btrfs_release_path(root
, &path
);
804 if (path
.slots
[0] == 0) {
805 btrfs_release_path(root
, &path
);
811 item
= btrfs_item_ptr(btrfs_buffer_leaf(path
.nodes
[0]), path
.slots
[0],
812 struct btrfs_file_extent_item
);
813 leaf
= btrfs_buffer_leaf(path
.nodes
[0]);
814 blocknr
= btrfs_file_extent_disk_blocknr(item
);
815 blocknr
+= btrfs_file_extent_offset(item
);
817 /* exact match found, use it */
820 map_bh(result
, inode
->i_sb
, blocknr
);
821 btrfs_release_path(root
, &path
);
825 /* are we inside the extent that was found? */
826 found_key
= &leaf
->items
[path
.slots
[0]].key
;
827 if (btrfs_disk_key_objectid(found_key
) != objectid
||
828 btrfs_disk_key_type(found_key
) != BTRFS_EXTENT_DATA_KEY
) {
831 btrfs_release_path(root
, &path
);
835 extent_start
= btrfs_disk_key_offset(&leaf
->items
[path
.slots
[0]].key
);
836 extent_start
= extent_start
>> inode
->i_blkbits
;
837 extent_start
+= btrfs_file_extent_offset(item
);
838 extent_end
= extent_start
+ btrfs_file_extent_num_blocks(item
);
839 btrfs_release_path(root
, &path
);
840 if (iblock
>= extent_start
&& iblock
< extent_end
) {
842 map_bh(result
, inode
->i_sb
, blocknr
+ iblock
- extent_start
);
846 /* ok, create a new extent */
851 ret
= btrfs_alloc_file_extent(trans
, root
, objectid
,
852 iblock
<< inode
->i_blkbits
,
853 1, extent_end
, &blocknr
);
858 inode
->i_blocks
+= inode
->i_sb
->s_blocksize
>> 9;
859 set_buffer_new(result
);
860 map_bh(result
, inode
->i_sb
, blocknr
);
864 btrfs_end_transaction(trans
, root
);
868 static int btrfs_get_block(struct inode
*inode
, sector_t iblock
,
869 struct buffer_head
*result
, int create
)
872 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
873 mutex_lock(&root
->fs_info
->fs_mutex
);
874 err
= btrfs_get_block_lock(inode
, iblock
, result
, create
);
875 mutex_unlock(&root
->fs_info
->fs_mutex
);
879 static int btrfs_prepare_write(struct file
*file
, struct page
*page
,
880 unsigned from
, unsigned to
)
883 return nobh_prepare_write(page
, from
, to
, btrfs_get_block
);
885 static int btrfs_commit_write(struct file
*file
, struct page
*page
,
886 unsigned from
, unsigned to
)
889 return nobh_commit_write(file
, page
, from
, to
);
892 static void btrfs_write_super(struct super_block
*sb
)
894 btrfs_sync_fs(sb
, 1);
897 static int btrfs_readpage(struct file
*file
, struct page
*page
)
899 return mpage_readpage(page
, btrfs_get_block
);
902 static int btrfs_readpages(struct file
*file
, struct address_space
*mapping
,
903 struct list_head
*pages
, unsigned nr_pages
)
905 return mpage_readpages(mapping
, pages
, nr_pages
, btrfs_get_block
);
908 static int btrfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
910 return nobh_writepage(page
, btrfs_get_block
, wbc
);
913 static void btrfs_truncate(struct inode
*inode
)
915 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
917 struct btrfs_trans_handle
*trans
;
919 if (!S_ISREG(inode
->i_mode
))
921 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
924 nobh_truncate_page(inode
->i_mapping
, inode
->i_size
);
926 /* FIXME, add redo link to tree so we don't leak on crash */
927 mutex_lock(&root
->fs_info
->fs_mutex
);
928 trans
= btrfs_start_transaction(root
, 1);
929 ret
= btrfs_truncate_in_trans(trans
, root
, inode
);
931 ret
= btrfs_end_transaction(trans
, root
);
933 mutex_unlock(&root
->fs_info
->fs_mutex
);
934 mark_inode_dirty(inode
);
937 static int btrfs_copy_from_user(loff_t pos
, int num_pages
, int write_bytes
,
938 struct page
**prepared_pages
,
939 const char __user
* buf
)
943 int offset
= pos
& (PAGE_CACHE_SIZE
- 1);
945 for (i
= 0; i
< num_pages
&& write_bytes
> 0; i
++, offset
= 0) {
946 size_t count
= min_t(size_t,
947 PAGE_CACHE_SIZE
- offset
, write_bytes
);
948 struct page
*page
= prepared_pages
[i
];
949 fault_in_pages_readable(buf
, count
);
951 /* Copy data from userspace to the current page */
953 page_fault
= __copy_from_user(page_address(page
) + offset
,
955 /* Flush processor's dcache for this page */
956 flush_dcache_page(page
);
959 write_bytes
-= count
;
964 return page_fault
? -EFAULT
: 0;
967 static void btrfs_drop_pages(struct page
**pages
, size_t num_pages
)
970 for (i
= 0; i
< num_pages
; i
++) {
973 unlock_page(pages
[i
]);
974 mark_page_accessed(pages
[i
]);
975 page_cache_release(pages
[i
]);
978 static int dirty_and_release_pages(struct btrfs_trans_handle
*trans
,
979 struct btrfs_root
*root
,
991 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
993 for (i
= 0; i
< num_pages
; i
++) {
994 offset
= pos
& (PAGE_CACHE_SIZE
-1);
995 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
996 /* FIXME, one block at a time */
998 mutex_lock(&root
->fs_info
->fs_mutex
);
999 trans
= btrfs_start_transaction(root
, 1);
1000 btrfs_csum_file_block(trans
, root
, inode
->i_ino
,
1001 pages
[i
]->index
<< PAGE_CACHE_SHIFT
,
1002 kmap(pages
[i
]), PAGE_CACHE_SIZE
);
1004 SetPageChecked(pages
[i
]);
1005 ret
= btrfs_end_transaction(trans
, root
);
1007 mutex_unlock(&root
->fs_info
->fs_mutex
);
1009 ret
= nobh_commit_write(file
, pages
[i
], offset
,
1010 offset
+ this_write
);
1016 WARN_ON(this_write
> write_bytes
);
1017 write_bytes
-= this_write
;
1023 static int prepare_pages(struct btrfs_trans_handle
*trans
,
1024 struct btrfs_root
*root
,
1026 struct page
**pages
,
1032 unsigned long index
= pos
>> PAGE_CACHE_SHIFT
;
1033 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1038 loff_t isize
= i_size_read(inode
);
1040 memset(pages
, 0, num_pages
* sizeof(struct page
*));
1042 for (i
= 0; i
< num_pages
; i
++) {
1043 pages
[i
] = grab_cache_page(inode
->i_mapping
, index
+ i
);
1046 goto failed_release
;
1048 offset
= pos
& (PAGE_CACHE_SIZE
-1);
1049 this_write
= min(PAGE_CACHE_SIZE
- offset
, write_bytes
);
1050 ret
= nobh_prepare_write(pages
[i
], offset
,
1051 offset
+ this_write
,
1056 goto failed_truncate
;
1058 WARN_ON(this_write
> write_bytes
);
1059 write_bytes
-= this_write
;
1064 btrfs_drop_pages(pages
, num_pages
);
1068 btrfs_drop_pages(pages
, num_pages
);
1070 vmtruncate(inode
, isize
);
1074 static ssize_t
btrfs_file_write(struct file
*file
, const char __user
*buf
,
1075 size_t count
, loff_t
*ppos
)
1078 size_t num_written
= 0;
1081 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1082 struct btrfs_root
*root
= btrfs_sb(inode
->i_sb
);
1083 struct page
*pages
[1];
1085 if (file
->f_flags
& O_DIRECT
)
1089 vfs_check_frozen(inode
->i_sb
, SB_FREEZE_WRITE
);
1090 current
->backing_dev_info
= inode
->i_mapping
->backing_dev_info
;
1091 err
= generic_write_checks(file
, &pos
, &count
, S_ISBLK(inode
->i_mode
));
1096 err
= remove_suid(file
->f_path
.dentry
);
1099 file_update_time(file
);
1100 mutex_lock(&inode
->i_mutex
);
1102 size_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1103 size_t write_bytes
= min(count
, PAGE_CACHE_SIZE
- offset
);
1104 size_t num_pages
= (write_bytes
+ PAGE_CACHE_SIZE
- 1) >>
1106 ret
= prepare_pages(NULL
, root
, file
, pages
, num_pages
,
1109 ret
= btrfs_copy_from_user(pos
, num_pages
,
1110 write_bytes
, pages
, buf
);
1113 ret
= dirty_and_release_pages(NULL
, root
, file
, pages
,
1114 num_pages
, pos
, write_bytes
);
1116 btrfs_drop_pages(pages
, num_pages
);
1119 count
-= write_bytes
;
1121 num_written
+= write_bytes
;
1123 balance_dirty_pages_ratelimited(inode
->i_mapping
);
1126 mutex_unlock(&inode
->i_mutex
);
1129 current
->backing_dev_info
= NULL
;
1130 return num_written
? num_written
: err
;
1133 static int btrfs_read_actor(read_descriptor_t
*desc
, struct page
*page
,
1134 unsigned long offset
, unsigned long size
)
1137 unsigned long left
, count
= desc
->count
;
1142 if (!PageChecked(page
)) {
1143 /* FIXME, do it per block */
1144 struct btrfs_root
*root
= btrfs_sb(page
->mapping
->host
->i_sb
);
1145 int ret
= btrfs_csum_verify_file_block(root
,
1146 page
->mapping
->host
->i_ino
,
1147 page
->index
<< PAGE_CACHE_SHIFT
,
1148 kmap(page
), PAGE_CACHE_SIZE
);
1150 printk("failed to verify ino %lu page %lu\n",
1151 page
->mapping
->host
->i_ino
,
1153 memset(page_address(page
), 0, PAGE_CACHE_SIZE
);
1155 SetPageChecked(page
);
1159 * Faults on the destination of a read are common, so do it before
1162 if (!fault_in_pages_writeable(desc
->arg
.buf
, size
)) {
1163 kaddr
= kmap_atomic(page
, KM_USER0
);
1164 left
= __copy_to_user_inatomic(desc
->arg
.buf
,
1165 kaddr
+ offset
, size
);
1166 kunmap_atomic(kaddr
, KM_USER0
);
1171 /* Do it the slow way */
1173 left
= __copy_to_user(desc
->arg
.buf
, kaddr
+ offset
, size
);
1178 desc
->error
= -EFAULT
;
1181 desc
->count
= count
- size
;
1182 desc
->written
+= size
;
1183 desc
->arg
.buf
+= size
;
1188 * btrfs_file_aio_read - filesystem read routine
1189 * @iocb: kernel I/O control block
1190 * @iov: io vector request
1191 * @nr_segs: number of segments in the iovec
1192 * @pos: current file position
1194 static ssize_t
btrfs_file_aio_read(struct kiocb
*iocb
, const struct iovec
*iov
,
1195 unsigned long nr_segs
, loff_t pos
)
1197 struct file
*filp
= iocb
->ki_filp
;
1201 loff_t
*ppos
= &iocb
->ki_pos
;
1204 for (seg
= 0; seg
< nr_segs
; seg
++) {
1205 const struct iovec
*iv
= &iov
[seg
];
1208 * If any segment has a negative length, or the cumulative
1209 * length ever wraps negative then return -EINVAL.
1211 count
+= iv
->iov_len
;
1212 if (unlikely((ssize_t
)(count
|iv
->iov_len
) < 0))
1214 if (access_ok(VERIFY_WRITE
, iv
->iov_base
, iv
->iov_len
))
1219 count
-= iv
->iov_len
; /* This segment is no good */
1224 for (seg
= 0; seg
< nr_segs
; seg
++) {
1225 read_descriptor_t desc
;
1228 desc
.arg
.buf
= iov
[seg
].iov_base
;
1229 desc
.count
= iov
[seg
].iov_len
;
1230 if (desc
.count
== 0)
1233 do_generic_file_read(filp
, ppos
, &desc
,
1235 retval
+= desc
.written
;
1237 retval
= retval
?: desc
.error
;
1245 static int btrfs_get_sb(struct file_system_type
*fs_type
,
1246 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1248 return get_sb_bdev(fs_type
, flags
, dev_name
, data
,
1249 btrfs_fill_super
, mnt
);
1252 static struct file_system_type btrfs_fs_type
= {
1253 .owner
= THIS_MODULE
,
1255 .get_sb
= btrfs_get_sb
,
1256 .kill_sb
= kill_block_super
,
1257 .fs_flags
= FS_REQUIRES_DEV
,
1260 static struct super_operations btrfs_super_ops
= {
1261 .statfs
= simple_statfs
,
1262 .delete_inode
= btrfs_delete_inode
,
1263 .put_super
= btrfs_put_super
,
1264 .read_inode
= btrfs_read_locked_inode
,
1265 .write_super
= btrfs_write_super
,
1266 .sync_fs
= btrfs_sync_fs
,
1267 .write_inode
= btrfs_write_inode
,
1270 static struct inode_operations btrfs_dir_inode_operations
= {
1271 .lookup
= btrfs_lookup
,
1272 .create
= btrfs_create
,
1273 .unlink
= btrfs_unlink
,
1274 .mkdir
= btrfs_mkdir
,
1275 .rmdir
= btrfs_rmdir
,
1278 static struct file_operations btrfs_dir_file_operations
= {
1279 .llseek
= generic_file_llseek
,
1280 .read
= generic_read_dir
,
1281 .readdir
= btrfs_readdir
,
1284 static struct address_space_operations btrfs_aops
= {
1285 .readpage
= btrfs_readpage
,
1286 .readpages
= btrfs_readpages
,
1287 .writepage
= btrfs_writepage
,
1288 .sync_page
= block_sync_page
,
1289 .prepare_write
= btrfs_prepare_write
,
1290 .commit_write
= btrfs_commit_write
,
1293 static struct inode_operations btrfs_file_inode_operations
= {
1294 .truncate
= btrfs_truncate
,
1297 static struct file_operations btrfs_file_operations
= {
1298 .llseek
= generic_file_llseek
,
1299 .read
= do_sync_read
,
1300 .aio_read
= btrfs_file_aio_read
,
1301 .write
= btrfs_file_write
,
1302 .mmap
= generic_file_mmap
,
1303 .open
= generic_file_open
,
1306 static int __init
init_btrfs_fs(void)
1308 printk("btrfs loaded!\n");
1309 return register_filesystem(&btrfs_fs_type
);
1312 static void __exit
exit_btrfs_fs(void)
1314 unregister_filesystem(&btrfs_fs_type
);
1315 printk("btrfs unloaded\n");
1318 module_init(init_btrfs_fs
)
1319 module_exit(exit_btrfs_fs
)
1321 MODULE_LICENSE("GPL");