1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/fs/befs/linuxvfs.c
5 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/module.h>
12 #include <linux/slab.h>
14 #include <linux/fs_context.h>
15 #include <linux/fs_parser.h>
16 #include <linux/errno.h>
17 #include <linux/stat.h>
18 #include <linux/nls.h>
19 #include <linux/buffer_head.h>
20 #include <linux/vfs.h>
21 #include <linux/namei.h>
22 #include <linux/sched.h>
23 #include <linux/cred.h>
24 #include <linux/exportfs.h>
25 #include <linux/seq_file.h>
26 #include <linux/blkdev.h>
31 #include "datastream.h"
35 MODULE_DESCRIPTION("BeOS File System (BeFS) driver");
36 MODULE_AUTHOR("Will Dyson");
37 MODULE_LICENSE("GPL");
39 /* The units the vfs expects inode->i_blocks to be in */
40 #define VFS_BLOCK_SIZE 512
42 static int befs_readdir(struct file
*, struct dir_context
*);
43 static int befs_get_block(struct inode
*, sector_t
, struct buffer_head
*, int);
44 static int befs_read_folio(struct file
*file
, struct folio
*folio
);
45 static sector_t
befs_bmap(struct address_space
*mapping
, sector_t block
);
46 static struct dentry
*befs_lookup(struct inode
*, struct dentry
*,
48 static struct inode
*befs_iget(struct super_block
*, unsigned long);
49 static struct inode
*befs_alloc_inode(struct super_block
*sb
);
50 static void befs_free_inode(struct inode
*inode
);
51 static void befs_destroy_inodecache(void);
52 static int befs_symlink_read_folio(struct file
*, struct folio
*);
53 static int befs_utf2nls(struct super_block
*sb
, const char *in
, int in_len
,
54 char **out
, int *out_len
);
55 static int befs_nls2utf(struct super_block
*sb
, const char *in
, int in_len
,
56 char **out
, int *out_len
);
57 static void befs_put_super(struct super_block
*);
58 static int befs_statfs(struct dentry
*, struct kstatfs
*);
59 static int befs_show_options(struct seq_file
*, struct dentry
*);
60 static struct dentry
*befs_fh_to_dentry(struct super_block
*sb
,
61 struct fid
*fid
, int fh_len
, int fh_type
);
62 static struct dentry
*befs_fh_to_parent(struct super_block
*sb
,
63 struct fid
*fid
, int fh_len
, int fh_type
);
64 static struct dentry
*befs_get_parent(struct dentry
*child
);
65 static void befs_free_fc(struct fs_context
*fc
);
67 static const struct super_operations befs_sops
= {
68 .alloc_inode
= befs_alloc_inode
, /* allocate a new inode */
69 .free_inode
= befs_free_inode
, /* deallocate an inode */
70 .put_super
= befs_put_super
, /* uninit super */
71 .statfs
= befs_statfs
, /* statfs */
72 .show_options
= befs_show_options
,
75 /* slab cache for befs_inode_info objects */
76 static struct kmem_cache
*befs_inode_cachep
;
78 static const struct file_operations befs_dir_operations
= {
79 .read
= generic_read_dir
,
80 .iterate_shared
= befs_readdir
,
81 .llseek
= generic_file_llseek
,
84 static const struct inode_operations befs_dir_inode_operations
= {
85 .lookup
= befs_lookup
,
88 static const struct address_space_operations befs_aops
= {
89 .read_folio
= befs_read_folio
,
93 static const struct address_space_operations befs_symlink_aops
= {
94 .read_folio
= befs_symlink_read_folio
,
97 static const struct export_operations befs_export_operations
= {
98 .encode_fh
= generic_encode_ino32_fh
,
99 .fh_to_dentry
= befs_fh_to_dentry
,
100 .fh_to_parent
= befs_fh_to_parent
,
101 .get_parent
= befs_get_parent
,
105 * Called by generic_file_read() to read a folio of data
107 * In turn, simply calls a generic block read function and
108 * passes it the address of befs_get_block, for mapping file
109 * positions to disk blocks.
111 static int befs_read_folio(struct file
*file
, struct folio
*folio
)
113 return block_read_full_folio(folio
, befs_get_block
);
117 befs_bmap(struct address_space
*mapping
, sector_t block
)
119 return generic_block_bmap(mapping
, block
, befs_get_block
);
123 * Generic function to map a file position (block) to a
124 * disk offset (passed back in bh_result).
126 * Used by many higher level functions.
128 * Calls befs_fblock2brun() in datastream.c to do the real work.
132 befs_get_block(struct inode
*inode
, sector_t block
,
133 struct buffer_head
*bh_result
, int create
)
135 struct super_block
*sb
= inode
->i_sb
;
136 befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
137 befs_block_run run
= BAD_IADDR
;
141 befs_debug(sb
, "---> befs_get_block() for inode %lu, block %ld",
142 (unsigned long)inode
->i_ino
, (long)block
);
144 befs_error(sb
, "befs_get_block() was asked to write to "
145 "block %ld in inode %lu", (long)block
,
146 (unsigned long)inode
->i_ino
);
150 res
= befs_fblock2brun(sb
, ds
, block
, &run
);
151 if (res
!= BEFS_OK
) {
153 "<--- %s for inode %lu, block %ld ERROR",
154 __func__
, (unsigned long)inode
->i_ino
,
159 disk_off
= (ulong
) iaddr2blockno(sb
, &run
);
161 map_bh(bh_result
, inode
->i_sb
, disk_off
);
163 befs_debug(sb
, "<--- %s for inode %lu, block %ld, disk address %lu",
164 __func__
, (unsigned long)inode
->i_ino
, (long)block
,
165 (unsigned long)disk_off
);
170 static struct dentry
*
171 befs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
174 struct super_block
*sb
= dir
->i_sb
;
175 const befs_data_stream
*ds
= &BEFS_I(dir
)->i_data
.ds
;
180 const char *name
= dentry
->d_name
.name
;
182 befs_debug(sb
, "---> %s name %pd inode %ld", __func__
,
185 /* Convert to UTF-8 */
186 if (BEFS_SB(sb
)->nls
) {
188 befs_nls2utf(sb
, name
, strlen(name
), &utfname
, &utfnamelen
);
190 befs_debug(sb
, "<--- %s ERROR", __func__
);
193 ret
= befs_btree_find(sb
, ds
, utfname
, &offset
);
197 ret
= befs_btree_find(sb
, ds
, name
, &offset
);
200 if (ret
== BEFS_BT_NOT_FOUND
) {
201 befs_debug(sb
, "<--- %s %pd not found", __func__
, dentry
);
203 } else if (ret
!= BEFS_OK
|| offset
== 0) {
204 befs_error(sb
, "<--- %s Error", __func__
);
205 inode
= ERR_PTR(-ENODATA
);
207 inode
= befs_iget(dir
->i_sb
, (ino_t
) offset
);
209 befs_debug(sb
, "<--- %s", __func__
);
211 return d_splice_alias(inode
, dentry
);
215 befs_readdir(struct file
*file
, struct dir_context
*ctx
)
217 struct inode
*inode
= file_inode(file
);
218 struct super_block
*sb
= inode
->i_sb
;
219 const befs_data_stream
*ds
= &BEFS_I(inode
)->i_data
.ds
;
223 char keybuf
[BEFS_NAME_LEN
+ 1];
225 befs_debug(sb
, "---> %s name %pD, inode %ld, ctx->pos %lld",
226 __func__
, file
, inode
->i_ino
, ctx
->pos
);
229 result
= befs_btree_read(sb
, ds
, ctx
->pos
, BEFS_NAME_LEN
+ 1,
230 keybuf
, &keysize
, &value
);
232 if (result
== BEFS_ERR
) {
233 befs_debug(sb
, "<--- %s ERROR", __func__
);
234 befs_error(sb
, "IO error reading %pD (inode %lu)",
238 } else if (result
== BEFS_BT_END
) {
239 befs_debug(sb
, "<--- %s END", __func__
);
242 } else if (result
== BEFS_BT_EMPTY
) {
243 befs_debug(sb
, "<--- %s Empty directory", __func__
);
248 if (BEFS_SB(sb
)->nls
) {
253 befs_utf2nls(sb
, keybuf
, keysize
, &nlsname
,
256 befs_debug(sb
, "<--- %s ERROR", __func__
);
259 if (!dir_emit(ctx
, nlsname
, nlsnamelen
,
260 (ino_t
) value
, DT_UNKNOWN
)) {
266 if (!dir_emit(ctx
, keybuf
, keysize
,
267 (ino_t
) value
, DT_UNKNOWN
))
274 static struct inode
*
275 befs_alloc_inode(struct super_block
*sb
)
277 struct befs_inode_info
*bi
;
279 bi
= alloc_inode_sb(sb
, befs_inode_cachep
, GFP_KERNEL
);
282 return &bi
->vfs_inode
;
285 static void befs_free_inode(struct inode
*inode
)
287 kmem_cache_free(befs_inode_cachep
, BEFS_I(inode
));
290 static void init_once(void *foo
)
292 struct befs_inode_info
*bi
= (struct befs_inode_info
*) foo
;
294 inode_init_once(&bi
->vfs_inode
);
297 static struct inode
*befs_iget(struct super_block
*sb
, unsigned long ino
)
299 struct buffer_head
*bh
;
300 befs_inode
*raw_inode
;
301 struct befs_sb_info
*befs_sb
= BEFS_SB(sb
);
302 struct befs_inode_info
*befs_ino
;
305 befs_debug(sb
, "---> %s inode = %lu", __func__
, ino
);
307 inode
= iget_locked(sb
, ino
);
309 return ERR_PTR(-ENOMEM
);
310 if (!(inode
->i_state
& I_NEW
))
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
= sb_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
:
347 make_kuid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->uid
));
348 inode
->i_gid
= befs_sb
->mount_opts
.use_gid
?
349 befs_sb
->mount_opts
.gid
:
350 make_kgid(&init_user_ns
, fs32_to_cpu(sb
, raw_inode
->gid
));
355 * BEFS's time is 64 bits, but current VFS is 32 bits...
356 * BEFS don't have access time. Nor inode change time. VFS
357 * doesn't have creation time.
358 * Also, the lower 16 bits of the last_modified_time and
359 * create_time are just a counter to help ensure uniqueness
360 * for indexing purposes. (PFD, page 54)
363 inode_set_mtime(inode
,
364 fs64_to_cpu(sb
, raw_inode
->last_modified_time
) >> 16,
365 0);/* lower 16 bits are not a time */
366 inode_set_ctime_to_ts(inode
, inode_get_mtime(inode
));
367 inode_set_atime_to_ts(inode
, inode_get_mtime(inode
));
369 befs_ino
->i_inode_num
= fsrun_to_cpu(sb
, raw_inode
->inode_num
);
370 befs_ino
->i_parent
= fsrun_to_cpu(sb
, raw_inode
->parent
);
371 befs_ino
->i_attribute
= fsrun_to_cpu(sb
, raw_inode
->attributes
);
372 befs_ino
->i_flags
= fs32_to_cpu(sb
, raw_inode
->flags
);
374 if (S_ISLNK(inode
->i_mode
) && !(befs_ino
->i_flags
& BEFS_LONG_SYMLINK
)){
376 inode
->i_blocks
= befs_sb
->block_size
/ VFS_BLOCK_SIZE
;
377 strscpy(befs_ino
->i_data
.symlink
, raw_inode
->data
.symlink
,
382 befs_ino
->i_data
.ds
=
383 fsds_to_cpu(sb
, &raw_inode
->data
.datastream
);
385 num_blks
= befs_count_blocks(sb
, &befs_ino
->i_data
.ds
);
387 num_blks
* (befs_sb
->block_size
/ VFS_BLOCK_SIZE
);
388 inode
->i_size
= befs_ino
->i_data
.ds
.size
;
391 inode
->i_mapping
->a_ops
= &befs_aops
;
393 if (S_ISREG(inode
->i_mode
)) {
394 inode
->i_fop
= &generic_ro_fops
;
395 } else if (S_ISDIR(inode
->i_mode
)) {
396 inode
->i_op
= &befs_dir_inode_operations
;
397 inode
->i_fop
= &befs_dir_operations
;
398 } else if (S_ISLNK(inode
->i_mode
)) {
399 if (befs_ino
->i_flags
& BEFS_LONG_SYMLINK
) {
400 inode
->i_op
= &page_symlink_inode_operations
;
401 inode_nohighmem(inode
);
402 inode
->i_mapping
->a_ops
= &befs_symlink_aops
;
404 inode
->i_link
= befs_ino
->i_data
.symlink
;
405 inode
->i_op
= &simple_symlink_inode_operations
;
408 befs_error(sb
, "Inode %lu is not a regular file, "
409 "directory or symlink. THAT IS WRONG! BeFS has no "
410 "on disk special files", inode
->i_ino
);
415 befs_debug(sb
, "<--- %s", __func__
);
416 unlock_new_inode(inode
);
424 befs_debug(sb
, "<--- %s - Bad inode", __func__
);
425 return ERR_PTR(-EIO
);
428 /* Initialize the inode cache. Called at fs setup.
430 * Taken from NFS implementation by Al Viro.
433 befs_init_inodecache(void)
435 befs_inode_cachep
= kmem_cache_create_usercopy("befs_inode_cache",
436 sizeof(struct befs_inode_info
), 0,
437 SLAB_RECLAIM_ACCOUNT
| SLAB_ACCOUNT
,
438 offsetof(struct befs_inode_info
,
440 sizeof_field(struct befs_inode_info
,
443 if (befs_inode_cachep
== NULL
)
449 /* Called at fs teardown.
451 * Taken from NFS implementation by Al Viro.
454 befs_destroy_inodecache(void)
457 * Make sure all delayed rcu free inodes are flushed before we
461 kmem_cache_destroy(befs_inode_cachep
);
465 * The inode of symbolic link is different to data stream.
466 * The data stream become link name. Unless the LONG_SYMLINK
469 static int befs_symlink_read_folio(struct file
*unused
, struct folio
*folio
)
471 struct inode
*inode
= folio
->mapping
->host
;
472 struct super_block
*sb
= inode
->i_sb
;
473 struct befs_inode_info
*befs_ino
= BEFS_I(inode
);
474 befs_data_stream
*data
= &befs_ino
->i_data
.ds
;
475 befs_off_t len
= data
->size
;
476 char *link
= folio_address(folio
);
479 if (len
== 0 || len
> PAGE_SIZE
) {
480 befs_error(sb
, "Long symlink with illegal length");
483 befs_debug(sb
, "Follow long symlink");
485 if (befs_read_lsymlink(sb
, data
, link
, len
) != len
) {
486 befs_error(sb
, "Failed to read entire long symlink");
489 link
[len
- 1] = '\0';
492 folio_end_read(folio
, err
== 0);
497 * UTF-8 to NLS charset convert routine
499 * Uses uni2char() / char2uni() rather than 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
, "---> %s", __func__
);
519 befs_error(sb
, "%s called with no NLS table loaded", __func__
);
523 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
527 for (i
= o
= 0; i
< in_len
; i
+= utflen
, o
+= unilen
) {
529 /* convert from UTF-8 to Unicode */
530 utflen
= utf8_to_utf32(&in
[i
], in_len
- i
, &uni
);
534 /* convert from Unicode to nls */
535 if (uni
> MAX_WCHAR_T
)
537 unilen
= nls
->uni2char(uni
, &result
[o
], in_len
- o
);
544 befs_debug(sb
, "<--- %s", __func__
);
549 befs_error(sb
, "Name using character set %s contains a character that "
550 "cannot be converted to unicode.", nls
->charset
);
551 befs_debug(sb
, "<--- %s", __func__
);
557 * befs_nls2utf - Convert NLS string to utf8 encodeing
559 * @in: Input string buffer in NLS format
560 * @in_len: Length of input string in bytes
561 * @out: The output string in UTF-8 format
562 * @out_len: Length of the output buffer
564 * Converts input string @in, which is in the format of the loaded NLS map,
565 * into a utf8 string.
567 * The destination string @out is allocated by this function and the caller is
568 * responsible for freeing it with kfree()
570 * On return, *@out_len is the length of @out in bytes.
572 * On success, the return value is the number of utf8 characters written to
573 * the output buffer @out.
575 * On Failure, a negative number coresponding to the error code is returned.
579 befs_nls2utf(struct super_block
*sb
, const char *in
,
580 int in_len
, char **out
, int *out_len
)
582 struct nls_table
*nls
= BEFS_SB(sb
)->nls
;
588 * There are nls characters that will translate to 3-chars-wide UTF-8
589 * characters, an additional byte is needed to save the final \0
592 int maxlen
= (3 * in_len
) + 1;
594 befs_debug(sb
, "---> %s\n", __func__
);
597 befs_error(sb
, "%s called with no NLS table loaded.",
602 *out
= result
= kmalloc(maxlen
, GFP_NOFS
);
608 for (i
= o
= 0; i
< in_len
; i
+= unilen
, o
+= utflen
) {
610 /* convert from nls to unicode */
611 unilen
= nls
->char2uni(&in
[i
], in_len
- i
, &uni
);
615 /* convert from unicode to UTF-8 */
616 utflen
= utf32_to_utf8(uni
, &result
[o
], 3);
624 befs_debug(sb
, "<--- %s", __func__
);
629 befs_error(sb
, "Name using character set %s contains a character that "
630 "cannot be converted to unicode.", nls
->charset
);
631 befs_debug(sb
, "<--- %s", __func__
);
636 static struct inode
*befs_nfs_get_inode(struct super_block
*sb
, uint64_t ino
,
639 /* No need to handle i_generation */
640 return befs_iget(sb
, ino
);
644 * Map a NFS file handle to a corresponding dentry
646 static struct dentry
*befs_fh_to_dentry(struct super_block
*sb
,
647 struct fid
*fid
, int fh_len
, int fh_type
)
649 return generic_fh_to_dentry(sb
, fid
, fh_len
, fh_type
,
654 * Find the parent for a file specified by NFS handle
656 static struct dentry
*befs_fh_to_parent(struct super_block
*sb
,
657 struct fid
*fid
, int fh_len
, int fh_type
)
659 return generic_fh_to_parent(sb
, fid
, fh_len
, fh_type
,
663 static struct dentry
*befs_get_parent(struct dentry
*child
)
665 struct inode
*parent
;
666 struct befs_inode_info
*befs_ino
= BEFS_I(d_inode(child
));
668 parent
= befs_iget(child
->d_sb
,
669 (unsigned long)befs_ino
->i_parent
.start
);
670 return d_obtain_alias(parent
);
674 Opt_uid
, Opt_gid
, Opt_charset
, Opt_debug
,
677 static const struct fs_parameter_spec befs_param_spec
[] = {
678 fsparam_uid ("uid", Opt_uid
),
679 fsparam_gid ("gid", Opt_gid
),
680 fsparam_string ("iocharset", Opt_charset
),
681 fsparam_flag ("debug", Opt_debug
),
686 befs_parse_param(struct fs_context
*fc
, struct fs_parameter
*param
)
688 struct befs_mount_options
*opts
= fc
->fs_private
;
690 struct fs_parse_result result
;
692 /* befs ignores all options on remount */
693 if (fc
->purpose
== FS_CONTEXT_FOR_RECONFIGURE
)
696 token
= fs_parse(fc
, befs_param_spec
, param
, &result
);
702 opts
->uid
= result
.uid
;
706 opts
->gid
= result
.gid
;
710 kfree(opts
->iocharset
);
711 opts
->iocharset
= param
->string
;
712 param
->string
= NULL
;
723 static int befs_show_options(struct seq_file
*m
, struct dentry
*root
)
725 struct befs_sb_info
*befs_sb
= BEFS_SB(root
->d_sb
);
726 struct befs_mount_options
*opts
= &befs_sb
->mount_opts
;
728 if (!uid_eq(opts
->uid
, GLOBAL_ROOT_UID
))
729 seq_printf(m
, ",uid=%u",
730 from_kuid_munged(&init_user_ns
, opts
->uid
));
731 if (!gid_eq(opts
->gid
, GLOBAL_ROOT_GID
))
732 seq_printf(m
, ",gid=%u",
733 from_kgid_munged(&init_user_ns
, opts
->gid
));
735 seq_printf(m
, ",charset=%s", opts
->iocharset
);
737 seq_puts(m
, ",debug");
741 /* This function has the responsibiltiy of getting the
742 * filesystem ready for unmounting.
743 * Basically, we free everything that we allocated in
747 befs_put_super(struct super_block
*sb
)
749 kfree(BEFS_SB(sb
)->mount_opts
.iocharset
);
750 BEFS_SB(sb
)->mount_opts
.iocharset
= NULL
;
751 unload_nls(BEFS_SB(sb
)->nls
);
752 kfree(sb
->s_fs_info
);
753 sb
->s_fs_info
= NULL
;
757 * Copy the parsed options into the sbi mount_options member
760 befs_set_options(struct befs_sb_info
*sbi
, struct befs_mount_options
*opts
)
762 sbi
->mount_opts
.uid
= opts
->uid
;
763 sbi
->mount_opts
.gid
= opts
->gid
;
764 sbi
->mount_opts
.use_uid
= opts
->use_uid
;
765 sbi
->mount_opts
.use_gid
= opts
->use_gid
;
766 sbi
->mount_opts
.debug
= opts
->debug
;
767 sbi
->mount_opts
.iocharset
= opts
->iocharset
;
768 opts
->iocharset
= NULL
;
771 /* Allocate private field of the superblock, fill it.
773 * Finish filling the public superblock fields
774 * Make the root directory
775 * Load a set of NLS translations if needed.
778 befs_fill_super(struct super_block
*sb
, struct fs_context
*fc
)
780 struct buffer_head
*bh
;
781 struct befs_sb_info
*befs_sb
;
782 befs_super_block
*disk_sb
;
785 const unsigned long sb_block
= 0;
786 const off_t x86_sb_off
= 512;
788 struct befs_mount_options
*parsed_opts
= fc
->fs_private
;
789 int silent
= fc
->sb_flags
& SB_SILENT
;
791 sb
->s_fs_info
= kzalloc(sizeof(*befs_sb
), GFP_KERNEL
);
792 if (sb
->s_fs_info
== NULL
)
795 befs_sb
= BEFS_SB(sb
);
797 befs_set_options(befs_sb
, parsed_opts
);
799 befs_debug(sb
, "---> %s", __func__
);
801 if (!sb_rdonly(sb
)) {
803 "No write support. Marking filesystem read-only");
804 sb
->s_flags
|= SB_RDONLY
;
808 * Set dummy blocksize to read super block.
809 * Will be set to real fs blocksize later.
811 * Linux 2.4.10 and later refuse to read blocks smaller than
812 * the logical block size for the device. But we also need to read at
813 * least 1k to get the second 512 bytes of the volume.
815 blocksize
= sb_min_blocksize(sb
, 1024);
818 befs_error(sb
, "unable to set blocksize");
819 goto unacquire_priv_sbp
;
822 bh
= sb_bread(sb
, sb_block
);
825 befs_error(sb
, "unable to read superblock");
826 goto unacquire_priv_sbp
;
829 /* account for offset of super block on x86 */
830 disk_sb
= (befs_super_block
*) bh
->b_data
;
831 if ((disk_sb
->magic1
== BEFS_SUPER_MAGIC1_LE
) ||
832 (disk_sb
->magic1
== BEFS_SUPER_MAGIC1_BE
)) {
833 befs_debug(sb
, "Using PPC superblock location");
835 befs_debug(sb
, "Using x86 superblock location");
837 (befs_super_block
*) ((void *) bh
->b_data
+ x86_sb_off
);
840 if ((befs_load_sb(sb
, disk_sb
) != BEFS_OK
) ||
841 (befs_check_sb(sb
) != BEFS_OK
))
844 befs_dump_super_block(sb
, disk_sb
);
848 if (befs_sb
->num_blocks
> ~((sector_t
)0)) {
850 befs_error(sb
, "blocks count: %llu is larger than the host can use",
851 befs_sb
->num_blocks
);
852 goto unacquire_priv_sbp
;
856 * set up enough so that it can read an inode
857 * Fill in kernel superblock fields from private sb
859 sb
->s_magic
= BEFS_SUPER_MAGIC
;
860 /* Set real blocksize of fs */
861 sb_set_blocksize(sb
, (ulong
) befs_sb
->block_size
);
862 sb
->s_op
= &befs_sops
;
863 sb
->s_export_op
= &befs_export_operations
;
865 sb
->s_time_max
= 0xffffffffffffll
;
866 root
= befs_iget(sb
, iaddr2blockno(sb
, &(befs_sb
->root_dir
)));
869 goto unacquire_priv_sbp
;
871 sb
->s_root
= d_make_root(root
);
874 befs_error(sb
, "get root inode failed");
875 goto unacquire_priv_sbp
;
878 /* load nls library */
879 if (befs_sb
->mount_opts
.iocharset
) {
880 befs_debug(sb
, "Loading nls: %s",
881 befs_sb
->mount_opts
.iocharset
);
882 befs_sb
->nls
= load_nls(befs_sb
->mount_opts
.iocharset
);
884 befs_warning(sb
, "Cannot load nls %s"
885 " loading default nls",
886 befs_sb
->mount_opts
.iocharset
);
887 befs_sb
->nls
= load_nls_default();
889 /* load default nls if none is specified in mount options */
891 befs_debug(sb
, "Loading default nls");
892 befs_sb
->nls
= load_nls_default();
901 kfree(befs_sb
->mount_opts
.iocharset
);
902 kfree(sb
->s_fs_info
);
903 sb
->s_fs_info
= NULL
;
910 befs_reconfigure(struct fs_context
*fc
)
912 sync_filesystem(fc
->root
->d_sb
);
913 if (!(fc
->sb_flags
& SB_RDONLY
))
919 befs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
921 struct super_block
*sb
= dentry
->d_sb
;
922 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
924 befs_debug(sb
, "---> %s", __func__
);
926 buf
->f_type
= BEFS_SUPER_MAGIC
;
927 buf
->f_bsize
= sb
->s_blocksize
;
928 buf
->f_blocks
= BEFS_SB(sb
)->num_blocks
;
929 buf
->f_bfree
= BEFS_SB(sb
)->num_blocks
- BEFS_SB(sb
)->used_blocks
;
930 buf
->f_bavail
= buf
->f_bfree
;
931 buf
->f_files
= 0; /* UNKNOWN */
932 buf
->f_ffree
= 0; /* UNKNOWN */
933 buf
->f_fsid
= u64_to_fsid(id
);
934 buf
->f_namelen
= BEFS_NAME_LEN
;
936 befs_debug(sb
, "<--- %s", __func__
);
941 static int befs_get_tree(struct fs_context
*fc
)
943 return get_tree_bdev(fc
, befs_fill_super
);
946 static const struct fs_context_operations befs_context_ops
= {
947 .parse_param
= befs_parse_param
,
948 .get_tree
= befs_get_tree
,
949 .reconfigure
= befs_reconfigure
,
950 .free
= befs_free_fc
,
953 static int befs_init_fs_context(struct fs_context
*fc
)
955 struct befs_mount_options
*opts
;
957 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
961 /* Initialize options */
962 opts
->uid
= GLOBAL_ROOT_UID
;
963 opts
->gid
= GLOBAL_ROOT_GID
;
965 fc
->fs_private
= opts
;
966 fc
->ops
= &befs_context_ops
;
971 static void befs_free_fc(struct fs_context
*fc
)
973 struct befs_mount_options
*opts
= fc
->fs_private
;
975 kfree(opts
->iocharset
);
976 kfree(fc
->fs_private
);
979 static struct file_system_type befs_fs_type
= {
980 .owner
= THIS_MODULE
,
982 .kill_sb
= kill_block_super
,
983 .fs_flags
= FS_REQUIRES_DEV
,
984 .init_fs_context
= befs_init_fs_context
,
985 .parameters
= befs_param_spec
,
987 MODULE_ALIAS_FS("befs");
994 pr_info("version: %s\n", BEFS_VERSION
);
996 err
= befs_init_inodecache();
1000 err
= register_filesystem(&befs_fs_type
);
1002 goto unacquire_inodecache
;
1006 unacquire_inodecache
:
1007 befs_destroy_inodecache();
1016 befs_destroy_inodecache();
1018 unregister_filesystem(&befs_fs_type
);
1022 * Macros that typecheck the init and exit functions,
1023 * ensures that they are called at init and cleanup,
1024 * and eliminates warnings about unused functions.
1026 module_init(init_befs_fs
)
1027 module_exit(exit_befs_fs
)