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"
27 MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
28 MODULE_AUTHOR("Will Dyson");
29 MODULE_LICENSE("GPL");
31 /* The units the vfs expects inode->i_blocks to be in */
32 #define VFS_BLOCK_SIZE 512
34 static int befs_readdir(struct file
*, void *, filldir_t
);
35 static int befs_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
36 static int befs_readpage(struct file
*file
, struct page
*page
);
37 static sector_t
befs_bmap(struct address_space
*mapping
, sector_t block
);
38 static struct dentry
*befs_lookup(struct inode
*, struct dentry
*, struct nameidata
*);
39 static void befs_read_inode(struct inode
*ino
);
40 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
41 static void befs_destroy_inode(struct inode
*inode
);
42 static int befs_init_inodecache(void);
43 static void befs_destroy_inodecache(void);
44 static void *befs_follow_link(struct dentry
*, struct nameidata
*);
45 static void befs_put_link(struct dentry
*, struct nameidata
*, void *);
46 static int befs_utf2nls(struct super_block
*sb
, const char *in
, int in_len
,
47 char **out
, int *out_len
);
48 static int befs_nls2utf(struct super_block
*sb
, const char *in
, int in_len
,
49 char **out
, int *out_len
);
50 static void befs_put_super(struct super_block
*);
51 static int befs_remount(struct super_block
*, int *, char *);
52 static int befs_statfs(struct dentry
*, struct kstatfs
*);
53 static int parse_options(char *, befs_mount_options
*);
55 static const struct super_operations befs_sops
= {
56 .read_inode
= befs_read_inode
, /* initialize & read inode */
57 .alloc_inode
= befs_alloc_inode
, /* allocate a new inode */
58 .destroy_inode
= befs_destroy_inode
, /* deallocate an inode */
59 .put_super
= befs_put_super
, /* uninit super */
60 .statfs
= befs_statfs
, /* statfs */
61 .remount_fs
= befs_remount
,
64 /* slab cache for befs_inode_info objects */
65 static kmem_cache_t
*befs_inode_cachep
;
67 static const struct file_operations befs_dir_operations
= {
68 .read
= generic_read_dir
,
69 .readdir
= befs_readdir
,
72 static 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 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
= iget(dir
->i_sb
, (ino_t
) offset
);
204 return ERR_PTR(-EACCES
);
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_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_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
, kmem_cache_t
* cachep
, unsigned long flags
)
295 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
297 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
298 SLAB_CTOR_CONSTRUCTOR
) {
299 inode_init_once(&bi
->vfs_inode
);
304 befs_read_inode(struct inode
*inode
)
306 struct buffer_head
*bh
= NULL
;
307 befs_inode
*raw_inode
= NULL
;
309 struct super_block
*sb
= inode
->i_sb
;
310 befs_sb_info
*befs_sb
= BEFS_SB(sb
);
311 befs_inode_info
*befs_ino
= NULL
;
313 befs_debug(sb
, "---> befs_read_inode() " "inode = %lu", inode
->i_ino
);
315 befs_ino
= BEFS_I(inode
);
317 /* convert from vfs's inode number to befs's inode number */
318 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
320 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
321 befs_ino
->i_inode_num
.allocation_group
,
322 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
324 bh
= befs_bread(sb
, inode
->i_ino
);
326 befs_error(sb
, "unable to read inode block - "
327 "inode = %lu", inode
->i_ino
);
331 raw_inode
= (befs_inode
*) bh
->b_data
;
333 befs_dump_inode(sb
, raw_inode
);
335 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
336 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
340 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
343 * set uid and gid. But since current BeOS is single user OS, so
344 * you can change by "uid" or "gid" options.
347 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
348 befs_sb
->mount_opts
.uid
: (uid_t
) fs32_to_cpu(sb
, raw_inode
->uid
);
349 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
350 befs_sb
->mount_opts
.gid
: (gid_t
) fs32_to_cpu(sb
, raw_inode
->gid
);
355 * BEFS's time is 64 bits, but current VFS is 32 bits...
356 * BEFS don't have access time. Nor inode change time. VFS
357 * doesn't have creation time.
358 * Also, the lower 16 bits of the last_modified_time and
359 * create_time are just a counter to help ensure uniqueness
360 * for indexing purposes. (PFD, page 54)
363 inode
->i_mtime
.tv_sec
=
364 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16;
365 inode
->i_mtime
.tv_nsec
= 0; /* lower 16 bits are not a time */
366 inode
->i_ctime
= inode
->i_mtime
;
367 inode
->i_atime
= inode
->i_mtime
;
369 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
370 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
371 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
372 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
374 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
376 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
377 strncpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
382 befs_ino
->i_data
.ds
=
383 fsds_to_cpu(sb
, raw_inode
->data
.datastream
);
385 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
387 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
388 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
391 inode
->i_mapping
->a_ops
= &befs_aops
;
393 if (S_ISREG(inode
->i_mode
)) {
394 inode
->i_fop
= &generic_ro_fops
;
395 } else if (S_ISDIR(inode
->i_mode
)) {
396 inode
->i_op
= &befs_dir_inode_operations
;
397 inode
->i_fop
= &befs_dir_operations
;
398 } else if (S_ISLNK(inode
->i_mode
)) {
399 inode
->i_op
= &befs_symlink_inode_operations
;
401 befs_error(sb
, "Inode %lu is not a regular file, "
402 "directory or symlink. THAT IS WRONG! BeFS has no "
403 "on disk special files", inode
->i_ino
);
408 befs_debug(sb
, "<--- befs_read_inode()");
415 make_bad_inode(inode
);
416 befs_debug(sb
, "<--- befs_read_inode() - Bad inode");
420 /* Initialize the inode cache. Called at fs setup.
422 * Taken from NFS implementation by Al Viro.
425 befs_init_inodecache(void)
427 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
428 sizeof (struct befs_inode_info
),
429 0, (SLAB_RECLAIM_ACCOUNT
|
432 if (befs_inode_cachep
== NULL
) {
433 printk(KERN_ERR
"befs_init_inodecache: "
434 "Couldn't initalize inode slabcache\n");
441 /* Called at fs teardown.
443 * Taken from NFS implementation by Al Viro.
446 befs_destroy_inodecache(void)
448 kmem_cache_destroy(befs_inode_cachep
);
452 * The inode of symbolic link is different to data stream.
453 * The data stream become link name. Unless the LONG_SYMLINK
457 befs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
459 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
462 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
463 struct super_block
*sb
= dentry
->d_sb
;
464 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
465 befs_off_t len
= data
->size
;
467 befs_debug(sb
, "Follow long symlink");
469 link
= kmalloc(len
, GFP_NOFS
);
471 link
= ERR_PTR(-ENOMEM
);
472 } else if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
474 befs_error(sb
, "Failed to read entire long symlink");
475 link
= ERR_PTR(-EIO
);
478 link
= befs_ino
->i_data
.symlink
;
481 nd_set_link(nd
, link
);
485 static void befs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
487 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
488 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
489 char *p
= nd_get_link(nd
);
496 * UTF-8 to NLS charset convert routine
499 * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than
500 * the nls tables directly
504 befs_utf2nls(struct super_block
*sb
, const char *in
,
505 int in_len
, char **out
, int *out_len
)
507 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
512 /* The utf8->nls conversion won't make the final nls string bigger
513 * than the utf one, but if the string is pure ascii they'll have the
514 * same width and an extra char is needed to save the additional \0
516 int maxlen
= in_len
+ 1;
518 befs_debug(sb
, "---> utf2nls()");
521 befs_error(sb
, "befs_utf2nls called with no NLS table loaded");
525 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
527 befs_error(sb
, "befs_utf2nls() cannot allocate memory");
532 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
534 /* convert from UTF-8 to Unicode */
535 utflen
= utf8_mbtowc(&uni
, &in
[i
], in_len
- i
);
540 /* convert from Unicode to nls */
541 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
549 befs_debug(sb
, "<--- utf2nls()");
554 befs_error(sb
, "Name using character set %s contains a character that "
555 "cannot be converted to unicode.", nls
->charset
);
556 befs_debug(sb
, "<--- utf2nls()");
562 * befs_nls2utf - Convert NLS string to utf8 encodeing
564 * @src: Input string buffer in NLS format
565 * @srclen: Length of input string in bytes
566 * @dest: The output string in UTF-8 format
567 * @destlen: Length of the output buffer
569 * Converts input string @src, which is in the format of the loaded NLS map,
570 * into a utf8 string.
572 * The destination string @dest is allocated by this function and the caller is
573 * responsible for freeing it with kfree()
575 * On return, *@destlen is the length of @dest in bytes.
577 * On success, the return value is the number of utf8 characters written to
578 * the output buffer @dest.
580 * On Failure, a negative number coresponding to the error code is returned.
584 befs_nls2utf(struct super_block
*sb
, const char *in
,
585 int in_len
, char **out
, int *out_len
)
587 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
592 /* There're nls characters that will translate to 3-chars-wide UTF-8
593 * characters, a additional byte is needed to save the final \0
594 * in special cases */
595 int maxlen
= (3 * in_len
) + 1;
597 befs_debug(sb
, "---> nls2utf()\n");
600 befs_error(sb
, "befs_nls2utf called with no NLS table loaded.");
604 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
606 befs_error(sb
, "befs_nls2utf() cannot allocate memory");
611 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
613 /* convert from nls to unicode */
614 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
619 /* convert from unicode to UTF-8 */
620 utflen
= utf8_wctomb(&result
[o
], uni
, 3);
629 befs_debug(sb
, "<--- nls2utf()");
634 befs_error(sb
, "Name using charecter set %s contains a charecter that "
635 "cannot be converted to unicode.", nls
->charset
);
636 befs_debug(sb
, "<--- nls2utf()");
646 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
649 static match_table_t befs_tokens
= {
652 {Opt_charset
, "iocharset=%s"},
653 {Opt_debug
, "debug"},
658 parse_options(char *options
, befs_mount_options
* opts
)
661 substring_t args
[MAX_OPT_ARGS
];
664 /* Initialize options */
669 opts
->iocharset
= NULL
;
675 while ((p
= strsep(&options
, ",")) != NULL
) {
680 token
= match_token(p
, befs_tokens
, args
);
683 if (match_int(&args
[0], &option
))
686 printk(KERN_ERR
"BeFS: Invalid uid %d, "
687 "using default\n", option
);
694 if (match_int(&args
[0], &option
))
697 printk(KERN_ERR
"BeFS: Invalid gid %d, "
698 "using default\n", option
);
705 kfree(opts
->iocharset
);
706 opts
->iocharset
= match_strdup(&args
[0]);
707 if (!opts
->iocharset
) {
708 printk(KERN_ERR
"BeFS: allocation failure for "
709 "iocharset string\n");
717 printk(KERN_ERR
"BeFS: Unrecognized mount option \"%s\" "
718 "or missing value\n", p
);
725 /* This function has the responsibiltiy of getting the
726 * filesystem ready for unmounting.
727 * Basicly, we free everything that we allocated in
731 befs_put_super(struct super_block
*sb
)
733 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
734 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
736 if (BEFS_SB(sb
)->nls
) {
737 unload_nls(BEFS_SB(sb
)->nls
);
738 BEFS_SB(sb
)->nls
= NULL
;
741 kfree(sb
->s_fs_info
);
742 sb
->s_fs_info
= NULL
;
746 /* Allocate private field of the superblock, fill it.
748 * Finish filling the public superblock fields
749 * Make the root directory
750 * Load a set of NLS translations if needed.
753 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
755 struct buffer_head
*bh
;
756 befs_sb_info
*befs_sb
;
757 befs_super_block
*disk_sb
;
760 const unsigned long sb_block
= 0;
761 const off_t x86_sb_off
= 512;
763 sb
->s_fs_info
= kmalloc(sizeof (*befs_sb
), GFP_KERNEL
);
764 if (sb
->s_fs_info
== NULL
) {
766 "BeFS(%s): Unable to allocate memory for private "
767 "portion of superblock. Bailing.\n", sb
->s_id
);
770 befs_sb
= BEFS_SB(sb
);
771 memset(befs_sb
, 0, sizeof(befs_sb_info
));
773 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
774 befs_error(sb
, "cannot parse mount options");
775 goto unacquire_priv_sbp
;
778 befs_debug(sb
, "---> befs_fill_super()");
780 #ifndef CONFIG_BEFS_RW
781 if (!(sb
->s_flags
& MS_RDONLY
)) {
783 "No write support. Marking filesystem read-only");
784 sb
->s_flags
|= MS_RDONLY
;
786 #endif /* CONFIG_BEFS_RW */
789 * Set dummy blocksize to read super block.
790 * Will be set to real fs blocksize later.
792 * Linux 2.4.10 and later refuse to read blocks smaller than
793 * the hardsect size for the device. But we also need to read at
794 * least 1k to get the second 512 bytes of the volume.
797 sb_min_blocksize(sb
, 1024);
799 if (!(bh
= sb_bread(sb
, sb_block
))) {
800 befs_error(sb
, "unable to read superblock");
801 goto unacquire_priv_sbp
;
804 /* account for offset of super block on x86 */
805 disk_sb
= (befs_super_block
*) bh
->b_data
;
806 if ((le32_to_cpu(disk_sb
->magic1
) == BEFS_SUPER_MAGIC1
) ||
807 (be32_to_cpu(disk_sb
->magic1
) == BEFS_SUPER_MAGIC1
)) {
808 befs_debug(sb
, "Using PPC superblock location");
810 befs_debug(sb
, "Using x86 superblock location");
812 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
815 if (befs_load_sb(sb
, disk_sb
) != BEFS_OK
)
818 befs_dump_super_block(sb
, disk_sb
);
822 if (befs_check_sb(sb
) != BEFS_OK
)
823 goto unacquire_priv_sbp
;
825 if( befs_sb
->num_blocks
> ~((sector_t
)0) ) {
826 befs_error(sb
, "blocks count: %Lu "
827 "is larger than the host can use",
828 befs_sb
->num_blocks
);
829 goto unacquire_priv_sbp
;
833 * set up enough so that it can read an inode
834 * Fill in kernel superblock fields from private sb
836 sb
->s_magic
= BEFS_SUPER_MAGIC
;
837 /* Set real blocksize of fs */
838 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
839 sb
->s_op
= (struct super_operations
*) &befs_sops
;
840 root
= iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
841 sb
->s_root
= d_alloc_root(root
);
844 befs_error(sb
, "get root inode failed");
845 goto unacquire_priv_sbp
;
848 /* load nls library */
849 if (befs_sb
->mount_opts
.iocharset
) {
850 befs_debug(sb
, "Loading nls: %s",
851 befs_sb
->mount_opts
.iocharset
);
852 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
854 befs_warning(sb
, "Cannot load nls %s"
855 " loading default nls",
856 befs_sb
->mount_opts
.iocharset
);
857 befs_sb
->nls
= load_nls_default();
859 /* load default nls if none is specified in mount options */
861 befs_debug(sb
, "Loading default nls");
862 befs_sb
->nls
= load_nls_default();
871 kfree(sb
->s_fs_info
);
874 sb
->s_fs_info
= NULL
;
879 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
881 if (!(*flags
& MS_RDONLY
))
887 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
889 struct super_block
*sb
= dentry
->d_sb
;
891 befs_debug(sb
, "---> befs_statfs()");
893 buf
->f_type
= BEFS_SUPER_MAGIC
;
894 buf
->f_bsize
= sb
->s_blocksize
;
895 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
896 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
897 buf
->f_bavail
= buf
->f_bfree
;
898 buf
->f_files
= 0; /* UNKNOWN */
899 buf
->f_ffree
= 0; /* UNKNOWN */
900 buf
->f_namelen
= BEFS_NAME_LEN
;
902 befs_debug(sb
, "<--- befs_statfs()");
908 befs_get_sb(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
909 void *data
, struct vfsmount
*mnt
)
911 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
,
915 static struct file_system_type befs_fs_type
= {
916 .owner
= THIS_MODULE
,
918 .get_sb
= befs_get_sb
,
919 .kill_sb
= kill_block_super
,
920 .fs_flags
= FS_REQUIRES_DEV
,
928 printk(KERN_INFO
"BeFS version: %s\n", BEFS_VERSION
);
930 err
= befs_init_inodecache();
934 err
= register_filesystem(&befs_fs_type
);
936 goto unacquire_inodecache
;
940 unacquire_inodecache
:
941 befs_destroy_inodecache();
950 befs_destroy_inodecache();
952 unregister_filesystem(&befs_fs_type
);
956 Macros that typecheck the init and exit functions,
957 ensures that they are called at init and cleanup,
958 and eliminates warnings about unused functions.
960 module_init(init_befs_fs
)
961 module_exit(exit_befs_fs
)