2 * Optimized MPEG FS - inode and super operations.
3 * Copyright (C) 2006 Bob Copeland <me@bobcopeland.com>
4 * Released under GPL v2.
6 #include <linux/module.h>
7 #include <linux/sched.h>
8 #include <linux/slab.h>
10 #include <linux/vfs.h>
11 #include <linux/parser.h>
12 #include <linux/buffer_head.h>
13 #include <linux/vmalloc.h>
14 #include <linux/writeback.h>
15 #include <linux/crc-itu-t.h>
18 MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>");
19 MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux");
20 MODULE_LICENSE("GPL");
22 struct buffer_head
*omfs_bread(struct super_block
*sb
, sector_t block
)
24 struct omfs_sb_info
*sbi
= OMFS_SB(sb
);
25 if (block
>= sbi
->s_num_blocks
)
28 return sb_bread(sb
, clus_to_blk(sbi
, block
));
31 struct inode
*omfs_new_inode(struct inode
*dir
, int mode
)
37 struct omfs_sb_info
*sbi
= OMFS_SB(dir
->i_sb
);
39 inode
= new_inode(dir
->i_sb
);
41 return ERR_PTR(-ENOMEM
);
43 err
= omfs_allocate_range(dir
->i_sb
, sbi
->s_mirrors
, sbi
->s_mirrors
,
48 inode
->i_ino
= new_block
;
49 inode_init_owner(inode
, NULL
, mode
);
50 inode
->i_mapping
->a_ops
= &omfs_aops
;
52 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
53 switch (mode
& S_IFMT
) {
55 inode
->i_op
= &omfs_dir_inops
;
56 inode
->i_fop
= &omfs_dir_operations
;
57 inode
->i_size
= sbi
->s_sys_blocksize
;
61 inode
->i_op
= &omfs_file_inops
;
62 inode
->i_fop
= &omfs_file_operations
;
67 insert_inode_hash(inode
);
68 mark_inode_dirty(inode
);
71 make_bad_inode(inode
);
77 * Update the header checksums for a dirty inode based on its contents.
78 * Caller is expected to hold the buffer head underlying oi and mark it
81 static void omfs_update_checksums(struct omfs_inode
*oi
)
83 int xor, i
, ofs
= 0, count
;
85 unsigned char *ptr
= (unsigned char *) oi
;
87 count
= be32_to_cpu(oi
->i_head
.h_body_size
);
88 ofs
= sizeof(struct omfs_header
);
90 crc
= crc_itu_t(crc
, ptr
+ ofs
, count
);
91 oi
->i_head
.h_crc
= cpu_to_be16(crc
);
94 for (i
= 1; i
< OMFS_XOR_COUNT
; i
++)
97 oi
->i_head
.h_check_xor
= xor;
100 static int __omfs_write_inode(struct inode
*inode
, int wait
)
102 struct omfs_inode
*oi
;
103 struct omfs_sb_info
*sbi
= OMFS_SB(inode
->i_sb
);
104 struct buffer_head
*bh
, *bh2
;
110 /* get current inode since we may have written sibling ptrs etc. */
111 bh
= omfs_bread(inode
->i_sb
, inode
->i_ino
);
115 oi
= (struct omfs_inode
*) bh
->b_data
;
117 oi
->i_head
.h_self
= cpu_to_be64(inode
->i_ino
);
118 if (S_ISDIR(inode
->i_mode
))
119 oi
->i_type
= OMFS_DIR
;
120 else if (S_ISREG(inode
->i_mode
))
121 oi
->i_type
= OMFS_FILE
;
123 printk(KERN_WARNING
"omfs: unknown file type: %d\n",
128 oi
->i_head
.h_body_size
= cpu_to_be32(sbi
->s_sys_blocksize
-
129 sizeof(struct omfs_header
));
130 oi
->i_head
.h_version
= 1;
131 oi
->i_head
.h_type
= OMFS_INODE_NORMAL
;
132 oi
->i_head
.h_magic
= OMFS_IMAGIC
;
133 oi
->i_size
= cpu_to_be64(inode
->i_size
);
135 ctime
= inode
->i_ctime
.tv_sec
* 1000LL +
136 ((inode
->i_ctime
.tv_nsec
+ 999)/1000);
137 oi
->i_ctime
= cpu_to_be64(ctime
);
139 omfs_update_checksums(oi
);
141 mark_buffer_dirty(bh
);
143 sync_dirty_buffer(bh
);
144 if (buffer_req(bh
) && !buffer_uptodate(bh
))
148 /* if mirroring writes, copy to next fsblock */
149 for (i
= 1; i
< sbi
->s_mirrors
; i
++) {
150 bh2
= omfs_bread(inode
->i_sb
, inode
->i_ino
+ i
);
154 memcpy(bh2
->b_data
, bh
->b_data
, bh
->b_size
);
155 mark_buffer_dirty(bh2
);
157 sync_dirty_buffer(bh2
);
158 if (buffer_req(bh2
) && !buffer_uptodate(bh2
))
163 ret
= (sync_failed
) ? -EIO
: 0;
170 static int omfs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
172 return __omfs_write_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
175 int omfs_sync_inode(struct inode
*inode
)
177 return __omfs_write_inode(inode
, 1);
181 * called when an entry is deleted, need to clear the bits in the
184 static void omfs_evict_inode(struct inode
*inode
)
186 truncate_inode_pages(&inode
->i_data
, 0);
187 end_writeback(inode
);
192 if (S_ISREG(inode
->i_mode
)) {
194 omfs_shrink_inode(inode
);
197 omfs_clear_range(inode
->i_sb
, inode
->i_ino
, 2);
200 struct inode
*omfs_iget(struct super_block
*sb
, ino_t ino
)
202 struct omfs_sb_info
*sbi
= OMFS_SB(sb
);
203 struct omfs_inode
*oi
;
204 struct buffer_head
*bh
;
209 inode
= iget_locked(sb
, ino
);
211 return ERR_PTR(-ENOMEM
);
212 if (!(inode
->i_state
& I_NEW
))
215 bh
= omfs_bread(inode
->i_sb
, ino
);
219 oi
= (struct omfs_inode
*)bh
->b_data
;
222 if (ino
!= be64_to_cpu(oi
->i_head
.h_self
))
225 inode
->i_uid
= sbi
->s_uid
;
226 inode
->i_gid
= sbi
->s_gid
;
228 ctime
= be64_to_cpu(oi
->i_ctime
);
229 nsecs
= do_div(ctime
, 1000) * 1000L;
231 inode
->i_atime
.tv_sec
= ctime
;
232 inode
->i_mtime
.tv_sec
= ctime
;
233 inode
->i_ctime
.tv_sec
= ctime
;
234 inode
->i_atime
.tv_nsec
= nsecs
;
235 inode
->i_mtime
.tv_nsec
= nsecs
;
236 inode
->i_ctime
.tv_nsec
= nsecs
;
238 inode
->i_mapping
->a_ops
= &omfs_aops
;
240 switch (oi
->i_type
) {
242 inode
->i_mode
= S_IFDIR
| (S_IRWXUGO
& ~sbi
->s_dmask
);
243 inode
->i_op
= &omfs_dir_inops
;
244 inode
->i_fop
= &omfs_dir_operations
;
245 inode
->i_size
= sbi
->s_sys_blocksize
;
249 inode
->i_mode
= S_IFREG
| (S_IRWXUGO
& ~sbi
->s_fmask
);
250 inode
->i_fop
= &omfs_file_operations
;
251 inode
->i_size
= be64_to_cpu(oi
->i_size
);
255 unlock_new_inode(inode
);
261 return ERR_PTR(-EIO
);
264 static void omfs_put_super(struct super_block
*sb
)
266 struct omfs_sb_info
*sbi
= OMFS_SB(sb
);
269 sb
->s_fs_info
= NULL
;
272 static int omfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
274 struct super_block
*s
= dentry
->d_sb
;
275 struct omfs_sb_info
*sbi
= OMFS_SB(s
);
276 u64 id
= huge_encode_dev(s
->s_bdev
->bd_dev
);
278 buf
->f_type
= OMFS_MAGIC
;
279 buf
->f_bsize
= sbi
->s_blocksize
;
280 buf
->f_blocks
= sbi
->s_num_blocks
;
281 buf
->f_files
= sbi
->s_num_blocks
;
282 buf
->f_namelen
= OMFS_NAMELEN
;
283 buf
->f_fsid
.val
[0] = (u32
)id
;
284 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
286 buf
->f_bfree
= buf
->f_bavail
= buf
->f_ffree
=
292 static const struct super_operations omfs_sops
= {
293 .write_inode
= omfs_write_inode
,
294 .evict_inode
= omfs_evict_inode
,
295 .put_super
= omfs_put_super
,
296 .statfs
= omfs_statfs
,
297 .show_options
= generic_show_options
,
301 * For Rio Karma, there is an on-disk free bitmap whose location is
302 * stored in the root block. For ReplayTV, there is no such free bitmap
303 * so we have to walk the tree. Both inodes and file data are allocated
304 * from the same map. This array can be big (300k) so we allocate
305 * in units of the blocksize.
307 static int omfs_get_imap(struct super_block
*sb
)
312 struct omfs_sb_info
*sbi
= OMFS_SB(sb
);
313 struct buffer_head
*bh
;
317 bitmap_size
= DIV_ROUND_UP(sbi
->s_num_blocks
, 8);
318 array_size
= DIV_ROUND_UP(bitmap_size
, sb
->s_blocksize
);
320 if (sbi
->s_bitmap_ino
== ~0ULL)
323 sbi
->s_imap_size
= array_size
;
324 sbi
->s_imap
= kzalloc(array_size
* sizeof(unsigned long *), GFP_KERNEL
);
328 block
= clus_to_blk(sbi
, sbi
->s_bitmap_ino
);
329 if (block
>= sbi
->s_num_blocks
)
333 for (count
= bitmap_size
; count
> 0; count
-= sb
->s_blocksize
) {
334 bh
= sb_bread(sb
, block
++);
337 *ptr
= kmalloc(sb
->s_blocksize
, GFP_KERNEL
);
342 memcpy(*ptr
, bh
->b_data
, sb
->s_blocksize
);
343 if (count
< sb
->s_blocksize
)
344 memset((void *)*ptr
+ count
, 0xff,
345 sb
->s_blocksize
- count
);
353 for (count
= 0; count
< array_size
; count
++)
354 kfree(sbi
->s_imap
[count
]);
359 sbi
->s_imap_size
= 0;
364 Opt_uid
, Opt_gid
, Opt_umask
, Opt_dmask
, Opt_fmask
367 static const match_table_t tokens
= {
370 {Opt_umask
, "umask=%o"},
371 {Opt_dmask
, "dmask=%o"},
372 {Opt_fmask
, "fmask=%o"},
375 static int parse_options(char *options
, struct omfs_sb_info
*sbi
)
378 substring_t args
[MAX_OPT_ARGS
];
384 while ((p
= strsep(&options
, ",")) != NULL
) {
389 token
= match_token(p
, tokens
, args
);
392 if (match_int(&args
[0], &option
))
397 if (match_int(&args
[0], &option
))
402 if (match_octal(&args
[0], &option
))
404 sbi
->s_fmask
= sbi
->s_dmask
= option
;
407 if (match_octal(&args
[0], &option
))
409 sbi
->s_dmask
= option
;
412 if (match_octal(&args
[0], &option
))
414 sbi
->s_fmask
= option
;
423 static int omfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
425 struct buffer_head
*bh
, *bh2
;
426 struct omfs_super_block
*omfs_sb
;
427 struct omfs_root_block
*omfs_rb
;
428 struct omfs_sb_info
*sbi
;
432 save_mount_options(sb
, (char *) data
);
434 sbi
= kzalloc(sizeof(struct omfs_sb_info
), GFP_KERNEL
);
440 sbi
->s_uid
= current_uid();
441 sbi
->s_gid
= current_gid();
442 sbi
->s_dmask
= sbi
->s_fmask
= current_umask();
444 if (!parse_options((char *) data
, sbi
))
447 sb
->s_maxbytes
= 0xffffffff;
449 sb_set_blocksize(sb
, 0x200);
451 bh
= sb_bread(sb
, 0);
455 omfs_sb
= (struct omfs_super_block
*)bh
->b_data
;
457 if (omfs_sb
->s_magic
!= cpu_to_be32(OMFS_MAGIC
)) {
459 printk(KERN_ERR
"omfs: Invalid superblock (%x)\n",
463 sb
->s_magic
= OMFS_MAGIC
;
465 sbi
->s_num_blocks
= be64_to_cpu(omfs_sb
->s_num_blocks
);
466 sbi
->s_blocksize
= be32_to_cpu(omfs_sb
->s_blocksize
);
467 sbi
->s_mirrors
= be32_to_cpu(omfs_sb
->s_mirrors
);
468 sbi
->s_root_ino
= be64_to_cpu(omfs_sb
->s_root_block
);
469 sbi
->s_sys_blocksize
= be32_to_cpu(omfs_sb
->s_sys_blocksize
);
470 mutex_init(&sbi
->s_bitmap_lock
);
472 if (sbi
->s_sys_blocksize
> PAGE_SIZE
) {
473 printk(KERN_ERR
"omfs: sysblock size (%d) is out of range\n",
474 sbi
->s_sys_blocksize
);
478 if (sbi
->s_blocksize
< sbi
->s_sys_blocksize
||
479 sbi
->s_blocksize
> OMFS_MAX_BLOCK_SIZE
) {
480 printk(KERN_ERR
"omfs: block size (%d) is out of range\n",
486 * Use sys_blocksize as the fs block since it is smaller than a
487 * page while the fs blocksize can be larger.
489 sb_set_blocksize(sb
, sbi
->s_sys_blocksize
);
492 * ...and the difference goes into a shift. sys_blocksize is always
493 * a power of two factor of blocksize.
495 sbi
->s_block_shift
= get_bitmask_order(sbi
->s_blocksize
) -
496 get_bitmask_order(sbi
->s_sys_blocksize
);
498 bh2
= omfs_bread(sb
, be64_to_cpu(omfs_sb
->s_root_block
));
502 omfs_rb
= (struct omfs_root_block
*)bh2
->b_data
;
504 sbi
->s_bitmap_ino
= be64_to_cpu(omfs_rb
->r_bitmap
);
505 sbi
->s_clustersize
= be32_to_cpu(omfs_rb
->r_clustersize
);
507 if (sbi
->s_num_blocks
!= be64_to_cpu(omfs_rb
->r_num_blocks
)) {
508 printk(KERN_ERR
"omfs: block count discrepancy between "
509 "super and root blocks (%llx, %llx)\n",
510 (unsigned long long)sbi
->s_num_blocks
,
511 (unsigned long long)be64_to_cpu(omfs_rb
->r_num_blocks
));
515 if (sbi
->s_bitmap_ino
!= ~0ULL &&
516 sbi
->s_bitmap_ino
> sbi
->s_num_blocks
) {
517 printk(KERN_ERR
"omfs: free space bitmap location is corrupt "
518 "(%llx, total blocks %llx)\n",
519 (unsigned long long) sbi
->s_bitmap_ino
,
520 (unsigned long long) sbi
->s_num_blocks
);
523 if (sbi
->s_clustersize
< 1 ||
524 sbi
->s_clustersize
> OMFS_MAX_CLUSTER_SIZE
) {
525 printk(KERN_ERR
"omfs: cluster size out of range (%d)",
530 ret
= omfs_get_imap(sb
);
534 sb
->s_op
= &omfs_sops
;
536 root
= omfs_iget(sb
, be64_to_cpu(omfs_rb
->r_root_dir
));
542 sb
->s_root
= d_alloc_root(root
);
547 printk(KERN_DEBUG
"omfs: Mounted volume %s\n", omfs_rb
->r_name
);
560 static struct dentry
*omfs_mount(struct file_system_type
*fs_type
,
561 int flags
, const char *dev_name
, void *data
)
563 return mount_bdev(fs_type
, flags
, dev_name
, data
, omfs_fill_super
);
566 static struct file_system_type omfs_fs_type
= {
567 .owner
= THIS_MODULE
,
570 .kill_sb
= kill_block_super
,
571 .fs_flags
= FS_REQUIRES_DEV
,
574 static int __init
init_omfs_fs(void)
576 return register_filesystem(&omfs_fs_type
);
579 static void __exit
exit_omfs_fs(void)
581 unregister_filesystem(&omfs_fs_type
);
584 module_init(init_omfs_fs
);
585 module_exit(exit_omfs_fs
);