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 81da177e4SLinus Torvalds #include <linux/module.h> 91da177e4SLinus Torvalds #include <linux/slab.h> 101da177e4SLinus Torvalds #include <linux/fs.h> 111da177e4SLinus Torvalds #include <linux/errno.h> 121da177e4SLinus Torvalds #include <linux/stat.h> 131da177e4SLinus Torvalds #include <linux/nls.h> 141da177e4SLinus Torvalds #include <linux/buffer_head.h> 151da177e4SLinus Torvalds #include <linux/vfs.h> 161da177e4SLinus Torvalds #include <linux/parser.h> 171da177e4SLinus Torvalds #include <linux/namei.h> 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds #include "befs.h" 201da177e4SLinus Torvalds #include "btree.h" 211da177e4SLinus Torvalds #include "inode.h" 221da177e4SLinus Torvalds #include "datastream.h" 231da177e4SLinus Torvalds #include "super.h" 241da177e4SLinus Torvalds #include "io.h" 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds MODULE_DESCRIPTION("BeOS File System (BeFS) driver"); 271da177e4SLinus Torvalds MODULE_AUTHOR("Will Dyson"); 281da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds /* The units the vfs expects inode->i_blocks to be in */ 311da177e4SLinus Torvalds #define VFS_BLOCK_SIZE 512 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds static int befs_readdir(struct file *, void *, filldir_t); 341da177e4SLinus Torvalds static int befs_get_block(struct inode *, sector_t, struct buffer_head *, int); 351da177e4SLinus Torvalds static int befs_readpage(struct file *file, struct page *page); 361da177e4SLinus Torvalds static sector_t befs_bmap(struct address_space *mapping, sector_t block); 371da177e4SLinus Torvalds static struct dentry *befs_lookup(struct inode *, struct dentry *, struct nameidata *); 3896eb5419SDavid Howells static struct inode *befs_iget(struct super_block *, unsigned long); 391da177e4SLinus Torvalds static struct inode *befs_alloc_inode(struct super_block *sb); 401da177e4SLinus Torvalds static void befs_destroy_inode(struct inode *inode); 411da177e4SLinus Torvalds static int befs_init_inodecache(void); 421da177e4SLinus Torvalds static void befs_destroy_inodecache(void); 43008b150aSAl Viro static void *befs_follow_link(struct dentry *, struct nameidata *); 44008b150aSAl Viro static void befs_put_link(struct dentry *, struct nameidata *, void *); 451da177e4SLinus Torvalds static int befs_utf2nls(struct super_block *sb, const char *in, int in_len, 461da177e4SLinus Torvalds char **out, int *out_len); 471da177e4SLinus Torvalds static int befs_nls2utf(struct super_block *sb, const char *in, int in_len, 481da177e4SLinus Torvalds char **out, int *out_len); 491da177e4SLinus Torvalds static void befs_put_super(struct super_block *); 501da177e4SLinus Torvalds static int befs_remount(struct super_block *, int *, char *); 51726c3342SDavid Howells static int befs_statfs(struct dentry *, struct kstatfs *); 521da177e4SLinus Torvalds static int parse_options(char *, befs_mount_options *); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds static const struct super_operations befs_sops = { 551da177e4SLinus Torvalds .alloc_inode = befs_alloc_inode, /* allocate a new inode */ 561da177e4SLinus Torvalds .destroy_inode = befs_destroy_inode, /* deallocate an inode */ 571da177e4SLinus Torvalds .put_super = befs_put_super, /* uninit super */ 581da177e4SLinus Torvalds .statfs = befs_statfs, /* statfs */ 591da177e4SLinus Torvalds .remount_fs = befs_remount, 60552c3c6cSMiklos Szeredi .show_options = generic_show_options, 611da177e4SLinus Torvalds }; 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* slab cache for befs_inode_info objects */ 64e18b890bSChristoph Lameter static struct kmem_cache *befs_inode_cachep; 651da177e4SLinus Torvalds 664b6f5d20SArjan van de Ven static const struct file_operations befs_dir_operations = { 671da177e4SLinus Torvalds .read = generic_read_dir, 681da177e4SLinus Torvalds .readdir = befs_readdir, 6959af1584SAl Viro .llseek = generic_file_llseek, 701da177e4SLinus Torvalds }; 711da177e4SLinus Torvalds 72754661f1SArjan van de Ven static const struct inode_operations befs_dir_inode_operations = { 731da177e4SLinus Torvalds .lookup = befs_lookup, 741da177e4SLinus Torvalds }; 751da177e4SLinus Torvalds 76f5e54d6eSChristoph Hellwig static const struct address_space_operations befs_aops = { 771da177e4SLinus Torvalds .readpage = befs_readpage, 781da177e4SLinus Torvalds .bmap = befs_bmap, 791da177e4SLinus Torvalds }; 801da177e4SLinus Torvalds 81754661f1SArjan van de Ven static const struct inode_operations befs_symlink_inode_operations = { 821da177e4SLinus Torvalds .readlink = generic_readlink, 831da177e4SLinus Torvalds .follow_link = befs_follow_link, 841da177e4SLinus Torvalds .put_link = befs_put_link, 851da177e4SLinus Torvalds }; 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds /* 881da177e4SLinus Torvalds * Called by generic_file_read() to read a page of data 891da177e4SLinus Torvalds * 901da177e4SLinus Torvalds * In turn, simply calls a generic block read function and 911da177e4SLinus Torvalds * passes it the address of befs_get_block, for mapping file 921da177e4SLinus Torvalds * positions to disk blocks. 931da177e4SLinus Torvalds */ 941da177e4SLinus Torvalds static int 951da177e4SLinus Torvalds befs_readpage(struct file *file, struct page *page) 961da177e4SLinus Torvalds { 971da177e4SLinus Torvalds return block_read_full_page(page, befs_get_block); 981da177e4SLinus Torvalds } 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds static sector_t 1011da177e4SLinus Torvalds befs_bmap(struct address_space *mapping, sector_t block) 1021da177e4SLinus Torvalds { 1031da177e4SLinus Torvalds return generic_block_bmap(mapping, block, befs_get_block); 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds /* 1071da177e4SLinus Torvalds * Generic function to map a file position (block) to a 1081da177e4SLinus Torvalds * disk offset (passed back in bh_result). 1091da177e4SLinus Torvalds * 1101da177e4SLinus Torvalds * Used by many higher level functions. 1111da177e4SLinus Torvalds * 1121da177e4SLinus Torvalds * Calls befs_fblock2brun() in datastream.c to do the real work. 1131da177e4SLinus Torvalds * 1141da177e4SLinus Torvalds * -WD 10-26-01 1151da177e4SLinus Torvalds */ 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds static int 1181da177e4SLinus Torvalds befs_get_block(struct inode *inode, sector_t block, 1191da177e4SLinus Torvalds struct buffer_head *bh_result, int create) 1201da177e4SLinus Torvalds { 1211da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 1221da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 1231da177e4SLinus Torvalds befs_block_run run = BAD_IADDR; 1241da177e4SLinus Torvalds int res = 0; 1251da177e4SLinus Torvalds ulong disk_off; 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld", 1281da177e4SLinus Torvalds inode->i_ino, block); 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds if (block < 0) { 1311da177e4SLinus Torvalds befs_error(sb, "befs_get_block() was asked for a block " 1321da177e4SLinus Torvalds "number less than zero: block %ld in inode %lu", 1331da177e4SLinus Torvalds block, inode->i_ino); 1341da177e4SLinus Torvalds return -EIO; 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds if (create) { 1381da177e4SLinus Torvalds befs_error(sb, "befs_get_block() was asked to write to " 1391da177e4SLinus Torvalds "block %ld in inode %lu", block, inode->i_ino); 1401da177e4SLinus Torvalds return -EPERM; 1411da177e4SLinus Torvalds } 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds res = befs_fblock2brun(sb, ds, block, &run); 1441da177e4SLinus Torvalds if (res != BEFS_OK) { 1451da177e4SLinus Torvalds befs_error(sb, 1461da177e4SLinus Torvalds "<--- befs_get_block() for inode %lu, block " 1471da177e4SLinus Torvalds "%ld ERROR", inode->i_ino, block); 1481da177e4SLinus Torvalds return -EFBIG; 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds disk_off = (ulong) iaddr2blockno(sb, &run); 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds map_bh(bh_result, inode->i_sb, disk_off); 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds befs_debug(sb, "<--- befs_get_block() for inode %lu, block %ld, " 1561da177e4SLinus Torvalds "disk address %lu", inode->i_ino, block, disk_off); 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds return 0; 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds static struct dentry * 1621da177e4SLinus Torvalds befs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 1631da177e4SLinus Torvalds { 1641da177e4SLinus Torvalds struct inode *inode = NULL; 1651da177e4SLinus Torvalds struct super_block *sb = dir->i_sb; 1661da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(dir)->i_data.ds; 1671da177e4SLinus Torvalds befs_off_t offset; 1681da177e4SLinus Torvalds int ret; 1691da177e4SLinus Torvalds int utfnamelen; 1701da177e4SLinus Torvalds char *utfname; 1711da177e4SLinus Torvalds const char *name = dentry->d_name.name; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds befs_debug(sb, "---> befs_lookup() " 1741da177e4SLinus Torvalds "name %s inode %ld", dentry->d_name.name, dir->i_ino); 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds /* Convert to UTF-8 */ 1771da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 1781da177e4SLinus Torvalds ret = 1791da177e4SLinus Torvalds befs_nls2utf(sb, name, strlen(name), &utfname, &utfnamelen); 1801da177e4SLinus Torvalds if (ret < 0) { 1811da177e4SLinus Torvalds befs_debug(sb, "<--- befs_lookup() ERROR"); 1821da177e4SLinus Torvalds return ERR_PTR(ret); 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, utfname, &offset); 1851da177e4SLinus Torvalds kfree(utfname); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds } else { 1881da177e4SLinus Torvalds ret = befs_btree_find(sb, ds, dentry->d_name.name, &offset); 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds if (ret == BEFS_BT_NOT_FOUND) { 1921da177e4SLinus Torvalds befs_debug(sb, "<--- befs_lookup() %s not found", 1931da177e4SLinus Torvalds dentry->d_name.name); 1941da177e4SLinus Torvalds return ERR_PTR(-ENOENT); 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds } else if (ret != BEFS_OK || offset == 0) { 1971da177e4SLinus Torvalds befs_warning(sb, "<--- befs_lookup() Error"); 1981da177e4SLinus Torvalds return ERR_PTR(-ENODATA); 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds 20196eb5419SDavid Howells inode = befs_iget(dir->i_sb, (ino_t) offset); 20296eb5419SDavid Howells if (IS_ERR(inode)) 20396eb5419SDavid Howells return ERR_CAST(inode); 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds d_add(dentry, inode); 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds befs_debug(sb, "<--- befs_lookup()"); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds return NULL; 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds static int 2131da177e4SLinus Torvalds befs_readdir(struct file *filp, void *dirent, filldir_t filldir) 2141da177e4SLinus Torvalds { 21528f375fdSJosef Sipek struct inode *inode = filp->f_path.dentry->d_inode; 2161da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 2171da177e4SLinus Torvalds befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; 2181da177e4SLinus Torvalds befs_off_t value; 2191da177e4SLinus Torvalds int result; 2201da177e4SLinus Torvalds size_t keysize; 2211da177e4SLinus Torvalds unsigned char d_type; 2221da177e4SLinus Torvalds char keybuf[BEFS_NAME_LEN + 1]; 2231da177e4SLinus Torvalds char *nlsname; 2241da177e4SLinus Torvalds int nlsnamelen; 22528f375fdSJosef Sipek const char *dirname = filp->f_path.dentry->d_name.name; 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds befs_debug(sb, "---> befs_readdir() " 2281da177e4SLinus Torvalds "name %s, inode %ld, filp->f_pos %Ld", 2291da177e4SLinus Torvalds dirname, inode->i_ino, filp->f_pos); 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds result = befs_btree_read(sb, ds, filp->f_pos, BEFS_NAME_LEN + 1, 2321da177e4SLinus Torvalds keybuf, &keysize, &value); 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds if (result == BEFS_ERR) { 2351da177e4SLinus Torvalds befs_debug(sb, "<--- befs_readdir() ERROR"); 2361da177e4SLinus Torvalds befs_error(sb, "IO error reading %s (inode %lu)", 2371da177e4SLinus Torvalds dirname, inode->i_ino); 2381da177e4SLinus Torvalds return -EIO; 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds } else if (result == BEFS_BT_END) { 2411da177e4SLinus Torvalds befs_debug(sb, "<--- befs_readdir() END"); 2421da177e4SLinus Torvalds return 0; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds } else if (result == BEFS_BT_EMPTY) { 2451da177e4SLinus Torvalds befs_debug(sb, "<--- befs_readdir() Empty directory"); 2461da177e4SLinus Torvalds return 0; 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds d_type = DT_UNKNOWN; 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Convert to NLS */ 2521da177e4SLinus Torvalds if (BEFS_SB(sb)->nls) { 2531da177e4SLinus Torvalds result = 2541da177e4SLinus Torvalds befs_utf2nls(sb, keybuf, keysize, &nlsname, &nlsnamelen); 2551da177e4SLinus Torvalds if (result < 0) { 2561da177e4SLinus Torvalds befs_debug(sb, "<--- befs_readdir() ERROR"); 2571da177e4SLinus Torvalds return result; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds result = filldir(dirent, nlsname, nlsnamelen, filp->f_pos, 2601da177e4SLinus Torvalds (ino_t) value, d_type); 2611da177e4SLinus Torvalds kfree(nlsname); 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds } else { 2641da177e4SLinus Torvalds result = filldir(dirent, keybuf, keysize, filp->f_pos, 2651da177e4SLinus Torvalds (ino_t) value, d_type); 2661da177e4SLinus Torvalds } 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds filp->f_pos++; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds befs_debug(sb, "<--- befs_readdir() filp->f_pos %Ld", filp->f_pos); 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds return 0; 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds static struct inode * 2761da177e4SLinus Torvalds befs_alloc_inode(struct super_block *sb) 2771da177e4SLinus Torvalds { 2781da177e4SLinus Torvalds struct befs_inode_info *bi; 2791da177e4SLinus Torvalds bi = (struct befs_inode_info *)kmem_cache_alloc(befs_inode_cachep, 280e94b1766SChristoph Lameter GFP_KERNEL); 2811da177e4SLinus Torvalds if (!bi) 2821da177e4SLinus Torvalds return NULL; 2831da177e4SLinus Torvalds return &bi->vfs_inode; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 286fa0d7e3dSNick Piggin static void befs_i_callback(struct rcu_head *head) 2871da177e4SLinus Torvalds { 288fa0d7e3dSNick Piggin struct inode *inode = container_of(head, struct inode, i_rcu); 289fa0d7e3dSNick Piggin INIT_LIST_HEAD(&inode->i_dentry); 2901da177e4SLinus Torvalds kmem_cache_free(befs_inode_cachep, BEFS_I(inode)); 2911da177e4SLinus Torvalds } 2921da177e4SLinus Torvalds 293fa0d7e3dSNick Piggin static void befs_destroy_inode(struct inode *inode) 294fa0d7e3dSNick Piggin { 295fa0d7e3dSNick Piggin call_rcu(&inode->i_rcu, befs_i_callback); 296fa0d7e3dSNick Piggin } 297fa0d7e3dSNick Piggin 29851cc5068SAlexey Dobriyan static void init_once(void *foo) 2991da177e4SLinus Torvalds { 3001da177e4SLinus Torvalds struct befs_inode_info *bi = (struct befs_inode_info *) foo; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds inode_init_once(&bi->vfs_inode); 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds 30596eb5419SDavid Howells static struct inode *befs_iget(struct super_block *sb, unsigned long ino) 3061da177e4SLinus Torvalds { 3071da177e4SLinus Torvalds struct buffer_head *bh = NULL; 3081da177e4SLinus Torvalds befs_inode *raw_inode = NULL; 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds befs_sb_info *befs_sb = BEFS_SB(sb); 3111da177e4SLinus Torvalds befs_inode_info *befs_ino = NULL; 31296eb5419SDavid Howells struct inode *inode; 31396eb5419SDavid Howells long ret = -EIO; 3141da177e4SLinus Torvalds 31596eb5419SDavid Howells befs_debug(sb, "---> befs_read_inode() " "inode = %lu", ino); 31696eb5419SDavid Howells 31796eb5419SDavid Howells inode = iget_locked(sb, ino); 31896eb5419SDavid Howells if (IS_ERR(inode)) 31996eb5419SDavid Howells return inode; 32096eb5419SDavid Howells if (!(inode->i_state & I_NEW)) 32196eb5419SDavid Howells return inode; 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds befs_ino = BEFS_I(inode); 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds /* convert from vfs's inode number to befs's inode number */ 3261da177e4SLinus Torvalds befs_ino->i_inode_num = blockno2iaddr(sb, inode->i_ino); 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds befs_debug(sb, " real inode number [%u, %hu, %hu]", 3291da177e4SLinus Torvalds befs_ino->i_inode_num.allocation_group, 3301da177e4SLinus Torvalds befs_ino->i_inode_num.start, befs_ino->i_inode_num.len); 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds bh = befs_bread(sb, inode->i_ino); 3331da177e4SLinus Torvalds if (!bh) { 3341da177e4SLinus Torvalds befs_error(sb, "unable to read inode block - " 3351da177e4SLinus Torvalds "inode = %lu", inode->i_ino); 3360418726bSAdrian Bunk goto unacquire_none; 3371da177e4SLinus Torvalds } 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds raw_inode = (befs_inode *) bh->b_data; 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds befs_dump_inode(sb, raw_inode); 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) { 3441da177e4SLinus Torvalds befs_error(sb, "Bad inode: %lu", inode->i_ino); 3450418726bSAdrian Bunk goto unacquire_bh; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds inode->i_mode = (umode_t) fs32_to_cpu(sb, raw_inode->mode); 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds /* 3511da177e4SLinus Torvalds * set uid and gid. But since current BeOS is single user OS, so 3521da177e4SLinus Torvalds * you can change by "uid" or "gid" options. 3531da177e4SLinus Torvalds */ 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds inode->i_uid = befs_sb->mount_opts.use_uid ? 3561da177e4SLinus Torvalds befs_sb->mount_opts.uid : (uid_t) fs32_to_cpu(sb, raw_inode->uid); 3571da177e4SLinus Torvalds inode->i_gid = befs_sb->mount_opts.use_gid ? 3581da177e4SLinus Torvalds befs_sb->mount_opts.gid : (gid_t) fs32_to_cpu(sb, raw_inode->gid); 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds inode->i_nlink = 1; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds /* 3631da177e4SLinus Torvalds * BEFS's time is 64 bits, but current VFS is 32 bits... 3641da177e4SLinus Torvalds * BEFS don't have access time. Nor inode change time. VFS 3651da177e4SLinus Torvalds * doesn't have creation time. 3661da177e4SLinus Torvalds * Also, the lower 16 bits of the last_modified_time and 3671da177e4SLinus Torvalds * create_time are just a counter to help ensure uniqueness 3681da177e4SLinus Torvalds * for indexing purposes. (PFD, page 54) 3691da177e4SLinus Torvalds */ 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds inode->i_mtime.tv_sec = 3721da177e4SLinus Torvalds fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16; 3731da177e4SLinus Torvalds inode->i_mtime.tv_nsec = 0; /* lower 16 bits are not a time */ 3741da177e4SLinus Torvalds inode->i_ctime = inode->i_mtime; 3751da177e4SLinus Torvalds inode->i_atime = inode->i_mtime; 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num); 3781da177e4SLinus Torvalds befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent); 3791da177e4SLinus Torvalds befs_ino->i_attribute = fsrun_to_cpu(sb, raw_inode->attributes); 3801da177e4SLinus Torvalds befs_ino->i_flags = fs32_to_cpu(sb, raw_inode->flags); 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){ 3831da177e4SLinus Torvalds inode->i_size = 0; 3841da177e4SLinus Torvalds inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; 3851da177e4SLinus Torvalds strncpy(befs_ino->i_data.symlink, raw_inode->data.symlink, 3867df5fa06SDuane Griffin BEFS_SYMLINK_LEN - 1); 3877df5fa06SDuane Griffin befs_ino->i_data.symlink[BEFS_SYMLINK_LEN - 1] = '\0'; 3881da177e4SLinus Torvalds } else { 3891da177e4SLinus Torvalds int num_blks; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds befs_ino->i_data.ds = 392e0e3d32bSJesper Juhl fsds_to_cpu(sb, &raw_inode->data.datastream); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds num_blks = befs_count_blocks(sb, &befs_ino->i_data.ds); 3951da177e4SLinus Torvalds inode->i_blocks = 3961da177e4SLinus Torvalds num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); 3971da177e4SLinus Torvalds inode->i_size = befs_ino->i_data.ds.size; 3981da177e4SLinus Torvalds } 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds inode->i_mapping->a_ops = &befs_aops; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds if (S_ISREG(inode->i_mode)) { 4032cf06916SChristoph Hellwig inode->i_fop = &generic_ro_fops; 4041da177e4SLinus Torvalds } else if (S_ISDIR(inode->i_mode)) { 4051da177e4SLinus Torvalds inode->i_op = &befs_dir_inode_operations; 4061da177e4SLinus Torvalds inode->i_fop = &befs_dir_operations; 4071da177e4SLinus Torvalds } else if (S_ISLNK(inode->i_mode)) { 4081da177e4SLinus Torvalds inode->i_op = &befs_symlink_inode_operations; 4091da177e4SLinus Torvalds } else { 4101da177e4SLinus Torvalds befs_error(sb, "Inode %lu is not a regular file, " 4111da177e4SLinus Torvalds "directory or symlink. THAT IS WRONG! BeFS has no " 4121da177e4SLinus Torvalds "on disk special files", inode->i_ino); 4130418726bSAdrian Bunk goto unacquire_bh; 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds brelse(bh); 4171da177e4SLinus Torvalds befs_debug(sb, "<--- befs_read_inode()"); 41896eb5419SDavid Howells unlock_new_inode(inode); 41996eb5419SDavid Howells return inode; 4201da177e4SLinus Torvalds 4210418726bSAdrian Bunk unacquire_bh: 4221da177e4SLinus Torvalds brelse(bh); 4231da177e4SLinus Torvalds 4240418726bSAdrian Bunk unacquire_none: 42596eb5419SDavid Howells iget_failed(inode); 4261da177e4SLinus Torvalds befs_debug(sb, "<--- befs_read_inode() - Bad inode"); 42796eb5419SDavid Howells return ERR_PTR(ret); 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds /* Initialize the inode cache. Called at fs setup. 4311da177e4SLinus Torvalds * 4321da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4331da177e4SLinus Torvalds */ 4341da177e4SLinus Torvalds static int 4351da177e4SLinus Torvalds befs_init_inodecache(void) 4361da177e4SLinus Torvalds { 4371da177e4SLinus Torvalds befs_inode_cachep = kmem_cache_create("befs_inode_cache", 4381da177e4SLinus Torvalds sizeof (struct befs_inode_info), 439fffb60f9SPaul Jackson 0, (SLAB_RECLAIM_ACCOUNT| 440fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 44120c2df83SPaul Mundt init_once); 4421da177e4SLinus Torvalds if (befs_inode_cachep == NULL) { 4431da177e4SLinus Torvalds printk(KERN_ERR "befs_init_inodecache: " 444421f91d2SUwe Kleine-König "Couldn't initialize inode slabcache\n"); 4451da177e4SLinus Torvalds return -ENOMEM; 4461da177e4SLinus Torvalds } 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds return 0; 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds /* Called at fs teardown. 4521da177e4SLinus Torvalds * 4531da177e4SLinus Torvalds * Taken from NFS implementation by Al Viro. 4541da177e4SLinus Torvalds */ 4551da177e4SLinus Torvalds static void 4561da177e4SLinus Torvalds befs_destroy_inodecache(void) 4571da177e4SLinus Torvalds { 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 */ 466db873896SLinus Torvalds static void * 4671da177e4SLinus Torvalds befs_follow_link(struct dentry *dentry, struct nameidata *nd) 4681da177e4SLinus Torvalds { 4691da177e4SLinus Torvalds befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 4701da177e4SLinus Torvalds char *link; 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds if (befs_ino->i_flags & BEFS_LONG_SYMLINK) { 4731da177e4SLinus Torvalds struct super_block *sb = dentry->d_sb; 4741da177e4SLinus Torvalds befs_data_stream *data = &befs_ino->i_data.ds; 4751da177e4SLinus Torvalds befs_off_t len = data->size; 4761da177e4SLinus Torvalds 477338d0f0aSTimo Warns if (len == 0) { 478338d0f0aSTimo Warns befs_error(sb, "Long symlink with illegal length"); 479338d0f0aSTimo Warns link = ERR_PTR(-EIO); 480338d0f0aSTimo Warns } else { 4811da177e4SLinus Torvalds befs_debug(sb, "Follow long symlink"); 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds link = kmalloc(len, GFP_NOFS); 4841da177e4SLinus Torvalds if (!link) { 4851da177e4SLinus Torvalds link = ERR_PTR(-ENOMEM); 4861da177e4SLinus Torvalds } else if (befs_read_lsymlink(sb, data, link, len) != len) { 4871da177e4SLinus Torvalds kfree(link); 4881da177e4SLinus Torvalds befs_error(sb, "Failed to read entire long symlink"); 4891da177e4SLinus Torvalds link = ERR_PTR(-EIO); 4907df5fa06SDuane Griffin } else { 4917df5fa06SDuane Griffin link[len - 1] = '\0'; 4921da177e4SLinus Torvalds } 493338d0f0aSTimo Warns } 4941da177e4SLinus Torvalds } else { 4951da177e4SLinus Torvalds link = befs_ino->i_data.symlink; 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds nd_set_link(nd, link); 499008b150aSAl Viro return NULL; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 502008b150aSAl Viro static void befs_put_link(struct dentry *dentry, struct nameidata *nd, void *p) 5031da177e4SLinus Torvalds { 5041da177e4SLinus Torvalds befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 5051da177e4SLinus Torvalds if (befs_ino->i_flags & BEFS_LONG_SYMLINK) { 50663e3453eSHarvey Harrison char *link = nd_get_link(nd); 50763e3453eSHarvey Harrison if (!IS_ERR(link)) 50863e3453eSHarvey Harrison kfree(link); 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds /* 5131da177e4SLinus Torvalds * UTF-8 to NLS charset convert routine 5141da177e4SLinus Torvalds * 5151da177e4SLinus Torvalds * 5161da177e4SLinus Torvalds * Changed 8/10/01 by Will Dyson. Now use uni2char() / char2uni() rather than 5171da177e4SLinus Torvalds * the nls tables directly 5181da177e4SLinus Torvalds */ 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds static int 5211da177e4SLinus Torvalds befs_utf2nls(struct super_block *sb, const char *in, 5221da177e4SLinus Torvalds int in_len, char **out, int *out_len) 5231da177e4SLinus Torvalds { 5241da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 5251da177e4SLinus Torvalds int i, o; 52674675a58SAlan Stern unicode_t uni; 5271da177e4SLinus Torvalds int unilen, utflen; 5281da177e4SLinus Torvalds char *result; 52994f563c4SDiego Calleja /* The utf8->nls conversion won't make the final nls string bigger 53094f563c4SDiego Calleja * than the utf one, but if the string is pure ascii they'll have the 53194f563c4SDiego Calleja * same width and an extra char is needed to save the additional \0 53294f563c4SDiego Calleja */ 53394f563c4SDiego Calleja int maxlen = in_len + 1; 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds befs_debug(sb, "---> utf2nls()"); 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds if (!nls) { 5381da177e4SLinus Torvalds befs_error(sb, "befs_utf2nls called with no NLS table loaded"); 5391da177e4SLinus Torvalds return -EINVAL; 5401da177e4SLinus Torvalds } 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 5431da177e4SLinus Torvalds if (!*out) { 5441da177e4SLinus Torvalds befs_error(sb, "befs_utf2nls() cannot allocate memory"); 5451da177e4SLinus Torvalds *out_len = 0; 5461da177e4SLinus Torvalds return -ENOMEM; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += utflen, o += unilen) { 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds /* convert from UTF-8 to Unicode */ 55274675a58SAlan Stern utflen = utf8_to_utf32(&in[i], in_len - i, &uni); 55374675a58SAlan Stern if (utflen < 0) 5541da177e4SLinus Torvalds goto conv_err; 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds /* convert from Unicode to nls */ 55774675a58SAlan Stern if (uni > MAX_WCHAR_T) 5581da177e4SLinus Torvalds goto conv_err; 55974675a58SAlan Stern unilen = nls->uni2char(uni, &result[o], in_len - o); 56074675a58SAlan Stern if (unilen < 0) 56174675a58SAlan Stern goto conv_err; 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds result[o] = '\0'; 5641da177e4SLinus Torvalds *out_len = o; 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds befs_debug(sb, "<--- utf2nls()"); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds return o; 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds conv_err: 5711da177e4SLinus Torvalds befs_error(sb, "Name using character set %s contains a character that " 5721da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 5731da177e4SLinus Torvalds befs_debug(sb, "<--- utf2nls()"); 5741da177e4SLinus Torvalds kfree(result); 5751da177e4SLinus Torvalds return -EILSEQ; 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds /** 5791da177e4SLinus Torvalds * befs_nls2utf - Convert NLS string to utf8 encodeing 5801da177e4SLinus Torvalds * @sb: Superblock 5811da177e4SLinus Torvalds * @src: Input string buffer in NLS format 5821da177e4SLinus Torvalds * @srclen: Length of input string in bytes 5834de151d8SAlexey Dobriyan * @dest: The output string in UTF-8 format 5841da177e4SLinus Torvalds * @destlen: Length of the output buffer 5851da177e4SLinus Torvalds * 5861da177e4SLinus Torvalds * Converts input string @src, which is in the format of the loaded NLS map, 5871da177e4SLinus Torvalds * into a utf8 string. 5881da177e4SLinus Torvalds * 5891da177e4SLinus Torvalds * The destination string @dest is allocated by this function and the caller is 5901da177e4SLinus Torvalds * responsible for freeing it with kfree() 5911da177e4SLinus Torvalds * 5921da177e4SLinus Torvalds * On return, *@destlen is the length of @dest in bytes. 5931da177e4SLinus Torvalds * 5941da177e4SLinus Torvalds * On success, the return value is the number of utf8 characters written to 5951da177e4SLinus Torvalds * the output buffer @dest. 5961da177e4SLinus Torvalds * 5971da177e4SLinus Torvalds * On Failure, a negative number coresponding to the error code is returned. 5981da177e4SLinus Torvalds */ 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds static int 6011da177e4SLinus Torvalds befs_nls2utf(struct super_block *sb, const char *in, 6021da177e4SLinus Torvalds int in_len, char **out, int *out_len) 6031da177e4SLinus Torvalds { 6041da177e4SLinus Torvalds struct nls_table *nls = BEFS_SB(sb)->nls; 6051da177e4SLinus Torvalds int i, o; 6061da177e4SLinus Torvalds wchar_t uni; 6071da177e4SLinus Torvalds int unilen, utflen; 6081da177e4SLinus Torvalds char *result; 60994f563c4SDiego Calleja /* There're nls characters that will translate to 3-chars-wide UTF-8 61094f563c4SDiego Calleja * characters, a additional byte is needed to save the final \0 61194f563c4SDiego Calleja * in special cases */ 61294f563c4SDiego Calleja int maxlen = (3 * in_len) + 1; 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds befs_debug(sb, "---> nls2utf()\n"); 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds if (!nls) { 6171da177e4SLinus Torvalds befs_error(sb, "befs_nls2utf called with no NLS table loaded."); 6181da177e4SLinus Torvalds return -EINVAL; 6191da177e4SLinus Torvalds } 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds *out = result = kmalloc(maxlen, GFP_NOFS); 6221da177e4SLinus Torvalds if (!*out) { 6231da177e4SLinus Torvalds befs_error(sb, "befs_nls2utf() cannot allocate memory"); 6241da177e4SLinus Torvalds *out_len = 0; 6251da177e4SLinus Torvalds return -ENOMEM; 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds for (i = o = 0; i < in_len; i += unilen, o += utflen) { 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* convert from nls to unicode */ 6311da177e4SLinus Torvalds unilen = nls->char2uni(&in[i], in_len - i, &uni); 63274675a58SAlan Stern if (unilen < 0) 6331da177e4SLinus Torvalds goto conv_err; 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds /* convert from unicode to UTF-8 */ 63674675a58SAlan Stern utflen = utf32_to_utf8(uni, &result[o], 3); 63774675a58SAlan Stern if (utflen <= 0) 6381da177e4SLinus Torvalds goto conv_err; 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds result[o] = '\0'; 6421da177e4SLinus Torvalds *out_len = o; 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds befs_debug(sb, "<--- nls2utf()"); 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds return i; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds conv_err: 6491da177e4SLinus Torvalds befs_error(sb, "Name using charecter set %s contains a charecter that " 6501da177e4SLinus Torvalds "cannot be converted to unicode.", nls->charset); 6511da177e4SLinus Torvalds befs_debug(sb, "<--- nls2utf()"); 6521da177e4SLinus Torvalds kfree(result); 6531da177e4SLinus Torvalds return -EILSEQ; 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds /** 6571da177e4SLinus Torvalds * Use the 6581da177e4SLinus Torvalds * 6591da177e4SLinus Torvalds */ 6601da177e4SLinus Torvalds enum { 6611da177e4SLinus Torvalds Opt_uid, Opt_gid, Opt_charset, Opt_debug, Opt_err, 6621da177e4SLinus Torvalds }; 6631da177e4SLinus Torvalds 664a447c093SSteven Whitehouse static const match_table_t befs_tokens = { 6651da177e4SLinus Torvalds {Opt_uid, "uid=%d"}, 6661da177e4SLinus Torvalds {Opt_gid, "gid=%d"}, 6671da177e4SLinus Torvalds {Opt_charset, "iocharset=%s"}, 6681da177e4SLinus Torvalds {Opt_debug, "debug"}, 6691da177e4SLinus Torvalds {Opt_err, NULL} 6701da177e4SLinus Torvalds }; 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds static int 6731da177e4SLinus Torvalds parse_options(char *options, befs_mount_options * opts) 6741da177e4SLinus Torvalds { 6751da177e4SLinus Torvalds char *p; 6761da177e4SLinus Torvalds substring_t args[MAX_OPT_ARGS]; 6771da177e4SLinus Torvalds int option; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* Initialize options */ 6801da177e4SLinus Torvalds opts->uid = 0; 6811da177e4SLinus Torvalds opts->gid = 0; 6821da177e4SLinus Torvalds opts->use_uid = 0; 6831da177e4SLinus Torvalds opts->use_gid = 0; 6841da177e4SLinus Torvalds opts->iocharset = NULL; 6851da177e4SLinus Torvalds opts->debug = 0; 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds if (!options) 6881da177e4SLinus Torvalds return 1; 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds while ((p = strsep(&options, ",")) != NULL) { 6911da177e4SLinus Torvalds int token; 6921da177e4SLinus Torvalds if (!*p) 6931da177e4SLinus Torvalds continue; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds token = match_token(p, befs_tokens, args); 6961da177e4SLinus Torvalds switch (token) { 6971da177e4SLinus Torvalds case Opt_uid: 6981da177e4SLinus Torvalds if (match_int(&args[0], &option)) 6991da177e4SLinus Torvalds return 0; 7001da177e4SLinus Torvalds if (option < 0) { 7011da177e4SLinus Torvalds printk(KERN_ERR "BeFS: Invalid uid %d, " 7021da177e4SLinus Torvalds "using default\n", option); 7031da177e4SLinus Torvalds break; 7041da177e4SLinus Torvalds } 7051da177e4SLinus Torvalds opts->uid = option; 7061da177e4SLinus Torvalds opts->use_uid = 1; 7071da177e4SLinus Torvalds break; 7081da177e4SLinus Torvalds case Opt_gid: 7091da177e4SLinus Torvalds if (match_int(&args[0], &option)) 7101da177e4SLinus Torvalds return 0; 7111da177e4SLinus Torvalds if (option < 0) { 7121da177e4SLinus Torvalds printk(KERN_ERR "BeFS: Invalid gid %d, " 7131da177e4SLinus Torvalds "using default\n", option); 7141da177e4SLinus Torvalds break; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds opts->gid = option; 7171da177e4SLinus Torvalds opts->use_gid = 1; 7181da177e4SLinus Torvalds break; 7191da177e4SLinus Torvalds case Opt_charset: 7201da177e4SLinus Torvalds kfree(opts->iocharset); 7211da177e4SLinus Torvalds opts->iocharset = match_strdup(&args[0]); 7221da177e4SLinus Torvalds if (!opts->iocharset) { 7231da177e4SLinus Torvalds printk(KERN_ERR "BeFS: allocation failure for " 7241da177e4SLinus Torvalds "iocharset string\n"); 7251da177e4SLinus Torvalds return 0; 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds break; 7281da177e4SLinus Torvalds case Opt_debug: 7291da177e4SLinus Torvalds opts->debug = 1; 7301da177e4SLinus Torvalds break; 7311da177e4SLinus Torvalds default: 7321da177e4SLinus Torvalds printk(KERN_ERR "BeFS: Unrecognized mount option \"%s\" " 7331da177e4SLinus Torvalds "or missing value\n", p); 7341da177e4SLinus Torvalds return 0; 7351da177e4SLinus Torvalds } 7361da177e4SLinus Torvalds } 7371da177e4SLinus Torvalds return 1; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds /* This function has the responsibiltiy of getting the 7411da177e4SLinus Torvalds * filesystem ready for unmounting. 74225985edcSLucas De Marchi * Basically, we free everything that we allocated in 7431da177e4SLinus Torvalds * befs_read_inode 7441da177e4SLinus Torvalds */ 7451da177e4SLinus Torvalds static void 7461da177e4SLinus Torvalds befs_put_super(struct super_block *sb) 7471da177e4SLinus Torvalds { 7481da177e4SLinus Torvalds kfree(BEFS_SB(sb)->mount_opts.iocharset); 7491da177e4SLinus Torvalds BEFS_SB(sb)->mount_opts.iocharset = NULL; 7501da177e4SLinus Torvalds unload_nls(BEFS_SB(sb)->nls); 7511da177e4SLinus Torvalds kfree(sb->s_fs_info); 7521da177e4SLinus Torvalds sb->s_fs_info = NULL; 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds /* Allocate private field of the superblock, fill it. 7561da177e4SLinus Torvalds * 7571da177e4SLinus Torvalds * Finish filling the public superblock fields 7581da177e4SLinus Torvalds * Make the root directory 7591da177e4SLinus Torvalds * Load a set of NLS translations if needed. 7601da177e4SLinus Torvalds */ 7611da177e4SLinus Torvalds static int 7621da177e4SLinus Torvalds befs_fill_super(struct super_block *sb, void *data, int silent) 7631da177e4SLinus Torvalds { 7641da177e4SLinus Torvalds struct buffer_head *bh; 7651da177e4SLinus Torvalds befs_sb_info *befs_sb; 7661da177e4SLinus Torvalds befs_super_block *disk_sb; 7671da177e4SLinus Torvalds struct inode *root; 76896eb5419SDavid Howells long ret = -EINVAL; 7691da177e4SLinus Torvalds const unsigned long sb_block = 0; 7701da177e4SLinus Torvalds const off_t x86_sb_off = 512; 7711da177e4SLinus Torvalds 772552c3c6cSMiklos Szeredi save_mount_options(sb, data); 773552c3c6cSMiklos Szeredi 7741da177e4SLinus Torvalds sb->s_fs_info = kmalloc(sizeof (*befs_sb), GFP_KERNEL); 7751da177e4SLinus Torvalds if (sb->s_fs_info == NULL) { 7761da177e4SLinus Torvalds printk(KERN_ERR 7771da177e4SLinus Torvalds "BeFS(%s): Unable to allocate memory for private " 7781da177e4SLinus Torvalds "portion of superblock. Bailing.\n", sb->s_id); 7790418726bSAdrian Bunk goto unacquire_none; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds befs_sb = BEFS_SB(sb); 7821da177e4SLinus Torvalds memset(befs_sb, 0, sizeof(befs_sb_info)); 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds if (!parse_options((char *) data, &befs_sb->mount_opts)) { 7851da177e4SLinus Torvalds befs_error(sb, "cannot parse mount options"); 7860418726bSAdrian Bunk goto unacquire_priv_sbp; 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds befs_debug(sb, "---> befs_fill_super()"); 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds #ifndef CONFIG_BEFS_RW 7921da177e4SLinus Torvalds if (!(sb->s_flags & MS_RDONLY)) { 7931da177e4SLinus Torvalds befs_warning(sb, 7941da177e4SLinus Torvalds "No write support. Marking filesystem read-only"); 7951da177e4SLinus Torvalds sb->s_flags |= MS_RDONLY; 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds #endif /* CONFIG_BEFS_RW */ 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds /* 8001da177e4SLinus Torvalds * Set dummy blocksize to read super block. 8011da177e4SLinus Torvalds * Will be set to real fs blocksize later. 8021da177e4SLinus Torvalds * 8031da177e4SLinus Torvalds * Linux 2.4.10 and later refuse to read blocks smaller than 8041da177e4SLinus Torvalds * the hardsect size for the device. But we also need to read at 8051da177e4SLinus Torvalds * least 1k to get the second 512 bytes of the volume. 8061da177e4SLinus Torvalds * -WD 10-26-01 8071da177e4SLinus Torvalds */ 8081da177e4SLinus Torvalds sb_min_blocksize(sb, 1024); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds if (!(bh = sb_bread(sb, sb_block))) { 8111da177e4SLinus Torvalds befs_error(sb, "unable to read superblock"); 8120418726bSAdrian Bunk goto unacquire_priv_sbp; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds /* account for offset of super block on x86 */ 8161da177e4SLinus Torvalds disk_sb = (befs_super_block *) bh->b_data; 817152b95a1SHarvey Harrison if ((disk_sb->magic1 == BEFS_SUPER_MAGIC1_LE) || 818152b95a1SHarvey Harrison (disk_sb->magic1 == BEFS_SUPER_MAGIC1_BE)) { 8191da177e4SLinus Torvalds befs_debug(sb, "Using PPC superblock location"); 8201da177e4SLinus Torvalds } else { 8211da177e4SLinus Torvalds befs_debug(sb, "Using x86 superblock location"); 8221da177e4SLinus Torvalds disk_sb = 8231da177e4SLinus Torvalds (befs_super_block *) ((void *) bh->b_data + x86_sb_off); 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds if (befs_load_sb(sb, disk_sb) != BEFS_OK) 8270418726bSAdrian Bunk goto unacquire_bh; 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds befs_dump_super_block(sb, disk_sb); 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds brelse(bh); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds if (befs_check_sb(sb) != BEFS_OK) 8340418726bSAdrian Bunk goto unacquire_priv_sbp; 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds if( befs_sb->num_blocks > ~((sector_t)0) ) { 8371da177e4SLinus Torvalds befs_error(sb, "blocks count: %Lu " 8381da177e4SLinus Torvalds "is larger than the host can use", 8391da177e4SLinus Torvalds befs_sb->num_blocks); 8400418726bSAdrian Bunk goto unacquire_priv_sbp; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds /* 8441da177e4SLinus Torvalds * set up enough so that it can read an inode 8451da177e4SLinus Torvalds * Fill in kernel superblock fields from private sb 8461da177e4SLinus Torvalds */ 8471da177e4SLinus Torvalds sb->s_magic = BEFS_SUPER_MAGIC; 8481da177e4SLinus Torvalds /* Set real blocksize of fs */ 8491da177e4SLinus Torvalds sb_set_blocksize(sb, (ulong) befs_sb->block_size); 850b87221deSAlexey Dobriyan sb->s_op = &befs_sops; 85196eb5419SDavid Howells root = befs_iget(sb, iaddr2blockno(sb, &(befs_sb->root_dir))); 85296eb5419SDavid Howells if (IS_ERR(root)) { 85396eb5419SDavid Howells ret = PTR_ERR(root); 85496eb5419SDavid Howells goto unacquire_priv_sbp; 85596eb5419SDavid Howells } 8561da177e4SLinus Torvalds sb->s_root = d_alloc_root(root); 8571da177e4SLinus Torvalds if (!sb->s_root) { 8581da177e4SLinus Torvalds iput(root); 8591da177e4SLinus Torvalds befs_error(sb, "get root inode failed"); 8600418726bSAdrian Bunk goto unacquire_priv_sbp; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds /* load nls library */ 8641da177e4SLinus Torvalds if (befs_sb->mount_opts.iocharset) { 8651da177e4SLinus Torvalds befs_debug(sb, "Loading nls: %s", 8661da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8671da177e4SLinus Torvalds befs_sb->nls = load_nls(befs_sb->mount_opts.iocharset); 8681da177e4SLinus Torvalds if (!befs_sb->nls) { 8691da177e4SLinus Torvalds befs_warning(sb, "Cannot load nls %s" 8701da177e4SLinus Torvalds " loading default nls", 8711da177e4SLinus Torvalds befs_sb->mount_opts.iocharset); 8721da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds /* load default nls if none is specified in mount options */ 8751da177e4SLinus Torvalds } else { 8761da177e4SLinus Torvalds befs_debug(sb, "Loading default nls"); 8771da177e4SLinus Torvalds befs_sb->nls = load_nls_default(); 8781da177e4SLinus Torvalds } 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds return 0; 8811da177e4SLinus Torvalds /*****************/ 8820418726bSAdrian Bunk unacquire_bh: 8831da177e4SLinus Torvalds brelse(bh); 8841da177e4SLinus Torvalds 8850418726bSAdrian Bunk unacquire_priv_sbp: 8868dd5ca53SAl Viro kfree(befs_sb->mount_opts.iocharset); 8871da177e4SLinus Torvalds kfree(sb->s_fs_info); 8881da177e4SLinus Torvalds 8890418726bSAdrian Bunk unacquire_none: 8901da177e4SLinus Torvalds sb->s_fs_info = NULL; 89196eb5419SDavid Howells return ret; 8921da177e4SLinus Torvalds } 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds static int 8951da177e4SLinus Torvalds befs_remount(struct super_block *sb, int *flags, char *data) 8961da177e4SLinus Torvalds { 8971da177e4SLinus Torvalds if (!(*flags & MS_RDONLY)) 8981da177e4SLinus Torvalds return -EINVAL; 8991da177e4SLinus Torvalds return 0; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds static int 903726c3342SDavid Howells befs_statfs(struct dentry *dentry, struct kstatfs *buf) 9041da177e4SLinus Torvalds { 905726c3342SDavid Howells struct super_block *sb = dentry->d_sb; 9068587246aSColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds befs_debug(sb, "---> befs_statfs()"); 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds buf->f_type = BEFS_SUPER_MAGIC; 9111da177e4SLinus Torvalds buf->f_bsize = sb->s_blocksize; 9121da177e4SLinus Torvalds buf->f_blocks = BEFS_SB(sb)->num_blocks; 9131da177e4SLinus Torvalds buf->f_bfree = BEFS_SB(sb)->num_blocks - BEFS_SB(sb)->used_blocks; 9141da177e4SLinus Torvalds buf->f_bavail = buf->f_bfree; 9151da177e4SLinus Torvalds buf->f_files = 0; /* UNKNOWN */ 9161da177e4SLinus Torvalds buf->f_ffree = 0; /* UNKNOWN */ 9178587246aSColy Li buf->f_fsid.val[0] = (u32)id; 9188587246aSColy Li buf->f_fsid.val[1] = (u32)(id >> 32); 9191da177e4SLinus Torvalds buf->f_namelen = BEFS_NAME_LEN; 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds befs_debug(sb, "<--- befs_statfs()"); 9221da177e4SLinus Torvalds 9231da177e4SLinus Torvalds return 0; 9241da177e4SLinus Torvalds } 9251da177e4SLinus Torvalds 926152a0836SAl Viro static struct dentry * 927152a0836SAl Viro befs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, 928152a0836SAl Viro void *data) 9291da177e4SLinus Torvalds { 930152a0836SAl Viro return mount_bdev(fs_type, flags, dev_name, data, befs_fill_super); 9311da177e4SLinus Torvalds } 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds static struct file_system_type befs_fs_type = { 9341da177e4SLinus Torvalds .owner = THIS_MODULE, 9351da177e4SLinus Torvalds .name = "befs", 936152a0836SAl Viro .mount = befs_mount, 9371da177e4SLinus Torvalds .kill_sb = kill_block_super, 9381da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV, 9391da177e4SLinus Torvalds }; 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds static int __init 9421da177e4SLinus Torvalds init_befs_fs(void) 9431da177e4SLinus Torvalds { 9441da177e4SLinus Torvalds int err; 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds printk(KERN_INFO "BeFS version: %s\n", BEFS_VERSION); 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds err = befs_init_inodecache(); 9491da177e4SLinus Torvalds if (err) 9500418726bSAdrian Bunk goto unacquire_none; 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds err = register_filesystem(&befs_fs_type); 9531da177e4SLinus Torvalds if (err) 9540418726bSAdrian Bunk goto unacquire_inodecache; 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds return 0; 9571da177e4SLinus Torvalds 9580418726bSAdrian Bunk unacquire_inodecache: 9591da177e4SLinus Torvalds befs_destroy_inodecache(); 9601da177e4SLinus Torvalds 9610418726bSAdrian Bunk unacquire_none: 9621da177e4SLinus Torvalds return err; 9631da177e4SLinus Torvalds } 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds static void __exit 9661da177e4SLinus Torvalds exit_befs_fs(void) 9671da177e4SLinus Torvalds { 9681da177e4SLinus Torvalds befs_destroy_inodecache(); 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds unregister_filesystem(&befs_fs_type); 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds /* 9741da177e4SLinus Torvalds Macros that typecheck the init and exit functions, 9751da177e4SLinus Torvalds ensures that they are called at init and cleanup, 9761da177e4SLinus Torvalds and eliminates warnings about unused functions. 9771da177e4SLinus Torvalds */ 9781da177e4SLinus Torvalds module_init(init_befs_fs) 9791da177e4SLinus Torvalds module_exit(exit_befs_fs) 980