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 void befs_read_inode(struct inode
*ino
);
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 .read_inode
= befs_read_inode
, /* initialize & read inode */
56 .alloc_inode
= befs_alloc_inode
, /* allocate a new inode */
57 .destroy_inode
= befs_destroy_inode
, /* deallocate an inode */
58 .put_super
= befs_put_super
, /* uninit super */
59 .statfs
= befs_statfs
, /* statfs */
60 .remount_fs
= befs_remount
,
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
,
71 static const struct inode_operations befs_dir_inode_operations
= {
72 .lookup
= befs_lookup
,
75 static const struct address_space_operations befs_aops
= {
76 .readpage
= befs_readpage
,
77 .sync_page
= block_sync_page
,
81 static const struct inode_operations befs_symlink_inode_operations
= {
82 .readlink
= generic_readlink
,
83 .follow_link
= befs_follow_link
,
84 .put_link
= befs_put_link
,
88 * Called by generic_file_read() to read a page of data
90 * In turn, simply calls a generic block read function and
91 * passes it the address of befs_get_block, for mapping file
92 * positions to disk blocks.
95 befs_readpage(struct file
*file
, struct page
*page
)
97 return block_read_full_page(page
, befs_get_block
);
101 befs_bmap(struct address_space
*mapping
, sector_t block
)
103 return generic_block_bmap(mapping
, block
, befs_get_block
);
107 * Generic function to map a file position (block) to a
108 * disk offset (passed back in bh_result).
110 * Used by many higher level functions.
112 * Calls befs_fblock2brun() in datastream.c to do the real work.
118 befs_get_block(struct inode
*inode
, sector_t block
,
119 struct buffer_head
*bh_result
, int create
)
121 struct super_block
*sb
= inode
->i_sb
;
122 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
123 befs_block_run run
= BAD_IADDR
;
127 befs_debug(sb
, "---> befs_get_block() for inode %lu, block %ld",
128 inode
->i_ino
, block
);
131 befs_error(sb
, "befs_get_block() was asked for a block "
132 "number less than zero: block %ld in inode %lu",
133 block
, inode
->i_ino
);
138 befs_error(sb
, "befs_get_block() was asked to write to "
139 "block %ld in inode %lu", block
, inode
->i_ino
);
143 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
144 if (res
!= BEFS_OK
) {
146 "<--- befs_get_block() for inode %lu, block "
147 "%ld ERROR", inode
->i_ino
, block
);
151 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
153 map_bh(bh_result
, inode
->i_sb
, disk_off
);
155 befs_debug(sb
, "<--- befs_get_block() for inode %lu, block %ld, "
156 "disk address %lu", inode
->i_ino
, block
, disk_off
);
161 static struct dentry
*
162 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
164 struct inode
*inode
= NULL
;
165 struct super_block
*sb
= dir
->i_sb
;
166 befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
171 const char *name
= dentry
->d_name
.name
;
173 befs_debug(sb
, "---> befs_lookup() "
174 "name %s inode %ld", dentry
->d_name
.name
, dir
->i_ino
);
176 /* Convert to UTF-8 */
177 if (BEFS_SB(sb
)->nls
) {
179 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
181 befs_debug(sb
, "<--- befs_lookup() ERROR");
184 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
188 ret
= befs_btree_find(sb
, ds
, dentry
->d_name
.name
, &offset
);
191 if (ret
== BEFS_BT_NOT_FOUND
) {
192 befs_debug(sb
, "<--- befs_lookup() %s not found",
193 dentry
->d_name
.name
);
194 return ERR_PTR(-ENOENT
);
196 } else if (ret
!= BEFS_OK
|| offset
== 0) {
197 befs_warning(sb
, "<--- befs_lookup() Error");
198 return ERR_PTR(-ENODATA
);
201 inode
= iget(dir
->i_sb
, (ino_t
) offset
);
203 return ERR_PTR(-EACCES
);
205 d_add(dentry
, inode
);
207 befs_debug(sb
, "<--- befs_lookup()");
213 befs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
215 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
216 struct super_block
*sb
= inode
->i_sb
;
217 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
221 unsigned char d_type
;
222 char keybuf
[BEFS_NAME_LEN
+ 1];
225 const char *dirname
= filp
->f_path
.dentry
->d_name
.name
;
227 befs_debug(sb
, "---> befs_readdir() "
228 "name %s, inode %ld, filp->f_pos %Ld",
229 dirname
, inode
->i_ino
, filp
->f_pos
);
231 result
= befs_btree_read(sb
, ds
, filp
->f_pos
, BEFS_NAME_LEN
+ 1,
232 keybuf
, &keysize
, &value
);
234 if (result
== BEFS_ERR
) {
235 befs_debug(sb
, "<--- befs_readdir() ERROR");
236 befs_error(sb
, "IO error reading %s (inode %lu)",
237 dirname
, inode
->i_ino
);
240 } else if (result
== BEFS_BT_END
) {
241 befs_debug(sb
, "<--- befs_readdir() END");
244 } else if (result
== BEFS_BT_EMPTY
) {
245 befs_debug(sb
, "<--- befs_readdir() Empty directory");
252 if (BEFS_SB(sb
)->nls
) {
254 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
, &nlsnamelen
);
256 befs_debug(sb
, "<--- befs_readdir() ERROR");
259 result
= filldir(dirent
, nlsname
, nlsnamelen
, filp
->f_pos
,
260 (ino_t
) value
, d_type
);
264 result
= filldir(dirent
, keybuf
, keysize
, filp
->f_pos
,
265 (ino_t
) value
, d_type
);
270 befs_debug(sb
, "<--- befs_readdir() filp->f_pos %Ld", filp
->f_pos
);
275 static struct inode
*
276 befs_alloc_inode(struct super_block
*sb
)
278 struct befs_inode_info
*bi
;
279 bi
= (struct befs_inode_info
*)kmem_cache_alloc(befs_inode_cachep
,
283 return &bi
->vfs_inode
;
287 befs_destroy_inode(struct inode
*inode
)
289 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
292 static void init_once(void * foo
, struct kmem_cache
* cachep
, unsigned long flags
)
294 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
296 if (flags
& SLAB_CTOR_CONSTRUCTOR
) {
297 inode_init_once(&bi
->vfs_inode
);
302 befs_read_inode(struct inode
*inode
)
304 struct buffer_head
*bh
= NULL
;
305 befs_inode
*raw_inode
= NULL
;
307 struct super_block
*sb
= inode
->i_sb
;
308 befs_sb_info
*befs_sb
= BEFS_SB(sb
);
309 befs_inode_info
*befs_ino
= NULL
;
311 befs_debug(sb
, "---> befs_read_inode() " "inode = %lu", inode
->i_ino
);
313 befs_ino
= BEFS_I(inode
);
315 /* convert from vfs's inode number to befs's inode number */
316 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
318 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
319 befs_ino
->i_inode_num
.allocation_group
,
320 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
322 bh
= befs_bread(sb
, inode
->i_ino
);
324 befs_error(sb
, "unable to read inode block - "
325 "inode = %lu", inode
->i_ino
);
329 raw_inode
= (befs_inode
*) bh
->b_data
;
331 befs_dump_inode(sb
, raw_inode
);
333 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
334 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
338 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
341 * set uid and gid. But since current BeOS is single user OS, so
342 * you can change by "uid" or "gid" options.
345 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
346 befs_sb
->mount_opts
.uid
: (uid_t
) fs32_to_cpu(sb
, raw_inode
->uid
);
347 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
348 befs_sb
->mount_opts
.gid
: (gid_t
) fs32_to_cpu(sb
, raw_inode
->gid
);
353 * BEFS's time is 64 bits, but current VFS is 32 bits...
354 * BEFS don't have access time. Nor inode change time. VFS
355 * doesn't have creation time.
356 * Also, the lower 16 bits of the last_modified_time and
357 * create_time are just a counter to help ensure uniqueness
358 * for indexing purposes. (PFD, page 54)
361 inode
->i_mtime
.tv_sec
=
362 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16;
363 inode
->i_mtime
.tv_nsec
= 0; /* lower 16 bits are not a time */
364 inode
->i_ctime
= inode
->i_mtime
;
365 inode
->i_atime
= inode
->i_mtime
;
367 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
368 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
369 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
370 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
372 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
374 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
375 strncpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
380 befs_ino
->i_data
.ds
=
381 fsds_to_cpu(sb
, raw_inode
->data
.datastream
);
383 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
385 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
386 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
389 inode
->i_mapping
->a_ops
= &befs_aops
;
391 if (S_ISREG(inode
->i_mode
)) {
392 inode
->i_fop
= &generic_ro_fops
;
393 } else if (S_ISDIR(inode
->i_mode
)) {
394 inode
->i_op
= &befs_dir_inode_operations
;
395 inode
->i_fop
= &befs_dir_operations
;
396 } else if (S_ISLNK(inode
->i_mode
)) {
397 inode
->i_op
= &befs_symlink_inode_operations
;
399 befs_error(sb
, "Inode %lu is not a regular file, "
400 "directory or symlink. THAT IS WRONG! BeFS has no "
401 "on disk special files", inode
->i_ino
);
406 befs_debug(sb
, "<--- befs_read_inode()");
413 make_bad_inode(inode
);
414 befs_debug(sb
, "<--- befs_read_inode() - Bad inode");
418 /* Initialize the inode cache. Called at fs setup.
420 * Taken from NFS implementation by Al Viro.
423 befs_init_inodecache(void)
425 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
426 sizeof (struct befs_inode_info
),
427 0, (SLAB_RECLAIM_ACCOUNT
|
430 if (befs_inode_cachep
== NULL
) {
431 printk(KERN_ERR
"befs_init_inodecache: "
432 "Couldn't initalize inode slabcache\n");
439 /* Called at fs teardown.
441 * Taken from NFS implementation by Al Viro.
444 befs_destroy_inodecache(void)
446 kmem_cache_destroy(befs_inode_cachep
);
450 * The inode of symbolic link is different to data stream.
451 * The data stream become link name. Unless the LONG_SYMLINK
455 befs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
457 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
460 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
461 struct super_block
*sb
= dentry
->d_sb
;
462 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
463 befs_off_t len
= data
->size
;
465 befs_debug(sb
, "Follow long symlink");
467 link
= kmalloc(len
, GFP_NOFS
);
469 link
= ERR_PTR(-ENOMEM
);
470 } else if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
472 befs_error(sb
, "Failed to read entire long symlink");
473 link
= ERR_PTR(-EIO
);
476 link
= befs_ino
->i_data
.symlink
;
479 nd_set_link(nd
, link
);
483 static void befs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *p
)
485 befs_inode_info
*befs_ino
= BEFS_I(dentry
->d_inode
);
486 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
487 char *p
= nd_get_link(nd
);
494 * UTF-8 to NLS charset convert routine
497 * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than
498 * the nls tables directly
502 befs_utf2nls(struct super_block
*sb
, const char *in
,
503 int in_len
, char **out
, int *out_len
)
505 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
510 /* The utf8->nls conversion won't make the final nls string bigger
511 * than the utf one, but if the string is pure ascii they'll have the
512 * same width and an extra char is needed to save the additional \0
514 int maxlen
= in_len
+ 1;
516 befs_debug(sb
, "---> utf2nls()");
519 befs_error(sb
, "befs_utf2nls called with no NLS table loaded");
523 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
525 befs_error(sb
, "befs_utf2nls() cannot allocate memory");
530 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
532 /* convert from UTF-8 to Unicode */
533 utflen
= utf8_mbtowc(&uni
, &in
[i
], in_len
- i
);
538 /* convert from Unicode to nls */
539 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
547 befs_debug(sb
, "<--- utf2nls()");
552 befs_error(sb
, "Name using character set %s contains a character that "
553 "cannot be converted to unicode.", nls
->charset
);
554 befs_debug(sb
, "<--- utf2nls()");
560 * befs_nls2utf - Convert NLS string to utf8 encodeing
562 * @src: Input string buffer in NLS format
563 * @srclen: Length of input string in bytes
564 * @dest: The output string in UTF-8 format
565 * @destlen: Length of the output buffer
567 * Converts input string @src, which is in the format of the loaded NLS map,
568 * into a utf8 string.
570 * The destination string @dest is allocated by this function and the caller is
571 * responsible for freeing it with kfree()
573 * On return, *@destlen is the length of @dest in bytes.
575 * On success, the return value is the number of utf8 characters written to
576 * the output buffer @dest.
578 * On Failure, a negative number coresponding to the error code is returned.
582 befs_nls2utf(struct super_block
*sb
, const char *in
,
583 int in_len
, char **out
, int *out_len
)
585 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
590 /* There're nls characters that will translate to 3-chars-wide UTF-8
591 * characters, a additional byte is needed to save the final \0
592 * in special cases */
593 int maxlen
= (3 * in_len
) + 1;
595 befs_debug(sb
, "---> nls2utf()\n");
598 befs_error(sb
, "befs_nls2utf called with no NLS table loaded.");
602 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
604 befs_error(sb
, "befs_nls2utf() cannot allocate memory");
609 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
611 /* convert from nls to unicode */
612 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
617 /* convert from unicode to UTF-8 */
618 utflen
= utf8_wctomb(&result
[o
], uni
, 3);
627 befs_debug(sb
, "<--- nls2utf()");
632 befs_error(sb
, "Name using charecter set %s contains a charecter that "
633 "cannot be converted to unicode.", nls
->charset
);
634 befs_debug(sb
, "<--- nls2utf()");
644 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
647 static match_table_t befs_tokens
= {
650 {Opt_charset
, "iocharset=%s"},
651 {Opt_debug
, "debug"},
656 parse_options(char *options
, befs_mount_options
* opts
)
659 substring_t args
[MAX_OPT_ARGS
];
662 /* Initialize options */
667 opts
->iocharset
= NULL
;
673 while ((p
= strsep(&options
, ",")) != NULL
) {
678 token
= match_token(p
, befs_tokens
, args
);
681 if (match_int(&args
[0], &option
))
684 printk(KERN_ERR
"BeFS: Invalid uid %d, "
685 "using default\n", option
);
692 if (match_int(&args
[0], &option
))
695 printk(KERN_ERR
"BeFS: Invalid gid %d, "
696 "using default\n", option
);
703 kfree(opts
->iocharset
);
704 opts
->iocharset
= match_strdup(&args
[0]);
705 if (!opts
->iocharset
) {
706 printk(KERN_ERR
"BeFS: allocation failure for "
707 "iocharset string\n");
715 printk(KERN_ERR
"BeFS: Unrecognized mount option \"%s\" "
716 "or missing value\n", p
);
723 /* This function has the responsibiltiy of getting the
724 * filesystem ready for unmounting.
725 * Basicly, we free everything that we allocated in
729 befs_put_super(struct super_block
*sb
)
731 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
732 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
734 if (BEFS_SB(sb
)->nls
) {
735 unload_nls(BEFS_SB(sb
)->nls
);
736 BEFS_SB(sb
)->nls
= NULL
;
739 kfree(sb
->s_fs_info
);
740 sb
->s_fs_info
= NULL
;
744 /* Allocate private field of the superblock, fill it.
746 * Finish filling the public superblock fields
747 * Make the root directory
748 * Load a set of NLS translations if needed.
751 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
753 struct buffer_head
*bh
;
754 befs_sb_info
*befs_sb
;
755 befs_super_block
*disk_sb
;
758 const unsigned long sb_block
= 0;
759 const off_t x86_sb_off
= 512;
761 sb
->s_fs_info
= kmalloc(sizeof (*befs_sb
), GFP_KERNEL
);
762 if (sb
->s_fs_info
== NULL
) {
764 "BeFS(%s): Unable to allocate memory for private "
765 "portion of superblock. Bailing.\n", sb
->s_id
);
768 befs_sb
= BEFS_SB(sb
);
769 memset(befs_sb
, 0, sizeof(befs_sb_info
));
771 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
772 befs_error(sb
, "cannot parse mount options");
773 goto unacquire_priv_sbp
;
776 befs_debug(sb
, "---> befs_fill_super()");
778 #ifndef CONFIG_BEFS_RW
779 if (!(sb
->s_flags
& MS_RDONLY
)) {
781 "No write support. Marking filesystem read-only");
782 sb
->s_flags
|= MS_RDONLY
;
784 #endif /* CONFIG_BEFS_RW */
787 * Set dummy blocksize to read super block.
788 * Will be set to real fs blocksize later.
790 * Linux 2.4.10 and later refuse to read blocks smaller than
791 * the hardsect size for the device. But we also need to read at
792 * least 1k to get the second 512 bytes of the volume.
795 sb_min_blocksize(sb
, 1024);
797 if (!(bh
= sb_bread(sb
, sb_block
))) {
798 befs_error(sb
, "unable to read superblock");
799 goto unacquire_priv_sbp
;
802 /* account for offset of super block on x86 */
803 disk_sb
= (befs_super_block
*) bh
->b_data
;
804 if ((le32_to_cpu(disk_sb
->magic1
) == BEFS_SUPER_MAGIC1
) ||
805 (be32_to_cpu(disk_sb
->magic1
) == BEFS_SUPER_MAGIC1
)) {
806 befs_debug(sb
, "Using PPC superblock location");
808 befs_debug(sb
, "Using x86 superblock location");
810 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
813 if (befs_load_sb(sb
, disk_sb
) != BEFS_OK
)
816 befs_dump_super_block(sb
, disk_sb
);
820 if (befs_check_sb(sb
) != BEFS_OK
)
821 goto unacquire_priv_sbp
;
823 if( befs_sb
->num_blocks
> ~((sector_t
)0) ) {
824 befs_error(sb
, "blocks count: %Lu "
825 "is larger than the host can use",
826 befs_sb
->num_blocks
);
827 goto unacquire_priv_sbp
;
831 * set up enough so that it can read an inode
832 * Fill in kernel superblock fields from private sb
834 sb
->s_magic
= BEFS_SUPER_MAGIC
;
835 /* Set real blocksize of fs */
836 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
837 sb
->s_op
= (struct super_operations
*) &befs_sops
;
838 root
= iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
839 sb
->s_root
= d_alloc_root(root
);
842 befs_error(sb
, "get root inode failed");
843 goto unacquire_priv_sbp
;
846 /* load nls library */
847 if (befs_sb
->mount_opts
.iocharset
) {
848 befs_debug(sb
, "Loading nls: %s",
849 befs_sb
->mount_opts
.iocharset
);
850 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
852 befs_warning(sb
, "Cannot load nls %s"
853 " loading default nls",
854 befs_sb
->mount_opts
.iocharset
);
855 befs_sb
->nls
= load_nls_default();
857 /* load default nls if none is specified in mount options */
859 befs_debug(sb
, "Loading default nls");
860 befs_sb
->nls
= load_nls_default();
869 kfree(sb
->s_fs_info
);
872 sb
->s_fs_info
= NULL
;
877 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
879 if (!(*flags
& MS_RDONLY
))
885 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
887 struct super_block
*sb
= dentry
->d_sb
;
889 befs_debug(sb
, "---> befs_statfs()");
891 buf
->f_type
= BEFS_SUPER_MAGIC
;
892 buf
->f_bsize
= sb
->s_blocksize
;
893 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
894 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
895 buf
->f_bavail
= buf
->f_bfree
;
896 buf
->f_files
= 0; /* UNKNOWN */
897 buf
->f_ffree
= 0; /* UNKNOWN */
898 buf
->f_namelen
= BEFS_NAME_LEN
;
900 befs_debug(sb
, "<--- befs_statfs()");
906 befs_get_sb(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
907 void *data
, struct vfsmount
*mnt
)
909 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
,
913 static struct file_system_type befs_fs_type
= {
914 .owner
= THIS_MODULE
,
916 .get_sb
= befs_get_sb
,
917 .kill_sb
= kill_block_super
,
918 .fs_flags
= FS_REQUIRES_DEV
,
926 printk(KERN_INFO
"BeFS version: %s\n", BEFS_VERSION
);
928 err
= befs_init_inodecache();
932 err
= register_filesystem(&befs_fs_type
);
934 goto unacquire_inodecache
;
938 unacquire_inodecache
:
939 befs_destroy_inodecache();
948 befs_destroy_inodecache();
950 unregister_filesystem(&befs_fs_type
);
954 Macros that typecheck the init and exit functions,
955 ensures that they are called at init and cleanup,
956 and eliminates warnings about unused functions.
958 module_init(init_befs_fs
)
959 module_exit(exit_befs_fs
)