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>
21 #include <linux/cred.h>
22 #include <linux/exportfs.h>
27 #include "datastream.h"
31 MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
32 MODULE_AUTHOR("Will Dyson");
33 MODULE_LICENSE("GPL");
35 /* The units the vfs expects inode->i_blocks to be in */
36 #define VFS_BLOCK_SIZE 512
38 static int befs_readdir(struct file
*, struct dir_context
*);
39 static int befs_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
40 static int befs_readpage(struct file
*file
, struct page
*page
);
41 static sector_t
befs_bmap(struct address_space
*mapping
, sector_t block
);
42 static struct dentry
*befs_lookup(struct inode
*, struct dentry
*,
44 static struct inode
*befs_iget(struct super_block
*, unsigned long);
45 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
46 static void befs_destroy_inode(struct inode
*inode
);
47 static void befs_destroy_inodecache(void);
48 static int befs_symlink_readpage(struct file
*, struct page
*);
49 static int befs_utf2nls(struct super_block
*sb
, const char *in
, int in_len
,
50 char **out
, int *out_len
);
51 static int befs_nls2utf(struct super_block
*sb
, const char *in
, int in_len
,
52 char **out
, int *out_len
);
53 static void befs_put_super(struct super_block
*);
54 static int befs_remount(struct super_block
*, int *, char *);
55 static int befs_statfs(struct dentry
*, struct kstatfs
*);
56 static int parse_options(char *, struct befs_mount_options
*);
57 static struct dentry
*befs_fh_to_dentry(struct super_block
*sb
,
58 struct fid
*fid
, int fh_len
, int fh_type
);
59 static struct dentry
*befs_fh_to_parent(struct super_block
*sb
,
60 struct fid
*fid
, int fh_len
, int fh_type
);
61 static struct dentry
*befs_get_parent(struct dentry
*child
);
63 static const struct super_operations befs_sops
= {
64 .alloc_inode
= befs_alloc_inode
, /* allocate a new inode */
65 .destroy_inode
= befs_destroy_inode
, /* deallocate an inode */
66 .put_super
= befs_put_super
, /* uninit super */
67 .statfs
= befs_statfs
, /* statfs */
68 .remount_fs
= befs_remount
,
69 .show_options
= generic_show_options
,
72 /* slab cache for befs_inode_info objects */
73 static struct kmem_cache
*befs_inode_cachep
;
75 static const struct file_operations befs_dir_operations
= {
76 .read
= generic_read_dir
,
77 .iterate_shared
= befs_readdir
,
78 .llseek
= generic_file_llseek
,
81 static const struct inode_operations befs_dir_inode_operations
= {
82 .lookup
= befs_lookup
,
85 static const struct address_space_operations befs_aops
= {
86 .readpage
= befs_readpage
,
90 static const struct address_space_operations befs_symlink_aops
= {
91 .readpage
= befs_symlink_readpage
,
94 static const struct export_operations befs_export_operations
= {
95 .fh_to_dentry
= befs_fh_to_dentry
,
96 .fh_to_parent
= befs_fh_to_parent
,
97 .get_parent
= befs_get_parent
,
101 * Called by generic_file_read() to read a page of data
103 * In turn, simply calls a generic block read function and
104 * passes it the address of befs_get_block, for mapping file
105 * positions to disk blocks.
108 befs_readpage(struct file
*file
, struct page
*page
)
110 return block_read_full_page(page
, befs_get_block
);
114 befs_bmap(struct address_space
*mapping
, sector_t block
)
116 return generic_block_bmap(mapping
, block
, befs_get_block
);
120 * Generic function to map a file position (block) to a
121 * disk offset (passed back in bh_result).
123 * Used by many higher level functions.
125 * Calls befs_fblock2brun() in datastream.c to do the real work.
129 befs_get_block(struct inode
*inode
, sector_t block
,
130 struct buffer_head
*bh_result
, int create
)
132 struct super_block
*sb
= inode
->i_sb
;
133 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
134 befs_block_run run
= BAD_IADDR
;
138 befs_debug(sb
, "---> befs_get_block() for inode %lu, block %ld",
139 (unsigned long)inode
->i_ino
, (long)block
);
141 befs_error(sb
, "befs_get_block() was asked to write to "
142 "block %ld in inode %lu", (long)block
,
143 (unsigned long)inode
->i_ino
);
147 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
148 if (res
!= BEFS_OK
) {
150 "<--- %s for inode %lu, block %ld ERROR",
151 __func__
, (unsigned long)inode
->i_ino
,
156 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
158 map_bh(bh_result
, inode
->i_sb
, disk_off
);
160 befs_debug(sb
, "<--- %s for inode %lu, block %ld, disk address %lu",
161 __func__
, (unsigned long)inode
->i_ino
, (long)block
,
162 (unsigned long)disk_off
);
167 static struct dentry
*
168 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
171 struct super_block
*sb
= dir
->i_sb
;
172 const befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
177 const char *name
= dentry
->d_name
.name
;
179 befs_debug(sb
, "---> %s name %pd inode %ld", __func__
,
182 /* Convert to UTF-8 */
183 if (BEFS_SB(sb
)->nls
) {
185 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
187 befs_debug(sb
, "<--- %s ERROR", __func__
);
190 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
194 ret
= befs_btree_find(sb
, ds
, name
, &offset
);
197 if (ret
== BEFS_BT_NOT_FOUND
) {
198 befs_debug(sb
, "<--- %s %pd not found", __func__
, dentry
);
200 return ERR_PTR(-ENOENT
);
202 } else if (ret
!= BEFS_OK
|| offset
== 0) {
203 befs_error(sb
, "<--- %s Error", __func__
);
204 return ERR_PTR(-ENODATA
);
207 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
209 return ERR_CAST(inode
);
211 d_add(dentry
, inode
);
213 befs_debug(sb
, "<--- %s", __func__
);
219 befs_readdir(struct file
*file
, struct dir_context
*ctx
)
221 struct inode
*inode
= file_inode(file
);
222 struct super_block
*sb
= inode
->i_sb
;
223 const befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
227 char keybuf
[BEFS_NAME_LEN
+ 1];
229 befs_debug(sb
, "---> %s name %pD, inode %ld, ctx->pos %lld",
230 __func__
, file
, inode
->i_ino
, ctx
->pos
);
233 result
= befs_btree_read(sb
, ds
, ctx
->pos
, BEFS_NAME_LEN
+ 1,
234 keybuf
, &keysize
, &value
);
236 if (result
== BEFS_ERR
) {
237 befs_debug(sb
, "<--- %s ERROR", __func__
);
238 befs_error(sb
, "IO error reading %pD (inode %lu)",
242 } else if (result
== BEFS_BT_END
) {
243 befs_debug(sb
, "<--- %s END", __func__
);
246 } else if (result
== BEFS_BT_EMPTY
) {
247 befs_debug(sb
, "<--- %s Empty directory", __func__
);
252 if (BEFS_SB(sb
)->nls
) {
257 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
,
260 befs_debug(sb
, "<--- %s ERROR", __func__
);
263 if (!dir_emit(ctx
, nlsname
, nlsnamelen
,
264 (ino_t
) value
, DT_UNKNOWN
)) {
270 if (!dir_emit(ctx
, keybuf
, keysize
,
271 (ino_t
) value
, DT_UNKNOWN
))
278 static struct inode
*
279 befs_alloc_inode(struct super_block
*sb
)
281 struct befs_inode_info
*bi
;
283 bi
= kmem_cache_alloc(befs_inode_cachep
, GFP_KERNEL
);
286 return &bi
->vfs_inode
;
289 static void befs_i_callback(struct rcu_head
*head
)
291 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
292 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
295 static void befs_destroy_inode(struct inode
*inode
)
297 call_rcu(&inode
->i_rcu
, befs_i_callback
);
300 static void init_once(void *foo
)
302 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
304 inode_init_once(&bi
->vfs_inode
);
307 static struct inode
*befs_iget(struct super_block
*sb
, unsigned long ino
)
309 struct buffer_head
*bh
;
310 befs_inode
*raw_inode
;
311 struct befs_sb_info
*befs_sb
= BEFS_SB(sb
);
312 struct befs_inode_info
*befs_ino
;
315 befs_debug(sb
, "---> %s inode = %lu", __func__
, ino
);
317 inode
= iget_locked(sb
, ino
);
319 return ERR_PTR(-ENOMEM
);
320 if (!(inode
->i_state
& I_NEW
))
323 befs_ino
= BEFS_I(inode
);
325 /* convert from vfs's inode number to befs's inode number */
326 befs_ino
->i_inode_num
= blockno2iaddr(sb
, inode
->i_ino
);
328 befs_debug(sb
, " real inode number [%u, %hu, %hu]",
329 befs_ino
->i_inode_num
.allocation_group
,
330 befs_ino
->i_inode_num
.start
, befs_ino
->i_inode_num
.len
);
332 bh
= sb_bread(sb
, inode
->i_ino
);
334 befs_error(sb
, "unable to read inode block - "
335 "inode = %lu", inode
->i_ino
);
339 raw_inode
= (befs_inode
*) bh
->b_data
;
341 befs_dump_inode(sb
, raw_inode
);
343 if (befs_check_inode(sb
, raw_inode
, inode
->i_ino
) != BEFS_OK
) {
344 befs_error(sb
, "Bad inode: %lu", inode
->i_ino
);
348 inode
->i_mode
= (umode_t
) fs32_to_cpu(sb
, raw_inode
->mode
);
351 * set uid and gid. But since current BeOS is single user OS, so
352 * you can change by "uid" or "gid" options.
355 inode
->i_uid
= befs_sb
->mount_opts
.use_uid
?
356 befs_sb
->mount_opts
.uid
:
357 make_kuid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->uid
));
358 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
359 befs_sb
->mount_opts
.gid
:
360 make_kgid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->gid
));
365 * BEFS's time is 64 bits, but current VFS is 32 bits...
366 * BEFS don't have access time. Nor inode change time. VFS
367 * doesn't have creation time.
368 * Also, the lower 16 bits of the last_modified_time and
369 * create_time are just a counter to help ensure uniqueness
370 * for indexing purposes. (PFD, page 54)
373 inode
->i_mtime
.tv_sec
=
374 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16;
375 inode
->i_mtime
.tv_nsec
= 0; /* lower 16 bits are not a time */
376 inode
->i_ctime
= inode
->i_mtime
;
377 inode
->i_atime
= inode
->i_mtime
;
379 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
380 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
381 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
382 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
384 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
386 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
387 strlcpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
392 befs_ino
->i_data
.ds
=
393 fsds_to_cpu(sb
, &raw_inode
->data
.datastream
);
395 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
397 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
398 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
401 inode
->i_mapping
->a_ops
= &befs_aops
;
403 if (S_ISREG(inode
->i_mode
)) {
404 inode
->i_fop
= &generic_ro_fops
;
405 } else if (S_ISDIR(inode
->i_mode
)) {
406 inode
->i_op
= &befs_dir_inode_operations
;
407 inode
->i_fop
= &befs_dir_operations
;
408 } else if (S_ISLNK(inode
->i_mode
)) {
409 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
410 inode
->i_op
= &page_symlink_inode_operations
;
411 inode_nohighmem(inode
);
412 inode
->i_mapping
->a_ops
= &befs_symlink_aops
;
414 inode
->i_link
= befs_ino
->i_data
.symlink
;
415 inode
->i_op
= &simple_symlink_inode_operations
;
418 befs_error(sb
, "Inode %lu is not a regular file, "
419 "directory or symlink. THAT IS WRONG! BeFS has no "
420 "on disk special files", inode
->i_ino
);
425 befs_debug(sb
, "<--- %s", __func__
);
426 unlock_new_inode(inode
);
434 befs_debug(sb
, "<--- %s - Bad inode", __func__
);
435 return ERR_PTR(-EIO
);
438 /* Initialize the inode cache. Called at fs setup.
440 * Taken from NFS implementation by Al Viro.
443 befs_init_inodecache(void)
445 befs_inode_cachep
= kmem_cache_create("befs_inode_cache",
446 sizeof (struct befs_inode_info
),
447 0, (SLAB_RECLAIM_ACCOUNT
|
448 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
),
450 if (befs_inode_cachep
== NULL
)
456 /* Called at fs teardown.
458 * Taken from NFS implementation by Al Viro.
461 befs_destroy_inodecache(void)
464 * Make sure all delayed rcu free inodes are flushed before we
468 kmem_cache_destroy(befs_inode_cachep
);
472 * The inode of symbolic link is different to data stream.
473 * The data stream become link name. Unless the LONG_SYMLINK
476 static int befs_symlink_readpage(struct file
*unused
, struct page
*page
)
478 struct inode
*inode
= page
->mapping
->host
;
479 struct super_block
*sb
= inode
->i_sb
;
480 struct befs_inode_info
*befs_ino
= BEFS_I(inode
);
481 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
482 befs_off_t len
= data
->size
;
483 char *link
= page_address(page
);
485 if (len
== 0 || len
> PAGE_SIZE
) {
486 befs_error(sb
, "Long symlink with illegal length");
489 befs_debug(sb
, "Follow long symlink");
491 if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
492 befs_error(sb
, "Failed to read entire long symlink");
495 link
[len
- 1] = '\0';
496 SetPageUptodate(page
);
506 * UTF-8 to NLS charset convert routine
508 * Uses uni2char() / char2uni() rather than the nls tables directly
511 befs_utf2nls(struct super_block
*sb
, const char *in
,
512 int in_len
, char **out
, int *out_len
)
514 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
519 /* The utf8->nls conversion won't make the final nls string bigger
520 * than the utf one, but if the string is pure ascii they'll have the
521 * same width and an extra char is needed to save the additional \0
523 int maxlen
= in_len
+ 1;
525 befs_debug(sb
, "---> %s", __func__
);
528 befs_error(sb
, "%s called with no NLS table loaded", __func__
);
532 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
536 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
538 /* convert from UTF-8 to Unicode */
539 utflen
= utf8_to_utf32(&in
[i
], in_len
- i
, &uni
);
543 /* convert from Unicode to nls */
544 if (uni
> MAX_WCHAR_T
)
546 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
553 befs_debug(sb
, "<--- %s", __func__
);
558 befs_error(sb
, "Name using character set %s contains a character that "
559 "cannot be converted to unicode.", nls
->charset
);
560 befs_debug(sb
, "<--- %s", __func__
);
566 * befs_nls2utf - Convert NLS string to utf8 encodeing
568 * @in: Input string buffer in NLS format
569 * @in_len: Length of input string in bytes
570 * @out: The output string in UTF-8 format
571 * @out_len: Length of the output buffer
573 * Converts input string @in, which is in the format of the loaded NLS map,
574 * into a utf8 string.
576 * The destination string @out is allocated by this function and the caller is
577 * responsible for freeing it with kfree()
579 * On return, *@out_len is the length of @out in bytes.
581 * On success, the return value is the number of utf8 characters written to
582 * the output buffer @out.
584 * On Failure, a negative number coresponding to the error code is returned.
588 befs_nls2utf(struct super_block
*sb
, const char *in
,
589 int in_len
, char **out
, int *out_len
)
591 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
597 * There are nls characters that will translate to 3-chars-wide UTF-8
598 * characters, an additional byte is needed to save the final \0
601 int maxlen
= (3 * in_len
) + 1;
603 befs_debug(sb
, "---> %s\n", __func__
);
606 befs_error(sb
, "%s called with no NLS table loaded.",
611 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
617 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
619 /* convert from nls to unicode */
620 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
624 /* convert from unicode to UTF-8 */
625 utflen
= utf32_to_utf8(uni
, &result
[o
], 3);
633 befs_debug(sb
, "<--- %s", __func__
);
638 befs_error(sb
, "Name using character set %s contains a character that "
639 "cannot be converted to unicode.", nls
->charset
);
640 befs_debug(sb
, "<--- %s", __func__
);
645 static struct inode
*befs_nfs_get_inode(struct super_block
*sb
, uint64_t ino
,
648 /* No need to handle i_generation */
649 return befs_iget(sb
, ino
);
653 * Map a NFS file handle to a corresponding dentry
655 static struct dentry
*befs_fh_to_dentry(struct super_block
*sb
,
656 struct fid
*fid
, int fh_len
, int fh_type
)
658 return generic_fh_to_dentry(sb
, fid
, fh_len
, fh_type
,
663 * Find the parent for a file specified by NFS handle
665 static struct dentry
*befs_fh_to_parent(struct super_block
*sb
,
666 struct fid
*fid
, int fh_len
, int fh_type
)
668 return generic_fh_to_parent(sb
, fid
, fh_len
, fh_type
,
672 static struct dentry
*befs_get_parent(struct dentry
*child
)
674 struct inode
*parent
;
675 struct befs_inode_info
*befs_ino
= BEFS_I(d_inode(child
));
677 parent
= befs_iget(child
->d_sb
,
678 (unsigned long)befs_ino
->i_parent
.start
);
680 return ERR_CAST(parent
);
682 return d_obtain_alias(parent
);
686 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
, Opt_err
,
689 static const match_table_t befs_tokens
= {
692 {Opt_charset
, "iocharset=%s"},
693 {Opt_debug
, "debug"},
698 parse_options(char *options
, struct befs_mount_options
*opts
)
701 substring_t args
[MAX_OPT_ARGS
];
706 /* Initialize options */
707 opts
->uid
= GLOBAL_ROOT_UID
;
708 opts
->gid
= GLOBAL_ROOT_GID
;
711 opts
->iocharset
= NULL
;
717 while ((p
= strsep(&options
, ",")) != NULL
) {
723 token
= match_token(p
, befs_tokens
, args
);
726 if (match_int(&args
[0], &option
))
730 uid
= make_kuid(current_user_ns(), option
);
731 if (!uid_valid(uid
)) {
732 pr_err("Invalid uid %d, "
733 "using default\n", option
);
740 if (match_int(&args
[0], &option
))
744 gid
= make_kgid(current_user_ns(), option
);
745 if (!gid_valid(gid
)) {
746 pr_err("Invalid gid %d, "
747 "using default\n", option
);
754 kfree(opts
->iocharset
);
755 opts
->iocharset
= match_strdup(&args
[0]);
756 if (!opts
->iocharset
) {
757 pr_err("allocation failure for "
758 "iocharset string\n");
766 pr_err("Unrecognized mount option \"%s\" "
767 "or missing value\n", p
);
774 /* This function has the responsibiltiy of getting the
775 * filesystem ready for unmounting.
776 * Basically, we free everything that we allocated in
780 befs_put_super(struct super_block
*sb
)
782 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
783 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
784 unload_nls(BEFS_SB(sb
)->nls
);
785 kfree(sb
->s_fs_info
);
786 sb
->s_fs_info
= NULL
;
789 /* Allocate private field of the superblock, fill it.
791 * Finish filling the public superblock fields
792 * Make the root directory
793 * Load a set of NLS translations if needed.
796 befs_fill_super(struct super_block
*sb
, void *data
, int silent
)
798 struct buffer_head
*bh
;
799 struct befs_sb_info
*befs_sb
;
800 befs_super_block
*disk_sb
;
803 const unsigned long sb_block
= 0;
804 const off_t x86_sb_off
= 512;
807 save_mount_options(sb
, data
);
809 sb
->s_fs_info
= kzalloc(sizeof(*befs_sb
), GFP_KERNEL
);
810 if (sb
->s_fs_info
== NULL
)
813 befs_sb
= BEFS_SB(sb
);
815 if (!parse_options((char *) data
, &befs_sb
->mount_opts
)) {
817 befs_error(sb
, "cannot parse mount options");
818 goto unacquire_priv_sbp
;
821 befs_debug(sb
, "---> %s", __func__
);
823 if (!(sb
->s_flags
& MS_RDONLY
)) {
825 "No write support. Marking filesystem read-only");
826 sb
->s_flags
|= MS_RDONLY
;
830 * Set dummy blocksize to read super block.
831 * Will be set to real fs blocksize later.
833 * Linux 2.4.10 and later refuse to read blocks smaller than
834 * the logical block size for the device. But we also need to read at
835 * least 1k to get the second 512 bytes of the volume.
837 blocksize
= sb_min_blocksize(sb
, 1024);
840 befs_error(sb
, "unable to set blocksize");
841 goto unacquire_priv_sbp
;
844 bh
= sb_bread(sb
, sb_block
);
847 befs_error(sb
, "unable to read superblock");
848 goto unacquire_priv_sbp
;
851 /* account for offset of super block on x86 */
852 disk_sb
= (befs_super_block
*) bh
->b_data
;
853 if ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
854 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
855 befs_debug(sb
, "Using PPC superblock location");
857 befs_debug(sb
, "Using x86 superblock location");
859 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
862 if ((befs_load_sb(sb
, disk_sb
) != BEFS_OK
) ||
863 (befs_check_sb(sb
) != BEFS_OK
))
866 befs_dump_super_block(sb
, disk_sb
);
870 if (befs_sb
->num_blocks
> ~((sector_t
)0)) {
872 befs_error(sb
, "blocks count: %llu is larger than the host can use",
873 befs_sb
->num_blocks
);
874 goto unacquire_priv_sbp
;
878 * set up enough so that it can read an inode
879 * Fill in kernel superblock fields from private sb
881 sb
->s_magic
= BEFS_SUPER_MAGIC
;
882 /* Set real blocksize of fs */
883 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
884 sb
->s_op
= &befs_sops
;
885 sb
->s_export_op
= &befs_export_operations
;
886 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
889 goto unacquire_priv_sbp
;
891 sb
->s_root
= d_make_root(root
);
894 befs_error(sb
, "get root inode failed");
895 goto unacquire_priv_sbp
;
898 /* load nls library */
899 if (befs_sb
->mount_opts
.iocharset
) {
900 befs_debug(sb
, "Loading nls: %s",
901 befs_sb
->mount_opts
.iocharset
);
902 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
904 befs_warning(sb
, "Cannot load nls %s"
905 " loading default nls",
906 befs_sb
->mount_opts
.iocharset
);
907 befs_sb
->nls
= load_nls_default();
909 /* load default nls if none is specified in mount options */
911 befs_debug(sb
, "Loading default nls");
912 befs_sb
->nls
= load_nls_default();
921 kfree(befs_sb
->mount_opts
.iocharset
);
922 kfree(sb
->s_fs_info
);
923 sb
->s_fs_info
= NULL
;
930 befs_remount(struct super_block
*sb
, int *flags
, char *data
)
933 if (!(*flags
& MS_RDONLY
))
939 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
941 struct super_block
*sb
= dentry
->d_sb
;
942 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
944 befs_debug(sb
, "---> %s", __func__
);
946 buf
->f_type
= BEFS_SUPER_MAGIC
;
947 buf
->f_bsize
= sb
->s_blocksize
;
948 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
949 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
950 buf
->f_bavail
= buf
->f_bfree
;
951 buf
->f_files
= 0; /* UNKNOWN */
952 buf
->f_ffree
= 0; /* UNKNOWN */
953 buf
->f_fsid
.val
[0] = (u32
)id
;
954 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
955 buf
->f_namelen
= BEFS_NAME_LEN
;
957 befs_debug(sb
, "<--- %s", __func__
);
962 static struct dentry
*
963 befs_mount(struct file_system_type
*fs_type
, int flags
, const char *dev_name
,
966 return mount_bdev(fs_type
, flags
, dev_name
, data
, befs_fill_super
);
969 static struct file_system_type befs_fs_type
= {
970 .owner
= THIS_MODULE
,
973 .kill_sb
= kill_block_super
,
974 .fs_flags
= FS_REQUIRES_DEV
,
976 MODULE_ALIAS_FS("befs");
983 pr_info("version: %s\n", BEFS_VERSION
);
985 err
= befs_init_inodecache();
989 err
= register_filesystem(&befs_fs_type
);
991 goto unacquire_inodecache
;
995 unacquire_inodecache
:
996 befs_destroy_inodecache();
1005 befs_destroy_inodecache();
1007 unregister_filesystem(&befs_fs_type
);
1011 * Macros that typecheck the init and exit functions,
1012 * ensures that they are called at init and cleanup,
1013 * and eliminates warnings about unused functions.
1015 module_init(init_befs_fs
)
1016 module_exit(exit_befs_fs
)