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 void dump_imap(const char *prefix
, struct super_block
*s
);
35 static void bfs_read_inode(struct inode
*inode
)
37 unsigned long ino
= inode
->i_ino
;
39 struct buffer_head
*bh
;
42 if ((ino
< BFS_ROOT_INO
) || (ino
> BFS_SB(inode
->i_sb
)->si_lasti
)) {
43 printf("Bad inode number %s:%08lx\n", inode
->i_sb
->s_id
, ino
);
44 make_bad_inode(inode
);
48 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
49 bh
= sb_bread(inode
->i_sb
, block
);
51 printf("Unable to read inode %s:%08lx\n", inode
->i_sb
->s_id
,
53 make_bad_inode(inode
);
57 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
58 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
60 inode
->i_mode
= 0x0000FFFF & le32_to_cpu(di
->i_mode
);
61 if (le32_to_cpu(di
->i_vtype
) == BFS_VDIR
) {
62 inode
->i_mode
|= S_IFDIR
;
63 inode
->i_op
= &bfs_dir_inops
;
64 inode
->i_fop
= &bfs_dir_operations
;
65 } else if (le32_to_cpu(di
->i_vtype
) == BFS_VREG
) {
66 inode
->i_mode
|= S_IFREG
;
67 inode
->i_op
= &bfs_file_inops
;
68 inode
->i_fop
= &bfs_file_operations
;
69 inode
->i_mapping
->a_ops
= &bfs_aops
;
72 BFS_I(inode
)->i_sblock
= le32_to_cpu(di
->i_sblock
);
73 BFS_I(inode
)->i_eblock
= le32_to_cpu(di
->i_eblock
);
74 BFS_I(inode
)->i_dsk_ino
= le16_to_cpu(di
->i_ino
);
75 inode
->i_uid
= le32_to_cpu(di
->i_uid
);
76 inode
->i_gid
= le32_to_cpu(di
->i_gid
);
77 inode
->i_nlink
= le32_to_cpu(di
->i_nlink
);
78 inode
->i_size
= BFS_FILESIZE(di
);
79 inode
->i_blocks
= BFS_FILEBLOCKS(di
);
80 inode
->i_atime
.tv_sec
= le32_to_cpu(di
->i_atime
);
81 inode
->i_mtime
.tv_sec
= le32_to_cpu(di
->i_mtime
);
82 inode
->i_ctime
.tv_sec
= le32_to_cpu(di
->i_ctime
);
83 inode
->i_atime
.tv_nsec
= 0;
84 inode
->i_mtime
.tv_nsec
= 0;
85 inode
->i_ctime
.tv_nsec
= 0;
90 static int bfs_write_inode(struct inode
*inode
, int unused
)
92 unsigned int ino
= (u16
)inode
->i_ino
;
93 unsigned long i_sblock
;
95 struct buffer_head
*bh
;
98 dprintf("ino=%08x\n", ino
);
100 if ((ino
< BFS_ROOT_INO
) || (ino
> BFS_SB(inode
->i_sb
)->si_lasti
)) {
101 printf("Bad inode number %s:%08x\n", inode
->i_sb
->s_id
, ino
);
106 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
107 bh
= sb_bread(inode
->i_sb
, block
);
109 printf("Unable to read inode %s:%08x\n",
110 inode
->i_sb
->s_id
, ino
);
115 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
116 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
118 if (ino
== BFS_ROOT_INO
)
119 di
->i_vtype
= cpu_to_le32(BFS_VDIR
);
121 di
->i_vtype
= cpu_to_le32(BFS_VREG
);
123 di
->i_ino
= cpu_to_le16(ino
);
124 di
->i_mode
= cpu_to_le32(inode
->i_mode
);
125 di
->i_uid
= cpu_to_le32(inode
->i_uid
);
126 di
->i_gid
= cpu_to_le32(inode
->i_gid
);
127 di
->i_nlink
= cpu_to_le32(inode
->i_nlink
);
128 di
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
129 di
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
130 di
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
131 i_sblock
= BFS_I(inode
)->i_sblock
;
132 di
->i_sblock
= cpu_to_le32(i_sblock
);
133 di
->i_eblock
= cpu_to_le32(BFS_I(inode
)->i_eblock
);
134 di
->i_eoffset
= cpu_to_le32(i_sblock
* BFS_BSIZE
+ inode
->i_size
- 1);
136 mark_buffer_dirty(bh
);
142 static void bfs_delete_inode(struct inode
*inode
)
144 unsigned long ino
= inode
->i_ino
;
145 struct bfs_inode
*di
;
146 struct buffer_head
*bh
;
148 struct super_block
*s
= inode
->i_sb
;
149 struct bfs_sb_info
*info
= BFS_SB(s
);
150 struct bfs_inode_info
*bi
= BFS_I(inode
);
152 dprintf("ino=%08lx\n", ino
);
154 truncate_inode_pages(&inode
->i_data
, 0);
156 if ((ino
< BFS_ROOT_INO
) || (ino
> info
->si_lasti
)) {
157 printf("invalid ino=%08lx\n", ino
);
162 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME_SEC
;
164 mark_inode_dirty(inode
);
166 block
= (ino
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
167 bh
= sb_bread(s
, block
);
169 printf("Unable to read inode %s:%08lx\n",
170 inode
->i_sb
->s_id
, ino
);
174 off
= (ino
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
175 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
176 memset((void *)di
, 0, sizeof(struct bfs_inode
));
177 mark_buffer_dirty(bh
);
181 info
->si_freeb
+= BFS_FILEBLOCKS(bi
);
183 clear_bit(ino
, info
->si_imap
);
184 dump_imap("delete_inode", s
);
188 * If this was the last file, make the previous block
189 * "last block of the last file" even if there is no
190 * real file there, saves us 1 gap.
192 if (info
->si_lf_eblk
== bi
->i_eblock
) {
193 info
->si_lf_eblk
= bi
->i_sblock
- 1;
194 mark_buffer_dirty(info
->si_sbh
);
200 static void bfs_put_super(struct super_block
*s
)
202 struct bfs_sb_info
*info
= BFS_SB(s
);
203 brelse(info
->si_sbh
);
204 kfree(info
->si_imap
);
209 static int bfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
211 struct super_block
*s
= dentry
->d_sb
;
212 struct bfs_sb_info
*info
= BFS_SB(s
);
213 u64 id
= huge_encode_dev(s
->s_bdev
->bd_dev
);
214 buf
->f_type
= BFS_MAGIC
;
215 buf
->f_bsize
= s
->s_blocksize
;
216 buf
->f_blocks
= info
->si_blocks
;
217 buf
->f_bfree
= buf
->f_bavail
= info
->si_freeb
;
218 buf
->f_files
= info
->si_lasti
+ 1 - BFS_ROOT_INO
;
219 buf
->f_ffree
= info
->si_freei
;
220 buf
->f_fsid
.val
[0] = (u32
)id
;
221 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
222 buf
->f_namelen
= BFS_NAMELEN
;
226 static void bfs_write_super(struct super_block
*s
)
229 if (!(s
->s_flags
& MS_RDONLY
))
230 mark_buffer_dirty(BFS_SB(s
)->si_sbh
);
235 static struct kmem_cache
*bfs_inode_cachep
;
237 static struct inode
*bfs_alloc_inode(struct super_block
*sb
)
239 struct bfs_inode_info
*bi
;
240 bi
= kmem_cache_alloc(bfs_inode_cachep
, GFP_KERNEL
);
243 return &bi
->vfs_inode
;
246 static void bfs_destroy_inode(struct inode
*inode
)
248 kmem_cache_free(bfs_inode_cachep
, BFS_I(inode
));
251 static void init_once(struct kmem_cache
*cachep
, void *foo
)
253 struct bfs_inode_info
*bi
= foo
;
255 inode_init_once(&bi
->vfs_inode
);
258 static int init_inodecache(void)
260 bfs_inode_cachep
= kmem_cache_create("bfs_inode_cache",
261 sizeof(struct bfs_inode_info
),
262 0, (SLAB_RECLAIM_ACCOUNT
|
265 if (bfs_inode_cachep
== NULL
)
270 static void destroy_inodecache(void)
272 kmem_cache_destroy(bfs_inode_cachep
);
275 static const struct super_operations bfs_sops
= {
276 .alloc_inode
= bfs_alloc_inode
,
277 .destroy_inode
= bfs_destroy_inode
,
278 .read_inode
= bfs_read_inode
,
279 .write_inode
= bfs_write_inode
,
280 .delete_inode
= bfs_delete_inode
,
281 .put_super
= bfs_put_super
,
282 .write_super
= bfs_write_super
,
283 .statfs
= bfs_statfs
,
286 void dump_imap(const char *prefix
, struct super_block
*s
)
290 char *tmpbuf
= (char *)get_zeroed_page(GFP_KERNEL
);
294 for (i
= BFS_SB(s
)->si_lasti
; i
>= 0; i
--) {
295 if (i
> PAGE_SIZE
- 100) break;
296 if (test_bit(i
, BFS_SB(s
)->si_imap
))
301 printf("BFS-fs: %s: lasti=%08lx <%s>\n",
302 prefix
, BFS_SB(s
)->si_lasti
, tmpbuf
);
303 free_page((unsigned long)tmpbuf
);
307 static int bfs_fill_super(struct super_block
*s
, void *data
, int silent
)
309 struct buffer_head
*bh
;
310 struct bfs_super_block
*bfs_sb
;
312 unsigned i
, imap_len
;
313 struct bfs_sb_info
*info
;
315 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
320 sb_set_blocksize(s
, BFS_BSIZE
);
325 bfs_sb
= (struct bfs_super_block
*)bh
->b_data
;
326 if (le32_to_cpu(bfs_sb
->s_magic
) != BFS_MAGIC
) {
328 printf("No BFS filesystem on %s (magic=%08x)\n",
329 s
->s_id
, le32_to_cpu(bfs_sb
->s_magic
));
332 if (BFS_UNCLEAN(bfs_sb
, s
) && !silent
)
333 printf("%s is unclean, continuing\n", s
->s_id
);
335 s
->s_magic
= BFS_MAGIC
;
337 info
->si_lasti
= (le32_to_cpu(bfs_sb
->s_start
) - BFS_BSIZE
) /
338 sizeof(struct bfs_inode
)
340 imap_len
= (info
->si_lasti
/ 8) + 1;
341 info
->si_imap
= kzalloc(imap_len
, GFP_KERNEL
);
344 for (i
= 0; i
< BFS_ROOT_INO
; i
++)
345 set_bit(i
, info
->si_imap
);
348 inode
= iget(s
, BFS_ROOT_INO
);
350 kfree(info
->si_imap
);
353 s
->s_root
= d_alloc_root(inode
);
356 kfree(info
->si_imap
);
360 info
->si_blocks
= (le32_to_cpu(bfs_sb
->s_end
) + 1) >> BFS_BSIZE_BITS
;
361 info
->si_freeb
= (le32_to_cpu(bfs_sb
->s_end
) + 1
362 - le32_to_cpu(bfs_sb
->s_start
)) >> BFS_BSIZE_BITS
;
364 info
->si_lf_eblk
= 0;
366 for (i
= BFS_ROOT_INO
; i
<= info
->si_lasti
; i
++) {
367 struct bfs_inode
*di
;
368 int block
= (i
- BFS_ROOT_INO
) / BFS_INODES_PER_BLOCK
+ 1;
369 int off
= (i
- BFS_ROOT_INO
) % BFS_INODES_PER_BLOCK
;
370 unsigned long sblock
, eblock
;
374 bh
= sb_bread(s
, block
);
380 di
= (struct bfs_inode
*)bh
->b_data
+ off
;
386 set_bit(i
, info
->si_imap
);
387 info
->si_freeb
-= BFS_FILEBLOCKS(di
);
389 sblock
= le32_to_cpu(di
->i_sblock
);
390 eblock
= le32_to_cpu(di
->i_eblock
);
391 if (eblock
> info
->si_lf_eblk
)
392 info
->si_lf_eblk
= eblock
;
395 if (!(s
->s_flags
& MS_RDONLY
)) {
396 mark_buffer_dirty(info
->si_sbh
);
399 dump_imap("read_super", s
);
409 static int bfs_get_sb(struct file_system_type
*fs_type
,
410 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
412 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, bfs_fill_super
, mnt
);
415 static struct file_system_type bfs_fs_type
= {
416 .owner
= THIS_MODULE
,
418 .get_sb
= bfs_get_sb
,
419 .kill_sb
= kill_block_super
,
420 .fs_flags
= FS_REQUIRES_DEV
,
423 static int __init
init_bfs_fs(void)
425 int err
= init_inodecache();
428 err
= register_filesystem(&bfs_fs_type
);
433 destroy_inodecache();
438 static void __exit
exit_bfs_fs(void)
440 unregister_filesystem(&bfs_fs_type
);
441 destroy_inodecache();
444 module_init(init_bfs_fs
)
445 module_exit(exit_bfs_fs
)