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
*,
42 static struct inode
*befs_iget(struct super_block
*, unsigned long);
43 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
44 static void befs_destroy_inode(struct inode
*inode
);
45 static void befs_destroy_inodecache(void);
46 static int befs_symlink_readpage(struct file
*, struct page
*);
47 static int befs_utf2nls(struct super_block
*sb
, const char *in
, int in_len
,
48 char **out
, int *out_len
);
49 static int befs_nls2utf(struct super_block
*sb
, const char *in
, int in_len
,
50 char **out
, int *out_len
);
51 static void befs_put_super(struct super_block
*);
52 static int befs_remount(struct super_block
*, int *, char *);
53 static int befs_statfs(struct dentry
*, struct kstatfs
*);
54 static int parse_options(char *, struct befs_mount_options
*);
56 static const struct super_operations befs_sops
= {
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
,
62 .show_options
= generic_show_options
,
65 /* slab cache for befs_inode_info objects */
66 static struct kmem_cache
*befs_inode_cachep
;
68 static const struct file_operations befs_dir_operations
= {
69 .read
= generic_read_dir
,
70 .iterate_shared
= befs_readdir
,
71 .llseek
= generic_file_llseek
,
74 static const struct inode_operations befs_dir_inode_operations
= {
75 .lookup
= befs_lookup
,
78 static const struct address_space_operations befs_aops
= {
79 .readpage
= befs_readpage
,
83 static const struct address_space_operations befs_symlink_aops
= {
84 .readpage
= befs_symlink_readpage
,
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 (unsigned long)inode
->i_ino
, (long)block
);
130 befs_error(sb
, "befs_get_block() was asked to write to "
131 "block %ld in inode %lu", (long)block
,
132 (unsigned long)inode
->i_ino
);
136 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
137 if (res
!= BEFS_OK
) {
139 "<--- %s for inode %lu, block %ld ERROR",
140 __func__
, (unsigned long)inode
->i_ino
,
145 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
147 map_bh(bh_result
, inode
->i_sb
, disk_off
);
149 befs_debug(sb
, "<--- %s for inode %lu, block %ld, disk address %lu",
150 __func__
, (unsigned long)inode
->i_ino
, (long)block
,
151 (unsigned long)disk_off
);
156 static struct dentry
*
157 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
160 struct super_block
*sb
= dir
->i_sb
;
161 const befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
166 const char *name
= dentry
->d_name
.name
;
168 befs_debug(sb
, "---> %s name %pd inode %ld", __func__
,
171 /* Convert to UTF-8 */
172 if (BEFS_SB(sb
)->nls
) {
174 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
176 befs_debug(sb
, "<--- %s ERROR", __func__
);
179 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
183 ret
= befs_btree_find(sb
, ds
, name
, &offset
);
186 if (ret
== BEFS_BT_NOT_FOUND
) {
187 befs_debug(sb
, "<--- %s %pd not found", __func__
, dentry
);
189 return ERR_PTR(-ENOENT
);
191 } else if (ret
!= BEFS_OK
|| offset
== 0) {
192 befs_error(sb
, "<--- %s Error", __func__
);
193 return ERR_PTR(-ENODATA
);
196 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
198 return ERR_CAST(inode
);
200 d_add(dentry
, inode
);
202 befs_debug(sb
, "<--- %s", __func__
);
208 befs_readdir(struct file
*file
, struct dir_context
*ctx
)
210 struct inode
*inode
= file_inode(file
);
211 struct super_block
*sb
= inode
->i_sb
;
212 const befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
216 char keybuf
[BEFS_NAME_LEN
+ 1];
218 befs_debug(sb
, "---> %s name %pD, inode %ld, ctx->pos %lld",
219 __func__
, file
, inode
->i_ino
, ctx
->pos
);
222 result
= befs_btree_read(sb
, ds
, ctx
->pos
, BEFS_NAME_LEN
+ 1,
223 keybuf
, &keysize
, &value
);
225 if (result
== BEFS_ERR
) {
226 befs_debug(sb
, "<--- %s ERROR", __func__
);
227 befs_error(sb
, "IO error reading %pD (inode %lu)",
231 } else if (result
== BEFS_BT_END
) {
232 befs_debug(sb
, "<--- %s END", __func__
);
235 } else if (result
== BEFS_BT_EMPTY
) {
236 befs_debug(sb
, "<--- %s Empty directory", __func__
);
241 if (BEFS_SB(sb
)->nls
) {
246 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
,
249 befs_debug(sb
, "<--- %s ERROR", __func__
);
252 if (!dir_emit(ctx
, nlsname
, nlsnamelen
,
253 (ino_t
) value
, DT_UNKNOWN
)) {
259 if (!dir_emit(ctx
, keybuf
, keysize
,
260 (ino_t
) value
, DT_UNKNOWN
))
267 static struct inode
*
268 befs_alloc_inode(struct super_block
*sb
)
270 struct befs_inode_info
*bi
;
272 bi
= kmem_cache_alloc(befs_inode_cachep
, GFP_KERNEL
);
275 return &bi
->vfs_inode
;
278 static void befs_i_callback(struct rcu_head
*head
)
280 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
281 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
284 static void befs_destroy_inode(struct inode
*inode
)
286 call_rcu(&inode
->i_rcu
, befs_i_callback
);
289 static void init_once(void *foo
)
291 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
293 inode_init_once(&bi
->vfs_inode
);
296 static struct inode
*befs_iget(struct super_block
*sb
, unsigned long ino
)
298 struct buffer_head
*bh
;
299 befs_inode
*raw_inode
;
300 struct befs_sb_info
*befs_sb
= BEFS_SB(sb
);
301 struct befs_inode_info
*befs_ino
;
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
= sb_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_nohighmem(inode
);
401 inode
->i_mapping
->a_ops
= &befs_symlink_aops
;
403 inode
->i_link
= befs_ino
->i_data
.symlink
;
404 inode
->i_op
= &simple_symlink_inode_operations
;
407 befs_error(sb
, "Inode %lu is not a regular file, "
408 "directory or symlink. THAT IS WRONG! BeFS has no "
409 "on disk special files", inode
->i_ino
);
414 befs_debug(sb
, "<--- %s", __func__
);
415 unlock_new_inode(inode
);
423 befs_debug(sb
, "<--- %s - Bad inode", __func__
);
424 return ERR_PTR(-EIO
);
427 /* Initialize the inode cache. Called at fs setup.
429 * Taken from NFS implementation by Al Viro.
432 befs_init_inodecache(void)
434 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
435 sizeof (struct befs_inode_info
),
436 0, (SLAB_RECLAIM_ACCOUNT
|
437 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
),
439 if (befs_inode_cachep
== NULL
)
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
= page_address(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
);
495 * UTF-8 to NLS charset convert routine
497 * Uses uni2char() / char2uni() rather than the nls tables directly
500 befs_utf2nls(struct super_block
*sb
, const char *in
,
501 int in_len
, char **out
, int *out_len
)
503 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
508 /* The utf8->nls conversion won't make the final nls string bigger
509 * than the utf one, but if the string is pure ascii they'll have the
510 * same width and an extra char is needed to save the additional \0
512 int maxlen
= in_len
+ 1;
514 befs_debug(sb
, "---> %s", __func__
);
517 befs_error(sb
, "%s called with no NLS table loaded", __func__
);
521 *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
590 int maxlen
= (3 * in_len
) + 1;
592 befs_debug(sb
, "---> %s\n", __func__
);
595 befs_error(sb
, "%s called with no NLS table loaded.",
600 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
606 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
608 /* convert from nls to unicode */
609 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
613 /* convert from unicode to UTF-8 */
614 utflen
= utf32_to_utf8(uni
, &result
[o
], 3);
622 befs_debug(sb
, "<--- %s", __func__
);
627 befs_error(sb
, "Name using character set %s contains a character that "
628 "cannot be converted to unicode.", nls
->charset
);
629 befs_debug(sb
, "<--- %s", __func__
);
635 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
638 static const match_table_t befs_tokens
= {
641 {Opt_charset
, "iocharset=%s"},
642 {Opt_debug
, "debug"},
647 parse_options(char *options
, struct befs_mount_options
*opts
)
650 substring_t args
[MAX_OPT_ARGS
];
655 /* Initialize options */
656 opts
->uid
= GLOBAL_ROOT_UID
;
657 opts
->gid
= GLOBAL_ROOT_GID
;
660 opts
->iocharset
= NULL
;
666 while ((p
= strsep(&options
, ",")) != NULL
) {
672 token
= match_token(p
, befs_tokens
, args
);
675 if (match_int(&args
[0], &option
))
679 uid
= make_kuid(current_user_ns(), option
);
680 if (!uid_valid(uid
)) {
681 pr_err("Invalid uid %d, "
682 "using default\n", option
);
689 if (match_int(&args
[0], &option
))
693 gid
= make_kgid(current_user_ns(), option
);
694 if (!gid_valid(gid
)) {
695 pr_err("Invalid gid %d, "
696 "using default\n", option
);
703 kfree(opts
->iocharset
);
704 opts
->iocharset
= match_strdup(&args
[0]);
705 if (!opts
->iocharset
) {
706 pr_err("allocation failure for "
707 "iocharset string\n");
715 pr_err("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 * Basically, 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
;
733 unload_nls(BEFS_SB(sb
)->nls
);
734 kfree(sb
->s_fs_info
);
735 sb
->s_fs_info
= NULL
;
738 /* Allocate private field of the superblock, fill it.
740 * Finish filling the public superblock fields
741 * Make the root directory
742 * Load a set of NLS translations if needed.
745 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
747 struct buffer_head
*bh
;
748 struct befs_sb_info
*befs_sb
;
749 befs_super_block
*disk_sb
;
752 const unsigned long sb_block
= 0;
753 const off_t x86_sb_off
= 512;
756 save_mount_options(sb
, data
);
758 sb
->s_fs_info
= kzalloc(sizeof(*befs_sb
), GFP_KERNEL
);
759 if (sb
->s_fs_info
== NULL
)
762 befs_sb
= BEFS_SB(sb
);
764 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
766 befs_error(sb
, "cannot parse mount options");
767 goto unacquire_priv_sbp
;
770 befs_debug(sb
, "---> %s", __func__
);
772 if (!(sb
->s_flags
& MS_RDONLY
)) {
774 "No write support. Marking filesystem read-only");
775 sb
->s_flags
|= MS_RDONLY
;
779 * Set dummy blocksize to read super block.
780 * Will be set to real fs blocksize later.
782 * Linux 2.4.10 and later refuse to read blocks smaller than
783 * the logical block size for the device. But we also need to read at
784 * least 1k to get the second 512 bytes of the volume.
787 blocksize
= sb_min_blocksize(sb
, 1024);
790 befs_error(sb
, "unable to set blocksize");
791 goto unacquire_priv_sbp
;
794 bh
= sb_bread(sb
, sb_block
);
797 befs_error(sb
, "unable to read superblock");
798 goto unacquire_priv_sbp
;
801 /* account for offset of super block on x86 */
802 disk_sb
= (befs_super_block
*) bh
->b_data
;
803 if ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
804 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
805 befs_debug(sb
, "Using PPC superblock location");
807 befs_debug(sb
, "Using x86 superblock location");
809 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
812 if ((befs_load_sb(sb
, disk_sb
) != BEFS_OK
) ||
813 (befs_check_sb(sb
) != BEFS_OK
))
816 befs_dump_super_block(sb
, disk_sb
);
820 if (befs_sb
->num_blocks
> ~((sector_t
)0)) {
822 befs_error(sb
, "blocks count: %llu is larger than the host can use",
823 befs_sb
->num_blocks
);
824 goto unacquire_priv_sbp
;
828 * set up enough so that it can read an inode
829 * Fill in kernel superblock fields from private sb
831 sb
->s_magic
= BEFS_SUPER_MAGIC
;
832 /* Set real blocksize of fs */
833 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
834 sb
->s_op
= &befs_sops
;
835 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
838 goto unacquire_priv_sbp
;
840 sb
->s_root
= d_make_root(root
);
843 befs_error(sb
, "get root inode failed");
844 goto unacquire_priv_sbp
;
847 /* load nls library */
848 if (befs_sb
->mount_opts
.iocharset
) {
849 befs_debug(sb
, "Loading nls: %s",
850 befs_sb
->mount_opts
.iocharset
);
851 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
853 befs_warning(sb
, "Cannot load nls %s"
854 " loading default nls",
855 befs_sb
->mount_opts
.iocharset
);
856 befs_sb
->nls
= load_nls_default();
858 /* load default nls if none is specified in mount options */
860 befs_debug(sb
, "Loading default nls");
861 befs_sb
->nls
= load_nls_default();
870 kfree(befs_sb
->mount_opts
.iocharset
);
871 kfree(sb
->s_fs_info
);
872 sb
->s_fs_info
= NULL
;
879 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
882 if (!(*flags
& MS_RDONLY
))
888 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
890 struct super_block
*sb
= dentry
->d_sb
;
891 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
893 befs_debug(sb
, "---> %s", __func__
);
895 buf
->f_type
= BEFS_SUPER_MAGIC
;
896 buf
->f_bsize
= sb
->s_blocksize
;
897 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
898 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
899 buf
->f_bavail
= buf
->f_bfree
;
900 buf
->f_files
= 0; /* UNKNOWN */
901 buf
->f_ffree
= 0; /* UNKNOWN */
902 buf
->f_fsid
.val
[0] = (u32
)id
;
903 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
904 buf
->f_namelen
= BEFS_NAME_LEN
;
906 befs_debug(sb
, "<--- %s", __func__
);
911 static struct dentry
*
912 befs_mount(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
915 return mount_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
);
918 static struct file_system_type befs_fs_type
= {
919 .owner
= THIS_MODULE
,
922 .kill_sb
= kill_block_super
,
923 .fs_flags
= FS_REQUIRES_DEV
,
925 MODULE_ALIAS_FS("befs");
932 pr_info("version: %s\n", BEFS_VERSION
);
934 err
= befs_init_inodecache();
938 err
= register_filesystem(&befs_fs_type
);
940 goto unacquire_inodecache
;
944 unacquire_inodecache
:
945 befs_destroy_inodecache();
954 befs_destroy_inodecache();
956 unregister_filesystem(&befs_fs_type
);
960 * Macros that typecheck the init and exit functions,
961 * ensures that they are called at init and cleanup,
962 * and eliminates warnings about unused functions.
964 module_init(init_befs_fs
)
965 module_exit(exit_befs_fs
)