2 * linux/fs/befs/linuxvfs.c
4 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/module.h>
11 #include <linux/slab.h>
13 #include <linux/errno.h>
14 #include <linux/stat.h>
15 #include <linux/nls.h>
16 #include <linux/buffer_head.h>
17 #include <linux/vfs.h>
18 #include <linux/parser.h>
19 #include <linux/namei.h>
20 #include <linux/sched.h>
25 #include "datastream.h"
29 MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
30 MODULE_AUTHOR("Will Dyson");
31 MODULE_LICENSE("GPL");
33 /* The units the vfs expects inode->i_blocks to be in */
34 #define VFS_BLOCK_SIZE 512
36 static int befs_readdir(struct file
*, struct dir_context
*);
37 static int befs_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
38 static int befs_readpage(struct file
*file
, struct page
*page
);
39 static sector_t
befs_bmap(struct address_space
*mapping
, sector_t block
);
40 static struct dentry
*befs_lookup(struct inode
*, struct dentry
*, unsigned int);
41 static struct inode
*befs_iget(struct super_block
*, unsigned long);
42 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
43 static void befs_destroy_inode(struct inode
*inode
);
44 static void befs_destroy_inodecache(void);
45 static int befs_symlink_readpage(struct file
*, struct page
*);
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 *, struct befs_mount_options
*);
55 static const struct super_operations befs_sops
= {
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
,
61 .show_options
= generic_show_options
,
64 /* slab cache for befs_inode_info objects */
65 static struct kmem_cache
*befs_inode_cachep
;
67 static const struct file_operations befs_dir_operations
= {
68 .read
= generic_read_dir
,
69 .iterate
= befs_readdir
,
70 .llseek
= generic_file_llseek
,
73 static const struct inode_operations befs_dir_inode_operations
= {
74 .lookup
= befs_lookup
,
77 static const struct address_space_operations befs_aops
= {
78 .readpage
= befs_readpage
,
82 static const struct address_space_operations befs_symlink_aops
= {
83 .readpage
= befs_symlink_readpage
,
87 * Called by generic_file_read() to read a page of data
89 * In turn, simply calls a generic block read function and
90 * passes it the address of befs_get_block, for mapping file
91 * positions to disk blocks.
94 befs_readpage(struct file
*file
, struct page
*page
)
96 return block_read_full_page(page
, befs_get_block
);
100 befs_bmap(struct address_space
*mapping
, sector_t block
)
102 return generic_block_bmap(mapping
, block
, befs_get_block
);
106 * Generic function to map a file position (block) to a
107 * disk offset (passed back in bh_result).
109 * Used by many higher level functions.
111 * Calls befs_fblock2brun() in datastream.c to do the real work.
117 befs_get_block(struct inode
*inode
, sector_t block
,
118 struct buffer_head
*bh_result
, int create
)
120 struct super_block
*sb
= inode
->i_sb
;
121 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
122 befs_block_run run
= BAD_IADDR
;
126 befs_debug(sb
, "---> befs_get_block() for inode %lu, block %ld",
127 (unsigned long)inode
->i_ino
, (long)block
);
129 befs_error(sb
, "befs_get_block() was asked to write to "
130 "block %ld in inode %lu", (long)block
,
131 (unsigned long)inode
->i_ino
);
135 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
136 if (res
!= BEFS_OK
) {
138 "<--- %s for inode %lu, block %ld ERROR",
139 __func__
, (unsigned long)inode
->i_ino
,
144 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
146 map_bh(bh_result
, inode
->i_sb
, disk_off
);
148 befs_debug(sb
, "<--- %s for inode %lu, block %ld, disk address %lu",
149 __func__
, (unsigned long)inode
->i_ino
, (long)block
,
150 (unsigned long)disk_off
);
155 static struct dentry
*
156 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
158 struct inode
*inode
= NULL
;
159 struct super_block
*sb
= dir
->i_sb
;
160 befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
165 const char *name
= dentry
->d_name
.name
;
167 befs_debug(sb
, "---> %s name %pd inode %ld", __func__
,
170 /* Convert to UTF-8 */
171 if (BEFS_SB(sb
)->nls
) {
173 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
175 befs_debug(sb
, "<--- %s ERROR", __func__
);
178 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
182 ret
= befs_btree_find(sb
, ds
, dentry
->d_name
.name
, &offset
);
185 if (ret
== BEFS_BT_NOT_FOUND
) {
186 befs_debug(sb
, "<--- %s %pd not found", __func__
, dentry
);
187 return ERR_PTR(-ENOENT
);
189 } else if (ret
!= BEFS_OK
|| offset
== 0) {
190 befs_warning(sb
, "<--- %s Error", __func__
);
191 return ERR_PTR(-ENODATA
);
194 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
196 return ERR_CAST(inode
);
198 d_add(dentry
, inode
);
200 befs_debug(sb
, "<--- %s", __func__
);
206 befs_readdir(struct file
*file
, struct dir_context
*ctx
)
208 struct inode
*inode
= file_inode(file
);
209 struct super_block
*sb
= inode
->i_sb
;
210 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
214 unsigned char d_type
;
215 char keybuf
[BEFS_NAME_LEN
+ 1];
217 befs_debug(sb
, "---> %s name %pD, inode %ld, ctx->pos %lld",
218 __func__
, file
, inode
->i_ino
, ctx
->pos
);
221 result
= befs_btree_read(sb
, ds
, ctx
->pos
, BEFS_NAME_LEN
+ 1,
222 keybuf
, &keysize
, &value
);
224 if (result
== BEFS_ERR
) {
225 befs_debug(sb
, "<--- %s ERROR", __func__
);
226 befs_error(sb
, "IO error reading %pD (inode %lu)",
230 } else if (result
== BEFS_BT_END
) {
231 befs_debug(sb
, "<--- %s END", __func__
);
234 } else if (result
== BEFS_BT_EMPTY
) {
235 befs_debug(sb
, "<--- %s Empty directory", __func__
);
242 if (BEFS_SB(sb
)->nls
) {
246 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
, &nlsnamelen
);
248 befs_debug(sb
, "<--- %s ERROR", __func__
);
251 if (!dir_emit(ctx
, nlsname
, nlsnamelen
,
252 (ino_t
) value
, d_type
)) {
258 if (!dir_emit(ctx
, keybuf
, keysize
,
259 (ino_t
) value
, d_type
))
266 static struct inode
*
267 befs_alloc_inode(struct super_block
*sb
)
269 struct befs_inode_info
*bi
;
271 bi
= kmem_cache_alloc(befs_inode_cachep
, GFP_KERNEL
);
274 return &bi
->vfs_inode
;
277 static void befs_i_callback(struct rcu_head
*head
)
279 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
280 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
283 static void befs_destroy_inode(struct inode
*inode
)
285 call_rcu(&inode
->i_rcu
, befs_i_callback
);
288 static void init_once(void *foo
)
290 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
292 inode_init_once(&bi
->vfs_inode
);
295 static struct inode
*befs_iget(struct super_block
*sb
, unsigned long ino
)
297 struct buffer_head
*bh
= NULL
;
298 befs_inode
*raw_inode
= NULL
;
299 struct befs_sb_info
*befs_sb
= BEFS_SB(sb
);
300 struct befs_inode_info
*befs_ino
= NULL
;
304 befs_debug(sb
, "---> %s inode = %lu", __func__
, ino
);
306 inode
= iget_locked(sb
, ino
);
308 return ERR_PTR(-ENOMEM
);
309 if (!(inode
->i_state
& I_NEW
))
312 befs_ino
= BEFS_I(inode
);
314 /* convert from vfs's inode number to befs's inode number */
315 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
317 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
318 befs_ino
->i_inode_num
.allocation_group
,
319 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
321 bh
= befs_bread(sb
, inode
->i_ino
);
323 befs_error(sb
, "unable to read inode block - "
324 "inode = %lu", inode
->i_ino
);
328 raw_inode
= (befs_inode
*) bh
->b_data
;
330 befs_dump_inode(sb
, raw_inode
);
332 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
333 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
337 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
340 * set uid and gid. But since current BeOS is single user OS, so
341 * you can change by "uid" or "gid" options.
344 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
345 befs_sb
->mount_opts
.uid
:
346 make_kuid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->uid
));
347 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
348 befs_sb
->mount_opts
.gid
:
349 make_kgid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->gid
));
354 * BEFS's time is 64 bits, but current VFS is 32 bits...
355 * BEFS don't have access time. Nor inode change time. VFS
356 * doesn't have creation time.
357 * Also, the lower 16 bits of the last_modified_time and
358 * create_time are just a counter to help ensure uniqueness
359 * for indexing purposes. (PFD, page 54)
362 inode
->i_mtime
.tv_sec
=
363 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16;
364 inode
->i_mtime
.tv_nsec
= 0; /* lower 16 bits are not a time */
365 inode
->i_ctime
= inode
->i_mtime
;
366 inode
->i_atime
= inode
->i_mtime
;
368 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
369 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
370 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
371 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
373 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
375 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
376 strlcpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
381 befs_ino
->i_data
.ds
=
382 fsds_to_cpu(sb
, &raw_inode
->data
.datastream
);
384 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
386 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
387 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
390 inode
->i_mapping
->a_ops
= &befs_aops
;
392 if (S_ISREG(inode
->i_mode
)) {
393 inode
->i_fop
= &generic_ro_fops
;
394 } else if (S_ISDIR(inode
->i_mode
)) {
395 inode
->i_op
= &befs_dir_inode_operations
;
396 inode
->i_fop
= &befs_dir_operations
;
397 } else if (S_ISLNK(inode
->i_mode
)) {
398 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
399 inode
->i_op
= &page_symlink_inode_operations
;
400 inode
->i_mapping
->a_ops
= &befs_symlink_aops
;
402 inode
->i_link
= befs_ino
->i_data
.symlink
;
403 inode
->i_op
= &simple_symlink_inode_operations
;
406 befs_error(sb
, "Inode %lu is not a regular file, "
407 "directory or symlink. THAT IS WRONG! BeFS has no "
408 "on disk special files", inode
->i_ino
);
413 befs_debug(sb
, "<--- %s", __func__
);
414 unlock_new_inode(inode
);
422 befs_debug(sb
, "<--- %s - Bad inode", __func__
);
426 /* Initialize the inode cache. Called at fs setup.
428 * Taken from NFS implementation by Al Viro.
431 befs_init_inodecache(void)
433 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
434 sizeof (struct befs_inode_info
),
435 0, (SLAB_RECLAIM_ACCOUNT
|
438 if (befs_inode_cachep
== NULL
) {
439 pr_err("%s: Couldn't initialize inode slabcache\n", __func__
);
445 /* Called at fs teardown.
447 * Taken from NFS implementation by Al Viro.
450 befs_destroy_inodecache(void)
453 * Make sure all delayed rcu free inodes are flushed before we
457 kmem_cache_destroy(befs_inode_cachep
);
461 * The inode of symbolic link is different to data stream.
462 * The data stream become link name. Unless the LONG_SYMLINK
465 static int befs_symlink_readpage(struct file
*unused
, struct page
*page
)
467 struct inode
*inode
= page
->mapping
->host
;
468 struct super_block
*sb
= inode
->i_sb
;
469 struct befs_inode_info
*befs_ino
= BEFS_I(inode
);
470 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
471 befs_off_t len
= data
->size
;
472 char *link
= kmap(page
);
474 if (len
== 0 || len
> PAGE_SIZE
) {
475 befs_error(sb
, "Long symlink with illegal length");
478 befs_debug(sb
, "Follow long symlink");
480 if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
481 befs_error(sb
, "Failed to read entire long symlink");
484 link
[len
- 1] = '\0';
485 SetPageUptodate(page
);
497 * UTF-8 to NLS charset convert routine
500 * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than
501 * the nls tables directly
505 befs_utf2nls(struct super_block
*sb
, const char *in
,
506 int in_len
, char **out
, int *out_len
)
508 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
513 /* The utf8->nls conversion won't make the final nls string bigger
514 * than the utf one, but if the string is pure ascii they'll have the
515 * same width and an extra char is needed to save the additional \0
517 int maxlen
= in_len
+ 1;
519 befs_debug(sb
, "---> %s", __func__
);
522 befs_error(sb
, "%s called with no NLS table loaded", __func__
);
526 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
528 befs_error(sb
, "%s cannot allocate memory", __func__
);
533 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
535 /* convert from UTF-8 to Unicode */
536 utflen
= utf8_to_utf32(&in
[i
], in_len
- i
, &uni
);
540 /* convert from Unicode to nls */
541 if (uni
> MAX_WCHAR_T
)
543 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
550 befs_debug(sb
, "<--- %s", __func__
);
555 befs_error(sb
, "Name using character set %s contains a character that "
556 "cannot be converted to unicode.", nls
->charset
);
557 befs_debug(sb
, "<--- %s", __func__
);
563 * befs_nls2utf - Convert NLS string to utf8 encodeing
565 * @in: Input string buffer in NLS format
566 * @in_len: Length of input string in bytes
567 * @out: The output string in UTF-8 format
568 * @out_len: Length of the output buffer
570 * Converts input string @in, which is in the format of the loaded NLS map,
571 * into a utf8 string.
573 * The destination string @out is allocated by this function and the caller is
574 * responsible for freeing it with kfree()
576 * On return, *@out_len is the length of @out in bytes.
578 * On success, the return value is the number of utf8 characters written to
579 * the output buffer @out.
581 * On Failure, a negative number coresponding to the error code is returned.
585 befs_nls2utf(struct super_block
*sb
, const char *in
,
586 int in_len
, char **out
, int *out_len
)
588 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
593 /* There're nls characters that will translate to 3-chars-wide UTF-8
594 * characters, a additional byte is needed to save the final \0
595 * in special cases */
596 int maxlen
= (3 * in_len
) + 1;
598 befs_debug(sb
, "---> %s\n", __func__
);
601 befs_error(sb
, "%s called with no NLS table loaded.",
606 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
608 befs_error(sb
, "%s cannot allocate memory", __func__
);
613 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
615 /* convert from nls to unicode */
616 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
620 /* convert from unicode to UTF-8 */
621 utflen
= utf32_to_utf8(uni
, &result
[o
], 3);
629 befs_debug(sb
, "<--- %s", __func__
);
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
, "<--- %s", __func__
);
646 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
649 static const match_table_t befs_tokens
= {
652 {Opt_charset
, "iocharset=%s"},
653 {Opt_debug
, "debug"},
658 parse_options(char *options
, struct befs_mount_options
*opts
)
661 substring_t args
[MAX_OPT_ARGS
];
666 /* Initialize options */
667 opts
->uid
= GLOBAL_ROOT_UID
;
668 opts
->gid
= GLOBAL_ROOT_GID
;
671 opts
->iocharset
= NULL
;
677 while ((p
= strsep(&options
, ",")) != NULL
) {
682 token
= match_token(p
, befs_tokens
, args
);
685 if (match_int(&args
[0], &option
))
689 uid
= make_kuid(current_user_ns(), option
);
690 if (!uid_valid(uid
)) {
691 pr_err("Invalid uid %d, "
692 "using default\n", option
);
699 if (match_int(&args
[0], &option
))
703 gid
= make_kgid(current_user_ns(), option
);
704 if (!gid_valid(gid
)) {
705 pr_err("Invalid gid %d, "
706 "using default\n", option
);
713 kfree(opts
->iocharset
);
714 opts
->iocharset
= match_strdup(&args
[0]);
715 if (!opts
->iocharset
) {
716 pr_err("allocation failure for "
717 "iocharset string\n");
725 pr_err("Unrecognized mount option \"%s\" "
726 "or missing value\n", p
);
733 /* This function has the responsibiltiy of getting the
734 * filesystem ready for unmounting.
735 * Basically, we free everything that we allocated in
739 befs_put_super(struct super_block
*sb
)
741 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
742 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
743 unload_nls(BEFS_SB(sb
)->nls
);
744 kfree(sb
->s_fs_info
);
745 sb
->s_fs_info
= NULL
;
748 /* Allocate private field of the superblock, fill it.
750 * Finish filling the public superblock fields
751 * Make the root directory
752 * Load a set of NLS translations if needed.
755 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
757 struct buffer_head
*bh
;
758 struct befs_sb_info
*befs_sb
;
759 befs_super_block
*disk_sb
;
762 const unsigned long sb_block
= 0;
763 const off_t x86_sb_off
= 512;
765 save_mount_options(sb
, data
);
767 sb
->s_fs_info
= kzalloc(sizeof(*befs_sb
), GFP_KERNEL
);
768 if (sb
->s_fs_info
== NULL
) {
769 pr_err("(%s): Unable to allocate memory for private "
770 "portion of superblock. Bailing.\n", sb
->s_id
);
773 befs_sb
= BEFS_SB(sb
);
775 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
776 befs_error(sb
, "cannot parse mount options");
777 goto unacquire_priv_sbp
;
780 befs_debug(sb
, "---> %s", __func__
);
782 if (!(sb
->s_flags
& MS_RDONLY
)) {
784 "No write support. Marking filesystem read-only");
785 sb
->s_flags
|= MS_RDONLY
;
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 ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
807 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
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
) ||
816 (befs_check_sb(sb
) != BEFS_OK
))
819 befs_dump_super_block(sb
, disk_sb
);
823 if( befs_sb
->num_blocks
> ~((sector_t
)0) ) {
824 befs_error(sb
, "blocks count: %llu "
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
= &befs_sops
;
838 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
841 goto unacquire_priv_sbp
;
843 sb
->s_root
= d_make_root(root
);
845 befs_error(sb
, "get root inode failed");
846 goto unacquire_priv_sbp
;
849 /* load nls library */
850 if (befs_sb
->mount_opts
.iocharset
) {
851 befs_debug(sb
, "Loading nls: %s",
852 befs_sb
->mount_opts
.iocharset
);
853 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
855 befs_warning(sb
, "Cannot load nls %s"
856 " loading default nls",
857 befs_sb
->mount_opts
.iocharset
);
858 befs_sb
->nls
= load_nls_default();
860 /* load default nls if none is specified in mount options */
862 befs_debug(sb
, "Loading default nls");
863 befs_sb
->nls
= load_nls_default();
872 kfree(befs_sb
->mount_opts
.iocharset
);
873 kfree(sb
->s_fs_info
);
876 sb
->s_fs_info
= NULL
;
881 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
884 if (!(*flags
& MS_RDONLY
))
890 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
892 struct super_block
*sb
= dentry
->d_sb
;
893 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
895 befs_debug(sb
, "---> %s", __func__
);
897 buf
->f_type
= BEFS_SUPER_MAGIC
;
898 buf
->f_bsize
= sb
->s_blocksize
;
899 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
900 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
901 buf
->f_bavail
= buf
->f_bfree
;
902 buf
->f_files
= 0; /* UNKNOWN */
903 buf
->f_ffree
= 0; /* UNKNOWN */
904 buf
->f_fsid
.val
[0] = (u32
)id
;
905 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
906 buf
->f_namelen
= BEFS_NAME_LEN
;
908 befs_debug(sb
, "<--- %s", __func__
);
913 static struct dentry
*
914 befs_mount(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
917 return mount_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
);
920 static struct file_system_type befs_fs_type
= {
921 .owner
= THIS_MODULE
,
924 .kill_sb
= kill_block_super
,
925 .fs_flags
= FS_REQUIRES_DEV
,
927 MODULE_ALIAS_FS("befs");
934 pr_info("version: %s\n", BEFS_VERSION
);
936 err
= befs_init_inodecache();
940 err
= register_filesystem(&befs_fs_type
);
942 goto unacquire_inodecache
;
946 unacquire_inodecache
:
947 befs_destroy_inodecache();
956 befs_destroy_inodecache();
958 unregister_filesystem(&befs_fs_type
);
962 Macros that typecheck the init and exit functions,
963 ensures that they are called at init and cleanup,
964 and eliminates warnings about unused functions.
966 module_init(init_befs_fs
)
967 module_exit(exit_befs_fs
)