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); 45008b150aSAl Viro static void *befs_follow_link(struct dentry *, struct nameidata *); 4648bc06e7SAl Viro static void *befs_fast_follow_link(struct dentry *, struct nameidata *); 471da177e4SLinus Torvalds static int befs_utf2nls(struct super_block *sb, const char *in, int in_len, 481da177e4SLinus Torvalds char **out, int *out_len); 491da177e4SLinus Torvalds static int befs_nls2utf(struct super_block *sb, const char *in, int in_len, 501da177e4SLinus Torvalds char **out, int *out_len); 511da177e4SLinus Torvalds static void befs_put_super(struct super_block *); 521da177e4SLinus Torvalds static int befs_remount(struct super_block *, int *, char *); 53726c3342SDavid Howells static int befs_statfs(struct dentry *, struct kstatfs *); 541da177e4SLinus Torvalds static int parse_options(char *, befs_mount_options *); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds static const struct super_operations befs_sops = { 571da177e4SLinus Torvalds .alloc_inode = befs_alloc_inode, /* allocate a new inode */ 581da177e4SLinus Torvalds .destroy_inode = befs_destroy_inode, /* deallocate an inode */ 591da177e4SLinus Torvalds .put_super = befs_put_super, /* uninit super */ 601da177e4SLinus Torvalds .statfs = befs_statfs, /* statfs */ 611da177e4SLinus Torvalds .remount_fs = befs_remount, 62552c3c6cSMiklos Szeredi .show_options = generic_show_options, 631da177e4SLinus Torvalds }; 641da177e4SLinus Torvalds 651da177e4SLinus Torvalds /* slab cache for befs_inode_info objects */ 66e18b890bSChristoph Lameter static struct kmem_cache *befs_inode_cachep; 671da177e4SLinus Torvalds 684b6f5d20SArjan van de Ven static const struct file_operations befs_dir_operations = { 691da177e4SLinus Torvalds .read = generic_read_dir, 70f0f49ef5SAl Viro .iterate = befs_readdir, 7159af1584SAl Viro .llseek = generic_file_llseek, 721da177e4SLinus Torvalds }; 731da177e4SLinus Torvalds 74754661f1SArjan van de Ven static const struct inode_operations befs_dir_inode_operations = { 751da177e4SLinus Torvalds .lookup = befs_lookup, 761da177e4SLinus Torvalds }; 771da177e4SLinus Torvalds 78f5e54d6eSChristoph Hellwig static const struct address_space_operations befs_aops = { 791da177e4SLinus Torvalds .readpage = befs_readpage, 801da177e4SLinus Torvalds .bmap = befs_bmap, 811da177e4SLinus Torvalds }; 821da177e4SLinus Torvalds 8348bc06e7SAl Viro static const struct inode_operations befs_fast_symlink_inode_operations = { 8448bc06e7SAl Viro .readlink = generic_readlink, 8548bc06e7SAl Viro .follow_link = befs_fast_follow_link, 8648bc06e7SAl Viro }; 8748bc06e7SAl Viro 88754661f1SArjan van de Ven static const struct inode_operations befs_symlink_inode_operations = { 891da177e4SLinus Torvalds .readlink = generic_readlink, 901da177e4SLinus Torvalds .follow_link = befs_follow_link, 9148bc06e7SAl Viro .put_link = kfree_put_link, 921da177e4SLinus Torvalds }; 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* 951da177e4SLinus Torvalds * Called by generic_file_read() to read a page of data 961da177e4SLinus Torvalds * 971da177e4SLinus Torvalds * In turn, simply calls a generic block read function and 981da177e4SLinus Torvalds * passes it the address of befs_get_block, for mapping file 991da177e4SLinus Torvalds * positions to disk blocks. 1001da177e4SLinus Torvalds */ 1011da177e4SLinus Torvalds static int 1021da177e4SLinus Torvalds befs_readpage(struct file *file, struct page *page) 1031da177e4SLinus Torvalds { 1041da177e4SLinus Torvalds return block_read_full_page(page, befs_get_block); 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static sector_t 1081da177e4SLinus Torvalds befs_bmap(struct address_space *mapping, sector_t block) 1091da177e4SLinus Torvalds { 1101da177e4SLinus Torvalds return generic_block_bmap(mapping, block, befs_get_block); 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds /* 1141da177e4SLinus Torvalds * Generic function to map a file position (block) to a 1151da177e4SLinus Torvalds * disk offset (passed back in bh_result). 1161da177e4SLinus Torvalds * 1171da177e4SLinus Torvalds * Used by many higher level functions. 1181da177e4SLinus Torvalds * 1191da177e4SLinus Torvalds * Calls befs_fblock2brun() in datastream.c to do the real work. 1201da177e4SLinus Torvalds * 1211da177e4SLinus Torvalds * -WD 10-26-01 1221da177e4SLinus Torvalds */ 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds static int 1251da177e4SLinus Torvalds befs_get_block(struct inode *inode, sector_t block, 1261da177e4SLinus Torvalds struct buffer_head *bh_result, int create) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 1291da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 1301da177e4SLinus Torvalds befs_block_run run = BAD_IADDR; 1311da177e4SLinus Torvalds int res = 0; 1321da177e4SLinus Torvalds ulong disk_off; 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld", 135dac52fc1SFabian Frederick (unsigned long)inode->i_ino, (long)block); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds if (block < 0) { 1381da177e4SLinus Torvalds befs_error(sb, "befs_get_block() was asked for a block " 1391da177e4SLinus Torvalds "number less than zero: block %ld in inode %lu", 140dac52fc1SFabian Frederick (long)block, (unsigned long)inode->i_ino); 1411da177e4SLinus Torvalds return -EIO; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds if (create) { 1451da177e4SLinus Torvalds befs_error(sb, "befs_get_block() was asked to write to " 146dac52fc1SFabian Frederick "block %ld in inode %lu", (long)block, 147dac52fc1SFabian Frederick (unsigned long)inode->i_ino); 1481da177e4SLinus Torvalds return -EPERM; 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds res = befs_fblock2brun(sb, ds, block, &run); 1521da177e4SLinus Torvalds if (res != BEFS_OK) { 1531da177e4SLinus Torvalds befs_error(sb, 154dac52fc1SFabian Frederick "<--- %s for inode %lu, block %ld ERROR", 155dac52fc1SFabian Frederick __func__, (unsigned long)inode->i_ino, 156dac52fc1SFabian Frederick (long)block); 1571da177e4SLinus Torvalds return -EFBIG; 1581da177e4SLinus Torvalds } 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds disk_off = (ulong) iaddr2blockno(sb, &run); 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds map_bh(bh_result, inode->i_sb, disk_off); 1631da177e4SLinus Torvalds 164dac52fc1SFabian Frederick befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu", 165dac52fc1SFabian Frederick __func__, (unsigned long)inode->i_ino, (long)block, 166dac52fc1SFabian Frederick (unsigned long)disk_off); 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds return 0; 1691da177e4SLinus Torvalds } 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds static struct dentry * 17200cd8dd3SAl Viro befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 1731da177e4SLinus Torvalds { 1741da177e4SLinus Torvalds struct inode *inode = NULL; 1751da177e4SLinus Torvalds struct super_block *sb = dir->i_sb; 1761da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(dir)->i_data.ds; 1771da177e4SLinus Torvalds befs_off_t offset; 1781da177e4SLinus Torvalds int ret; 1791da177e4SLinus Torvalds int utfnamelen; 1801da177e4SLinus Torvalds char *utfname; 1811da177e4SLinus Torvalds const char *name = dentry->d_name.name; 1821da177e4SLinus Torvalds 183dac52fc1SFabian Frederick befs_debug(sb, "---> %s name %s inode %ld", __func__, 184dac52fc1SFabian Frederick dentry->d_name.name, dir->i_ino); 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds /* Convert to UTF-8 */ 1871da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 1881da177e4SLinus Torvalds ret = 1891da177e4SLinus Torvalds befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen); 1901da177e4SLinus Torvalds if (ret < 0) { 191dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 1921da177e4SLinus Torvalds return ERR_PTR(ret); 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, utfname, &offset); 1951da177e4SLinus Torvalds kfree(utfname); 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds } else { 1981da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, dentry->d_name.name, &offset); 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds if (ret == BEFS_BT_NOT_FOUND) { 202dac52fc1SFabian Frederick befs_debug(sb, "<--- %s %s not found", __func__, 2031da177e4SLinus Torvalds dentry->d_name.name); 2041da177e4SLinus Torvalds return ERR_PTR(-ENOENT); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds } else if (ret != BEFS_OK || offset == 0) { 207dac52fc1SFabian Frederick befs_warning(sb, "<--- %s Error", __func__); 2081da177e4SLinus Torvalds return ERR_PTR(-ENODATA); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds 21196eb5419SDavid Howells inode = befs_iget(dir->i_sb, (ino_t) offset); 21296eb5419SDavid Howells if (IS_ERR(inode)) 21396eb5419SDavid Howells return ERR_CAST(inode); 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds d_add(dentry, inode); 2161da177e4SLinus Torvalds 217dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds return NULL; 2201da177e4SLinus Torvalds } 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds static int 223f0f49ef5SAl Viro befs_readdir(struct file *file, struct dir_context *ctx) 2241da177e4SLinus Torvalds { 225f0f49ef5SAl Viro struct inode *inode = file_inode(file); 2261da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 2271da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 2281da177e4SLinus Torvalds befs_off_t value; 2291da177e4SLinus Torvalds int result; 2301da177e4SLinus Torvalds size_t keysize; 2311da177e4SLinus Torvalds unsigned char d_type; 2321da177e4SLinus Torvalds char keybuf[BEFS_NAME_LEN + 1]; 233f0f49ef5SAl Viro const char *dirname = file->f_path.dentry->d_name.name; 2341da177e4SLinus Torvalds 235dac52fc1SFabian Frederick befs_debug(sb, "---> %s name %s, inode %ld, ctx->pos %lld", 236dac52fc1SFabian Frederick __func__, dirname, inode->i_ino, ctx->pos); 2371da177e4SLinus Torvalds 238f0f49ef5SAl Viro more: 239f0f49ef5SAl Viro result = befs_btree_read(sb, ds, ctx->pos, BEFS_NAME_LEN + 1, 2401da177e4SLinus Torvalds keybuf, &keysize, &value); 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds if (result == BEFS_ERR) { 243dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 2441da177e4SLinus Torvalds befs_error(sb, "IO error reading %s (inode %lu)", 2451da177e4SLinus Torvalds dirname, inode->i_ino); 2461da177e4SLinus Torvalds return -EIO; 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds } else if (result == BEFS_BT_END) { 249dac52fc1SFabian Frederick befs_debug(sb, "<--- %s END", __func__); 2501da177e4SLinus Torvalds return 0; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds } else if (result == BEFS_BT_EMPTY) { 253dac52fc1SFabian Frederick befs_debug(sb, "<--- %s Empty directory", __func__); 2541da177e4SLinus Torvalds return 0; 2551da177e4SLinus Torvalds } 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds d_type = DT_UNKNOWN; 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds /* Convert to NLS */ 2601da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 261f0f49ef5SAl Viro char *nlsname; 262f0f49ef5SAl Viro int nlsnamelen; 2631da177e4SLinus Torvalds result = 2641da177e4SLinus Torvalds befs_utf2nls(sb, keybuf, keysize, &nlsname, &nlsnamelen); 2651da177e4SLinus Torvalds if (result < 0) { 266dac52fc1SFabian Frederick befs_debug(sb, "<--- %s ERROR", __func__); 2671da177e4SLinus Torvalds return result; 2681da177e4SLinus Torvalds } 269f0f49ef5SAl Viro if (!dir_emit(ctx, nlsname, nlsnamelen, 270f0f49ef5SAl Viro (ino_t) value, d_type)) { 2711da177e4SLinus Torvalds kfree(nlsname); 272f0f49ef5SAl Viro return 0; 2731da177e4SLinus Torvalds } 274f0f49ef5SAl Viro kfree(nlsname); 275f0f49ef5SAl Viro } else { 276f0f49ef5SAl Viro if (!dir_emit(ctx, keybuf, keysize, 277f0f49ef5SAl Viro (ino_t) value, d_type)) 278f0f49ef5SAl Viro return 0; 279f0f49ef5SAl Viro } 280f0f49ef5SAl Viro ctx->pos++; 281f0f49ef5SAl Viro goto more; 2821da177e4SLinus Torvalds 283dac52fc1SFabian Frederick befs_debug(sb, "<--- %s pos %lld", __func__, ctx->pos); 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds return 0; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds static struct inode * 2891da177e4SLinus Torvalds befs_alloc_inode(struct super_block *sb) 2901da177e4SLinus Torvalds { 2911da177e4SLinus Torvalds struct befs_inode_info *bi; 2921da177e4SLinus Torvalds bi = (struct befs_inode_info *)kmem_cache_alloc(befs_inode_cachep, 293e94b1766SChristoph Lameter GFP_KERNEL); 2941da177e4SLinus Torvalds if (!bi) 2951da177e4SLinus Torvalds return NULL; 2961da177e4SLinus Torvalds return &bi->vfs_inode; 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds 299fa0d7e3dSNick Piggin static void befs_i_callback(struct rcu_head *head) 3001da177e4SLinus Torvalds { 301fa0d7e3dSNick Piggin struct inode *inode = container_of(head, struct inode, i_rcu); 3021da177e4SLinus Torvalds kmem_cache_free(befs_inode_cachep, BEFS_I(inode)); 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 305fa0d7e3dSNick Piggin static void befs_destroy_inode(struct inode *inode) 306fa0d7e3dSNick Piggin { 307fa0d7e3dSNick Piggin call_rcu(&inode->i_rcu, befs_i_callback); 308fa0d7e3dSNick Piggin } 309fa0d7e3dSNick Piggin 31051cc5068SAlexey Dobriyan static void init_once(void *foo) 3111da177e4SLinus Torvalds { 3121da177e4SLinus Torvalds struct befs_inode_info *bi = (struct befs_inode_info *) foo; 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds inode_init_once(&bi->vfs_inode); 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 31796eb5419SDavid Howells static struct inode *befs_iget(struct super_block *sb, unsigned long ino) 3181da177e4SLinus Torvalds { 3191da177e4SLinus Torvalds struct buffer_head *bh = NULL; 3201da177e4SLinus Torvalds befs_inode *raw_inode = NULL; 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds befs_sb_info *befs_sb = BEFS_SB(sb); 3231da177e4SLinus Torvalds befs_inode_info *befs_ino = NULL; 32496eb5419SDavid Howells struct inode *inode; 32596eb5419SDavid Howells long ret = -EIO; 3261da177e4SLinus Torvalds 327dac52fc1SFabian Frederick befs_debug(sb, "---> %s inode = %lu", __func__, ino); 32896eb5419SDavid Howells 32996eb5419SDavid Howells inode = iget_locked(sb, ino); 330ac34a1b3SRakesh Pandit if (!inode) 331ac34a1b3SRakesh Pandit return ERR_PTR(-ENOMEM); 33296eb5419SDavid Howells if (!(inode->i_state & I_NEW)) 33396eb5419SDavid Howells return inode; 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds befs_ino = BEFS_I(inode); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds /* convert from vfs's inode number to befs's inode number */ 3381da177e4SLinus Torvalds befs_ino->i_inode_num = blockno2iaddr(sb, inode->i_ino); 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds befs_debug(sb, " real inode number [%u, %hu, %hu]", 3411da177e4SLinus Torvalds befs_ino->i_inode_num.allocation_group, 3421da177e4SLinus Torvalds befs_ino->i_inode_num.start, befs_ino->i_inode_num.len); 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds bh = befs_bread(sb, inode->i_ino); 3451da177e4SLinus Torvalds if (!bh) { 3461da177e4SLinus Torvalds befs_error(sb, "unable to read inode block - " 3471da177e4SLinus Torvalds "inode = %lu", inode->i_ino); 3480418726bSAdrian Bunk goto unacquire_none; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds raw_inode = (befs_inode *) bh->b_data; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds befs_dump_inode(sb, raw_inode); 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) { 3561da177e4SLinus Torvalds befs_error(sb, "Bad inode: %lu", inode->i_ino); 3570418726bSAdrian Bunk goto unacquire_bh; 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode); 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds /* 3631da177e4SLinus Torvalds * set uid and gid. But since current BeOS is single user OS, so 3641da177e4SLinus Torvalds * you can change by "uid" or "gid" options. 3651da177e4SLinus Torvalds */ 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds inode->i_uid = befs_sb->mount_opts.use_uid ? 36831aba059SEric W. Biederman befs_sb->mount_opts.uid : 36931aba059SEric W. Biederman make_kuid(&init_user_ns, fs32_to_cpu(sb, raw_inode->uid)); 3701da177e4SLinus Torvalds inode->i_gid = befs_sb->mount_opts.use_gid ? 37131aba059SEric W. Biederman befs_sb->mount_opts.gid : 37231aba059SEric W. Biederman make_kgid(&init_user_ns, fs32_to_cpu(sb, raw_inode->gid)); 3731da177e4SLinus Torvalds 374bfe86848SMiklos Szeredi set_nlink(inode, 1); 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds /* 3771da177e4SLinus Torvalds * BEFS's time is 64 bits, but current VFS is 32 bits... 3781da177e4SLinus Torvalds * BEFS don't have access time. Nor inode change time. VFS 3791da177e4SLinus Torvalds * doesn't have creation time. 3801da177e4SLinus Torvalds * Also, the lower 16 bits of the last_modified_time and 3811da177e4SLinus Torvalds * create_time are just a counter to help ensure uniqueness 3821da177e4SLinus Torvalds * for indexing purposes. (PFD, page 54) 3831da177e4SLinus Torvalds */ 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds inode->i_mtime.tv_sec = 3861da177e4SLinus Torvalds fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16; 3871da177e4SLinus Torvalds inode->i_mtime.tv_nsec = 0; /* lower 16 bits are not a time */ 3881da177e4SLinus Torvalds inode->i_ctime = inode->i_mtime; 3891da177e4SLinus Torvalds inode->i_atime = inode->i_mtime; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num); 3921da177e4SLinus Torvalds befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent); 3931da177e4SLinus Torvalds befs_ino->i_attribute = fsrun_to_cpu(sb, raw_inode->attributes); 3941da177e4SLinus Torvalds befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){ 3971da177e4SLinus Torvalds inode->i_size = 0; 3981da177e4SLinus Torvalds inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; 39939d7a29fSFabian Frederick strlcpy(befs_ino->i_data.symlink, raw_inode->data.symlink, 40039d7a29fSFabian Frederick BEFS_SYMLINK_LEN); 4011da177e4SLinus Torvalds } else { 4021da177e4SLinus Torvalds int num_blks; 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds befs_ino->i_data.ds = 405e0e3d32bSJesper Juhl fsds_to_cpu(sb, &raw_inode->data.datastream); 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds num_blks = befs_count_blocks(sb, &befs_ino->i_data.ds); 4081da177e4SLinus Torvalds inode->i_blocks = 4091da177e4SLinus Torvalds num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); 4101da177e4SLinus Torvalds inode->i_size = befs_ino->i_data.ds.size; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds inode->i_mapping->a_ops = &befs_aops; 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds if (S_ISREG(inode->i_mode)) { 4162cf06916SChristoph Hellwig inode->i_fop = &generic_ro_fops; 4171da177e4SLinus Torvalds } else if (S_ISDIR(inode->i_mode)) { 4181da177e4SLinus Torvalds inode->i_op = &befs_dir_inode_operations; 4191da177e4SLinus Torvalds inode->i_fop = &befs_dir_operations; 4201da177e4SLinus Torvalds } else if (S_ISLNK(inode->i_mode)) { 42148bc06e7SAl Viro if (befs_ino->i_flags & BEFS_LONG_SYMLINK) 4221da177e4SLinus Torvalds inode->i_op = &befs_symlink_inode_operations; 42348bc06e7SAl Viro else 42448bc06e7SAl Viro inode->i_op = &befs_fast_symlink_inode_operations; 4251da177e4SLinus Torvalds } else { 4261da177e4SLinus Torvalds befs_error(sb, "Inode %lu is not a regular file, " 4271da177e4SLinus Torvalds "directory or symlink. THAT IS WRONG! BeFS has no " 4281da177e4SLinus Torvalds "on disk special files", inode->i_ino); 4290418726bSAdrian Bunk goto unacquire_bh; 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds brelse(bh); 433dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 43496eb5419SDavid Howells unlock_new_inode(inode); 43596eb5419SDavid Howells return inode; 4361da177e4SLinus Torvalds 4370418726bSAdrian Bunk unacquire_bh: 4381da177e4SLinus Torvalds brelse(bh); 4391da177e4SLinus Torvalds 4400418726bSAdrian Bunk unacquire_none: 44196eb5419SDavid Howells iget_failed(inode); 442dac52fc1SFabian Frederick befs_debug(sb, "<--- %s - Bad inode", __func__); 44396eb5419SDavid Howells return ERR_PTR(ret); 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds /* Initialize the inode cache. Called at fs setup. 4471da177e4SLinus Torvalds * 4481da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4491da177e4SLinus Torvalds */ 45091a52ab7SFabian Frederick static int __init 4511da177e4SLinus Torvalds befs_init_inodecache(void) 4521da177e4SLinus Torvalds { 4531da177e4SLinus Torvalds befs_inode_cachep = kmem_cache_create("befs_inode_cache", 4541da177e4SLinus Torvalds sizeof (struct befs_inode_info), 455fffb60f9SPaul Jackson 0, (SLAB_RECLAIM_ACCOUNT| 456fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 45720c2df83SPaul Mundt init_once); 4581da177e4SLinus Torvalds if (befs_inode_cachep == NULL) { 459dac52fc1SFabian Frederick pr_err("%s: Couldn't initialize inode slabcache\n", __func__); 4601da177e4SLinus Torvalds return -ENOMEM; 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds return 0; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds /* Called at fs teardown. 4661da177e4SLinus Torvalds * 4671da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4681da177e4SLinus Torvalds */ 4691da177e4SLinus Torvalds static void 4701da177e4SLinus Torvalds befs_destroy_inodecache(void) 4711da177e4SLinus Torvalds { 4728c0a8537SKirill A. Shutemov /* 4738c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we 4748c0a8537SKirill A. Shutemov * destroy cache. 4758c0a8537SKirill A. Shutemov */ 4768c0a8537SKirill A. Shutemov rcu_barrier(); 4771a1d92c1SAlexey Dobriyan kmem_cache_destroy(befs_inode_cachep); 4781da177e4SLinus Torvalds } 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds /* 4811da177e4SLinus Torvalds * The inode of symbolic link is different to data stream. 4821da177e4SLinus Torvalds * The data stream become link name. Unless the LONG_SYMLINK 4831da177e4SLinus Torvalds * flag is set. 4841da177e4SLinus Torvalds */ 485db873896SLinus Torvalds static void * 4861da177e4SLinus Torvalds befs_follow_link(struct dentry *dentry, struct nameidata *nd) 4871da177e4SLinus Torvalds { 4881da177e4SLinus Torvalds struct super_block *sb = dentry->d_sb; 48948bc06e7SAl Viro befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 4901da177e4SLinus Torvalds befs_data_stream *data = &befs_ino->i_data.ds; 4911da177e4SLinus Torvalds befs_off_t len = data->size; 49248bc06e7SAl Viro char *link; 4931da177e4SLinus Torvalds 494338d0f0aSTimo Warns if (len == 0) { 495338d0f0aSTimo Warns befs_error(sb, "Long symlink with illegal length"); 496338d0f0aSTimo Warns link = ERR_PTR(-EIO); 497338d0f0aSTimo Warns } else { 4981da177e4SLinus Torvalds befs_debug(sb, "Follow long symlink"); 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds link = kmalloc(len, GFP_NOFS); 5011da177e4SLinus Torvalds if (!link) { 5021da177e4SLinus Torvalds link = ERR_PTR(-ENOMEM); 5031da177e4SLinus Torvalds } else if (befs_read_lsymlink(sb, data, link, len) != len) { 5041da177e4SLinus Torvalds kfree(link); 5051da177e4SLinus Torvalds befs_error(sb, "Failed to read entire long symlink"); 5061da177e4SLinus Torvalds link = ERR_PTR(-EIO); 5077df5fa06SDuane Griffin } else { 5087df5fa06SDuane Griffin link[len - 1] = '\0'; 5091da177e4SLinus Torvalds } 510338d0f0aSTimo Warns } 5111da177e4SLinus Torvalds nd_set_link(nd, link); 512008b150aSAl Viro return NULL; 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 51548bc06e7SAl Viro 51648bc06e7SAl Viro static void * 51748bc06e7SAl Viro befs_fast_follow_link(struct dentry *dentry, struct nameidata *nd) 5181da177e4SLinus Torvalds { 5191da177e4SLinus Torvalds befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 52048bc06e7SAl Viro nd_set_link(nd, befs_ino->i_data.symlink); 52148bc06e7SAl Viro return NULL; 5221da177e4SLinus Torvalds } 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds /* 5251da177e4SLinus Torvalds * UTF-8 to NLS charset convert routine 5261da177e4SLinus Torvalds * 5271da177e4SLinus Torvalds * 5281da177e4SLinus Torvalds * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than 5291da177e4SLinus Torvalds * the nls tables directly 5301da177e4SLinus Torvalds */ 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds static int 5331da177e4SLinus Torvalds befs_utf2nls(struct super_block *sb, const char *in, 5341da177e4SLinus Torvalds int in_len, char **out, int *out_len) 5351da177e4SLinus Torvalds { 5361da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 5371da177e4SLinus Torvalds int i, o; 53874675a58SAlan Stern unicode_t uni; 5391da177e4SLinus Torvalds int unilen, utflen; 5401da177e4SLinus Torvalds char *result; 54194f563c4SDiego Calleja /* The utf8->nls conversion won't make the final nls string bigger 54294f563c4SDiego Calleja * than the utf one, but if the string is pure ascii they'll have the 54394f563c4SDiego Calleja * same width and an extra char is needed to save the additional \0 54494f563c4SDiego Calleja */ 54594f563c4SDiego Calleja int maxlen = in_len + 1; 5461da177e4SLinus Torvalds 547dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (!nls) { 550dac52fc1SFabian Frederick befs_error(sb, "%s called with no NLS table loaded", __func__); 5511da177e4SLinus Torvalds return -EINVAL; 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 5551da177e4SLinus Torvalds if (!*out) { 556dac52fc1SFabian Frederick befs_error(sb, "%s cannot allocate memory", __func__); 5571da177e4SLinus Torvalds *out_len = 0; 5581da177e4SLinus Torvalds return -ENOMEM; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += utflen, o += unilen) { 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds /* convert from UTF-8 to Unicode */ 56474675a58SAlan Stern utflen = utf8_to_utf32(&in[i], in_len - i, &uni); 56574675a58SAlan Stern if (utflen < 0) 5661da177e4SLinus Torvalds goto conv_err; 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds /* convert from Unicode to nls */ 56974675a58SAlan Stern if (uni > MAX_WCHAR_T) 5701da177e4SLinus Torvalds goto conv_err; 57174675a58SAlan Stern unilen = nls->uni2char(uni, &result[o], in_len - o); 57274675a58SAlan Stern if (unilen < 0) 57374675a58SAlan Stern goto conv_err; 5741da177e4SLinus Torvalds } 5751da177e4SLinus Torvalds result[o] = '\0'; 5761da177e4SLinus Torvalds *out_len = o; 5771da177e4SLinus Torvalds 578dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds return o; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds conv_err: 5831da177e4SLinus Torvalds befs_error(sb, "Name using character set %s contains a character that " 5841da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 585dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 5861da177e4SLinus Torvalds kfree(result); 5871da177e4SLinus Torvalds return -EILSEQ; 5881da177e4SLinus Torvalds } 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds /** 5911da177e4SLinus Torvalds * befs_nls2utf - Convert NLS string to utf8 encodeing 5921da177e4SLinus Torvalds * @sb: Superblock 5931da177e4SLinus Torvalds * @src: Input string buffer in NLS format 5941da177e4SLinus Torvalds * @srclen: Length of input string in bytes 5954de151d8SAlexey Dobriyan * @dest: The output string in UTF-8 format 5961da177e4SLinus Torvalds * @destlen: Length of the output buffer 5971da177e4SLinus Torvalds * 5981da177e4SLinus Torvalds * Converts input string @src, which is in the format of the loaded NLS map, 5991da177e4SLinus Torvalds * into a utf8 string. 6001da177e4SLinus Torvalds * 6011da177e4SLinus Torvalds * The destination string @dest is allocated by this function and the caller is 6021da177e4SLinus Torvalds * responsible for freeing it with kfree() 6031da177e4SLinus Torvalds * 6041da177e4SLinus Torvalds * On return, *@destlen is the length of @dest in bytes. 6051da177e4SLinus Torvalds * 6061da177e4SLinus Torvalds * On success, the return value is the number of utf8 characters written to 6071da177e4SLinus Torvalds * the output buffer @dest. 6081da177e4SLinus Torvalds * 6091da177e4SLinus Torvalds * On Failure, a negative number coresponding to the error code is returned. 6101da177e4SLinus Torvalds */ 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds static int 6131da177e4SLinus Torvalds befs_nls2utf(struct super_block *sb, const char *in, 6141da177e4SLinus Torvalds int in_len, char **out, int *out_len) 6151da177e4SLinus Torvalds { 6161da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 6171da177e4SLinus Torvalds int i, o; 6181da177e4SLinus Torvalds wchar_t uni; 6191da177e4SLinus Torvalds int unilen, utflen; 6201da177e4SLinus Torvalds char *result; 62194f563c4SDiego Calleja /* There're nls characters that will translate to 3-chars-wide UTF-8 62294f563c4SDiego Calleja * characters, a additional byte is needed to save the final \0 62394f563c4SDiego Calleja * in special cases */ 62494f563c4SDiego Calleja int maxlen = (3 * in_len) + 1; 6251da177e4SLinus Torvalds 626dac52fc1SFabian Frederick befs_debug(sb, "---> %s\n", __func__); 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if (!nls) { 629dac52fc1SFabian Frederick befs_error(sb, "%s called with no NLS table loaded.", 630dac52fc1SFabian Frederick __func__); 6311da177e4SLinus Torvalds return -EINVAL; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 6351da177e4SLinus Torvalds if (!*out) { 636dac52fc1SFabian Frederick befs_error(sb, "%s cannot allocate memory", __func__); 6371da177e4SLinus Torvalds *out_len = 0; 6381da177e4SLinus Torvalds return -ENOMEM; 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += unilen, o += utflen) { 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds /* convert from nls to unicode */ 6441da177e4SLinus Torvalds unilen = nls->char2uni(&in[i], in_len - i, &uni); 64574675a58SAlan Stern if (unilen < 0) 6461da177e4SLinus Torvalds goto conv_err; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds /* convert from unicode to UTF-8 */ 64974675a58SAlan Stern utflen = utf32_to_utf8(uni, &result[o], 3); 65074675a58SAlan Stern if (utflen <= 0) 6511da177e4SLinus Torvalds goto conv_err; 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds result[o] = '\0'; 6551da177e4SLinus Torvalds *out_len = o; 6561da177e4SLinus Torvalds 657dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds return i; 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds conv_err: 6621da177e4SLinus Torvalds befs_error(sb, "Name using charecter set %s contains a charecter that " 6631da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 664dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 6651da177e4SLinus Torvalds kfree(result); 6661da177e4SLinus Torvalds return -EILSEQ; 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds /** 6701da177e4SLinus Torvalds * Use the 6711da177e4SLinus Torvalds * 6721da177e4SLinus Torvalds */ 6731da177e4SLinus Torvalds enum { 6741da177e4SLinus Torvalds Opt_uid, Opt_gid, Opt_charset, Opt_debug, Opt_err, 6751da177e4SLinus Torvalds }; 6761da177e4SLinus Torvalds 677a447c093SSteven Whitehouse static const match_table_t befs_tokens = { 6781da177e4SLinus Torvalds {Opt_uid, "uid=%d"}, 6791da177e4SLinus Torvalds {Opt_gid, "gid=%d"}, 6801da177e4SLinus Torvalds {Opt_charset, "iocharset=%s"}, 6811da177e4SLinus Torvalds {Opt_debug, "debug"}, 6821da177e4SLinus Torvalds {Opt_err, NULL} 6831da177e4SLinus Torvalds }; 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds static int 6861da177e4SLinus Torvalds parse_options(char *options, befs_mount_options * opts) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds char *p; 6891da177e4SLinus Torvalds substring_t args[MAX_OPT_ARGS]; 6901da177e4SLinus Torvalds int option; 69131aba059SEric W. Biederman kuid_t uid; 69231aba059SEric W. Biederman kgid_t gid; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds /* Initialize options */ 69531aba059SEric W. Biederman opts->uid = GLOBAL_ROOT_UID; 69631aba059SEric W. Biederman opts->gid = GLOBAL_ROOT_GID; 6971da177e4SLinus Torvalds opts->use_uid = 0; 6981da177e4SLinus Torvalds opts->use_gid = 0; 6991da177e4SLinus Torvalds opts->iocharset = NULL; 7001da177e4SLinus Torvalds opts->debug = 0; 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds if (!options) 7031da177e4SLinus Torvalds return 1; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds while ((p = strsep(&options, ",")) != NULL) { 7061da177e4SLinus Torvalds int token; 7071da177e4SLinus Torvalds if (!*p) 7081da177e4SLinus Torvalds continue; 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds token = match_token(p, befs_tokens, args); 7111da177e4SLinus Torvalds switch (token) { 7121da177e4SLinus Torvalds case Opt_uid: 7131da177e4SLinus Torvalds if (match_int(&args[0], &option)) 7141da177e4SLinus Torvalds return 0; 71531aba059SEric W. Biederman uid = INVALID_UID; 71631aba059SEric W. Biederman if (option >= 0) 71731aba059SEric W. Biederman uid = make_kuid(current_user_ns(), option); 71831aba059SEric W. Biederman if (!uid_valid(uid)) { 719dac52fc1SFabian Frederick pr_err("Invalid uid %d, " 7201da177e4SLinus Torvalds "using default\n", option); 7211da177e4SLinus Torvalds break; 7221da177e4SLinus Torvalds } 72331aba059SEric W. Biederman opts->uid = uid; 7241da177e4SLinus Torvalds opts->use_uid = 1; 7251da177e4SLinus Torvalds break; 7261da177e4SLinus Torvalds case Opt_gid: 7271da177e4SLinus Torvalds if (match_int(&args[0], &option)) 7281da177e4SLinus Torvalds return 0; 72931aba059SEric W. Biederman gid = INVALID_GID; 73031aba059SEric W. Biederman if (option >= 0) 73131aba059SEric W. Biederman gid = make_kgid(current_user_ns(), option); 73231aba059SEric W. Biederman if (!gid_valid(gid)) { 733dac52fc1SFabian Frederick pr_err("Invalid gid %d, " 7341da177e4SLinus Torvalds "using default\n", option); 7351da177e4SLinus Torvalds break; 7361da177e4SLinus Torvalds } 73731aba059SEric W. Biederman opts->gid = gid; 7381da177e4SLinus Torvalds opts->use_gid = 1; 7391da177e4SLinus Torvalds break; 7401da177e4SLinus Torvalds case Opt_charset: 7411da177e4SLinus Torvalds kfree(opts->iocharset); 7421da177e4SLinus Torvalds opts->iocharset = match_strdup(&args[0]); 7431da177e4SLinus Torvalds if (!opts->iocharset) { 744dac52fc1SFabian Frederick pr_err("allocation failure for " 7451da177e4SLinus Torvalds "iocharset string\n"); 7461da177e4SLinus Torvalds return 0; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds break; 7491da177e4SLinus Torvalds case Opt_debug: 7501da177e4SLinus Torvalds opts->debug = 1; 7511da177e4SLinus Torvalds break; 7521da177e4SLinus Torvalds default: 753dac52fc1SFabian Frederick pr_err("Unrecognized mount option \"%s\" " 7541da177e4SLinus Torvalds "or missing value\n", p); 7551da177e4SLinus Torvalds return 0; 7561da177e4SLinus Torvalds } 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds return 1; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds /* This function has the responsibiltiy of getting the 7621da177e4SLinus Torvalds * filesystem ready for unmounting. 76325985edcSLucas De Marchi * Basically, we free everything that we allocated in 7641da177e4SLinus Torvalds * befs_read_inode 7651da177e4SLinus Torvalds */ 7661da177e4SLinus Torvalds static void 7671da177e4SLinus Torvalds befs_put_super(struct super_block *sb) 7681da177e4SLinus Torvalds { 7691da177e4SLinus Torvalds kfree(BEFS_SB(sb)->mount_opts.iocharset); 7701da177e4SLinus Torvalds BEFS_SB(sb)->mount_opts.iocharset = NULL; 7711da177e4SLinus Torvalds unload_nls(BEFS_SB(sb)->nls); 7721da177e4SLinus Torvalds kfree(sb->s_fs_info); 7731da177e4SLinus Torvalds sb->s_fs_info = NULL; 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds /* Allocate private field of the superblock, fill it. 7771da177e4SLinus Torvalds * 7781da177e4SLinus Torvalds * Finish filling the public superblock fields 7791da177e4SLinus Torvalds * Make the root directory 7801da177e4SLinus Torvalds * Load a set of NLS translations if needed. 7811da177e4SLinus Torvalds */ 7821da177e4SLinus Torvalds static int 7831da177e4SLinus Torvalds befs_fill_super(struct super_block *sb, void *data, int silent) 7841da177e4SLinus Torvalds { 7851da177e4SLinus Torvalds struct buffer_head *bh; 7861da177e4SLinus Torvalds befs_sb_info *befs_sb; 7871da177e4SLinus Torvalds befs_super_block *disk_sb; 7881da177e4SLinus Torvalds struct inode *root; 78996eb5419SDavid Howells long ret = -EINVAL; 7901da177e4SLinus Torvalds const unsigned long sb_block = 0; 7911da177e4SLinus Torvalds const off_t x86_sb_off = 512; 7921da177e4SLinus Torvalds 793552c3c6cSMiklos Szeredi save_mount_options(sb, data); 794552c3c6cSMiklos Szeredi 7952d4319efSFabian Frederick sb->s_fs_info = kzalloc(sizeof(*befs_sb), GFP_KERNEL); 7961da177e4SLinus Torvalds if (sb->s_fs_info == NULL) { 797dac52fc1SFabian Frederick pr_err("(%s): Unable to allocate memory for private " 7981da177e4SLinus Torvalds "portion of superblock. Bailing.\n", sb->s_id); 7990418726bSAdrian Bunk goto unacquire_none; 8001da177e4SLinus Torvalds } 8011da177e4SLinus Torvalds befs_sb = BEFS_SB(sb); 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds if (!parse_options((char *) data, &befs_sb->mount_opts)) { 8041da177e4SLinus Torvalds befs_error(sb, "cannot parse mount options"); 8050418726bSAdrian Bunk goto unacquire_priv_sbp; 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds 808dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds #ifndef CONFIG_BEFS_RW 8111da177e4SLinus Torvalds if (!(sb->s_flags & MS_RDONLY)) { 8121da177e4SLinus Torvalds befs_warning(sb, 8131da177e4SLinus Torvalds "No write support. Marking filesystem read-only"); 8141da177e4SLinus Torvalds sb->s_flags |= MS_RDONLY; 8151da177e4SLinus Torvalds } 8161da177e4SLinus Torvalds #endif /* CONFIG_BEFS_RW */ 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* 8191da177e4SLinus Torvalds * Set dummy blocksize to read super block. 8201da177e4SLinus Torvalds * Will be set to real fs blocksize later. 8211da177e4SLinus Torvalds * 8221da177e4SLinus Torvalds * Linux 2.4.10 and later refuse to read blocks smaller than 8231da177e4SLinus Torvalds * the hardsect size for the device. But we also need to read at 8241da177e4SLinus Torvalds * least 1k to get the second 512 bytes of the volume. 8251da177e4SLinus Torvalds * -WD 10-26-01 8261da177e4SLinus Torvalds */ 8271da177e4SLinus Torvalds sb_min_blocksize(sb, 1024); 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds if (!(bh = sb_bread(sb, sb_block))) { 8301da177e4SLinus Torvalds befs_error(sb, "unable to read superblock"); 8310418726bSAdrian Bunk goto unacquire_priv_sbp; 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds /* account for offset of super block on x86 */ 8351da177e4SLinus Torvalds disk_sb = (befs_super_block *) bh->b_data; 836152b95a1SHarvey Harrison if ((disk_sb->magic1 == BEFS_SUPER_MAGIC1_LE) || 837152b95a1SHarvey Harrison (disk_sb->magic1 == BEFS_SUPER_MAGIC1_BE)) { 8381da177e4SLinus Torvalds befs_debug(sb, "Using PPC superblock location"); 8391da177e4SLinus Torvalds } else { 8401da177e4SLinus Torvalds befs_debug(sb, "Using x86 superblock location"); 8411da177e4SLinus Torvalds disk_sb = 8421da177e4SLinus Torvalds (befs_super_block *) ((void *) bh->b_data + x86_sb_off); 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds if (befs_load_sb(sb, disk_sb) != BEFS_OK) 8460418726bSAdrian Bunk goto unacquire_bh; 8471da177e4SLinus Torvalds 8481da177e4SLinus Torvalds befs_dump_super_block(sb, disk_sb); 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds brelse(bh); 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds if (befs_check_sb(sb) != BEFS_OK) 8530418726bSAdrian Bunk goto unacquire_priv_sbp; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds if( befs_sb->num_blocks > ~((sector_t)0) ) { 856dac52fc1SFabian Frederick befs_error(sb, "blocks count: %llu " 8571da177e4SLinus Torvalds "is larger than the host can use", 8581da177e4SLinus Torvalds befs_sb->num_blocks); 8590418726bSAdrian Bunk goto unacquire_priv_sbp; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* 8631da177e4SLinus Torvalds * set up enough so that it can read an inode 8641da177e4SLinus Torvalds * Fill in kernel superblock fields from private sb 8651da177e4SLinus Torvalds */ 8661da177e4SLinus Torvalds sb->s_magic = BEFS_SUPER_MAGIC; 8671da177e4SLinus Torvalds /* Set real blocksize of fs */ 8681da177e4SLinus Torvalds sb_set_blocksize(sb, (ulong) befs_sb->block_size); 869b87221deSAlexey Dobriyan sb->s_op = &befs_sops; 87096eb5419SDavid Howells root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir))); 87196eb5419SDavid Howells if (IS_ERR(root)) { 87296eb5419SDavid Howells ret = PTR_ERR(root); 87396eb5419SDavid Howells goto unacquire_priv_sbp; 87496eb5419SDavid Howells } 87548fde701SAl Viro sb->s_root = d_make_root(root); 8761da177e4SLinus Torvalds if (!sb->s_root) { 8771da177e4SLinus Torvalds befs_error(sb, "get root inode failed"); 8780418726bSAdrian Bunk goto unacquire_priv_sbp; 8791da177e4SLinus Torvalds } 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds /* load nls library */ 8821da177e4SLinus Torvalds if (befs_sb->mount_opts.iocharset) { 8831da177e4SLinus Torvalds befs_debug(sb, "Loading nls: %s", 8841da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8851da177e4SLinus Torvalds befs_sb->nls = load_nls(befs_sb->mount_opts.iocharset); 8861da177e4SLinus Torvalds if (!befs_sb->nls) { 8871da177e4SLinus Torvalds befs_warning(sb, "Cannot load nls %s" 8881da177e4SLinus Torvalds " loading default nls", 8891da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8901da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds /* load default nls if none is specified in mount options */ 8931da177e4SLinus Torvalds } else { 8941da177e4SLinus Torvalds befs_debug(sb, "Loading default nls"); 8951da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8961da177e4SLinus Torvalds } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds return 0; 8991da177e4SLinus Torvalds /*****************/ 9000418726bSAdrian Bunk unacquire_bh: 9011da177e4SLinus Torvalds brelse(bh); 9021da177e4SLinus Torvalds 9030418726bSAdrian Bunk unacquire_priv_sbp: 9048dd5ca53SAl Viro kfree(befs_sb->mount_opts.iocharset); 9051da177e4SLinus Torvalds kfree(sb->s_fs_info); 9061da177e4SLinus Torvalds 9070418726bSAdrian Bunk unacquire_none: 9081da177e4SLinus Torvalds sb->s_fs_info = NULL; 90996eb5419SDavid Howells return ret; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds static int 9131da177e4SLinus Torvalds befs_remount(struct super_block *sb, int *flags, char *data) 9141da177e4SLinus Torvalds { 91502b9984dSTheodore Ts'o sync_filesystem(sb); 9161da177e4SLinus Torvalds if (!(*flags & MS_RDONLY)) 9171da177e4SLinus Torvalds return -EINVAL; 9181da177e4SLinus Torvalds return 0; 9191da177e4SLinus Torvalds } 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds static int 922726c3342SDavid Howells befs_statfs(struct dentry *dentry, struct kstatfs *buf) 9231da177e4SLinus Torvalds { 924726c3342SDavid Howells struct super_block *sb = dentry->d_sb; 9258587246aSColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 9261da177e4SLinus Torvalds 927dac52fc1SFabian Frederick befs_debug(sb, "---> %s", __func__); 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds buf->f_type = BEFS_SUPER_MAGIC; 9301da177e4SLinus Torvalds buf->f_bsize = sb->s_blocksize; 9311da177e4SLinus Torvalds buf->f_blocks = BEFS_SB(sb)->num_blocks; 9321da177e4SLinus Torvalds buf->f_bfree = BEFS_SB(sb)->num_blocks - BEFS_SB(sb)->used_blocks; 9331da177e4SLinus Torvalds buf->f_bavail = buf->f_bfree; 9341da177e4SLinus Torvalds buf->f_files = 0; /* UNKNOWN */ 9351da177e4SLinus Torvalds buf->f_ffree = 0; /* UNKNOWN */ 9368587246aSColy Li buf->f_fsid.val[0] = (u32)id; 9378587246aSColy Li buf->f_fsid.val[1] = (u32)(id >> 32); 9381da177e4SLinus Torvalds buf->f_namelen = BEFS_NAME_LEN; 9391da177e4SLinus Torvalds 940dac52fc1SFabian Frederick befs_debug(sb, "<--- %s", __func__); 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds return 0; 9431da177e4SLinus Torvalds } 9441da177e4SLinus Torvalds 945152a0836SAl Viro static struct dentry * 946152a0836SAl Viro befs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, 947152a0836SAl Viro void *data) 9481da177e4SLinus Torvalds { 949152a0836SAl Viro return mount_bdev(fs_type, flags, dev_name, data, befs_fill_super); 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds static struct file_system_type befs_fs_type = { 9531da177e4SLinus Torvalds .owner = THIS_MODULE, 9541da177e4SLinus Torvalds .name = "befs", 955152a0836SAl Viro .mount = befs_mount, 9561da177e4SLinus Torvalds .kill_sb = kill_block_super, 9571da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV, 9581da177e4SLinus Torvalds }; 9597f78e035SEric W. Biederman MODULE_ALIAS_FS("befs"); 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds static int __init 9621da177e4SLinus Torvalds init_befs_fs(void) 9631da177e4SLinus Torvalds { 9641da177e4SLinus Torvalds int err; 9651da177e4SLinus Torvalds 966dac52fc1SFabian Frederick pr_info("version: %s\n", BEFS_VERSION); 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds err = befs_init_inodecache(); 9691da177e4SLinus Torvalds if (err) 9700418726bSAdrian Bunk goto unacquire_none; 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds err = register_filesystem(&befs_fs_type); 9731da177e4SLinus Torvalds if (err) 9740418726bSAdrian Bunk goto unacquire_inodecache; 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds return 0; 9771da177e4SLinus Torvalds 9780418726bSAdrian Bunk unacquire_inodecache: 9791da177e4SLinus Torvalds befs_destroy_inodecache(); 9801da177e4SLinus Torvalds 9810418726bSAdrian Bunk unacquire_none: 9821da177e4SLinus Torvalds return err; 9831da177e4SLinus Torvalds } 9841da177e4SLinus Torvalds 9851da177e4SLinus Torvalds static void __exit 9861da177e4SLinus Torvalds exit_befs_fs(void) 9871da177e4SLinus Torvalds { 9881da177e4SLinus Torvalds befs_destroy_inodecache(); 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds unregister_filesystem(&befs_fs_type); 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds /* 9941da177e4SLinus Torvalds Macros that typecheck the init and exit functions, 9951da177e4SLinus Torvalds ensures that they are called at init and cleanup, 9961da177e4SLinus Torvalds and eliminates warnings about unused functions. 9971da177e4SLinus Torvalds */ 9981da177e4SLinus Torvalds module_init(init_befs_fs) 9991da177e4SLinus Torvalds module_exit(exit_befs_fs) 1000