2 * linux/fs/befs/linuxvfs.c
4 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com
8 #include <linux/module.h>
9 #include <linux/slab.h>
11 #include <linux/errno.h>
12 #include <linux/stat.h>
13 #include <linux/nls.h>
14 #include <linux/buffer_head.h>
15 #include <linux/vfs.h>
16 #include <linux/parser.h>
17 #include <linux/namei.h>
22 #include "datastream.h"
26 MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
27 MODULE_AUTHOR("Will Dyson");
28 MODULE_LICENSE("GPL");
30 /* The units the vfs expects inode->i_blocks to be in */
31 #define VFS_BLOCK_SIZE 512
33 static int befs_readdir(struct file
*, void *, filldir_t
);
34 static int befs_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
35 static int befs_readpage(struct file
*file
, struct page
*page
);
36 static sector_t
befs_bmap(struct address_space
*mapping
, sector_t block
);
37 static struct dentry
*befs_lookup(struct inode
*, struct dentry
*, struct nameidata
*);
38 static struct inode
*befs_iget(struct super_block
*, unsigned long);
39 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
40 static void befs_destroy_inode(struct inode
*inode
);
41 static int befs_init_inodecache(void);
42 static void befs_destroy_inodecache(void);
43 static void *befs_follow_link(struct dentry
*, struct nameidata
*);
44 static void befs_put_link(struct dentry
*, struct nameidata
*, void *);
45 static int befs_utf2nls(struct super_block
*sb
, const char *in
, int in_len
,
46 char **out
, int *out_len
);
47 static int befs_nls2utf(struct super_block
*sb
, const char *in
, int in_len
,
48 char **out
, int *out_len
);
49 static void befs_put_super(struct super_block
*);
50 static int befs_remount(struct super_block
*, int *, char *);
51 static int befs_statfs(struct dentry
*, struct kstatfs
*);
52 static int parse_options(char *, befs_mount_options
*);
54 static const struct super_operations befs_sops
= {
55 .alloc_inode
= befs_alloc_inode
, /* allocate a new inode */
56 .destroy_inode
= befs_destroy_inode
, /* deallocate an inode */
57 .put_super
= befs_put_super
, /* uninit super */
58 .statfs
= befs_statfs
, /* statfs */
59 .remount_fs
= befs_remount
,
60 .show_options
= generic_show_options
,
63 /* slab cache for befs_inode_info objects */
64 static struct kmem_cache
*befs_inode_cachep
;
66 static const struct file_operations befs_dir_operations
= {
67 .read
= generic_read_dir
,
68 .readdir
= befs_readdir
,
69 .llseek
= generic_file_llseek
,
72 static const struct inode_operations befs_dir_inode_operations
= {
73 .lookup
= befs_lookup
,
76 static const struct address_space_operations befs_aops
= {
77 .readpage
= befs_readpage
,
78 .sync_page
= block_sync_page
,
82 static const struct inode_operations befs_symlink_inode_operations
= {
83 .readlink
= generic_readlink
,
84 .follow_link
= befs_follow_link
,
85 .put_link
= befs_put_link
,
89 * Called by generic_file_read() to read a page of data
91 * In turn, simply calls a generic block read function and
92 * passes it the address of befs_get_block, for mapping file
93 * positions to disk blocks.
96 befs_readpage(struct file
*file
, struct page
*page
)
98 return block_read_full_page(page
, befs_get_block
);
102 befs_bmap(struct address_space
*mapping
, sector_t block
)
104 return generic_block_bmap(mapping
, block
, befs_get_block
);
108 * Generic function to map a file position (block) to a
109 * disk offset (passed back in bh_result).
111 * Used by many higher level functions.
113 * Calls befs_fblock2brun() in datastream.c to do the real work.
119 befs_get_block(struct inode
*inode
, sector_t block
,
120 struct buffer_head
*bh_result
, int create
)
122 struct super_block
*sb
= inode
->i_sb
;
123 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
124 befs_block_run run
= BAD_IADDR
;
128 befs_debug(sb
, "---> befs_get_block() for inode %lu, block %ld",
129 inode
->i_ino
, block
);
132 befs_error(sb
, "befs_get_block() was asked for a block "
133 "number less than zero: block %ld in inode %lu",
134 block
, inode
->i_ino
);
139 befs_error(sb
, "befs_get_block() was asked to write to "
140 "block %ld in inode %lu", block
, inode
->i_ino
);
144 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
145 if (res
!= BEFS_OK
) {
147 "<--- befs_get_block() for inode %lu, block "
148 "%ld ERROR", inode
->i_ino
, block
);
152 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
154 map_bh(bh_result
, inode
->i_sb
, disk_off
);
156 befs_debug(sb
, "<--- befs_get_block() for inode %lu, block %ld, "
157 "disk address %lu", inode
->i_ino
, block
, disk_off
);
162 static struct dentry
*
163 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
165 struct inode
*inode
= NULL
;
166 struct super_block
*sb
= dir
->i_sb
;
167 befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
172 const char *name
= dentry
->d_name
.name
;
174 befs_debug(sb
, "---> befs_lookup() "
175 "name %s inode %ld", dentry
->d_name
.name
, dir
->i_ino
);
177 /* Convert to UTF-8 */
178 if (BEFS_SB(sb
)->nls
) {
180 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
182 befs_debug(sb
, "<--- befs_lookup() ERROR");
185 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
189 ret
= befs_btree_find(sb
, ds
, dentry
->d_name
.name
, &offset
);
192 if (ret
== BEFS_BT_NOT_FOUND
) {
193 befs_debug(sb
, "<--- befs_lookup() %s not found",
194 dentry
->d_name
.name
);
195 return ERR_PTR(-ENOENT
);
197 } else if (ret
!= BEFS_OK
|| offset
== 0) {
198 befs_warning(sb
, "<--- befs_lookup() Error");
199 return ERR_PTR(-ENODATA
);
202 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
204 return ERR_CAST(inode
);
206 d_add(dentry
, inode
);
208 befs_debug(sb
, "<--- befs_lookup()");
214 befs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
216 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
217 struct super_block
*sb
= inode
->i_sb
;
218 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
222 unsigned char d_type
;
223 char keybuf
[BEFS_NAME_LEN
+ 1];
226 const char *dirname
= filp
->f_path
.dentry
->d_name
.name
;
228 befs_debug(sb
, "---> befs_readdir() "
229 "name %s, inode %ld, filp->f_pos %Ld",
230 dirname
, inode
->i_ino
, filp
->f_pos
);
232 result
= befs_btree_read(sb
, ds
, filp
->f_pos
, BEFS_NAME_LEN
+ 1,
233 keybuf
, &keysize
, &value
);
235 if (result
== BEFS_ERR
) {
236 befs_debug(sb
, "<--- befs_readdir() ERROR");
237 befs_error(sb
, "IO error reading %s (inode %lu)",
238 dirname
, inode
->i_ino
);
241 } else if (result
== BEFS_BT_END
) {
242 befs_debug(sb
, "<--- befs_readdir() END");
245 } else if (result
== BEFS_BT_EMPTY
) {
246 befs_debug(sb
, "<--- befs_readdir() Empty directory");
253 if (BEFS_SB(sb
)->nls
) {
255 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
, &nlsnamelen
);
257 befs_debug(sb
, "<--- befs_readdir() ERROR");
260 result
= filldir(dirent
, nlsname
, nlsnamelen
, filp
->f_pos
,
261 (ino_t
) value
, d_type
);
265 result
= filldir(dirent
, keybuf
, keysize
, filp
->f_pos
,
266 (ino_t
) value
, d_type
);
271 befs_debug(sb
, "<--- befs_readdir() filp->f_pos %Ld", filp
->f_pos
);
276 static struct inode
*
277 befs_alloc_inode(struct super_block
*sb
)
279 struct befs_inode_info
*bi
;
280 bi
= (struct befs_inode_info
*)kmem_cache_alloc(befs_inode_cachep
,
284 return &bi
->vfs_inode
;
288 befs_destroy_inode(struct inode
*inode
)
290 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
293 static void init_once(void *foo
)
295 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
297 inode_init_once(&bi
->vfs_inode
);
300 static struct inode
*befs_iget(struct super_block
*sb
, unsigned long ino
)
302 struct buffer_head
*bh
= NULL
;
303 befs_inode
*raw_inode
= NULL
;
305 befs_sb_info
*befs_sb
= BEFS_SB(sb
);
306 befs_inode_info
*befs_ino
= NULL
;
310 befs_debug(sb
, "---> befs_read_inode() " "inode = %lu", ino
);
312 inode
= iget_locked(sb
, ino
);
315 if (!(inode
->i_state
& I_NEW
))
318 befs_ino
= BEFS_I(inode
);
320 /* convert from vfs's inode number to befs's inode number */
321 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
323 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
324 befs_ino
->i_inode_num
.allocation_group
,
325 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
327 bh
= befs_bread(sb
, inode
->i_ino
);
329 befs_error(sb
, "unable to read inode block - "
330 "inode = %lu", inode
->i_ino
);
334 raw_inode
= (befs_inode
*) bh
->b_data
;
336 befs_dump_inode(sb
, raw_inode
);
338 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
339 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
343 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
346 * set uid and gid. But since current BeOS is single user OS, so
347 * you can change by "uid" or "gid" options.
350 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
351 befs_sb
->mount_opts
.uid
: (uid_t
) fs32_to_cpu(sb
, raw_inode
->uid
);
352 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
353 befs_sb
->mount_opts
.gid
: (gid_t
) fs32_to_cpu(sb
, raw_inode
->gid
);
358 * BEFS's time is 64 bits, but current VFS is 32 bits...
359 * BEFS don't have access time. Nor inode change time. VFS
360 * doesn't have creation time.
361 * Also, the lower 16 bits of the last_modified_time and
362 * create_time are just a counter to help ensure uniqueness
363 * for indexing purposes. (PFD, page 54)
366 inode
->i_mtime
.tv_sec
=
367 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16;
368 inode
->i_mtime
.tv_nsec
= 0; /* lower 16 bits are not a time */
369 inode
->i_ctime
= inode
->i_mtime
;
370 inode
->i_atime
= inode
->i_mtime
;
372 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
373 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
374 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
375 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
377 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
379 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
380 strncpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
385 befs_ino
->i_data
.ds
=
386 fsds_to_cpu(sb
, raw_inode
->data
.datastream
);
388 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
390 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
391 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
394 inode
->i_mapping
->a_ops
= &befs_aops
;
396 if (S_ISREG(inode
->i_mode
)) {
397 inode
->i_fop
= &generic_ro_fops
;
398 } else if (S_ISDIR(inode
->i_mode
)) {
399 inode
->i_op
= &befs_dir_inode_operations
;
400 inode
->i_fop
= &befs_dir_operations
;
401 } else if (S_ISLNK(inode
->i_mode
)) {
402 inode
->i_op
= &befs_symlink_inode_operations
;
404 befs_error(sb
, "Inode %lu is not a regular file, "
405 "directory or symlink. THAT IS WRONG! BeFS has no "
406 "on disk special files", inode
->i_ino
);
411 befs_debug(sb
, "<--- befs_read_inode()");
412 unlock_new_inode(inode
);
420 befs_debug(sb
, "<--- befs_read_inode() - Bad inode");
424 /* Initialize the inode cache. Called at fs setup.
426 * Taken from NFS implementation by Al Viro.
429 befs_init_inodecache(void)
431 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
432 sizeof (struct befs_inode_info
),
433 0, (SLAB_RECLAIM_ACCOUNT
|
436 if (befs_inode_cachep
== NULL
) {
437 printk(KERN_ERR
"befs_init_inodecache: "
438 "Couldn't initalize inode slabcache\n");
445 /* Called at fs teardown.
447 * Taken from NFS implementation by Al Viro.
450 befs_destroy_inodecache(void)
452 kmem_cache_destroy(befs_inode_cachep
);
456 * The inode of symbolic link is different to data stream.
457 * The data stream become link name. Unless the LONG_SYMLINK
461 befs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
463 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
466 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
467 struct super_block
*sb
= dentry
->d_sb
;
468 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
469 befs_off_t len
= data
->size
;
471 befs_debug(sb
, "Follow long symlink");
473 link
= kmalloc(len
, GFP_NOFS
);
475 link
= ERR_PTR(-ENOMEM
);
476 } else if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
478 befs_error(sb
, "Failed to read entire long symlink");
479 link
= ERR_PTR(-EIO
);
482 link
= befs_ino
->i_data
.symlink
;
485 nd_set_link(nd
, link
);
489 static void befs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
491 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
492 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
493 char *link
= nd_get_link(nd
);
500 * UTF-8 to NLS charset convert routine
503 * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than
504 * the nls tables directly
508 befs_utf2nls(struct super_block
*sb
, const char *in
,
509 int in_len
, char **out
, int *out_len
)
511 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
516 /* The utf8->nls conversion won't make the final nls string bigger
517 * than the utf one, but if the string is pure ascii they'll have the
518 * same width and an extra char is needed to save the additional \0
520 int maxlen
= in_len
+ 1;
522 befs_debug(sb
, "---> utf2nls()");
525 befs_error(sb
, "befs_utf2nls called with no NLS table loaded");
529 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
531 befs_error(sb
, "befs_utf2nls() cannot allocate memory");
536 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
538 /* convert from UTF-8 to Unicode */
539 utflen
= utf8_mbtowc(&uni
, &in
[i
], in_len
- i
);
544 /* convert from Unicode to nls */
545 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
553 befs_debug(sb
, "<--- utf2nls()");
558 befs_error(sb
, "Name using character set %s contains a character that "
559 "cannot be converted to unicode.", nls
->charset
);
560 befs_debug(sb
, "<--- utf2nls()");
566 * befs_nls2utf - Convert NLS string to utf8 encodeing
568 * @src: Input string buffer in NLS format
569 * @srclen: Length of input string in bytes
570 * @dest: The output string in UTF-8 format
571 * @destlen: Length of the output buffer
573 * Converts input string @src, which is in the format of the loaded NLS map,
574 * into a utf8 string.
576 * The destination string @dest is allocated by this function and the caller is
577 * responsible for freeing it with kfree()
579 * On return, *@destlen is the length of @dest in bytes.
581 * On success, the return value is the number of utf8 characters written to
582 * the output buffer @dest.
584 * On Failure, a negative number coresponding to the error code is returned.
588 befs_nls2utf(struct super_block
*sb
, const char *in
,
589 int in_len
, char **out
, int *out_len
)
591 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
596 /* There're nls characters that will translate to 3-chars-wide UTF-8
597 * characters, a additional byte is needed to save the final \0
598 * in special cases */
599 int maxlen
= (3 * in_len
) + 1;
601 befs_debug(sb
, "---> nls2utf()\n");
604 befs_error(sb
, "befs_nls2utf called with no NLS table loaded.");
608 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
610 befs_error(sb
, "befs_nls2utf() cannot allocate memory");
615 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
617 /* convert from nls to unicode */
618 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
623 /* convert from unicode to UTF-8 */
624 utflen
= utf8_wctomb(&result
[o
], uni
, 3);
633 befs_debug(sb
, "<--- nls2utf()");
638 befs_error(sb
, "Name using charecter set %s contains a charecter that "
639 "cannot be converted to unicode.", nls
->charset
);
640 befs_debug(sb
, "<--- nls2utf()");
650 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
653 static const match_table_t befs_tokens
= {
656 {Opt_charset
, "iocharset=%s"},
657 {Opt_debug
, "debug"},
662 parse_options(char *options
, befs_mount_options
* opts
)
665 substring_t args
[MAX_OPT_ARGS
];
668 /* Initialize options */
673 opts
->iocharset
= NULL
;
679 while ((p
= strsep(&options
, ",")) != NULL
) {
684 token
= match_token(p
, befs_tokens
, args
);
687 if (match_int(&args
[0], &option
))
690 printk(KERN_ERR
"BeFS: Invalid uid %d, "
691 "using default\n", option
);
698 if (match_int(&args
[0], &option
))
701 printk(KERN_ERR
"BeFS: Invalid gid %d, "
702 "using default\n", option
);
709 kfree(opts
->iocharset
);
710 opts
->iocharset
= match_strdup(&args
[0]);
711 if (!opts
->iocharset
) {
712 printk(KERN_ERR
"BeFS: allocation failure for "
713 "iocharset string\n");
721 printk(KERN_ERR
"BeFS: Unrecognized mount option \"%s\" "
722 "or missing value\n", p
);
729 /* This function has the responsibiltiy of getting the
730 * filesystem ready for unmounting.
731 * Basicly, we free everything that we allocated in
735 befs_put_super(struct super_block
*sb
)
737 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
738 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
740 if (BEFS_SB(sb
)->nls
) {
741 unload_nls(BEFS_SB(sb
)->nls
);
742 BEFS_SB(sb
)->nls
= NULL
;
745 kfree(sb
->s_fs_info
);
746 sb
->s_fs_info
= NULL
;
750 /* Allocate private field of the superblock, fill it.
752 * Finish filling the public superblock fields
753 * Make the root directory
754 * Load a set of NLS translations if needed.
757 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
759 struct buffer_head
*bh
;
760 befs_sb_info
*befs_sb
;
761 befs_super_block
*disk_sb
;
764 const unsigned long sb_block
= 0;
765 const off_t x86_sb_off
= 512;
767 save_mount_options(sb
, data
);
769 sb
->s_fs_info
= kmalloc(sizeof (*befs_sb
), GFP_KERNEL
);
770 if (sb
->s_fs_info
== NULL
) {
772 "BeFS(%s): Unable to allocate memory for private "
773 "portion of superblock. Bailing.\n", sb
->s_id
);
776 befs_sb
= BEFS_SB(sb
);
777 memset(befs_sb
, 0, sizeof(befs_sb_info
));
779 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
780 befs_error(sb
, "cannot parse mount options");
781 goto unacquire_priv_sbp
;
784 befs_debug(sb
, "---> befs_fill_super()");
786 #ifndef CONFIG_BEFS_RW
787 if (!(sb
->s_flags
& MS_RDONLY
)) {
789 "No write support. Marking filesystem read-only");
790 sb
->s_flags
|= MS_RDONLY
;
792 #endif /* CONFIG_BEFS_RW */
795 * Set dummy blocksize to read super block.
796 * Will be set to real fs blocksize later.
798 * Linux 2.4.10 and later refuse to read blocks smaller than
799 * the hardsect size for the device. But we also need to read at
800 * least 1k to get the second 512 bytes of the volume.
803 sb_min_blocksize(sb
, 1024);
805 if (!(bh
= sb_bread(sb
, sb_block
))) {
806 befs_error(sb
, "unable to read superblock");
807 goto unacquire_priv_sbp
;
810 /* account for offset of super block on x86 */
811 disk_sb
= (befs_super_block
*) bh
->b_data
;
812 if ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
813 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
814 befs_debug(sb
, "Using PPC superblock location");
816 befs_debug(sb
, "Using x86 superblock location");
818 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
821 if (befs_load_sb(sb
, disk_sb
) != BEFS_OK
)
824 befs_dump_super_block(sb
, disk_sb
);
828 if (befs_check_sb(sb
) != BEFS_OK
)
829 goto unacquire_priv_sbp
;
831 if( befs_sb
->num_blocks
> ~((sector_t
)0) ) {
832 befs_error(sb
, "blocks count: %Lu "
833 "is larger than the host can use",
834 befs_sb
->num_blocks
);
835 goto unacquire_priv_sbp
;
839 * set up enough so that it can read an inode
840 * Fill in kernel superblock fields from private sb
842 sb
->s_magic
= BEFS_SUPER_MAGIC
;
843 /* Set real blocksize of fs */
844 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
845 sb
->s_op
= (struct super_operations
*) &befs_sops
;
846 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
849 goto unacquire_priv_sbp
;
851 sb
->s_root
= d_alloc_root(root
);
854 befs_error(sb
, "get root inode failed");
855 goto unacquire_priv_sbp
;
858 /* load nls library */
859 if (befs_sb
->mount_opts
.iocharset
) {
860 befs_debug(sb
, "Loading nls: %s",
861 befs_sb
->mount_opts
.iocharset
);
862 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
864 befs_warning(sb
, "Cannot load nls %s"
865 " loading default nls",
866 befs_sb
->mount_opts
.iocharset
);
867 befs_sb
->nls
= load_nls_default();
869 /* load default nls if none is specified in mount options */
871 befs_debug(sb
, "Loading default nls");
872 befs_sb
->nls
= load_nls_default();
881 kfree(sb
->s_fs_info
);
884 sb
->s_fs_info
= NULL
;
889 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
891 if (!(*flags
& MS_RDONLY
))
897 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
899 struct super_block
*sb
= dentry
->d_sb
;
901 befs_debug(sb
, "---> befs_statfs()");
903 buf
->f_type
= BEFS_SUPER_MAGIC
;
904 buf
->f_bsize
= sb
->s_blocksize
;
905 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
906 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
907 buf
->f_bavail
= buf
->f_bfree
;
908 buf
->f_files
= 0; /* UNKNOWN */
909 buf
->f_ffree
= 0; /* UNKNOWN */
910 buf
->f_namelen
= BEFS_NAME_LEN
;
912 befs_debug(sb
, "<--- befs_statfs()");
918 befs_get_sb(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
919 void *data
, struct vfsmount
*mnt
)
921 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
,
925 static struct file_system_type befs_fs_type
= {
926 .owner
= THIS_MODULE
,
928 .get_sb
= befs_get_sb
,
929 .kill_sb
= kill_block_super
,
930 .fs_flags
= FS_REQUIRES_DEV
,
938 printk(KERN_INFO
"BeFS version: %s\n", BEFS_VERSION
);
940 err
= befs_init_inodecache();
944 err
= register_filesystem(&befs_fs_type
);
946 goto unacquire_inodecache
;
950 unacquire_inodecache
:
951 befs_destroy_inodecache();
960 befs_destroy_inodecache();
962 unregister_filesystem(&befs_fs_type
);
966 Macros that typecheck the init and exit functions,
967 ensures that they are called at init and cleanup,
968 and eliminates warnings about unused functions.
970 module_init(init_befs_fs
)
971 module_exit(exit_befs_fs
)