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_shared
= 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
)
159 struct super_block
*sb
= dir
->i_sb
;
160 const 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
, name
, &offset
);
185 if (ret
== BEFS_BT_NOT_FOUND
) {
186 befs_debug(sb
, "<--- %s %pd not found", __func__
, dentry
);
188 return ERR_PTR(-ENOENT
);
190 } else if (ret
!= BEFS_OK
|| offset
== 0) {
191 befs_error(sb
, "<--- %s Error", __func__
);
192 return ERR_PTR(-ENODATA
);
195 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
197 return ERR_CAST(inode
);
199 d_add(dentry
, inode
);
201 befs_debug(sb
, "<--- %s", __func__
);
207 befs_readdir(struct file
*file
, struct dir_context
*ctx
)
209 struct inode
*inode
= file_inode(file
);
210 struct super_block
*sb
= inode
->i_sb
;
211 const befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
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__
);
240 if (BEFS_SB(sb
)->nls
) {
245 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
,
248 befs_debug(sb
, "<--- %s ERROR", __func__
);
251 if (!dir_emit(ctx
, nlsname
, nlsnamelen
,
252 (ino_t
) value
, DT_UNKNOWN
)) {
258 if (!dir_emit(ctx
, keybuf
, keysize
,
259 (ino_t
) value
, DT_UNKNOWN
))
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
;
298 befs_inode
*raw_inode
;
299 struct befs_sb_info
*befs_sb
= BEFS_SB(sb
);
300 struct befs_inode_info
*befs_ino
;
303 befs_debug(sb
, "---> %s inode = %lu", __func__
, ino
);
305 inode
= iget_locked(sb
, ino
);
307 return ERR_PTR(-ENOMEM
);
308 if (!(inode
->i_state
& I_NEW
))
311 befs_ino
= BEFS_I(inode
);
313 /* convert from vfs's inode number to befs's inode number */
314 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
316 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
317 befs_ino
->i_inode_num
.allocation_group
,
318 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
320 bh
= sb_bread(sb
, inode
->i_ino
);
322 befs_error(sb
, "unable to read inode block - "
323 "inode = %lu", inode
->i_ino
);
327 raw_inode
= (befs_inode
*) bh
->b_data
;
329 befs_dump_inode(sb
, raw_inode
);
331 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
332 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
336 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
339 * set uid and gid. But since current BeOS is single user OS, so
340 * you can change by "uid" or "gid" options.
343 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
344 befs_sb
->mount_opts
.uid
:
345 make_kuid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->uid
));
346 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
347 befs_sb
->mount_opts
.gid
:
348 make_kgid(&init_user_ns
, 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 strlcpy(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 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
398 inode
->i_op
= &page_symlink_inode_operations
;
399 inode_nohighmem(inode
);
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__
);
423 return ERR_PTR(-EIO
);
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
|
436 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
),
438 if (befs_inode_cachep
== NULL
)
444 /* Called at fs teardown.
446 * Taken from NFS implementation by Al Viro.
449 befs_destroy_inodecache(void)
452 * Make sure all delayed rcu free inodes are flushed before we
456 kmem_cache_destroy(befs_inode_cachep
);
460 * The inode of symbolic link is different to data stream.
461 * The data stream become link name. Unless the LONG_SYMLINK
464 static int befs_symlink_readpage(struct file
*unused
, struct page
*page
)
466 struct inode
*inode
= page
->mapping
->host
;
467 struct super_block
*sb
= inode
->i_sb
;
468 struct befs_inode_info
*befs_ino
= BEFS_I(inode
);
469 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
470 befs_off_t len
= data
->size
;
471 char *link
= page_address(page
);
473 if (len
== 0 || len
> PAGE_SIZE
) {
474 befs_error(sb
, "Long symlink with illegal length");
477 befs_debug(sb
, "Follow long symlink");
479 if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
480 befs_error(sb
, "Failed to read entire long symlink");
483 link
[len
- 1] = '\0';
484 SetPageUptodate(page
);
494 * UTF-8 to NLS charset convert routine
496 * Uses uni2char() / char2uni() rather than the nls tables directly
499 befs_utf2nls(struct super_block
*sb
, const char *in
,
500 int in_len
, char **out
, int *out_len
)
502 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
507 /* The utf8->nls conversion won't make the final nls string bigger
508 * than the utf one, but if the string is pure ascii they'll have the
509 * same width and an extra char is needed to save the additional \0
511 int maxlen
= in_len
+ 1;
513 befs_debug(sb
, "---> %s", __func__
);
516 befs_error(sb
, "%s called with no NLS table loaded", __func__
);
520 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
525 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
527 /* convert from UTF-8 to Unicode */
528 utflen
= utf8_to_utf32(&in
[i
], in_len
- i
, &uni
);
532 /* convert from Unicode to nls */
533 if (uni
> MAX_WCHAR_T
)
535 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
542 befs_debug(sb
, "<--- %s", __func__
);
547 befs_error(sb
, "Name using character set %s contains a character that "
548 "cannot be converted to unicode.", nls
->charset
);
549 befs_debug(sb
, "<--- %s", __func__
);
555 * befs_nls2utf - Convert NLS string to utf8 encodeing
557 * @in: Input string buffer in NLS format
558 * @in_len: Length of input string in bytes
559 * @out: The output string in UTF-8 format
560 * @out_len: Length of the output buffer
562 * Converts input string @in, which is in the format of the loaded NLS map,
563 * into a utf8 string.
565 * The destination string @out is allocated by this function and the caller is
566 * responsible for freeing it with kfree()
568 * On return, *@out_len is the length of @out in bytes.
570 * On success, the return value is the number of utf8 characters written to
571 * the output buffer @out.
573 * On Failure, a negative number coresponding to the error code is returned.
577 befs_nls2utf(struct super_block
*sb
, const char *in
,
578 int in_len
, char **out
, int *out_len
)
580 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
586 * There are nls characters that will translate to 3-chars-wide UTF-8
587 * characters, an additional byte is needed to save the final \0
588 * in special cases */
589 int maxlen
= (3 * in_len
) + 1;
591 befs_debug(sb
, "---> %s\n", __func__
);
594 befs_error(sb
, "%s called with no NLS table loaded.",
599 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
605 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
607 /* convert from nls to unicode */
608 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
612 /* convert from unicode to UTF-8 */
613 utflen
= utf32_to_utf8(uni
, &result
[o
], 3);
621 befs_debug(sb
, "<--- %s", __func__
);
626 befs_error(sb
, "Name using character set %s contains a character that "
627 "cannot be converted to unicode.", nls
->charset
);
628 befs_debug(sb
, "<--- %s", __func__
);
634 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
637 static const match_table_t befs_tokens
= {
640 {Opt_charset
, "iocharset=%s"},
641 {Opt_debug
, "debug"},
646 parse_options(char *options
, struct befs_mount_options
*opts
)
649 substring_t args
[MAX_OPT_ARGS
];
654 /* Initialize options */
655 opts
->uid
= GLOBAL_ROOT_UID
;
656 opts
->gid
= GLOBAL_ROOT_GID
;
659 opts
->iocharset
= NULL
;
665 while ((p
= strsep(&options
, ",")) != NULL
) {
670 token
= match_token(p
, befs_tokens
, args
);
673 if (match_int(&args
[0], &option
))
677 uid
= make_kuid(current_user_ns(), option
);
678 if (!uid_valid(uid
)) {
679 pr_err("Invalid uid %d, "
680 "using default\n", option
);
687 if (match_int(&args
[0], &option
))
691 gid
= make_kgid(current_user_ns(), option
);
692 if (!gid_valid(gid
)) {
693 pr_err("Invalid gid %d, "
694 "using default\n", option
);
701 kfree(opts
->iocharset
);
702 opts
->iocharset
= match_strdup(&args
[0]);
703 if (!opts
->iocharset
) {
704 pr_err("allocation failure for "
705 "iocharset string\n");
713 pr_err("Unrecognized mount option \"%s\" "
714 "or missing value\n", p
);
721 /* This function has the responsibiltiy of getting the
722 * filesystem ready for unmounting.
723 * Basically, we free everything that we allocated in
727 befs_put_super(struct super_block
*sb
)
729 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
730 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
731 unload_nls(BEFS_SB(sb
)->nls
);
732 kfree(sb
->s_fs_info
);
733 sb
->s_fs_info
= NULL
;
736 /* Allocate private field of the superblock, fill it.
738 * Finish filling the public superblock fields
739 * Make the root directory
740 * Load a set of NLS translations if needed.
743 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
745 struct buffer_head
*bh
;
746 struct befs_sb_info
*befs_sb
;
747 befs_super_block
*disk_sb
;
750 const unsigned long sb_block
= 0;
751 const off_t x86_sb_off
= 512;
754 save_mount_options(sb
, data
);
756 sb
->s_fs_info
= kzalloc(sizeof(*befs_sb
), GFP_KERNEL
);
757 if (sb
->s_fs_info
== NULL
)
760 befs_sb
= BEFS_SB(sb
);
762 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
764 befs_error(sb
, "cannot parse mount options");
765 goto unacquire_priv_sbp
;
768 befs_debug(sb
, "---> %s", __func__
);
770 if (!(sb
->s_flags
& MS_RDONLY
)) {
772 "No write support. Marking filesystem read-only");
773 sb
->s_flags
|= MS_RDONLY
;
777 * Set dummy blocksize to read super block.
778 * Will be set to real fs blocksize later.
780 * Linux 2.4.10 and later refuse to read blocks smaller than
781 * the logical block size for the device. But we also need to read at
782 * least 1k to get the second 512 bytes of the volume.
785 blocksize
= sb_min_blocksize(sb
, 1024);
788 befs_error(sb
, "unable to set blocksize");
789 goto unacquire_priv_sbp
;
792 if (!(bh
= sb_bread(sb
, sb_block
))) {
794 befs_error(sb
, "unable to read superblock");
795 goto unacquire_priv_sbp
;
798 /* account for offset of super block on x86 */
799 disk_sb
= (befs_super_block
*) bh
->b_data
;
800 if ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
801 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
802 befs_debug(sb
, "Using PPC superblock location");
804 befs_debug(sb
, "Using x86 superblock location");
806 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
809 if ((befs_load_sb(sb
, disk_sb
) != BEFS_OK
) ||
810 (befs_check_sb(sb
) != BEFS_OK
))
813 befs_dump_super_block(sb
, disk_sb
);
817 if( befs_sb
->num_blocks
> ~((sector_t
)0) ) {
819 befs_error(sb
, "blocks count: %llu is larger than the host can use",
820 befs_sb
->num_blocks
);
821 goto unacquire_priv_sbp
;
825 * set up enough so that it can read an inode
826 * Fill in kernel superblock fields from private sb
828 sb
->s_magic
= BEFS_SUPER_MAGIC
;
829 /* Set real blocksize of fs */
830 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
831 sb
->s_op
= &befs_sops
;
832 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
835 goto unacquire_priv_sbp
;
837 sb
->s_root
= d_make_root(root
);
840 befs_error(sb
, "get root inode failed");
841 goto unacquire_priv_sbp
;
844 /* load nls library */
845 if (befs_sb
->mount_opts
.iocharset
) {
846 befs_debug(sb
, "Loading nls: %s",
847 befs_sb
->mount_opts
.iocharset
);
848 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
850 befs_warning(sb
, "Cannot load nls %s"
851 " loading default nls",
852 befs_sb
->mount_opts
.iocharset
);
853 befs_sb
->nls
= load_nls_default();
855 /* load default nls if none is specified in mount options */
857 befs_debug(sb
, "Loading default nls");
858 befs_sb
->nls
= load_nls_default();
867 kfree(befs_sb
->mount_opts
.iocharset
);
868 kfree(sb
->s_fs_info
);
869 sb
->s_fs_info
= NULL
;
876 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
;
888 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
890 befs_debug(sb
, "---> %s", __func__
);
892 buf
->f_type
= BEFS_SUPER_MAGIC
;
893 buf
->f_bsize
= sb
->s_blocksize
;
894 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
895 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
896 buf
->f_bavail
= buf
->f_bfree
;
897 buf
->f_files
= 0; /* UNKNOWN */
898 buf
->f_ffree
= 0; /* UNKNOWN */
899 buf
->f_fsid
.val
[0] = (u32
)id
;
900 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
901 buf
->f_namelen
= BEFS_NAME_LEN
;
903 befs_debug(sb
, "<--- %s", __func__
);
908 static struct dentry
*
909 befs_mount(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
912 return mount_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
);
915 static struct file_system_type befs_fs_type
= {
916 .owner
= THIS_MODULE
,
919 .kill_sb
= kill_block_super
,
920 .fs_flags
= FS_REQUIRES_DEV
,
922 MODULE_ALIAS_FS("befs");
929 pr_info("version: %s\n", BEFS_VERSION
);
931 err
= befs_init_inodecache();
935 err
= register_filesystem(&befs_fs_type
);
937 goto unacquire_inodecache
;
941 unacquire_inodecache
:
942 befs_destroy_inodecache();
951 befs_destroy_inodecache();
953 unregister_filesystem(&befs_fs_type
);
957 Macros that typecheck the init and exit functions,
958 ensures that they are called at init and cleanup,
959 and eliminates warnings about unused functions.
961 module_init(init_befs_fs
)
962 module_exit(exit_befs_fs
)