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 <linux/writeback.h>
19 #include <asm/uaccess.h>
22 MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
23 MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
24 MODULE_LICENSE("GPL");
29 #define dprintf(x...) printf(x)
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 struct bfs_inode
*find_inode(struct super_block
*sb
, u16 ino
, struct buffer_head
**p
)
103 if ((ino
< BFS_ROOT_INO
) || (ino
> BFS_SB(sb
)->si_lasti
)) {
104 printf("Bad inode number %s:%08x\n", sb
->s_id
, ino
);
105 return ERR_PTR(-EIO
);
110 *p
= sb_bread(sb
, 1 + ino
/ BFS_INODES_PER_BLOCK
);
112 printf("Unable to read inode %s:%08x\n", sb
->s_id
, ino
);
113 return ERR_PTR(-EIO
);
116 return (struct bfs_inode
*)(*p
)->b_data
+ ino
% BFS_INODES_PER_BLOCK
;
119 static int bfs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
121 struct bfs_sb_info
*info
= BFS_SB(inode
->i_sb
);
122 unsigned int ino
= (u16
)inode
->i_ino
;
123 unsigned long i_sblock
;
124 struct bfs_inode
*di
;
125 struct buffer_head
*bh
;
128 dprintf("ino=%08x\n", ino
);
130 di
= find_inode(inode
->i_sb
, ino
, &bh
);
134 mutex_lock(&info
->bfs_lock
);
136 if (ino
== BFS_ROOT_INO
)
137 di
->i_vtype
= cpu_to_le32(BFS_VDIR
);
139 di
->i_vtype
= cpu_to_le32(BFS_VREG
);
141 di
->i_ino
= cpu_to_le16(ino
);
142 di
->i_mode
= cpu_to_le32(inode
->i_mode
);
143 di
->i_uid
= cpu_to_le32(inode
->i_uid
);
144 di
->i_gid
= cpu_to_le32(inode
->i_gid
);
145 di
->i_nlink
= cpu_to_le32(inode
->i_nlink
);
146 di
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
147 di
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
148 di
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
149 i_sblock
= BFS_I(inode
)->i_sblock
;
150 di
->i_sblock
= cpu_to_le32(i_sblock
);
151 di
->i_eblock
= cpu_to_le32(BFS_I(inode
)->i_eblock
);
152 di
->i_eoffset
= cpu_to_le32(i_sblock
* BFS_BSIZE
+ inode
->i_size
- 1);
154 mark_buffer_dirty(bh
);
155 if (wbc
->sync_mode
== WB_SYNC_ALL
) {
156 sync_dirty_buffer(bh
);
157 if (buffer_req(bh
) && !buffer_uptodate(bh
))
161 mutex_unlock(&info
->bfs_lock
);
165 static void bfs_evict_inode(struct inode
*inode
)
167 unsigned long ino
= inode
->i_ino
;
168 struct bfs_inode
*di
;
169 struct buffer_head
*bh
;
170 struct super_block
*s
= inode
->i_sb
;
171 struct bfs_sb_info
*info
= BFS_SB(s
);
172 struct bfs_inode_info
*bi
= BFS_I(inode
);
174 dprintf("ino=%08lx\n", ino
);
176 truncate_inode_pages(&inode
->i_data
, 0);
177 invalidate_inode_buffers(inode
);
178 end_writeback(inode
);
183 di
= find_inode(s
, inode
->i_ino
, &bh
);
187 mutex_lock(&info
->bfs_lock
);
188 /* clear on-disk inode */
189 memset(di
, 0, sizeof(struct bfs_inode
));
190 mark_buffer_dirty(bh
);
195 info
->si_freeb
+= bi
->i_eblock
+ 1 - bi
->i_sblock
;
197 clear_bit(ino
, info
->si_imap
);
198 dump_imap("delete_inode", s
);
202 * If this was the last file, make the previous block
203 * "last block of the last file" even if there is no
204 * real file there, saves us 1 gap.
206 if (info
->si_lf_eblk
== bi
->i_eblock
)
207 info
->si_lf_eblk
= bi
->i_sblock
- 1;
208 mutex_unlock(&info
->bfs_lock
);
211 static void bfs_put_super(struct super_block
*s
)
213 struct bfs_sb_info
*info
= BFS_SB(s
);
220 mutex_destroy(&info
->bfs_lock
);
221 kfree(info
->si_imap
);
228 static int bfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
230 struct super_block
*s
= dentry
->d_sb
;
231 struct bfs_sb_info
*info
= BFS_SB(s
);
232 u64 id
= huge_encode_dev(s
->s_bdev
->bd_dev
);
233 buf
->f_type
= BFS_MAGIC
;
234 buf
->f_bsize
= s
->s_blocksize
;
235 buf
->f_blocks
= info
->si_blocks
;
236 buf
->f_bfree
= buf
->f_bavail
= info
->si_freeb
;
237 buf
->f_files
= info
->si_lasti
+ 1 - BFS_ROOT_INO
;
238 buf
->f_ffree
= info
->si_freei
;
239 buf
->f_fsid
.val
[0] = (u32
)id
;
240 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
241 buf
->f_namelen
= BFS_NAMELEN
;
245 static struct kmem_cache
*bfs_inode_cachep
;
247 static struct inode
*bfs_alloc_inode(struct super_block
*sb
)
249 struct bfs_inode_info
*bi
;
250 bi
= kmem_cache_alloc(bfs_inode_cachep
, GFP_KERNEL
);
253 return &bi
->vfs_inode
;
256 static void bfs_destroy_inode(struct inode
*inode
)
258 kmem_cache_free(bfs_inode_cachep
, BFS_I(inode
));
261 static void init_once(void *foo
)
263 struct bfs_inode_info
*bi
= foo
;
265 inode_init_once(&bi
->vfs_inode
);
268 static int init_inodecache(void)
270 bfs_inode_cachep
= kmem_cache_create("bfs_inode_cache",
271 sizeof(struct bfs_inode_info
),
272 0, (SLAB_RECLAIM_ACCOUNT
|
275 if (bfs_inode_cachep
== NULL
)
280 static void destroy_inodecache(void)
282 kmem_cache_destroy(bfs_inode_cachep
);
285 static const struct super_operations bfs_sops
= {
286 .alloc_inode
= bfs_alloc_inode
,
287 .destroy_inode
= bfs_destroy_inode
,
288 .write_inode
= bfs_write_inode
,
289 .evict_inode
= bfs_evict_inode
,
290 .put_super
= bfs_put_super
,
291 .statfs
= bfs_statfs
,
294 void dump_imap(const char *prefix
, struct super_block
*s
)
298 char *tmpbuf
= (char *)get_zeroed_page(GFP_KERNEL
);
302 for (i
= BFS_SB(s
)->si_lasti
; i
>= 0; i
--) {
303 if (i
> PAGE_SIZE
- 100) break;
304 if (test_bit(i
, BFS_SB(s
)->si_imap
))
309 printf("BFS-fs: %s: lasti=%08lx <%s>\n",
310 prefix
, BFS_SB(s
)->si_lasti
, tmpbuf
);
311 free_page((unsigned long)tmpbuf
);
315 static int bfs_fill_super(struct super_block
*s
, void *data
, int silent
)
317 struct buffer_head
*bh
, *sbh
;
318 struct bfs_super_block
*bfs_sb
;
320 unsigned i
, imap_len
;
321 struct bfs_sb_info
*info
;
323 unsigned long i_sblock
, i_eblock
, i_eoff
, s_size
;
325 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
328 mutex_init(&info
->bfs_lock
);
331 sb_set_blocksize(s
, BFS_BSIZE
);
333 sbh
= sb_bread(s
, 0);
336 bfs_sb
= (struct bfs_super_block
*)sbh
->b_data
;
337 if (le32_to_cpu(bfs_sb
->s_magic
) != BFS_MAGIC
) {
339 printf("No BFS filesystem on %s (magic=%08x)\n",
340 s
->s_id
, le32_to_cpu(bfs_sb
->s_magic
));
343 if (BFS_UNCLEAN(bfs_sb
, s
) && !silent
)
344 printf("%s is unclean, continuing\n", s
->s_id
);
346 s
->s_magic
= BFS_MAGIC
;
348 if (le32_to_cpu(bfs_sb
->s_start
) > le32_to_cpu(bfs_sb
->s_end
)) {
349 printf("Superblock is corrupted\n");
353 info
->si_lasti
= (le32_to_cpu(bfs_sb
->s_start
) - BFS_BSIZE
) /
354 sizeof(struct bfs_inode
)
356 imap_len
= (info
->si_lasti
/ 8) + 1;
357 info
->si_imap
= kzalloc(imap_len
, GFP_KERNEL
);
360 for (i
= 0; i
< BFS_ROOT_INO
; i
++)
361 set_bit(i
, info
->si_imap
);
364 inode
= bfs_iget(s
, BFS_ROOT_INO
);
366 ret
= PTR_ERR(inode
);
369 s
->s_root
= d_alloc_root(inode
);
376 info
->si_blocks
= (le32_to_cpu(bfs_sb
->s_end
) + 1) >> BFS_BSIZE_BITS
;
377 info
->si_freeb
= (le32_to_cpu(bfs_sb
->s_end
) + 1
378 - le32_to_cpu(bfs_sb
->s_start
)) >> BFS_BSIZE_BITS
;
380 info
->si_lf_eblk
= 0;
382 /* can we read the last block? */
383 bh
= sb_bread(s
, info
->si_blocks
- 1);
385 printf("Last block not available: %lu\n", info
->si_blocks
- 1);
392 for (i
= BFS_ROOT_INO
; i
<= info
->si_lasti
; i
++) {
393 struct bfs_inode
*di
;
394 int block
= (i
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
395 int off
= (i
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
396 unsigned long eblock
;
400 bh
= sb_bread(s
, block
);
406 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
408 /* test if filesystem is not corrupted */
410 i_eoff
= le32_to_cpu(di
->i_eoffset
);
411 i_sblock
= le32_to_cpu(di
->i_sblock
);
412 i_eblock
= le32_to_cpu(di
->i_eblock
);
413 s_size
= le32_to_cpu(bfs_sb
->s_end
);
415 if (i_sblock
> info
->si_blocks
||
416 i_eblock
> info
->si_blocks
||
417 i_sblock
> i_eblock
||
419 i_sblock
* BFS_BSIZE
> i_eoff
) {
421 printf("Inode 0x%08x corrupted\n", i
);
432 set_bit(i
, info
->si_imap
);
433 info
->si_freeb
-= BFS_FILEBLOCKS(di
);
435 eblock
= le32_to_cpu(di
->i_eblock
);
436 if (eblock
> info
->si_lf_eblk
)
437 info
->si_lf_eblk
= eblock
;
441 dump_imap("read_super", s
);
448 kfree(info
->si_imap
);
452 mutex_destroy(&info
->bfs_lock
);
458 static int bfs_get_sb(struct file_system_type
*fs_type
,
459 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
461 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, bfs_fill_super
, mnt
);
464 static struct file_system_type bfs_fs_type
= {
465 .owner
= THIS_MODULE
,
467 .get_sb
= bfs_get_sb
,
468 .kill_sb
= kill_block_super
,
469 .fs_flags
= FS_REQUIRES_DEV
,
472 static int __init
init_bfs_fs(void)
474 int err
= init_inodecache();
477 err
= register_filesystem(&bfs_fs_type
);
482 destroy_inodecache();
487 static void __exit
exit_bfs_fs(void)
489 unregister_filesystem(&bfs_fs_type
);
490 destroy_inodecache();
493 module_init(init_bfs_fs
)
494 module_exit(exit_bfs_fs
)