11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/befs/linuxvfs.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds */ 71da177e4SLinus Torvalds 8dac52fc1SFabian Frederick #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9dac52fc1SFabian Frederick 101da177e4SLinus Torvalds #include <linux/module.h> 111da177e4SLinus Torvalds #include <linux/slab.h> 121da177e4SLinus Torvalds #include <linux/fs.h> 131da177e4SLinus Torvalds #include <linux/errno.h> 141da177e4SLinus Torvalds #include <linux/stat.h> 151da177e4SLinus Torvalds #include <linux/nls.h> 161da177e4SLinus Torvalds #include <linux/buffer_head.h> 171da177e4SLinus Torvalds #include <linux/vfs.h> 181da177e4SLinus Torvalds #include <linux/parser.h> 191da177e4SLinus Torvalds #include <linux/namei.h> 2031aba059SEric W. Biederman #include <linux/sched.h> 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include "befs.h" 231da177e4SLinus Torvalds #include "btree.h" 241da177e4SLinus Torvalds #include "inode.h" 251da177e4SLinus Torvalds #include "datastream.h" 261da177e4SLinus Torvalds #include "super.h" 271da177e4SLinus Torvalds #include "io.h" 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds MODULE_DESCRIPTION("BeOS File System (BeFS) driver"); 301da177e4SLinus Torvalds MODULE_AUTHOR("Will Dyson"); 311da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds /* The units the vfs expects inode->i_blocks to be in */ 341da177e4SLinus Torvalds #define VFS_BLOCK_SIZE 512 351da177e4SLinus Torvalds 36f0f49ef5SAl Viro static int befs_readdir(struct file *, struct dir_context *); 371da177e4SLinus Torvalds static int befs_get_block(struct inode *, sector_t, struct buffer_head *, int); 381da177e4SLinus Torvalds static int befs_readpage(struct file *file, struct page *page); 391da177e4SLinus Torvalds static sector_t befs_bmap(struct address_space *mapping, sector_t block); 4000cd8dd3SAl Viro static struct dentry *befs_lookup(struct inode *, struct dentry *, unsigned int); 4196eb5419SDavid Howells static struct inode *befs_iget(struct super_block *, unsigned long); 421da177e4SLinus Torvalds static struct inode *befs_alloc_inode(struct super_block *sb); 431da177e4SLinus Torvalds static void befs_destroy_inode(struct inode *inode); 441da177e4SLinus Torvalds static void befs_destroy_inodecache(void); 4511803f97SAl Viro static int befs_symlink_readpage(struct file *, struct page *); 461da177e4SLinus Torvalds static int befs_utf2nls(struct super_block *sb, const char *in, int in_len, 471da177e4SLinus Torvalds char **out, int *out_len); 481da177e4SLinus Torvalds static int befs_nls2utf(struct super_block *sb, const char *in, int in_len, 491da177e4SLinus Torvalds char **out, int *out_len); 501da177e4SLinus Torvalds static void befs_put_super(struct super_block *); 511da177e4SLinus Torvalds static int befs_remount(struct super_block *, int *, char *); 52726c3342SDavid Howells static int befs_statfs(struct dentry *, struct kstatfs *); 5309ad0eaeSFabian Frederick static int parse_options(char *, struct befs_mount_options *); 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds static const struct super_operations befs_sops = { 561da177e4SLinus Torvalds .alloc_inode = befs_alloc_inode, /* allocate a new inode */ 571da177e4SLinus Torvalds .destroy_inode = befs_destroy_inode, /* deallocate an inode */ 581da177e4SLinus Torvalds .put_super = befs_put_super, /* uninit super */ 591da177e4SLinus Torvalds .statfs = befs_statfs, /* statfs */ 601da177e4SLinus Torvalds .remount_fs = befs_remount, 61552c3c6cSMiklos Szeredi .show_options = generic_show_options, 621da177e4SLinus Torvalds }; 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* slab cache for befs_inode_info objects */ 65e18b890bSChristoph Lameter static struct kmem_cache *befs_inode_cachep; 661da177e4SLinus Torvalds 674b6f5d20SArjan van de Ven static const struct file_operations befs_dir_operations = { 681da177e4SLinus Torvalds .read = generic_read_dir, 69e23e9aa7SAl Viro .iterate_shared = befs_readdir, 7059af1584SAl Viro .llseek = generic_file_llseek, 711da177e4SLinus Torvalds }; 721da177e4SLinus Torvalds 73754661f1SArjan van de Ven static const struct inode_operations befs_dir_inode_operations = { 741da177e4SLinus Torvalds .lookup = befs_lookup, 751da177e4SLinus Torvalds }; 761da177e4SLinus Torvalds 77f5e54d6eSChristoph Hellwig static const struct address_space_operations befs_aops = { 781da177e4SLinus Torvalds .readpage = befs_readpage, 791da177e4SLinus Torvalds .bmap = befs_bmap, 801da177e4SLinus Torvalds }; 811da177e4SLinus Torvalds 8211803f97SAl Viro static const struct address_space_operations befs_symlink_aops = { 8311803f97SAl Viro .readpage = befs_symlink_readpage, 841da177e4SLinus Torvalds }; 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* 871da177e4SLinus Torvalds * Called by generic_file_read() to read a page of data 881da177e4SLinus Torvalds * 891da177e4SLinus Torvalds * In turn, simply calls a generic block read function and 901da177e4SLinus Torvalds * passes it the address of befs_get_block, for mapping file 911da177e4SLinus Torvalds * positions to disk blocks. 921da177e4SLinus Torvalds */ 931da177e4SLinus Torvalds static int 941da177e4SLinus Torvalds befs_readpage(struct file *file, struct page *page) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds return block_read_full_page(page, befs_get_block); 971da177e4SLinus Torvalds } 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds static sector_t 1001da177e4SLinus Torvalds befs_bmap(struct address_space *mapping, sector_t block) 1011da177e4SLinus Torvalds { 1021da177e4SLinus Torvalds return generic_block_bmap(mapping, block, befs_get_block); 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds /* 1061da177e4SLinus Torvalds * Generic function to map a file position (block) to a 1071da177e4SLinus Torvalds * disk offset (passed back in bh_result). 1081da177e4SLinus Torvalds * 1091da177e4SLinus Torvalds * Used by many higher level functions. 1101da177e4SLinus Torvalds * 1111da177e4SLinus Torvalds * Calls befs_fblock2brun() in datastream.c to do the real work. 1121da177e4SLinus Torvalds * 1131da177e4SLinus Torvalds * -WD 10-26-01 1141da177e4SLinus Torvalds */ 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds static int 1171da177e4SLinus Torvalds befs_get_block(struct inode *inode, sector_t block, 1181da177e4SLinus Torvalds struct buffer_head *bh_result, int create) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 1211da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 1221da177e4SLinus Torvalds befs_block_run run = BAD_IADDR; 1231da177e4SLinus Torvalds int res = 0; 1241da177e4SLinus Torvalds ulong disk_off; 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld", 127dac52fc1SFabian Frederick (unsigned long)inode->i_ino, (long)block); 1281da177e4SLinus Torvalds if (create) { 1291da177e4SLinus Torvalds befs_error(sb, "befs_get_block() was asked to write to " 130dac52fc1SFabian Frederick "block %ld in inode %lu", (long)block, 131dac52fc1SFabian Frederick (unsigned long)inode->i_ino); 1321da177e4SLinus Torvalds return -EPERM; 1331da177e4SLinus Torvalds } 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds res = befs_fblock2brun(sb, ds, block, &run); 1361da177e4SLinus Torvalds if (res != BEFS_OK) { 1371da177e4SLinus Torvalds befs_error(sb, 138dac52fc1SFabian Frederick "<--- %s for inode %lu, block %ld ERROR", 139dac52fc1SFabian Frederick __func__, (unsigned long)inode->i_ino, 140dac52fc1SFabian Frederick (long)block); 1411da177e4SLinus Torvalds return -EFBIG; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds disk_off = (ulong) iaddr2blockno(sb, &run); 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds map_bh(bh_result, inode->i_sb, disk_off); 1471da177e4SLinus Torvalds 148dac52fc1SFabian Frederick befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu", 149dac52fc1SFabian Frederick __func__, (unsigned long)inode->i_ino, (long)block, 150dac52fc1SFabian Frederick (unsigned long)disk_off); 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds return 0; 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds static struct dentry * 15600cd8dd3SAl Viro befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 1571da177e4SLinus Torvalds { 158c9408763SSalah Triki struct inode *inode; 1591da177e4SLinus Torvalds struct super_block *sb = dir->i_sb; 16022341d8fSAl Viro const befs_data_stream *ds = &BEFS_I(dir)->i_data.ds; 1611da177e4SLinus Torvalds befs_off_t offset; 1621da177e4SLinus Torvalds int ret; 1631da177e4SLinus Torvalds int utfnamelen; 1641da177e4SLinus Torvalds char *utfname; 1651da177e4SLinus Torvalds const char *name = dentry->d_name.name; 1661da177e4SLinus Torvalds 167a455589fSAl Viro befs_debug(sb, "---> %s name %pd inode %ld", __func__, 168a455589fSAl Viro dentry, dir->i_ino); 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds /* Convert to UTF-8 */ 1711da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 1721da177e4SLinus Torvalds ret = 1731da177e4SLinus Torvalds befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen); 1741da177e4SLinus Torvalds if (ret < 0) { 175dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 1761da177e4SLinus Torvalds return ERR_PTR(ret); 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, utfname, &offset); 1791da177e4SLinus Torvalds kfree(utfname); 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds } else { 1821da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, dentry->d_name.name, &offset); 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds if (ret == BEFS_BT_NOT_FOUND) { 186a455589fSAl Viro befs_debug(sb, "<--- %s %pd not found", __func__, dentry); 1871da177e4SLinus Torvalds return ERR_PTR(-ENOENT); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds } else if (ret != BEFS_OK || offset == 0) { 190dac52fc1SFabian Frederick befs_warning(sb, "<--- %s Error", __func__); 1911da177e4SLinus Torvalds return ERR_PTR(-ENODATA); 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 19496eb5419SDavid Howells inode = befs_iget(dir->i_sb, (ino_t) offset); 19596eb5419SDavid Howells if (IS_ERR(inode)) 19696eb5419SDavid Howells return ERR_CAST(inode); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds d_add(dentry, inode); 1991da177e4SLinus Torvalds 200dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds return NULL; 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds static int 206f0f49ef5SAl Viro befs_readdir(struct file *file, struct dir_context *ctx) 2071da177e4SLinus Torvalds { 208f0f49ef5SAl Viro struct inode *inode = file_inode(file); 2091da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 21022341d8fSAl Viro const befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 2111da177e4SLinus Torvalds befs_off_t value; 2121da177e4SLinus Torvalds int result; 2131da177e4SLinus Torvalds size_t keysize; 2141da177e4SLinus Torvalds unsigned char d_type; 2151da177e4SLinus Torvalds char keybuf[BEFS_NAME_LEN + 1]; 2161da177e4SLinus Torvalds 217a455589fSAl Viro befs_debug(sb, "---> %s name %pD, inode %ld, ctx->pos %lld", 218a455589fSAl Viro __func__, file, inode->i_ino, ctx->pos); 2191da177e4SLinus Torvalds 220f0f49ef5SAl Viro more: 221f0f49ef5SAl Viro result = befs_btree_read(sb, ds, ctx->pos, BEFS_NAME_LEN + 1, 2221da177e4SLinus Torvalds keybuf, &keysize, &value); 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds if (result == BEFS_ERR) { 225dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 226a455589fSAl Viro befs_error(sb, "IO error reading %pD (inode %lu)", 227a455589fSAl Viro file, inode->i_ino); 2281da177e4SLinus Torvalds return -EIO; 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds } else if (result == BEFS_BT_END) { 231dac52fc1SFabian Frederick befs_debug(sb, "<--- %s END", __func__); 2321da177e4SLinus Torvalds return 0; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds } else if (result == BEFS_BT_EMPTY) { 235dac52fc1SFabian Frederick befs_debug(sb, "<--- %s Empty directory", __func__); 2361da177e4SLinus Torvalds return 0; 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds d_type = DT_UNKNOWN; 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds /* Convert to NLS */ 2421da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 243f0f49ef5SAl Viro char *nlsname; 244f0f49ef5SAl Viro int nlsnamelen; 2451da177e4SLinus Torvalds result = 2461da177e4SLinus Torvalds befs_utf2nls(sb, keybuf, keysize, &nlsname, &nlsnamelen); 2471da177e4SLinus Torvalds if (result < 0) { 248dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 2491da177e4SLinus Torvalds return result; 2501da177e4SLinus Torvalds } 251f0f49ef5SAl Viro if (!dir_emit(ctx, nlsname, nlsnamelen, 252f0f49ef5SAl Viro (ino_t) value, d_type)) { 2531da177e4SLinus Torvalds kfree(nlsname); 254f0f49ef5SAl Viro return 0; 2551da177e4SLinus Torvalds } 256f0f49ef5SAl Viro kfree(nlsname); 257f0f49ef5SAl Viro } else { 258f0f49ef5SAl Viro if (!dir_emit(ctx, keybuf, keysize, 259f0f49ef5SAl Viro (ino_t) value, d_type)) 260f0f49ef5SAl Viro return 0; 261f0f49ef5SAl Viro } 262f0f49ef5SAl Viro ctx->pos++; 263f0f49ef5SAl Viro goto more; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds static struct inode * 2671da177e4SLinus Torvalds befs_alloc_inode(struct super_block *sb) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds struct befs_inode_info *bi; 270111d639dSFabian Frederick 271111d639dSFabian Frederick bi = kmem_cache_alloc(befs_inode_cachep, GFP_KERNEL); 2721da177e4SLinus Torvalds if (!bi) 2731da177e4SLinus Torvalds return NULL; 2741da177e4SLinus Torvalds return &bi->vfs_inode; 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 277fa0d7e3dSNick Piggin static void befs_i_callback(struct rcu_head *head) 2781da177e4SLinus Torvalds { 279fa0d7e3dSNick Piggin struct inode *inode = container_of(head, struct inode, i_rcu); 2801da177e4SLinus Torvalds kmem_cache_free(befs_inode_cachep, BEFS_I(inode)); 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds 283fa0d7e3dSNick Piggin static void befs_destroy_inode(struct inode *inode) 284fa0d7e3dSNick Piggin { 285fa0d7e3dSNick Piggin call_rcu(&inode->i_rcu, befs_i_callback); 286fa0d7e3dSNick Piggin } 287fa0d7e3dSNick Piggin 28851cc5068SAlexey Dobriyan static void init_once(void *foo) 2891da177e4SLinus Torvalds { 2901da177e4SLinus Torvalds struct befs_inode_info *bi = (struct befs_inode_info *) foo; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds inode_init_once(&bi->vfs_inode); 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 29596eb5419SDavid Howells static struct inode *befs_iget(struct super_block *sb, unsigned long ino) 2961da177e4SLinus Torvalds { 297e4c7f5b1SSalah Triki struct buffer_head *bh; 29844ad8098SSalah Triki befs_inode *raw_inode; 299038428fcSFabian Frederick struct befs_sb_info *befs_sb = BEFS_SB(sb); 300d6e02033SSalah Triki struct befs_inode_info *befs_ino; 30196eb5419SDavid Howells struct inode *inode; 30296eb5419SDavid Howells long ret = -EIO; 3031da177e4SLinus Torvalds 304dac52fc1SFabian Frederick befs_debug(sb, "---> %s inode = %lu", __func__, ino); 30596eb5419SDavid Howells 30696eb5419SDavid Howells inode = iget_locked(sb, ino); 307ac34a1b3SRakesh Pandit if (!inode) 308ac34a1b3SRakesh Pandit return ERR_PTR(-ENOMEM); 30996eb5419SDavid Howells if (!(inode->i_state & I_NEW)) 31096eb5419SDavid Howells return inode; 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds befs_ino = BEFS_I(inode); 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds /* convert from vfs's inode number to befs's inode number */ 3151da177e4SLinus Torvalds befs_ino->i_inode_num = blockno2iaddr(sb, inode->i_ino); 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds befs_debug(sb, " real inode number [%u, %hu, %hu]", 3181da177e4SLinus Torvalds befs_ino->i_inode_num.allocation_group, 3191da177e4SLinus Torvalds befs_ino->i_inode_num.start, befs_ino->i_inode_num.len); 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds bh = befs_bread(sb, inode->i_ino); 3221da177e4SLinus Torvalds if (!bh) { 3231da177e4SLinus Torvalds befs_error(sb, "unable to read inode block - " 3241da177e4SLinus Torvalds "inode = %lu", inode->i_ino); 3250418726bSAdrian Bunk goto unacquire_none; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds raw_inode = (befs_inode *) bh->b_data; 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds befs_dump_inode(sb, raw_inode); 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) { 3331da177e4SLinus Torvalds befs_error(sb, "Bad inode: %lu", inode->i_ino); 3340418726bSAdrian Bunk goto unacquire_bh; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds /* 3401da177e4SLinus Torvalds * set uid and gid. But since current BeOS is single user OS, so 3411da177e4SLinus Torvalds * you can change by "uid" or "gid" options. 3421da177e4SLinus Torvalds */ 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds inode->i_uid = befs_sb->mount_opts.use_uid ? 34531aba059SEric W. Biederman befs_sb->mount_opts.uid : 34631aba059SEric W. Biederman make_kuid(&init_user_ns, fs32_to_cpu(sb, raw_inode->uid)); 3471da177e4SLinus Torvalds inode->i_gid = befs_sb->mount_opts.use_gid ? 34831aba059SEric W. Biederman befs_sb->mount_opts.gid : 34931aba059SEric W. Biederman make_kgid(&init_user_ns, fs32_to_cpu(sb, raw_inode->gid)); 3501da177e4SLinus Torvalds 351bfe86848SMiklos Szeredi set_nlink(inode, 1); 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds /* 3541da177e4SLinus Torvalds * BEFS's time is 64 bits, but current VFS is 32 bits... 3551da177e4SLinus Torvalds * BEFS don't have access time. Nor inode change time. VFS 3561da177e4SLinus Torvalds * doesn't have creation time. 3571da177e4SLinus Torvalds * Also, the lower 16 bits of the last_modified_time and 3581da177e4SLinus Torvalds * create_time are just a counter to help ensure uniqueness 3591da177e4SLinus Torvalds * for indexing purposes. (PFD, page 54) 3601da177e4SLinus Torvalds */ 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds inode->i_mtime.tv_sec = 3631da177e4SLinus Torvalds fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16; 3641da177e4SLinus Torvalds inode->i_mtime.tv_nsec = 0; /* lower 16 bits are not a time */ 3651da177e4SLinus Torvalds inode->i_ctime = inode->i_mtime; 3661da177e4SLinus Torvalds inode->i_atime = inode->i_mtime; 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num); 3691da177e4SLinus Torvalds befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent); 3701da177e4SLinus Torvalds befs_ino->i_attribute = fsrun_to_cpu(sb, raw_inode->attributes); 3711da177e4SLinus Torvalds befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags); 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){ 3741da177e4SLinus Torvalds inode->i_size = 0; 3751da177e4SLinus Torvalds inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; 37639d7a29fSFabian Frederick strlcpy(befs_ino->i_data.symlink, raw_inode->data.symlink, 37739d7a29fSFabian Frederick BEFS_SYMLINK_LEN); 3781da177e4SLinus Torvalds } else { 3791da177e4SLinus Torvalds int num_blks; 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds befs_ino->i_data.ds = 382e0e3d32bSJesper Juhl fsds_to_cpu(sb, &raw_inode->data.datastream); 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds num_blks = befs_count_blocks(sb, &befs_ino->i_data.ds); 3851da177e4SLinus Torvalds inode->i_blocks = 3861da177e4SLinus Torvalds num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); 3871da177e4SLinus Torvalds inode->i_size = befs_ino->i_data.ds.size; 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds inode->i_mapping->a_ops = &befs_aops; 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds if (S_ISREG(inode->i_mode)) { 3932cf06916SChristoph Hellwig inode->i_fop = &generic_ro_fops; 3941da177e4SLinus Torvalds } else if (S_ISDIR(inode->i_mode)) { 3951da177e4SLinus Torvalds inode->i_op = &befs_dir_inode_operations; 3961da177e4SLinus Torvalds inode->i_fop = &befs_dir_operations; 3971da177e4SLinus Torvalds } else if (S_ISLNK(inode->i_mode)) { 398d0deec19SAl Viro if (befs_ino->i_flags & BEFS_LONG_SYMLINK) { 39911803f97SAl Viro inode->i_op = &page_symlink_inode_operations; 40021fc61c7SAl Viro inode_nohighmem(inode); 40111803f97SAl Viro inode->i_mapping->a_ops = &befs_symlink_aops; 402d0deec19SAl Viro } else { 403d0deec19SAl Viro inode->i_link = befs_ino->i_data.symlink; 404d0deec19SAl Viro inode->i_op = &simple_symlink_inode_operations; 405d0deec19SAl Viro } 4061da177e4SLinus Torvalds } else { 4071da177e4SLinus Torvalds befs_error(sb, "Inode %lu is not a regular file, " 4081da177e4SLinus Torvalds "directory or symlink. THAT IS WRONG! BeFS has no " 4091da177e4SLinus Torvalds "on disk special files", inode->i_ino); 4100418726bSAdrian Bunk goto unacquire_bh; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds brelse(bh); 414dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 41596eb5419SDavid Howells unlock_new_inode(inode); 41696eb5419SDavid Howells return inode; 4171da177e4SLinus Torvalds 4180418726bSAdrian Bunk unacquire_bh: 4191da177e4SLinus Torvalds brelse(bh); 4201da177e4SLinus Torvalds 4210418726bSAdrian Bunk unacquire_none: 42296eb5419SDavid Howells iget_failed(inode); 423dac52fc1SFabian Frederick befs_debug(sb, "<--- %s - Bad inode", __func__); 42496eb5419SDavid Howells return ERR_PTR(ret); 4251da177e4SLinus Torvalds } 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds /* Initialize the inode cache. Called at fs setup. 4281da177e4SLinus Torvalds * 4291da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4301da177e4SLinus Torvalds */ 43191a52ab7SFabian Frederick static int __init 4321da177e4SLinus Torvalds befs_init_inodecache(void) 4331da177e4SLinus Torvalds { 4341da177e4SLinus Torvalds befs_inode_cachep = kmem_cache_create("befs_inode_cache", 4351da177e4SLinus Torvalds sizeof (struct befs_inode_info), 436fffb60f9SPaul Jackson 0, (SLAB_RECLAIM_ACCOUNT| 4375d097056SVladimir Davydov SLAB_MEM_SPREAD|SLAB_ACCOUNT), 43820c2df83SPaul Mundt init_once); 4391da177e4SLinus Torvalds if (befs_inode_cachep == NULL) { 440dac52fc1SFabian Frederick pr_err("%s: Couldn't initialize inode slabcache\n", __func__); 4411da177e4SLinus Torvalds return -ENOMEM; 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds return 0; 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds /* Called at fs teardown. 4471da177e4SLinus Torvalds * 4481da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4491da177e4SLinus Torvalds */ 4501da177e4SLinus Torvalds static void 4511da177e4SLinus Torvalds befs_destroy_inodecache(void) 4521da177e4SLinus Torvalds { 4538c0a8537SKirill A. Shutemov /* 4548c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we 4558c0a8537SKirill A. Shutemov * destroy cache. 4568c0a8537SKirill A. Shutemov */ 4578c0a8537SKirill A. Shutemov rcu_barrier(); 4581a1d92c1SAlexey Dobriyan kmem_cache_destroy(befs_inode_cachep); 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds /* 4621da177e4SLinus Torvalds * The inode of symbolic link is different to data stream. 4631da177e4SLinus Torvalds * The data stream become link name. Unless the LONG_SYMLINK 4641da177e4SLinus Torvalds * flag is set. 4651da177e4SLinus Torvalds */ 46611803f97SAl Viro static int befs_symlink_readpage(struct file *unused, struct page *page) 4671da177e4SLinus Torvalds { 46811803f97SAl Viro struct inode *inode = page->mapping->host; 46911803f97SAl Viro struct super_block *sb = inode->i_sb; 47011803f97SAl Viro struct befs_inode_info *befs_ino = BEFS_I(inode); 4711da177e4SLinus Torvalds befs_data_stream *data = &befs_ino->i_data.ds; 4721da177e4SLinus Torvalds befs_off_t len = data->size; 47321fc61c7SAl Viro char *link = page_address(page); 4741da177e4SLinus Torvalds 47511803f97SAl Viro if (len == 0 || len > PAGE_SIZE) { 476338d0f0aSTimo Warns befs_error(sb, "Long symlink with illegal length"); 47711803f97SAl Viro goto fail; 478680baacbSAl Viro } 4791da177e4SLinus Torvalds befs_debug(sb, "Follow long symlink"); 4801da177e4SLinus Torvalds 481680baacbSAl Viro if (befs_read_lsymlink(sb, data, link, len) != len) { 4821da177e4SLinus Torvalds befs_error(sb, "Failed to read entire long symlink"); 48311803f97SAl Viro goto fail; 484680baacbSAl Viro } 4857df5fa06SDuane Griffin link[len - 1] = '\0'; 48611803f97SAl Viro SetPageUptodate(page); 48711803f97SAl Viro unlock_page(page); 48811803f97SAl Viro return 0; 48911803f97SAl Viro fail: 49011803f97SAl Viro SetPageError(page); 49111803f97SAl Viro unlock_page(page); 49211803f97SAl Viro return -EIO; 4931da177e4SLinus Torvalds } 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds /* 4961da177e4SLinus Torvalds * UTF-8 to NLS charset convert routine 4971da177e4SLinus Torvalds * 4981da177e4SLinus Torvalds * 4991da177e4SLinus Torvalds * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than 5001da177e4SLinus Torvalds * the nls tables directly 5011da177e4SLinus Torvalds */ 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds static int 5041da177e4SLinus Torvalds befs_utf2nls(struct super_block *sb, const char *in, 5051da177e4SLinus Torvalds int in_len, char **out, int *out_len) 5061da177e4SLinus Torvalds { 5071da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 5081da177e4SLinus Torvalds int i, o; 50974675a58SAlan Stern unicode_t uni; 5101da177e4SLinus Torvalds int unilen, utflen; 5111da177e4SLinus Torvalds char *result; 51294f563c4SDiego Calleja /* The utf8->nls conversion won't make the final nls string bigger 51394f563c4SDiego Calleja * than the utf one, but if the string is pure ascii they'll have the 51494f563c4SDiego Calleja * same width and an extra char is needed to save the additional \0 51594f563c4SDiego Calleja */ 51694f563c4SDiego Calleja int maxlen = in_len + 1; 5171da177e4SLinus Torvalds 518dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds if (!nls) { 521dac52fc1SFabian Frederick befs_error(sb, "%s called with no NLS table loaded", __func__); 5221da177e4SLinus Torvalds return -EINVAL; 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 5261da177e4SLinus Torvalds if (!*out) { 527dac52fc1SFabian Frederick befs_error(sb, "%s cannot allocate memory", __func__); 5281da177e4SLinus Torvalds *out_len = 0; 5291da177e4SLinus Torvalds return -ENOMEM; 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += utflen, o += unilen) { 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds /* convert from UTF-8 to Unicode */ 53574675a58SAlan Stern utflen = utf8_to_utf32(&in[i], in_len - i, &uni); 53674675a58SAlan Stern if (utflen < 0) 5371da177e4SLinus Torvalds goto conv_err; 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds /* convert from Unicode to nls */ 54074675a58SAlan Stern if (uni > MAX_WCHAR_T) 5411da177e4SLinus Torvalds goto conv_err; 54274675a58SAlan Stern unilen = nls->uni2char(uni, &result[o], in_len - o); 54374675a58SAlan Stern if (unilen < 0) 54474675a58SAlan Stern goto conv_err; 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds result[o] = '\0'; 5471da177e4SLinus Torvalds *out_len = o; 5481da177e4SLinus Torvalds 549dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds return o; 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds conv_err: 5541da177e4SLinus Torvalds befs_error(sb, "Name using character set %s contains a character that " 5551da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 556dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 5571da177e4SLinus Torvalds kfree(result); 5581da177e4SLinus Torvalds return -EILSEQ; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds /** 5621da177e4SLinus Torvalds * befs_nls2utf - Convert NLS string to utf8 encodeing 5631da177e4SLinus Torvalds * @sb: Superblock 564817e1d90SFabian Frederick * @in: Input string buffer in NLS format 565817e1d90SFabian Frederick * @in_len: Length of input string in bytes 566817e1d90SFabian Frederick * @out: The output string in UTF-8 format 567817e1d90SFabian Frederick * @out_len: Length of the output buffer 5681da177e4SLinus Torvalds * 569817e1d90SFabian Frederick * Converts input string @in, which is in the format of the loaded NLS map, 5701da177e4SLinus Torvalds * into a utf8 string. 5711da177e4SLinus Torvalds * 572817e1d90SFabian Frederick * The destination string @out is allocated by this function and the caller is 5731da177e4SLinus Torvalds * responsible for freeing it with kfree() 5741da177e4SLinus Torvalds * 575817e1d90SFabian Frederick * On return, *@out_len is the length of @out in bytes. 5761da177e4SLinus Torvalds * 5771da177e4SLinus Torvalds * On success, the return value is the number of utf8 characters written to 578817e1d90SFabian Frederick * the output buffer @out. 5791da177e4SLinus Torvalds * 5801da177e4SLinus Torvalds * On Failure, a negative number coresponding to the error code is returned. 5811da177e4SLinus Torvalds */ 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds static int 5841da177e4SLinus Torvalds befs_nls2utf(struct super_block *sb, const char *in, 5851da177e4SLinus Torvalds int in_len, char **out, int *out_len) 5861da177e4SLinus Torvalds { 5871da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 5881da177e4SLinus Torvalds int i, o; 5891da177e4SLinus Torvalds wchar_t uni; 5901da177e4SLinus Torvalds int unilen, utflen; 5911da177e4SLinus Torvalds char *result; 59294f563c4SDiego Calleja /* There're nls characters that will translate to 3-chars-wide UTF-8 59394f563c4SDiego Calleja * characters, a additional byte is needed to save the final \0 59494f563c4SDiego Calleja * in special cases */ 59594f563c4SDiego Calleja int maxlen = (3 * in_len) + 1; 5961da177e4SLinus Torvalds 597dac52fc1SFabian Frederick befs_debug(sb, "---> %s\n", __func__); 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds if (!nls) { 600dac52fc1SFabian Frederick befs_error(sb, "%s called with no NLS table loaded.", 601dac52fc1SFabian Frederick __func__); 6021da177e4SLinus Torvalds return -EINVAL; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 6061da177e4SLinus Torvalds if (!*out) { 607dac52fc1SFabian Frederick befs_error(sb, "%s cannot allocate memory", __func__); 6081da177e4SLinus Torvalds *out_len = 0; 6091da177e4SLinus Torvalds return -ENOMEM; 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += unilen, o += utflen) { 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds /* convert from nls to unicode */ 6151da177e4SLinus Torvalds unilen = nls->char2uni(&in[i], in_len - i, &uni); 61674675a58SAlan Stern if (unilen < 0) 6171da177e4SLinus Torvalds goto conv_err; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* convert from unicode to UTF-8 */ 62074675a58SAlan Stern utflen = utf32_to_utf8(uni, &result[o], 3); 62174675a58SAlan Stern if (utflen <= 0) 6221da177e4SLinus Torvalds goto conv_err; 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds result[o] = '\0'; 6261da177e4SLinus Torvalds *out_len = o; 6271da177e4SLinus Torvalds 628dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds return i; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds conv_err: 6331da177e4SLinus Torvalds befs_error(sb, "Name using charecter set %s contains a charecter that " 6341da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 635dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 6361da177e4SLinus Torvalds kfree(result); 6371da177e4SLinus Torvalds return -EILSEQ; 6381da177e4SLinus Torvalds } 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds /** 6411da177e4SLinus Torvalds * Use the 6421da177e4SLinus Torvalds * 6431da177e4SLinus Torvalds */ 6441da177e4SLinus Torvalds enum { 6451da177e4SLinus Torvalds Opt_uid, Opt_gid, Opt_charset, Opt_debug, Opt_err, 6461da177e4SLinus Torvalds }; 6471da177e4SLinus Torvalds 648a447c093SSteven Whitehouse static const match_table_t befs_tokens = { 6491da177e4SLinus Torvalds {Opt_uid, "uid=%d"}, 6501da177e4SLinus Torvalds {Opt_gid, "gid=%d"}, 6511da177e4SLinus Torvalds {Opt_charset, "iocharset=%s"}, 6521da177e4SLinus Torvalds {Opt_debug, "debug"}, 6531da177e4SLinus Torvalds {Opt_err, NULL} 6541da177e4SLinus Torvalds }; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds static int 65709ad0eaeSFabian Frederick parse_options(char *options, struct befs_mount_options *opts) 6581da177e4SLinus Torvalds { 6591da177e4SLinus Torvalds char *p; 6601da177e4SLinus Torvalds substring_t args[MAX_OPT_ARGS]; 6611da177e4SLinus Torvalds int option; 66231aba059SEric W. Biederman kuid_t uid; 66331aba059SEric W. Biederman kgid_t gid; 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds /* Initialize options */ 66631aba059SEric W. Biederman opts->uid = GLOBAL_ROOT_UID; 66731aba059SEric W. Biederman opts->gid = GLOBAL_ROOT_GID; 6681da177e4SLinus Torvalds opts->use_uid = 0; 6691da177e4SLinus Torvalds opts->use_gid = 0; 6701da177e4SLinus Torvalds opts->iocharset = NULL; 6711da177e4SLinus Torvalds opts->debug = 0; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds if (!options) 6741da177e4SLinus Torvalds return 1; 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds while ((p = strsep(&options, ",")) != NULL) { 6771da177e4SLinus Torvalds int token; 6781da177e4SLinus Torvalds if (!*p) 6791da177e4SLinus Torvalds continue; 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds token = match_token(p, befs_tokens, args); 6821da177e4SLinus Torvalds switch (token) { 6831da177e4SLinus Torvalds case Opt_uid: 6841da177e4SLinus Torvalds if (match_int(&args[0], &option)) 6851da177e4SLinus Torvalds return 0; 68631aba059SEric W. Biederman uid = INVALID_UID; 68731aba059SEric W. Biederman if (option >= 0) 68831aba059SEric W. Biederman uid = make_kuid(current_user_ns(), option); 68931aba059SEric W. Biederman if (!uid_valid(uid)) { 690dac52fc1SFabian Frederick pr_err("Invalid uid %d, " 6911da177e4SLinus Torvalds "using default\n", option); 6921da177e4SLinus Torvalds break; 6931da177e4SLinus Torvalds } 69431aba059SEric W. Biederman opts->uid = uid; 6951da177e4SLinus Torvalds opts->use_uid = 1; 6961da177e4SLinus Torvalds break; 6971da177e4SLinus Torvalds case Opt_gid: 6981da177e4SLinus Torvalds if (match_int(&args[0], &option)) 6991da177e4SLinus Torvalds return 0; 70031aba059SEric W. Biederman gid = INVALID_GID; 70131aba059SEric W. Biederman if (option >= 0) 70231aba059SEric W. Biederman gid = make_kgid(current_user_ns(), option); 70331aba059SEric W. Biederman if (!gid_valid(gid)) { 704dac52fc1SFabian Frederick pr_err("Invalid gid %d, " 7051da177e4SLinus Torvalds "using default\n", option); 7061da177e4SLinus Torvalds break; 7071da177e4SLinus Torvalds } 70831aba059SEric W. Biederman opts->gid = gid; 7091da177e4SLinus Torvalds opts->use_gid = 1; 7101da177e4SLinus Torvalds break; 7111da177e4SLinus Torvalds case Opt_charset: 7121da177e4SLinus Torvalds kfree(opts->iocharset); 7131da177e4SLinus Torvalds opts->iocharset = match_strdup(&args[0]); 7141da177e4SLinus Torvalds if (!opts->iocharset) { 715dac52fc1SFabian Frederick pr_err("allocation failure for " 7161da177e4SLinus Torvalds "iocharset string\n"); 7171da177e4SLinus Torvalds return 0; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds case Opt_debug: 7211da177e4SLinus Torvalds opts->debug = 1; 7221da177e4SLinus Torvalds break; 7231da177e4SLinus Torvalds default: 724dac52fc1SFabian Frederick pr_err("Unrecognized mount option \"%s\" " 7251da177e4SLinus Torvalds "or missing value\n", p); 7261da177e4SLinus Torvalds return 0; 7271da177e4SLinus Torvalds } 7281da177e4SLinus Torvalds } 7291da177e4SLinus Torvalds return 1; 7301da177e4SLinus Torvalds } 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds /* This function has the responsibiltiy of getting the 7331da177e4SLinus Torvalds * filesystem ready for unmounting. 73425985edcSLucas De Marchi * Basically, we free everything that we allocated in 7351da177e4SLinus Torvalds * befs_read_inode 7361da177e4SLinus Torvalds */ 7371da177e4SLinus Torvalds static void 7381da177e4SLinus Torvalds befs_put_super(struct super_block *sb) 7391da177e4SLinus Torvalds { 7401da177e4SLinus Torvalds kfree(BEFS_SB(sb)->mount_opts.iocharset); 7411da177e4SLinus Torvalds BEFS_SB(sb)->mount_opts.iocharset = NULL; 7421da177e4SLinus Torvalds unload_nls(BEFS_SB(sb)->nls); 7431da177e4SLinus Torvalds kfree(sb->s_fs_info); 7441da177e4SLinus Torvalds sb->s_fs_info = NULL; 7451da177e4SLinus Torvalds } 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds /* Allocate private field of the superblock, fill it. 7481da177e4SLinus Torvalds * 7491da177e4SLinus Torvalds * Finish filling the public superblock fields 7501da177e4SLinus Torvalds * Make the root directory 7511da177e4SLinus Torvalds * Load a set of NLS translations if needed. 7521da177e4SLinus Torvalds */ 7531da177e4SLinus Torvalds static int 7541da177e4SLinus Torvalds befs_fill_super(struct super_block *sb, void *data, int silent) 7551da177e4SLinus Torvalds { 7561da177e4SLinus Torvalds struct buffer_head *bh; 757038428fcSFabian Frederick struct befs_sb_info *befs_sb; 7581da177e4SLinus Torvalds befs_super_block *disk_sb; 7591da177e4SLinus Torvalds struct inode *root; 76096eb5419SDavid Howells long ret = -EINVAL; 7611da177e4SLinus Torvalds const unsigned long sb_block = 0; 7621da177e4SLinus Torvalds const off_t x86_sb_off = 512; 7631da177e4SLinus Torvalds 764552c3c6cSMiklos Szeredi save_mount_options(sb, data); 765552c3c6cSMiklos Szeredi 7662d4319efSFabian Frederick sb->s_fs_info = kzalloc(sizeof(*befs_sb), GFP_KERNEL); 7671da177e4SLinus Torvalds if (sb->s_fs_info == NULL) { 768dac52fc1SFabian Frederick pr_err("(%s): Unable to allocate memory for private " 7691da177e4SLinus Torvalds "portion of superblock. Bailing.\n", sb->s_id); 7700418726bSAdrian Bunk goto unacquire_none; 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds befs_sb = BEFS_SB(sb); 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds if (!parse_options((char *) data, &befs_sb->mount_opts)) { 7751da177e4SLinus Torvalds befs_error(sb, "cannot parse mount options"); 7760418726bSAdrian Bunk goto unacquire_priv_sbp; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds 779dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds if (!(sb->s_flags & MS_RDONLY)) { 7821da177e4SLinus Torvalds befs_warning(sb, 7831da177e4SLinus Torvalds "No write support. Marking filesystem read-only"); 7841da177e4SLinus Torvalds sb->s_flags |= MS_RDONLY; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds /* 7881da177e4SLinus Torvalds * Set dummy blocksize to read super block. 7891da177e4SLinus Torvalds * Will be set to real fs blocksize later. 7901da177e4SLinus Torvalds * 7911da177e4SLinus Torvalds * Linux 2.4.10 and later refuse to read blocks smaller than 7921da177e4SLinus Torvalds * the hardsect size for the device. But we also need to read at 7931da177e4SLinus Torvalds * least 1k to get the second 512 bytes of the volume. 7941da177e4SLinus Torvalds * -WD 10-26-01 7951da177e4SLinus Torvalds */ 7961da177e4SLinus Torvalds sb_min_blocksize(sb, 1024); 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (!(bh = sb_bread(sb, sb_block))) { 7991da177e4SLinus Torvalds befs_error(sb, "unable to read superblock"); 8000418726bSAdrian Bunk goto unacquire_priv_sbp; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds /* account for offset of super block on x86 */ 8041da177e4SLinus Torvalds disk_sb = (befs_super_block *) bh->b_data; 805152b95a1SHarvey Harrison if ((disk_sb->magic1 == BEFS_SUPER_MAGIC1_LE) || 806152b95a1SHarvey Harrison (disk_sb->magic1 == BEFS_SUPER_MAGIC1_BE)) { 8071da177e4SLinus Torvalds befs_debug(sb, "Using PPC superblock location"); 8081da177e4SLinus Torvalds } else { 8091da177e4SLinus Torvalds befs_debug(sb, "Using x86 superblock location"); 8101da177e4SLinus Torvalds disk_sb = 8111da177e4SLinus Torvalds (befs_super_block *) ((void *) bh->b_data + x86_sb_off); 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds 8148e19189eSFabian Frederick if ((befs_load_sb(sb, disk_sb) != BEFS_OK) || 8158e19189eSFabian Frederick (befs_check_sb(sb) != BEFS_OK)) 8160418726bSAdrian Bunk goto unacquire_bh; 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds befs_dump_super_block(sb, disk_sb); 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds brelse(bh); 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds if( befs_sb->num_blocks > ~((sector_t)0) ) { 823dac52fc1SFabian Frederick befs_error(sb, "blocks count: %llu " 8241da177e4SLinus Torvalds "is larger than the host can use", 8251da177e4SLinus Torvalds befs_sb->num_blocks); 8260418726bSAdrian Bunk goto unacquire_priv_sbp; 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds /* 8301da177e4SLinus Torvalds * set up enough so that it can read an inode 8311da177e4SLinus Torvalds * Fill in kernel superblock fields from private sb 8321da177e4SLinus Torvalds */ 8331da177e4SLinus Torvalds sb->s_magic = BEFS_SUPER_MAGIC; 8341da177e4SLinus Torvalds /* Set real blocksize of fs */ 8351da177e4SLinus Torvalds sb_set_blocksize(sb, (ulong) befs_sb->block_size); 836b87221deSAlexey Dobriyan sb->s_op = &befs_sops; 83796eb5419SDavid Howells root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir))); 83896eb5419SDavid Howells if (IS_ERR(root)) { 83996eb5419SDavid Howells ret = PTR_ERR(root); 84096eb5419SDavid Howells goto unacquire_priv_sbp; 84196eb5419SDavid Howells } 84248fde701SAl Viro sb->s_root = d_make_root(root); 8431da177e4SLinus Torvalds if (!sb->s_root) { 8441da177e4SLinus Torvalds befs_error(sb, "get root inode failed"); 8450418726bSAdrian Bunk goto unacquire_priv_sbp; 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds 8481da177e4SLinus Torvalds /* load nls library */ 8491da177e4SLinus Torvalds if (befs_sb->mount_opts.iocharset) { 8501da177e4SLinus Torvalds befs_debug(sb, "Loading nls: %s", 8511da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8521da177e4SLinus Torvalds befs_sb->nls = load_nls(befs_sb->mount_opts.iocharset); 8531da177e4SLinus Torvalds if (!befs_sb->nls) { 8541da177e4SLinus Torvalds befs_warning(sb, "Cannot load nls %s" 8551da177e4SLinus Torvalds " loading default nls", 8561da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8571da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8581da177e4SLinus Torvalds } 8591da177e4SLinus Torvalds /* load default nls if none is specified in mount options */ 8601da177e4SLinus Torvalds } else { 8611da177e4SLinus Torvalds befs_debug(sb, "Loading default nls"); 8621da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds 8651da177e4SLinus Torvalds return 0; 8661da177e4SLinus Torvalds /*****************/ 8670418726bSAdrian Bunk unacquire_bh: 8681da177e4SLinus Torvalds brelse(bh); 8691da177e4SLinus Torvalds 8700418726bSAdrian Bunk unacquire_priv_sbp: 8718dd5ca53SAl Viro kfree(befs_sb->mount_opts.iocharset); 8721da177e4SLinus Torvalds kfree(sb->s_fs_info); 8731da177e4SLinus Torvalds 8740418726bSAdrian Bunk unacquire_none: 8751da177e4SLinus Torvalds sb->s_fs_info = NULL; 87696eb5419SDavid Howells return ret; 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds static int 8801da177e4SLinus Torvalds befs_remount(struct super_block *sb, int *flags, char *data) 8811da177e4SLinus Torvalds { 88202b9984dSTheodore Ts'o sync_filesystem(sb); 8831da177e4SLinus Torvalds if (!(*flags & MS_RDONLY)) 8841da177e4SLinus Torvalds return -EINVAL; 8851da177e4SLinus Torvalds return 0; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds 8881da177e4SLinus Torvalds static int 889726c3342SDavid Howells befs_statfs(struct dentry *dentry, struct kstatfs *buf) 8901da177e4SLinus Torvalds { 891726c3342SDavid Howells struct super_block *sb = dentry->d_sb; 8928587246aSColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 8931da177e4SLinus Torvalds 894dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 8951da177e4SLinus Torvalds 8961da177e4SLinus Torvalds buf->f_type = BEFS_SUPER_MAGIC; 8971da177e4SLinus Torvalds buf->f_bsize = sb->s_blocksize; 8981da177e4SLinus Torvalds buf->f_blocks = BEFS_SB(sb)->num_blocks; 8991da177e4SLinus Torvalds buf->f_bfree = BEFS_SB(sb)->num_blocks - BEFS_SB(sb)->used_blocks; 9001da177e4SLinus Torvalds buf->f_bavail = buf->f_bfree; 9011da177e4SLinus Torvalds buf->f_files = 0; /* UNKNOWN */ 9021da177e4SLinus Torvalds buf->f_ffree = 0; /* UNKNOWN */ 9038587246aSColy Li buf->f_fsid.val[0] = (u32)id; 9048587246aSColy Li buf->f_fsid.val[1] = (u32)(id >> 32); 9051da177e4SLinus Torvalds buf->f_namelen = BEFS_NAME_LEN; 9061da177e4SLinus Torvalds 907dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds return 0; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds 912152a0836SAl Viro static struct dentry * 913152a0836SAl Viro befs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, 914152a0836SAl Viro void *data) 9151da177e4SLinus Torvalds { 916152a0836SAl Viro return mount_bdev(fs_type, flags, dev_name, data, befs_fill_super); 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds static struct file_system_type befs_fs_type = { 9201da177e4SLinus Torvalds .owner = THIS_MODULE, 9211da177e4SLinus Torvalds .name = "befs", 922152a0836SAl Viro .mount = befs_mount, 9231da177e4SLinus Torvalds .kill_sb = kill_block_super, 9241da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV, 9251da177e4SLinus Torvalds }; 9267f78e035SEric W. Biederman MODULE_ALIAS_FS("befs"); 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds static int __init 9291da177e4SLinus Torvalds init_befs_fs(void) 9301da177e4SLinus Torvalds { 9311da177e4SLinus Torvalds int err; 9321da177e4SLinus Torvalds 933dac52fc1SFabian Frederick pr_info("version: %s\n", BEFS_VERSION); 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds err = befs_init_inodecache(); 9361da177e4SLinus Torvalds if (err) 9370418726bSAdrian Bunk goto unacquire_none; 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds err = register_filesystem(&befs_fs_type); 9401da177e4SLinus Torvalds if (err) 9410418726bSAdrian Bunk goto unacquire_inodecache; 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds return 0; 9441da177e4SLinus Torvalds 9450418726bSAdrian Bunk unacquire_inodecache: 9461da177e4SLinus Torvalds befs_destroy_inodecache(); 9471da177e4SLinus Torvalds 9480418726bSAdrian Bunk unacquire_none: 9491da177e4SLinus Torvalds return err; 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds static void __exit 9531da177e4SLinus Torvalds exit_befs_fs(void) 9541da177e4SLinus Torvalds { 9551da177e4SLinus Torvalds befs_destroy_inodecache(); 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds unregister_filesystem(&befs_fs_type); 9581da177e4SLinus Torvalds } 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds /* 9611da177e4SLinus Torvalds Macros that typecheck the init and exit functions, 9621da177e4SLinus Torvalds ensures that they are called at init and cleanup, 9631da177e4SLinus Torvalds and eliminates warnings about unused functions. 9641da177e4SLinus Torvalds */ 9651da177e4SLinus Torvalds module_init(init_befs_fs) 9661da177e4SLinus Torvalds module_exit(exit_befs_fs) 967