3 * BFS superblock and inode operations.
4 * Copyright (C) 1999-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
5 * From fs/minix, Copyright (C) 1991, 1992 Linus Torvalds.
7 * Made endianness-clean by Andrew Stribblehill <ads@wompom.org>, 2005.
10 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/init.h>
15 #include <linux/smp_lock.h>
16 #include <linux/buffer_head.h>
17 #include <linux/vfs.h>
18 #include <asm/uaccess.h>
21 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
22 MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
23 MODULE_LICENSE("GPL");
28 #define dprintf(x...) printf(x)
33 static void bfs_write_super(struct super_block
*s
);
34 void dump_imap(const char *prefix
, struct super_block
*s
);
36 struct inode
*bfs_iget(struct super_block
*sb
, unsigned long ino
)
40 struct buffer_head
*bh
;
43 inode
= iget_locked(sb
, ino
);
45 return ERR_PTR(-ENOMEM
);
46 if (!(inode
->i_state
& I_NEW
))
49 if ((ino
< BFS_ROOT_INO
) || (ino
> BFS_SB(inode
->i_sb
)->si_lasti
)) {
50 printf("Bad inode number %s:%08lx\n", inode
->i_sb
->s_id
, ino
);
54 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
55 bh
= sb_bread(inode
->i_sb
, block
);
57 printf("Unable to read inode %s:%08lx\n", inode
->i_sb
->s_id
,
62 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
63 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
65 inode
->i_mode
= 0x0000FFFF & le32_to_cpu(di
->i_mode
);
66 if (le32_to_cpu(di
->i_vtype
) == BFS_VDIR
) {
67 inode
->i_mode
|= S_IFDIR
;
68 inode
->i_op
= &bfs_dir_inops
;
69 inode
->i_fop
= &bfs_dir_operations
;
70 } else if (le32_to_cpu(di
->i_vtype
) == BFS_VREG
) {
71 inode
->i_mode
|= S_IFREG
;
72 inode
->i_op
= &bfs_file_inops
;
73 inode
->i_fop
= &bfs_file_operations
;
74 inode
->i_mapping
->a_ops
= &bfs_aops
;
77 BFS_I(inode
)->i_sblock
= le32_to_cpu(di
->i_sblock
);
78 BFS_I(inode
)->i_eblock
= le32_to_cpu(di
->i_eblock
);
79 BFS_I(inode
)->i_dsk_ino
= le16_to_cpu(di
->i_ino
);
80 inode
->i_uid
= le32_to_cpu(di
->i_uid
);
81 inode
->i_gid
= le32_to_cpu(di
->i_gid
);
82 inode
->i_nlink
= le32_to_cpu(di
->i_nlink
);
83 inode
->i_size
= BFS_FILESIZE(di
);
84 inode
->i_blocks
= BFS_FILEBLOCKS(di
);
85 inode
->i_atime
.tv_sec
= le32_to_cpu(di
->i_atime
);
86 inode
->i_mtime
.tv_sec
= le32_to_cpu(di
->i_mtime
);
87 inode
->i_ctime
.tv_sec
= le32_to_cpu(di
->i_ctime
);
88 inode
->i_atime
.tv_nsec
= 0;
89 inode
->i_mtime
.tv_nsec
= 0;
90 inode
->i_ctime
.tv_nsec
= 0;
93 unlock_new_inode(inode
);
101 static int bfs_write_inode(struct inode
*inode
, int unused
)
103 unsigned int ino
= (u16
)inode
->i_ino
;
104 unsigned long i_sblock
;
105 struct bfs_inode
*di
;
106 struct buffer_head
*bh
;
108 struct bfs_sb_info
*info
= BFS_SB(inode
->i_sb
);
110 dprintf("ino=%08x\n", ino
);
112 if ((ino
< BFS_ROOT_INO
) || (ino
> BFS_SB(inode
->i_sb
)->si_lasti
)) {
113 printf("Bad inode number %s:%08x\n", inode
->i_sb
->s_id
, ino
);
117 mutex_lock(&info
->bfs_lock
);
118 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
119 bh
= sb_bread(inode
->i_sb
, block
);
121 printf("Unable to read inode %s:%08x\n",
122 inode
->i_sb
->s_id
, ino
);
123 mutex_unlock(&info
->bfs_lock
);
127 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
128 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
130 if (ino
== BFS_ROOT_INO
)
131 di
->i_vtype
= cpu_to_le32(BFS_VDIR
);
133 di
->i_vtype
= cpu_to_le32(BFS_VREG
);
135 di
->i_ino
= cpu_to_le16(ino
);
136 di
->i_mode
= cpu_to_le32(inode
->i_mode
);
137 di
->i_uid
= cpu_to_le32(inode
->i_uid
);
138 di
->i_gid
= cpu_to_le32(inode
->i_gid
);
139 di
->i_nlink
= cpu_to_le32(inode
->i_nlink
);
140 di
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
141 di
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
142 di
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
143 i_sblock
= BFS_I(inode
)->i_sblock
;
144 di
->i_sblock
= cpu_to_le32(i_sblock
);
145 di
->i_eblock
= cpu_to_le32(BFS_I(inode
)->i_eblock
);
146 di
->i_eoffset
= cpu_to_le32(i_sblock
* BFS_BSIZE
+ inode
->i_size
- 1);
148 mark_buffer_dirty(bh
);
150 mutex_unlock(&info
->bfs_lock
);
154 static void bfs_delete_inode(struct inode
*inode
)
156 unsigned long ino
= inode
->i_ino
;
157 struct bfs_inode
*di
;
158 struct buffer_head
*bh
;
160 struct super_block
*s
= inode
->i_sb
;
161 struct bfs_sb_info
*info
= BFS_SB(s
);
162 struct bfs_inode_info
*bi
= BFS_I(inode
);
164 dprintf("ino=%08lx\n", ino
);
166 truncate_inode_pages(&inode
->i_data
, 0);
168 if ((ino
< BFS_ROOT_INO
) || (ino
> info
->si_lasti
)) {
169 printf("invalid ino=%08lx\n", ino
);
174 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
175 mutex_lock(&info
->bfs_lock
);
176 mark_inode_dirty(inode
);
178 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
179 bh
= sb_bread(s
, block
);
181 printf("Unable to read inode %s:%08lx\n",
182 inode
->i_sb
->s_id
, ino
);
183 mutex_unlock(&info
->bfs_lock
);
186 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
187 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
188 memset((void *)di
, 0, sizeof(struct bfs_inode
));
189 mark_buffer_dirty(bh
);
194 info
->si_freeb
+= bi
->i_eblock
+ 1 - bi
->i_sblock
;
196 clear_bit(ino
, info
->si_imap
);
197 dump_imap("delete_inode", s
);
201 * If this was the last file, make the previous block
202 * "last block of the last file" even if there is no
203 * real file there, saves us 1 gap.
205 if (info
->si_lf_eblk
== bi
->i_eblock
) {
206 info
->si_lf_eblk
= bi
->i_sblock
- 1;
207 mark_buffer_dirty(info
->si_sbh
);
209 mutex_unlock(&info
->bfs_lock
);
213 static void bfs_put_super(struct super_block
*s
)
215 struct bfs_sb_info
*info
= BFS_SB(s
);
225 brelse(info
->si_sbh
);
226 mutex_destroy(&info
->bfs_lock
);
227 kfree(info
->si_imap
);
234 static int bfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
236 struct super_block
*s
= dentry
->d_sb
;
237 struct bfs_sb_info
*info
= BFS_SB(s
);
238 u64 id
= huge_encode_dev(s
->s_bdev
->bd_dev
);
239 buf
->f_type
= BFS_MAGIC
;
240 buf
->f_bsize
= s
->s_blocksize
;
241 buf
->f_blocks
= info
->si_blocks
;
242 buf
->f_bfree
= buf
->f_bavail
= info
->si_freeb
;
243 buf
->f_files
= info
->si_lasti
+ 1 - BFS_ROOT_INO
;
244 buf
->f_ffree
= info
->si_freei
;
245 buf
->f_fsid
.val
[0] = (u32
)id
;
246 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
247 buf
->f_namelen
= BFS_NAMELEN
;
251 static void bfs_write_super(struct super_block
*s
)
253 struct bfs_sb_info
*info
= BFS_SB(s
);
255 mutex_lock(&info
->bfs_lock
);
256 if (!(s
->s_flags
& MS_RDONLY
))
257 mark_buffer_dirty(info
->si_sbh
);
259 mutex_unlock(&info
->bfs_lock
);
262 static struct kmem_cache
*bfs_inode_cachep
;
264 static struct inode
*bfs_alloc_inode(struct super_block
*sb
)
266 struct bfs_inode_info
*bi
;
267 bi
= kmem_cache_alloc(bfs_inode_cachep
, GFP_KERNEL
);
270 return &bi
->vfs_inode
;
273 static void bfs_destroy_inode(struct inode
*inode
)
275 kmem_cache_free(bfs_inode_cachep
, BFS_I(inode
));
278 static void init_once(void *foo
)
280 struct bfs_inode_info
*bi
= foo
;
282 inode_init_once(&bi
->vfs_inode
);
285 static int init_inodecache(void)
287 bfs_inode_cachep
= kmem_cache_create("bfs_inode_cache",
288 sizeof(struct bfs_inode_info
),
289 0, (SLAB_RECLAIM_ACCOUNT
|
292 if (bfs_inode_cachep
== NULL
)
297 static void destroy_inodecache(void)
299 kmem_cache_destroy(bfs_inode_cachep
);
302 static const struct super_operations bfs_sops
= {
303 .alloc_inode
= bfs_alloc_inode
,
304 .destroy_inode
= bfs_destroy_inode
,
305 .write_inode
= bfs_write_inode
,
306 .delete_inode
= bfs_delete_inode
,
307 .put_super
= bfs_put_super
,
308 .write_super
= bfs_write_super
,
309 .statfs
= bfs_statfs
,
312 void dump_imap(const char *prefix
, struct super_block
*s
)
316 char *tmpbuf
= (char *)get_zeroed_page(GFP_KERNEL
);
320 for (i
= BFS_SB(s
)->si_lasti
; i
>= 0; i
--) {
321 if (i
> PAGE_SIZE
- 100) break;
322 if (test_bit(i
, BFS_SB(s
)->si_imap
))
327 printf("BFS-fs: %s: lasti=%08lx <%s>\n",
328 prefix
, BFS_SB(s
)->si_lasti
, tmpbuf
);
329 free_page((unsigned long)tmpbuf
);
333 static int bfs_fill_super(struct super_block
*s
, void *data
, int silent
)
335 struct buffer_head
*bh
;
336 struct bfs_super_block
*bfs_sb
;
338 unsigned i
, imap_len
;
339 struct bfs_sb_info
*info
;
341 unsigned long i_sblock
, i_eblock
, i_eoff
, s_size
;
343 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
348 sb_set_blocksize(s
, BFS_BSIZE
);
353 bfs_sb
= (struct bfs_super_block
*)bh
->b_data
;
354 if (le32_to_cpu(bfs_sb
->s_magic
) != BFS_MAGIC
) {
356 printf("No BFS filesystem on %s (magic=%08x)\n",
357 s
->s_id
, le32_to_cpu(bfs_sb
->s_magic
));
360 if (BFS_UNCLEAN(bfs_sb
, s
) && !silent
)
361 printf("%s is unclean, continuing\n", s
->s_id
);
363 s
->s_magic
= BFS_MAGIC
;
366 if (le32_to_cpu(bfs_sb
->s_start
) > le32_to_cpu(bfs_sb
->s_end
)) {
367 printf("Superblock is corrupted\n");
371 info
->si_lasti
= (le32_to_cpu(bfs_sb
->s_start
) - BFS_BSIZE
) /
372 sizeof(struct bfs_inode
)
374 imap_len
= (info
->si_lasti
/ 8) + 1;
375 info
->si_imap
= kzalloc(imap_len
, GFP_KERNEL
);
378 for (i
= 0; i
< BFS_ROOT_INO
; i
++)
379 set_bit(i
, info
->si_imap
);
382 inode
= bfs_iget(s
, BFS_ROOT_INO
);
384 ret
= PTR_ERR(inode
);
385 kfree(info
->si_imap
);
388 s
->s_root
= d_alloc_root(inode
);
392 kfree(info
->si_imap
);
396 info
->si_blocks
= (le32_to_cpu(bfs_sb
->s_end
) + 1) >> BFS_BSIZE_BITS
;
397 info
->si_freeb
= (le32_to_cpu(bfs_sb
->s_end
) + 1
398 - le32_to_cpu(bfs_sb
->s_start
)) >> BFS_BSIZE_BITS
;
400 info
->si_lf_eblk
= 0;
402 /* can we read the last block? */
403 bh
= sb_bread(s
, info
->si_blocks
- 1);
405 printf("Last block not available: %lu\n", info
->si_blocks
- 1);
408 kfree(info
->si_imap
);
414 for (i
= BFS_ROOT_INO
; i
<= info
->si_lasti
; i
++) {
415 struct bfs_inode
*di
;
416 int block
= (i
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
417 int off
= (i
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
418 unsigned long eblock
;
422 bh
= sb_bread(s
, block
);
428 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
430 /* test if filesystem is not corrupted */
432 i_eoff
= le32_to_cpu(di
->i_eoffset
);
433 i_sblock
= le32_to_cpu(di
->i_sblock
);
434 i_eblock
= le32_to_cpu(di
->i_eblock
);
435 s_size
= le32_to_cpu(bfs_sb
->s_end
);
437 if (i_sblock
> info
->si_blocks
||
438 i_eblock
> info
->si_blocks
||
439 i_sblock
> i_eblock
||
441 i_sblock
* BFS_BSIZE
> i_eoff
) {
443 printf("Inode 0x%08x corrupted\n", i
);
447 kfree(info
->si_imap
);
457 set_bit(i
, info
->si_imap
);
458 info
->si_freeb
-= BFS_FILEBLOCKS(di
);
460 eblock
= le32_to_cpu(di
->i_eblock
);
461 if (eblock
> info
->si_lf_eblk
)
462 info
->si_lf_eblk
= eblock
;
465 if (!(s
->s_flags
& MS_RDONLY
)) {
466 mark_buffer_dirty(info
->si_sbh
);
469 dump_imap("read_super", s
);
470 mutex_init(&info
->bfs_lock
);
480 static int bfs_get_sb(struct file_system_type
*fs_type
,
481 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
483 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, bfs_fill_super
, mnt
);
486 static struct file_system_type bfs_fs_type
= {
487 .owner
= THIS_MODULE
,
489 .get_sb
= bfs_get_sb
,
490 .kill_sb
= kill_block_super
,
491 .fs_flags
= FS_REQUIRES_DEV
,
494 static int __init
init_bfs_fs(void)
496 int err
= init_inodecache();
499 err
= register_filesystem(&bfs_fs_type
);
504 destroy_inodecache();
509 static void __exit
exit_bfs_fs(void)
511 unregister_filesystem(&bfs_fs_type
);
512 destroy_inodecache();
515 module_init(init_bfs_fs
)
516 module_exit(exit_bfs_fs
)