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);
62 static const struct super_operations befs_sops = {
63 .alloc_inode = befs_alloc_inode, /* allocate a new inode */
64 .destroy_inode = befs_destroy_inode, /* deallocate an inode */
65 .put_super = befs_put_super, /* uninit super */
66 .statfs = befs_statfs, /* statfs */
67 .remount_fs = befs_remount,
68 .show_options = generic_show_options,
71 /* slab cache for befs_inode_info objects */
72 static struct kmem_cache *befs_inode_cachep;
74 static const struct file_operations befs_dir_operations = {
75 .read = generic_read_dir,
76 .iterate_shared = befs_readdir,
77 .llseek = generic_file_llseek,
80 static const struct inode_operations befs_dir_inode_operations = {
81 .lookup = befs_lookup,
84 static const struct address_space_operations befs_aops = {
85 .readpage = befs_readpage,
89 static const struct address_space_operations befs_symlink_aops = {
90 .readpage = befs_symlink_readpage,
93 static const struct export_operations befs_export_operations = {
94 .fh_to_dentry = befs_fh_to_dentry,
95 .fh_to_parent = befs_fh_to_parent,
99 * Called by generic_file_read() to read a page of data
101 * In turn, simply calls a generic block read function and
102 * passes it the address of befs_get_block, for mapping file
103 * positions to disk blocks.
106 befs_readpage(struct file *file, struct page *page)
108 return block_read_full_page(page, befs_get_block);
112 befs_bmap(struct address_space *mapping, sector_t block)
114 return generic_block_bmap(mapping, block, befs_get_block);
118 * Generic function to map a file position (block) to a
119 * disk offset (passed back in bh_result).
121 * Used by many higher level functions.
123 * Calls befs_fblock2brun() in datastream.c to do the real work.
127 befs_get_block(struct inode *inode, sector_t block,
128 struct buffer_head *bh_result, int create)
130 struct super_block *sb = inode->i_sb;
131 befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;
132 befs_block_run run = BAD_IADDR;
136 befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",
137 (unsigned long)inode->i_ino, (long)block);
139 befs_error(sb, "befs_get_block() was asked to write to "
140 "block %ld in inode %lu", (long)block,
141 (unsigned long)inode->i_ino);
145 res = befs_fblock2brun(sb, ds, block, &run);
146 if (res != BEFS_OK) {
148 "<--- %s for inode %lu, block %ld ERROR",
149 __func__, (unsigned long)inode->i_ino,
154 disk_off = (ulong) iaddr2blockno(sb, &run);
156 map_bh(bh_result, inode->i_sb, disk_off);
158 befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu",
159 __func__, (unsigned long)inode->i_ino, (long)block,
160 (unsigned long)disk_off);
165 static struct dentry *
166 befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
169 struct super_block *sb = dir->i_sb;
170 const befs_data_stream *ds = &BEFS_I(dir)->i_data.ds;
175 const char *name = dentry->d_name.name;
177 befs_debug(sb, "---> %s name %pd inode %ld", __func__,
180 /* Convert to UTF-8 */
181 if (BEFS_SB(sb)->nls) {
183 befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen);
185 befs_debug(sb, "<--- %s ERROR", __func__);
188 ret = befs_btree_find(sb, ds, utfname, &offset);
192 ret = befs_btree_find(sb, ds, name, &offset);
195 if (ret == BEFS_BT_NOT_FOUND) {
196 befs_debug(sb, "<--- %s %pd not found", __func__, dentry);
198 return ERR_PTR(-ENOENT);
200 } else if (ret != BEFS_OK || offset == 0) {
201 befs_error(sb, "<--- %s Error", __func__);
202 return ERR_PTR(-ENODATA);
205 inode = befs_iget(dir->i_sb, (ino_t) offset);
207 return ERR_CAST(inode);
209 d_add(dentry, inode);
211 befs_debug(sb, "<--- %s", __func__);
217 befs_readdir(struct file *file, struct dir_context *ctx)
219 struct inode *inode = file_inode(file);
220 struct super_block *sb = inode->i_sb;
221 const befs_data_stream *ds = &BEFS_I(inode)->i_data.ds;
225 char keybuf[BEFS_NAME_LEN + 1];
227 befs_debug(sb, "---> %s name %pD, inode %ld, ctx->pos %lld",
228 __func__, file, inode->i_ino, ctx->pos);
231 result = befs_btree_read(sb, ds, ctx->pos, BEFS_NAME_LEN + 1,
232 keybuf, &keysize, &value);
234 if (result == BEFS_ERR) {
235 befs_debug(sb, "<--- %s ERROR", __func__);
236 befs_error(sb, "IO error reading %pD (inode %lu)",
240 } else if (result == BEFS_BT_END) {
241 befs_debug(sb, "<--- %s END", __func__);
244 } else if (result == BEFS_BT_EMPTY) {
245 befs_debug(sb, "<--- %s Empty directory", __func__);
250 if (BEFS_SB(sb)->nls) {
255 befs_utf2nls(sb, keybuf, keysize, &nlsname,
258 befs_debug(sb, "<--- %s ERROR", __func__);
261 if (!dir_emit(ctx, nlsname, nlsnamelen,
262 (ino_t) value, DT_UNKNOWN)) {
268 if (!dir_emit(ctx, keybuf, keysize,
269 (ino_t) value, DT_UNKNOWN))
276 static struct inode *
277 befs_alloc_inode(struct super_block *sb)
279 struct befs_inode_info *bi;
281 bi = kmem_cache_alloc(befs_inode_cachep, GFP_KERNEL);
284 return &bi->vfs_inode;
287 static void befs_i_callback(struct rcu_head *head)
289 struct inode *inode = container_of(head, struct inode, i_rcu);
290 kmem_cache_free(befs_inode_cachep, BEFS_I(inode));
293 static void befs_destroy_inode(struct inode *inode)
295 call_rcu(&inode->i_rcu, befs_i_callback);
298 static void init_once(void *foo)
300 struct befs_inode_info *bi = (struct befs_inode_info *) foo;
302 inode_init_once(&bi->vfs_inode);
305 static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
307 struct buffer_head *bh;
308 befs_inode *raw_inode;
309 struct befs_sb_info *befs_sb = BEFS_SB(sb);
310 struct befs_inode_info *befs_ino;
313 befs_debug(sb, "---> %s inode = %lu", __func__, ino);
315 inode = iget_locked(sb, ino);
317 return ERR_PTR(-ENOMEM);
318 if (!(inode->i_state & I_NEW))
321 befs_ino = BEFS_I(inode);
323 /* convert from vfs's inode number to befs's inode number */
324 befs_ino->i_inode_num = blockno2iaddr(sb, inode->i_ino);
326 befs_debug(sb, " real inode number [%u, %hu, %hu]",
327 befs_ino->i_inode_num.allocation_group,
328 befs_ino->i_inode_num.start, befs_ino->i_inode_num.len);
330 bh = sb_bread(sb, inode->i_ino);
332 befs_error(sb, "unable to read inode block - "
333 "inode = %lu", inode->i_ino);
337 raw_inode = (befs_inode *) bh->b_data;
339 befs_dump_inode(sb, raw_inode);
341 if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) {
342 befs_error(sb, "Bad inode: %lu", inode->i_ino);
346 inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode);
349 * set uid and gid. But since current BeOS is single user OS, so
350 * you can change by "uid" or "gid" options.
353 inode->i_uid = befs_sb->mount_opts.use_uid ?
354 befs_sb->mount_opts.uid :
355 make_kuid(&init_user_ns, fs32_to_cpu(sb, raw_inode->uid));
356 inode->i_gid = befs_sb->mount_opts.use_gid ?
357 befs_sb->mount_opts.gid :
358 make_kgid(&init_user_ns, fs32_to_cpu(sb, raw_inode->gid));
363 * BEFS's time is 64 bits, but current VFS is 32 bits...
364 * BEFS don't have access time. Nor inode change time. VFS
365 * doesn't have creation time.
366 * Also, the lower 16 bits of the last_modified_time and
367 * create_time are just a counter to help ensure uniqueness
368 * for indexing purposes. (PFD, page 54)
371 inode->i_mtime.tv_sec =
372 fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16;
373 inode->i_mtime.tv_nsec = 0; /* lower 16 bits are not a time */
374 inode->i_ctime = inode->i_mtime;
375 inode->i_atime = inode->i_mtime;
377 befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num);
378 befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent);
379 befs_ino->i_attribute = fsrun_to_cpu(sb, raw_inode->attributes);
380 befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags);
382 if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){
384 inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE;
385 strlcpy(befs_ino->i_data.symlink, raw_inode->data.symlink,
390 befs_ino->i_data.ds =
391 fsds_to_cpu(sb, &raw_inode->data.datastream);
393 num_blks = befs_count_blocks(sb, &befs_ino->i_data.ds);
395 num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE);
396 inode->i_size = befs_ino->i_data.ds.size;
399 inode->i_mapping->a_ops = &befs_aops;
401 if (S_ISREG(inode->i_mode)) {
402 inode->i_fop = &generic_ro_fops;
403 } else if (S_ISDIR(inode->i_mode)) {
404 inode->i_op = &befs_dir_inode_operations;
405 inode->i_fop = &befs_dir_operations;
406 } else if (S_ISLNK(inode->i_mode)) {
407 if (befs_ino->i_flags & BEFS_LONG_SYMLINK) {
408 inode->i_op = &page_symlink_inode_operations;
409 inode_nohighmem(inode);
410 inode->i_mapping->a_ops = &befs_symlink_aops;
412 inode->i_link = befs_ino->i_data.symlink;
413 inode->i_op = &simple_symlink_inode_operations;
416 befs_error(sb, "Inode %lu is not a regular file, "
417 "directory or symlink. THAT IS WRONG! BeFS has no "
418 "on disk special files", inode->i_ino);
423 befs_debug(sb, "<--- %s", __func__);
424 unlock_new_inode(inode);
432 befs_debug(sb, "<--- %s - Bad inode", __func__);
433 return ERR_PTR(-EIO);
436 /* Initialize the inode cache. Called at fs setup.
438 * Taken from NFS implementation by Al Viro.
441 befs_init_inodecache(void)
443 befs_inode_cachep = kmem_cache_create("befs_inode_cache",
444 sizeof (struct befs_inode_info),
445 0, (SLAB_RECLAIM_ACCOUNT|
446 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
448 if (befs_inode_cachep == NULL)
454 /* Called at fs teardown.
456 * Taken from NFS implementation by Al Viro.
459 befs_destroy_inodecache(void)
462 * Make sure all delayed rcu free inodes are flushed before we
466 kmem_cache_destroy(befs_inode_cachep);
470 * The inode of symbolic link is different to data stream.
471 * The data stream become link name. Unless the LONG_SYMLINK
474 static int befs_symlink_readpage(struct file *unused, struct page *page)
476 struct inode *inode = page->mapping->host;
477 struct super_block *sb = inode->i_sb;
478 struct befs_inode_info *befs_ino = BEFS_I(inode);
479 befs_data_stream *data = &befs_ino->i_data.ds;
480 befs_off_t len = data->size;
481 char *link = page_address(page);
483 if (len == 0 || len > PAGE_SIZE) {
484 befs_error(sb, "Long symlink with illegal length");
487 befs_debug(sb, "Follow long symlink");
489 if (befs_read_lsymlink(sb, data, link, len) != len) {
490 befs_error(sb, "Failed to read entire long symlink");
493 link[len - 1] = '\0';
494 SetPageUptodate(page);
504 * UTF-8 to NLS charset convert routine
506 * Uses uni2char() / char2uni() rather than the nls tables directly
509 befs_utf2nls(struct super_block *sb, const char *in,
510 int in_len, char **out, int *out_len)
512 struct nls_table *nls = BEFS_SB(sb)->nls;
517 /* The utf8->nls conversion won't make the final nls string bigger
518 * than the utf one, but if the string is pure ascii they'll have the
519 * same width and an extra char is needed to save the additional \0
521 int maxlen = in_len + 1;
523 befs_debug(sb, "---> %s", __func__);
526 befs_error(sb, "%s called with no NLS table loaded", __func__);
530 *out = result = kmalloc(maxlen, GFP_NOFS);
534 for (i = o = 0; i < in_len; i += utflen, o += unilen) {
536 /* convert from UTF-8 to Unicode */
537 utflen = utf8_to_utf32(&in[i], in_len - i, &uni);
541 /* convert from Unicode to nls */
542 if (uni > MAX_WCHAR_T)
544 unilen = nls->uni2char(uni, &result[o], in_len - o);
551 befs_debug(sb, "<--- %s", __func__);
556 befs_error(sb, "Name using character set %s contains a character that "
557 "cannot be converted to unicode.", nls->charset);
558 befs_debug(sb, "<--- %s", __func__);
564 * befs_nls2utf - Convert NLS string to utf8 encodeing
566 * @in: Input string buffer in NLS format
567 * @in_len: Length of input string in bytes
568 * @out: The output string in UTF-8 format
569 * @out_len: Length of the output buffer
571 * Converts input string @in, which is in the format of the loaded NLS map,
572 * into a utf8 string.
574 * The destination string @out is allocated by this function and the caller is
575 * responsible for freeing it with kfree()
577 * On return, *@out_len is the length of @out in bytes.
579 * On success, the return value is the number of utf8 characters written to
580 * the output buffer @out.
582 * On Failure, a negative number coresponding to the error code is returned.
586 befs_nls2utf(struct super_block *sb, const char *in,
587 int in_len, char **out, int *out_len)
589 struct nls_table *nls = BEFS_SB(sb)->nls;
595 * There are nls characters that will translate to 3-chars-wide UTF-8
596 * characters, an additional byte is needed to save the final \0
599 int maxlen = (3 * in_len) + 1;
601 befs_debug(sb, "---> %s\n", __func__);
604 befs_error(sb, "%s called with no NLS table loaded.",
609 *out = result = kmalloc(maxlen, GFP_NOFS);
615 for (i = o = 0; i < in_len; i += unilen, o += utflen) {
617 /* convert from nls to unicode */
618 unilen = nls->char2uni(&in[i], in_len - i, &uni);
622 /* convert from unicode to UTF-8 */
623 utflen = utf32_to_utf8(uni, &result[o], 3);
631 befs_debug(sb, "<--- %s", __func__);
636 befs_error(sb, "Name using character set %s contains a character that "
637 "cannot be converted to unicode.", nls->charset);
638 befs_debug(sb, "<--- %s", __func__);
643 static struct inode *befs_nfs_get_inode(struct super_block *sb, uint64_t ino,
646 /* No need to handle i_generation */
647 return befs_iget(sb, ino);
651 * Map a NFS file handle to a corresponding dentry
653 static struct dentry *befs_fh_to_dentry(struct super_block *sb,
654 struct fid *fid, int fh_len, int fh_type)
656 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
661 * Find the parent for a file specified by NFS handle
663 static struct dentry *befs_fh_to_parent(struct super_block *sb,
664 struct fid *fid, int fh_len, int fh_type)
666 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
671 Opt_uid, Opt_gid, Opt_charset, Opt_debug, Opt_err,
674 static const match_table_t befs_tokens = {
677 {Opt_charset, "iocharset=%s"},
678 {Opt_debug, "debug"},
683 parse_options(char *options, struct befs_mount_options *opts)
686 substring_t args[MAX_OPT_ARGS];
691 /* Initialize options */
692 opts->uid = GLOBAL_ROOT_UID;
693 opts->gid = GLOBAL_ROOT_GID;
696 opts->iocharset = NULL;
702 while ((p = strsep(&options, ",")) != NULL) {
708 token = match_token(p, befs_tokens, args);
711 if (match_int(&args[0], &option))
715 uid = make_kuid(current_user_ns(), option);
716 if (!uid_valid(uid)) {
717 pr_err("Invalid uid %d, "
718 "using default\n", option);
725 if (match_int(&args[0], &option))
729 gid = make_kgid(current_user_ns(), option);
730 if (!gid_valid(gid)) {
731 pr_err("Invalid gid %d, "
732 "using default\n", option);
739 kfree(opts->iocharset);
740 opts->iocharset = match_strdup(&args[0]);
741 if (!opts->iocharset) {
742 pr_err("allocation failure for "
743 "iocharset string\n");
751 pr_err("Unrecognized mount option \"%s\" "
752 "or missing value\n", p);
759 /* This function has the responsibiltiy of getting the
760 * filesystem ready for unmounting.
761 * Basically, we free everything that we allocated in
765 befs_put_super(struct super_block *sb)
767 kfree(BEFS_SB(sb)->mount_opts.iocharset);
768 BEFS_SB(sb)->mount_opts.iocharset = NULL;
769 unload_nls(BEFS_SB(sb)->nls);
770 kfree(sb->s_fs_info);
771 sb->s_fs_info = NULL;
774 /* Allocate private field of the superblock, fill it.
776 * Finish filling the public superblock fields
777 * Make the root directory
778 * Load a set of NLS translations if needed.
781 befs_fill_super(struct super_block *sb, void *data, int silent)
783 struct buffer_head *bh;
784 struct befs_sb_info *befs_sb;
785 befs_super_block *disk_sb;
788 const unsigned long sb_block = 0;
789 const off_t x86_sb_off = 512;
792 save_mount_options(sb, data);
794 sb->s_fs_info = kzalloc(sizeof(*befs_sb), GFP_KERNEL);
795 if (sb->s_fs_info == NULL)
798 befs_sb = BEFS_SB(sb);
800 if (!parse_options((char *) data, &befs_sb->mount_opts)) {
802 befs_error(sb, "cannot parse mount options");
803 goto unacquire_priv_sbp;
806 befs_debug(sb, "---> %s", __func__);
808 if (!(sb->s_flags & MS_RDONLY)) {
810 "No write support. Marking filesystem read-only");
811 sb->s_flags |= MS_RDONLY;
815 * Set dummy blocksize to read super block.
816 * Will be set to real fs blocksize later.
818 * Linux 2.4.10 and later refuse to read blocks smaller than
819 * the logical block size for the device. But we also need to read at
820 * least 1k to get the second 512 bytes of the volume.
822 blocksize = sb_min_blocksize(sb, 1024);
825 befs_error(sb, "unable to set blocksize");
826 goto unacquire_priv_sbp;
829 bh = sb_bread(sb, sb_block);
832 befs_error(sb, "unable to read superblock");
833 goto unacquire_priv_sbp;
836 /* account for offset of super block on x86 */
837 disk_sb = (befs_super_block *) bh->b_data;
838 if ((disk_sb->magic1 == BEFS_SUPER_MAGIC1_LE) ||
839 (disk_sb->magic1 == BEFS_SUPER_MAGIC1_BE)) {
840 befs_debug(sb, "Using PPC superblock location");
842 befs_debug(sb, "Using x86 superblock location");
844 (befs_super_block *) ((void *) bh->b_data + x86_sb_off);
847 if ((befs_load_sb(sb, disk_sb) != BEFS_OK) ||
848 (befs_check_sb(sb) != BEFS_OK))
851 befs_dump_super_block(sb, disk_sb);
855 if (befs_sb->num_blocks > ~((sector_t)0)) {
857 befs_error(sb, "blocks count: %llu is larger than the host can use",
858 befs_sb->num_blocks);
859 goto unacquire_priv_sbp;
863 * set up enough so that it can read an inode
864 * Fill in kernel superblock fields from private sb
866 sb->s_magic = BEFS_SUPER_MAGIC;
867 /* Set real blocksize of fs */
868 sb_set_blocksize(sb, (ulong) befs_sb->block_size);
869 sb->s_op = &befs_sops;
870 sb->s_export_op = &befs_export_operations;
871 root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir)));
874 goto unacquire_priv_sbp;
876 sb->s_root = d_make_root(root);
879 befs_error(sb, "get root inode failed");
880 goto unacquire_priv_sbp;
883 /* load nls library */
884 if (befs_sb->mount_opts.iocharset) {
885 befs_debug(sb, "Loading nls: %s",
886 befs_sb->mount_opts.iocharset);
887 befs_sb->nls = load_nls(befs_sb->mount_opts.iocharset);
889 befs_warning(sb, "Cannot load nls %s"
890 " loading default nls",
891 befs_sb->mount_opts.iocharset);
892 befs_sb->nls = load_nls_default();
894 /* load default nls if none is specified in mount options */
896 befs_debug(sb, "Loading default nls");
897 befs_sb->nls = load_nls_default();
906 kfree(befs_sb->mount_opts.iocharset);
907 kfree(sb->s_fs_info);
908 sb->s_fs_info = NULL;
915 befs_remount(struct super_block *sb, int *flags, char *data)
918 if (!(*flags & MS_RDONLY))
924 befs_statfs(struct dentry *dentry, struct kstatfs *buf)
926 struct super_block *sb = dentry->d_sb;
927 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
929 befs_debug(sb, "---> %s", __func__);
931 buf->f_type = BEFS_SUPER_MAGIC;
932 buf->f_bsize = sb->s_blocksize;
933 buf->f_blocks = BEFS_SB(sb)->num_blocks;
934 buf->f_bfree = BEFS_SB(sb)->num_blocks - BEFS_SB(sb)->used_blocks;
935 buf->f_bavail = buf->f_bfree;
936 buf->f_files = 0; /* UNKNOWN */
937 buf->f_ffree = 0; /* UNKNOWN */
938 buf->f_fsid.val[0] = (u32)id;
939 buf->f_fsid.val[1] = (u32)(id >> 32);
940 buf->f_namelen = BEFS_NAME_LEN;
942 befs_debug(sb, "<--- %s", __func__);
947 static struct dentry *
948 befs_mount(struct file_system_type *fs_type, int flags, const char *dev_name,
951 return mount_bdev(fs_type, flags, dev_name, data, befs_fill_super);
954 static struct file_system_type befs_fs_type = {
955 .owner = THIS_MODULE,
958 .kill_sb = kill_block_super,
959 .fs_flags = FS_REQUIRES_DEV,
961 MODULE_ALIAS_FS("befs");
968 pr_info("version: %s\n", BEFS_VERSION);
970 err = befs_init_inodecache();
974 err = register_filesystem(&befs_fs_type);
976 goto unacquire_inodecache;
980 unacquire_inodecache:
981 befs_destroy_inodecache();
990 befs_destroy_inodecache();
992 unregister_filesystem(&befs_fs_type);
996 * Macros that typecheck the init and exit functions,
997 * ensures that they are called at init and cleanup,
998 * and eliminates warnings about unused functions.
1000 module_init(init_befs_fs)
1001 module_exit(exit_befs_fs)