[net-next-2.6.git] / fs / romfs / inode.c

/*
 * ROMFS file system, Linux implementation
 *
 * Copyright (C) 1997-1999  Janos Farkas <chexum@shadow.banki.hu>
 *
 * Using parts of the minix filesystem
 * Copyright (C) 1991, 1992  Linus Torvalds
 *
 * and parts of the affs filesystem additionally
 * Copyright (C) 1993  Ray Burr
 * Copyright (C) 1996  Hans-Joachim Widmaier
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * Changes
 *					Changed for 2.1.19 modules
 *	Jan 1997			Initial release
 *	Jun 1997			2.1.43+ changes
 *					Proper page locking in readpage
 *					Changed to work with 2.1.45+ fs
 *	Jul 1997			Fixed follow_link
 *			2.1.47
 *					lookup shouldn't return -ENOENT
 *					from Horst von Brand:
 *					  fail on wrong checksum
 *					  double unlock_super was possible
 *					  correct namelen for statfs
 *					spotted by Bill Hawes:
 *					  readlink shouldn't iput()
 *	Jun 1998	2.1.106		from Avery Pennarun: glibc scandir()
 *					  exposed a problem in readdir
 *			2.1.107		code-freeze spellchecker run
 *	Aug 1998			2.1.118+ VFS changes
 *	Sep 1998	2.1.122		another VFS change (follow_link)
 *	Apr 1999	2.2.7		no more EBADF checking in
 *					  lookup/readdir, use ERR_PTR
 *	Jun 1999	2.3.6		d_alloc_root use changed
 *			2.3.9		clean up usage of ENOENT/negative
 *					  dentries in lookup
 *					clean up page flags setting
 *					  (error, uptodate, locking) in
 *					  in readpage
 *					use init_special_inode for
 *					  fifos/sockets (and streamline) in
 *					  read_inode, fix _ops table order
 *	Aug 1999	2.3.16		__initfunc() => __init change
 *	Oct 1999	2.3.24		page->owner hack obsoleted
 *	Nov 1999	2.3.27		2.3.25+ page->offset => index change
 */

/* todo:
 *	- see Documentation/filesystems/romfs.txt
 *	- use allocated, not stack memory for file names?
 *	- considering write access...
 *	- network (tftp) files?
 *	- merge back some _op tables
 */

/*
 * Sorry about some optimizations and for some goto's.  I just wanted
 * to squeeze some more bytes out of this code.. :)
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/romfs_fs.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/pagemap.h>
#include <linux/smp_lock.h>
#include <linux/buffer_head.h>
#include <linux/vfs.h>

#include <asm/uaccess.h>

struct romfs_inode_info {
	unsigned long i_metasize;	/* size of non-data area */
	unsigned long i_dataoffset;	/* from the start of fs */
	struct inode vfs_inode;
};

static struct inode *romfs_iget(struct super_block *, unsigned long);

/* instead of private superblock data */
static inline unsigned long romfs_maxsize(struct super_block *sb)
{
	return (unsigned long)sb->s_fs_info;
}

static inline struct romfs_inode_info *ROMFS_I(struct inode *inode)
{
	return container_of(inode, struct romfs_inode_info, vfs_inode);
}

static __u32
romfs_checksum(void *data, int size)
{
	__u32 sum;
	__be32 *ptr;

	sum = 0; ptr = data;
	size>>=2;
	while (size>0) {
		sum += be32_to_cpu(*ptr++);
		size--;
	}
	return sum;
}

static const struct super_operations romfs_ops;

static int romfs_fill_super(struct super_block *s, void *data, int silent)
{
	struct buffer_head *bh;
	struct romfs_super_block *rsb;
	struct inode *root;
	int sz, ret = -EINVAL;

	/* I would parse the options here, but there are none.. :) */

	sb_set_blocksize(s, ROMBSIZE);
	s->s_maxbytes = 0xFFFFFFFF;

	bh = sb_bread(s, 0);
	if (!bh) {
		/* XXX merge with other printk? */
                printk ("romfs: unable to read superblock\n");
		goto outnobh;
	}

	rsb = (struct romfs_super_block *)bh->b_data;
	sz = be32_to_cpu(rsb->size);
	if (rsb->word0 != ROMSB_WORD0 || rsb->word1 != ROMSB_WORD1
	   || sz < ROMFH_SIZE) {
		if (!silent)
			printk ("VFS: Can't find a romfs filesystem on dev "
				"%s.\n", s->s_id);
		goto out;
	}
	if (romfs_checksum(rsb, min_t(int, sz, 512))) {
		printk ("romfs: bad initial checksum on dev "
			"%s.\n", s->s_id);
		goto out;
	}

	s->s_magic = ROMFS_MAGIC;
	s->s_fs_info = (void *)(long)sz;

	s->s_flags |= MS_RDONLY;

	/* Find the start of the fs */
	sz = (ROMFH_SIZE +
	      strnlen(rsb->name, ROMFS_MAXFN) + 1 + ROMFH_PAD)
	     & ROMFH_MASK;

	s->s_op	= &romfs_ops;
	root = romfs_iget(s, sz);
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out;
	}

	ret = -ENOMEM;
	s->s_root = d_alloc_root(root);
	if (!s->s_root)
		goto outiput;

	brelse(bh);
	return 0;

outiput:
	iput(root);
out:
	brelse(bh);
outnobh:
	return ret;
}

/* That's simple too. */

static int
romfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	buf->f_type = ROMFS_MAGIC;
	buf->f_bsize = ROMBSIZE;
	buf->f_bfree = buf->f_bavail = buf->f_ffree;
	buf->f_blocks = (romfs_maxsize(dentry->d_sb)+ROMBSIZE-1)>>ROMBSBITS;
	buf->f_namelen = ROMFS_MAXFN;
	return 0;
}

/* some helper routines */

static int
romfs_strnlen(struct inode *i, unsigned long offset, unsigned long count)
{
	struct buffer_head *bh;
	unsigned long avail, maxsize, res;

	maxsize = romfs_maxsize(i->i_sb);
	if (offset >= maxsize)
		return -1;

	/* strnlen is almost always valid */
	if (count > maxsize || offset+count > maxsize)
		count = maxsize-offset;

	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
	if (!bh)
		return -1;		/* error */

	avail = ROMBSIZE - (offset & ROMBMASK);
	maxsize = min_t(unsigned long, count, avail);
	res = strnlen(((char *)bh->b_data)+(offset&ROMBMASK), maxsize);
	brelse(bh);

	if (res < maxsize)
		return res;		/* found all of it */

	while (res < count) {
		offset += maxsize;

		bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
		if (!bh)
			return -1;
		maxsize = min_t(unsigned long, count - res, ROMBSIZE);
		avail = strnlen(bh->b_data, maxsize);
		res += avail;
		brelse(bh);
		if (avail < maxsize)
			return res;
	}
	return res;
}

static int
romfs_copyfrom(struct inode *i, void *dest, unsigned long offset, unsigned long count)
{
	struct buffer_head *bh;
	unsigned long avail, maxsize, res;

	maxsize = romfs_maxsize(i->i_sb);
	if (offset >= maxsize || count > maxsize || offset+count>maxsize)
		return -1;

	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
	if (!bh)
		return -1;		/* error */

	avail = ROMBSIZE - (offset & ROMBMASK);
	maxsize = min_t(unsigned long, count, avail);
	memcpy(dest, ((char *)bh->b_data) + (offset & ROMBMASK), maxsize);
	brelse(bh);

	res = maxsize;			/* all of it */

	while (res < count) {
		offset += maxsize;
		dest += maxsize;

		bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
		if (!bh)
			return -1;
		maxsize = min_t(unsigned long, count - res, ROMBSIZE);
		memcpy(dest, bh->b_data, maxsize);
		brelse(bh);
		res += maxsize;
	}
	return res;
}

static unsigned char romfs_dtype_table[] = {
	DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_SOCK, DT_FIFO
};

static int
romfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct inode *i = filp->f_path.dentry->d_inode;
	struct romfs_inode ri;
	unsigned long offset, maxoff;
	int j, ino, nextfh;
	int stored = 0;
	char fsname[ROMFS_MAXFN];	/* XXX dynamic? */

	lock_kernel();

	maxoff = romfs_maxsize(i->i_sb);

	offset = filp->f_pos;
	if (!offset) {
		offset = i->i_ino & ROMFH_MASK;
		if (romfs_copyfrom(i, &ri, offset, ROMFH_SIZE) <= 0)
			goto out;
		offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
	}

	/* Not really failsafe, but we are read-only... */
	for(;;) {
		if (!offset || offset >= maxoff) {
			offset = maxoff;
			filp->f_pos = offset;
			goto out;
		}
		filp->f_pos = offset;

		/* Fetch inode info */
		if (romfs_copyfrom(i, &ri, offset, ROMFH_SIZE) <= 0)
			goto out;

		j = romfs_strnlen(i, offset+ROMFH_SIZE, sizeof(fsname)-1);
		if (j < 0)
			goto out;

		fsname[j]=0;
		romfs_copyfrom(i, fsname, offset+ROMFH_SIZE, j);

		ino = offset;
		nextfh = be32_to_cpu(ri.next);
		if ((nextfh & ROMFH_TYPE) == ROMFH_HRD)
			ino = be32_to_cpu(ri.spec);
		if (filldir(dirent, fsname, j, offset, ino,
			    romfs_dtype_table[nextfh & ROMFH_TYPE]) < 0) {
			goto out;
		}
		stored++;
		offset = nextfh & ROMFH_MASK;
	}
out:
	unlock_kernel();
	return stored;
}

static struct dentry *
romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	unsigned long offset, maxoff;
	long res;
	int fslen;
	struct inode *inode = NULL;
	char fsname[ROMFS_MAXFN];	/* XXX dynamic? */
	struct romfs_inode ri;
	const char *name;		/* got from dentry */
	int len;

	res = -EACCES;			/* placeholder for "no data here" */
	offset = dir->i_ino & ROMFH_MASK;
	lock_kernel();
	if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
		goto error;

	maxoff = romfs_maxsize(dir->i_sb);
	offset = be32_to_cpu(ri.spec) & ROMFH_MASK;

	/* OK, now find the file whose name is in "dentry" in the
	 * directory specified by "dir".  */

	name = dentry->d_name.name;
	len = dentry->d_name.len;

	for(;;) {
		if (!offset || offset >= maxoff)
			goto success; /* negative success */
		if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
			goto error;

		/* try to match the first 16 bytes of name */
		fslen = romfs_strnlen(dir, offset+ROMFH_SIZE, ROMFH_SIZE);
		if (len < ROMFH_SIZE) {
			if (len == fslen) {
				/* both are shorter, and same size */
				romfs_copyfrom(dir, fsname, offset+ROMFH_SIZE, len+1);
				if (strncmp (name, fsname, len) == 0)
					break;
			}
		} else if (fslen >= ROMFH_SIZE) {
			/* both are longer; XXX optimize max size */
			fslen = romfs_strnlen(dir, offset+ROMFH_SIZE, sizeof(fsname)-1);
			if (len == fslen) {
				romfs_copyfrom(dir, fsname, offset+ROMFH_SIZE, len+1);
				if (strncmp(name, fsname, len) == 0)
					break;
			}
		}
		/* next entry */
		offset = be32_to_cpu(ri.next) & ROMFH_MASK;
	}

	/* Hard link handling */
	if ((be32_to_cpu(ri.next) & ROMFH_TYPE) == ROMFH_HRD)
		offset = be32_to_cpu(ri.spec) & ROMFH_MASK;

	inode = romfs_iget(dir->i_sb, offset);
	if (IS_ERR(inode)) {
		res = PTR_ERR(inode);
		goto error;
	}

success:
	d_add(dentry, inode);
	res = 0;
error:
	unlock_kernel();
	return ERR_PTR(res);
}

/*
 * Ok, we do readpage, to be able to execute programs.  Unfortunately,
 * we can't use bmap, since we may have looser alignments.
 */

static int
romfs_readpage(struct file *file, struct page * page)
{
	struct inode *inode = page->mapping->host;
	loff_t offset, avail, readlen;
	void *buf;
	int result = -EIO;

	page_cache_get(page);
	lock_kernel();
	buf = kmap(page);
	if (!buf)
		goto err_out;

	/* 32 bit warning -- but not for us :) */
	offset = page_offset(page);
	if (offset < i_size_read(inode)) {
		avail = inode->i_size-offset;
		readlen = min_t(unsigned long, avail, PAGE_SIZE);
		if (romfs_copyfrom(inode, buf, ROMFS_I(inode)->i_dataoffset+offset, readlen) == readlen) {
			if (readlen < PAGE_SIZE) {
				memset(buf + readlen,0,PAGE_SIZE-readlen);
			}
			SetPageUptodate(page);
			result = 0;
		}
	}
	if (result) {
		memset(buf, 0, PAGE_SIZE);
		SetPageError(page);
	}
	flush_dcache_page(page);

	unlock_page(page);

	kunmap(page);
err_out:
	page_cache_release(page);
	unlock_kernel();

	return result;
}

/* Mapping from our types to the kernel */

static const struct address_space_operations romfs_aops = {
	.readpage = romfs_readpage
};

static const struct file_operations romfs_dir_operations = {
	.read		= generic_read_dir,
	.readdir	= romfs_readdir,
};

static const struct inode_operations romfs_dir_inode_operations = {
	.lookup		= romfs_lookup,
};

static mode_t romfs_modemap[] =
{
	0, S_IFDIR+0644, S_IFREG+0644, S_IFLNK+0777,
	S_IFBLK+0600, S_IFCHR+0600, S_IFSOCK+0644, S_IFIFO+0644
};

static struct inode *
romfs_iget(struct super_block *sb, unsigned long ino)
{
	int nextfh;
	struct romfs_inode ri;
	struct inode *i;

	ino &= ROMFH_MASK;
	i = iget_locked(sb, ino);
	if (!i)
		return ERR_PTR(-ENOMEM);
	if (!(i->i_state & I_NEW))
		return i;

	i->i_mode = 0;

	/* Loop for finding the real hard link */
	for(;;) {
		if (romfs_copyfrom(i, &ri, ino, ROMFH_SIZE) <= 0) {
			printk(KERN_ERR "romfs: read error for inode 0x%lx\n",
				ino);
			iget_failed(i);
			return ERR_PTR(-EIO);
		}
		/* XXX: do romfs_checksum here too (with name) */

		nextfh = be32_to_cpu(ri.next);
		if ((nextfh & ROMFH_TYPE) != ROMFH_HRD)
			break;

		ino = be32_to_cpu(ri.spec) & ROMFH_MASK;
	}

	i->i_nlink = 1;		/* Hard to decide.. */
	i->i_size = be32_to_cpu(ri.size);
	i->i_mtime.tv_sec = i->i_atime.tv_sec = i->i_ctime.tv_sec = 0;
	i->i_mtime.tv_nsec = i->i_atime.tv_nsec = i->i_ctime.tv_nsec = 0;
	i->i_uid = i->i_gid = 0;

        /* Precalculate the data offset */
        ino = romfs_strnlen(i, ino+ROMFH_SIZE, ROMFS_MAXFN);
        if (ino >= 0)
                ino = ((ROMFH_SIZE+ino+1+ROMFH_PAD)&ROMFH_MASK);
        else
                ino = 0;

        ROMFS_I(i)->i_metasize = ino;
        ROMFS_I(i)->i_dataoffset = ino+(i->i_ino&ROMFH_MASK);

        /* Compute permissions */
        ino = romfs_modemap[nextfh & ROMFH_TYPE];
	/* only "normal" files have ops */
	switch (nextfh & ROMFH_TYPE) {
		case 1:
			i->i_size = ROMFS_I(i)->i_metasize;
			i->i_op = &romfs_dir_inode_operations;
			i->i_fop = &romfs_dir_operations;
			if (nextfh & ROMFH_EXEC)
				ino |= S_IXUGO;
			i->i_mode = ino;
			break;
		case 2:
			i->i_fop = &generic_ro_fops;
			i->i_data.a_ops = &romfs_aops;
			if (nextfh & ROMFH_EXEC)
				ino |= S_IXUGO;
			i->i_mode = ino;
			break;
		case 3:
			i->i_op = &page_symlink_inode_operations;
			i->i_data.a_ops = &romfs_aops;
			i->i_mode = ino | S_IRWXUGO;
			break;
		default:
			/* depending on MBZ for sock/fifos */
			nextfh = be32_to_cpu(ri.spec);
			init_special_inode(i, ino,
					MKDEV(nextfh>>16,nextfh&0xffff));
	}
	unlock_new_inode(i);
	return i;
}

static struct kmem_cache * romfs_inode_cachep;

static struct inode *romfs_alloc_inode(struct super_block *sb)
{
	struct romfs_inode_info *ei;
	ei = kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

static void romfs_destroy_inode(struct inode *inode)
{
	kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
}

static void init_once(void *foo)
{
	struct romfs_inode_info *ei = foo;

	inode_init_once(&ei->vfs_inode);
}

static int init_inodecache(void)
{
	romfs_inode_cachep = kmem_cache_create("romfs_inode_cache",
					     sizeof(struct romfs_inode_info),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     init_once);
	if (romfs_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
	kmem_cache_destroy(romfs_inode_cachep);
}

static int romfs_remount(struct super_block *sb, int *flags, char *data)
{
	*flags |= MS_RDONLY;
	return 0;
}

static const struct super_operations romfs_ops = {
	.alloc_inode	= romfs_alloc_inode,
	.destroy_inode	= romfs_destroy_inode,
	.statfs		= romfs_statfs,
	.remount_fs	= romfs_remount,
};

static int romfs_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
	return get_sb_bdev(fs_type, flags, dev_name, data, romfs_fill_super,
			   mnt);
}

static struct file_system_type romfs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "romfs",
	.get_sb		= romfs_get_sb,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};

static int __init init_romfs_fs(void)
{
	int err = init_inodecache();
	if (err)
		goto out1;
        err = register_filesystem(&romfs_fs_type);
	if (err)
		goto out;
	return 0;
out:
	destroy_inodecache();
out1:
	return err;
}

static void __exit exit_romfs_fs(void)
{
	unregister_filesystem(&romfs_fs_type);
	destroy_inodecache();
}

/* Yes, works even as a module... :) */

module_init(init_romfs_fs)
module_exit(exit_romfs_fs)
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ROMFS file system, Linux implementation
	3	*
	4	* Copyright (C) 1997-1999 Janos Farkas <chexum@shadow.banki.hu>
	5	*
	6	* Using parts of the minix filesystem
	7	* Copyright (C) 1991, 1992 Linus Torvalds
	8	*
	9	* and parts of the affs filesystem additionally
	10	* Copyright (C) 1993 Ray Burr
	11	* Copyright (C) 1996 Hans-Joachim Widmaier
	12	*
	13	* This program is free software; you can redistribute it and/or
	14	* modify it under the terms of the GNU General Public License
	15	* as published by the Free Software Foundation; either version
	16	* 2 of the License, or (at your option) any later version.
	17	*
	18	* Changes
	19	* Changed for 2.1.19 modules
	20	* Jan 1997 Initial release
	21	* Jun 1997 2.1.43+ changes
	22	* Proper page locking in readpage
	23	* Changed to work with 2.1.45+ fs
	24	* Jul 1997 Fixed follow_link
	25	* 2.1.47
	26	* lookup shouldn't return -ENOENT
	27	* from Horst von Brand:
	28	* fail on wrong checksum
	29	* double unlock_super was possible
	30	* correct namelen for statfs
	31	* spotted by Bill Hawes:
	32	* readlink shouldn't iput()
	33	* Jun 1998 2.1.106 from Avery Pennarun: glibc scandir()
	34	* exposed a problem in readdir
	35	* 2.1.107 code-freeze spellchecker run
	36	* Aug 1998 2.1.118+ VFS changes
	37	* Sep 1998 2.1.122 another VFS change (follow_link)
	38	* Apr 1999 2.2.7 no more EBADF checking in
	39	* lookup/readdir, use ERR_PTR
	40	* Jun 1999 2.3.6 d_alloc_root use changed
	41	* 2.3.9 clean up usage of ENOENT/negative
	42	* dentries in lookup
	43	* clean up page flags setting
	44	* (error, uptodate, locking) in
	45	* in readpage
	46	* use init_special_inode for
	47	* fifos/sockets (and streamline) in
	48	* read_inode, fix _ops table order
	49	* Aug 1999 2.3.16 __initfunc() => __init change
	50	* Oct 1999 2.3.24 page->owner hack obsoleted
	51	* Nov 1999 2.3.27 2.3.25+ page->offset => index change
	52	*/
	53
	54	/* todo:
	55	* - see Documentation/filesystems/romfs.txt
	56	* - use allocated, not stack memory for file names?
	57	* - considering write access...
	58	* - network (tftp) files?
	59	* - merge back some _op tables
	60	*/
	61
	62	/*
	63	* Sorry about some optimizations and for some goto's. I just wanted
	64	* to squeeze some more bytes out of this code.. :)
65	*/
66
67	#include <linux/module.h>
68	#include <linux/types.h>
69	#include <linux/errno.h>
70	#include <linux/slab.h>
71	#include <linux/romfs_fs.h>
72	#include <linux/fs.h>
73	#include <linux/init.h>
74	#include <linux/pagemap.h>
75	#include <linux/smp_lock.h>
76	#include <linux/buffer_head.h>
77	#include <linux/vfs.h>
78
79	#include <asm/uaccess.h>
80
81	struct romfs_inode_info {
82	unsigned long i_metasize; /* size of non-data area */
83	unsigned long i_dataoffset; /* from the start of fs */
84	struct inode vfs_inode;
85	};
86
78cc9120 DH	87	static struct inode romfs_iget(struct super_block , unsigned long);
78cc9120 DH	88
1da177e4 LT	89	/* instead of private superblock data */
	90	static inline unsigned long romfs_maxsize(struct super_block *sb)
	91	{
	92	return (unsigned long)sb->s_fs_info;
	93	}
	94
	95	static inline struct romfs_inode_info ROMFS_I(struct inode inode)
	96	{
55ca3e79	97	return container_of(inode, struct romfs_inode_info, vfs_inode);
1da177e4 LT	98	}
	99
	100	static __u32
	101	romfs_checksum(void *data, int size)
	102	{
	103	__u32 sum;
	104	__be32 *ptr;
	105
	106	sum = 0; ptr = data;
	107	size>>=2;
	108	while (size>0) {
	109	sum += be32_to_cpu(*ptr++);
	110	size--;
	111	}
	112	return sum;
	113	}
	114
ee9b6d61	115	static const struct super_operations romfs_ops;
1da177e4 LT	116
	117	static int romfs_fill_super(struct super_block s, void data, int silent)
	118	{
	119	struct buffer_head *bh;
	120	struct romfs_super_block *rsb;
	121	struct inode *root;
78cc9120	122	int sz, ret = -EINVAL;
1da177e4 LT	123
	124	/* I would parse the options here, but there are none.. :) */
	125
	126	sb_set_blocksize(s, ROMBSIZE);
	127	s->s_maxbytes = 0xFFFFFFFF;
	128
	129	bh = sb_bread(s, 0);
	130	if (!bh) {
	131	/* XXX merge with other printk? */
	132	printk ("romfs: unable to read superblock\n");
	133	goto outnobh;
	134	}
	135
	136	rsb = (struct romfs_super_block *)bh->b_data;
	137	sz = be32_to_cpu(rsb->size);
	138	if (rsb->word0 != ROMSB_WORD0 \|\| rsb->word1 != ROMSB_WORD1
	139	\|\| sz < ROMFH_SIZE) {
	140	if (!silent)
	141	printk ("VFS: Can't find a romfs filesystem on dev "
	142	"%s.\n", s->s_id);
	143	goto out;
	144	}
	145	if (romfs_checksum(rsb, min_t(int, sz, 512))) {
	146	printk ("romfs: bad initial checksum on dev "
	147	"%s.\n", s->s_id);
	148	goto out;
	149	}
	150
	151	s->s_magic = ROMFS_MAGIC;
	152	s->s_fs_info = (void *)(long)sz;
	153
	154	s->s_flags \|= MS_RDONLY;
	155
	156	/* Find the start of the fs */
	157	sz = (ROMFH_SIZE +
	158	strnlen(rsb->name, ROMFS_MAXFN) + 1 + ROMFH_PAD)
	159	& ROMFH_MASK;
	160
	161	s->s_op = &romfs_ops;
78cc9120 DH	162	root = romfs_iget(s, sz);
	163	if (IS_ERR(root)) {
	164	ret = PTR_ERR(root);
1da177e4	165	goto out;
78cc9120	166	}
1da177e4	167
78cc9120	168	ret = -ENOMEM;
1da177e4 LT	169	s->s_root = d_alloc_root(root);
	170	if (!s->s_root)
	171	goto outiput;
	172
	173	brelse(bh);
	174	return 0;
	175
	176	outiput:
	177	iput(root);
	178	out:
	179	brelse(bh);
	180	outnobh:
78cc9120	181	return ret;
1da177e4 LT	182	}
	183
	184	/* That's simple too. */
	185
	186	static int
726c3342	187	romfs_statfs(struct dentry dentry, struct kstatfs buf)
1da177e4 LT	188	{
	189	buf->f_type = ROMFS_MAGIC;
	190	buf->f_bsize = ROMBSIZE;
	191	buf->f_bfree = buf->f_bavail = buf->f_ffree;
726c3342	192	buf->f_blocks = (romfs_maxsize(dentry->d_sb)+ROMBSIZE-1)>>ROMBSBITS;
1da177e4 LT	193	buf->f_namelen = ROMFS_MAXFN;
	194	return 0;
	195	}
	196
	197	/* some helper routines */
	198
	199	static int
	200	romfs_strnlen(struct inode *i, unsigned long offset, unsigned long count)
	201	{
	202	struct buffer_head *bh;
	203	unsigned long avail, maxsize, res;
	204
	205	maxsize = romfs_maxsize(i->i_sb);
	206	if (offset >= maxsize)
	207	return -1;
	208
	209	/* strnlen is almost always valid */
	210	if (count > maxsize \|\| offset+count > maxsize)
	211	count = maxsize-offset;
	212
	213	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
	214	if (!bh)
	215	return -1; /* error */
	216
	217	avail = ROMBSIZE - (offset & ROMBMASK);
	218	maxsize = min_t(unsigned long, count, avail);
	219	res = strnlen(((char *)bh->b_data)+(offset&ROMBMASK), maxsize);
	220	brelse(bh);
	221
	222	if (res < maxsize)
	223	return res; /* found all of it */
	224
	225	while (res < count) {
	226	offset += maxsize;
	227
	228	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
	229	if (!bh)
	230	return -1;
	231	maxsize = min_t(unsigned long, count - res, ROMBSIZE);
	232	avail = strnlen(bh->b_data, maxsize);
	233	res += avail;
	234	brelse(bh);
	235	if (avail < maxsize)
	236	return res;
	237	}
	238	return res;
	239	}
	240
	241	static int
	242	romfs_copyfrom(struct inode i, void dest, unsigned long offset, unsigned long count)
	243	{
	244	struct buffer_head *bh;
	245	unsigned long avail, maxsize, res;
	246
	247	maxsize = romfs_maxsize(i->i_sb);
	248	if (offset >= maxsize \|\| count > maxsize \|\| offset+count>maxsize)
	249	return -1;
	250
	251	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
	252	if (!bh)
	253	return -1; /* error */
	254
	255	avail = ROMBSIZE - (offset & ROMBMASK);
	256	maxsize = min_t(unsigned long, count, avail);
257	memcpy(dest, ((char *)bh->b_data) + (offset & ROMBMASK), maxsize);
258	brelse(bh);
259
260	res = maxsize; /* all of it */
261
262	while (res < count) {
263	offset += maxsize;
264	dest += maxsize;
265
266	bh = sb_bread(i->i_sb, offset>>ROMBSBITS);
267	if (!bh)
268	return -1;
269	maxsize = min_t(unsigned long, count - res, ROMBSIZE);
270	memcpy(dest, bh->b_data, maxsize);
271	brelse(bh);
272	res += maxsize;
273	}
274	return res;
275	}
276
277	static unsigned char romfs_dtype_table[] = {
278	DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_SOCK, DT_FIFO
279	};
280
281	static int
282	romfs_readdir(struct file filp, void dirent, filldir_t filldir)
283	{
3027795e	284	struct inode *i = filp->f_path.dentry->d_inode;
1da177e4 LT	285	struct romfs_inode ri;
	286	unsigned long offset, maxoff;
	287	int j, ino, nextfh;
	288	int stored = 0;
	289	char fsname[ROMFS_MAXFN]; /* XXX dynamic? */
	290
	291	lock_kernel();
	292
	293	maxoff = romfs_maxsize(i->i_sb);
	294
	295	offset = filp->f_pos;
	296	if (!offset) {
	297	offset = i->i_ino & ROMFH_MASK;
	298	if (romfs_copyfrom(i, &ri, offset, ROMFH_SIZE) <= 0)
	299	goto out;
	300	offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
	301	}
	302
	303	/* Not really failsafe, but we are read-only... */
	304	for(;;) {
	305	if (!offset \|\| offset >= maxoff) {
	306	offset = maxoff;
	307	filp->f_pos = offset;
	308	goto out;
	309	}
	310	filp->f_pos = offset;
	311
	312	/* Fetch inode info */
	313	if (romfs_copyfrom(i, &ri, offset, ROMFH_SIZE) <= 0)
	314	goto out;
	315
	316	j = romfs_strnlen(i, offset+ROMFH_SIZE, sizeof(fsname)-1);
	317	if (j < 0)
	318	goto out;
	319
	320	fsname[j]=0;
	321	romfs_copyfrom(i, fsname, offset+ROMFH_SIZE, j);
	322
	323	ino = offset;
	324	nextfh = be32_to_cpu(ri.next);
	325	if ((nextfh & ROMFH_TYPE) == ROMFH_HRD)
	326	ino = be32_to_cpu(ri.spec);
	327	if (filldir(dirent, fsname, j, offset, ino,
	328	romfs_dtype_table[nextfh & ROMFH_TYPE]) < 0) {
	329	goto out;
	330	}
	331	stored++;
	332	offset = nextfh & ROMFH_MASK;
	333	}
	334	out:
	335	unlock_kernel();
	336	return stored;
	337	}
	338
	339	static struct dentry *
	340	romfs_lookup(struct inode dir, struct dentry dentry, struct nameidata *nd)
	341	{
	342	unsigned long offset, maxoff;
4ebf8984 DH	343	long res;
	344	int fslen;
	345	struct inode *inode = NULL;
1da177e4 LT	346	char fsname[ROMFS_MAXFN]; /* XXX dynamic? */
	347	struct romfs_inode ri;
	348	const char name; / got from dentry */
	349	int len;
	350
	351	res = -EACCES; /* placeholder for "no data here" */
	352	offset = dir->i_ino & ROMFH_MASK;
	353	lock_kernel();
	354	if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
4ebf8984	355	goto error;
1da177e4 LT	356
	357	maxoff = romfs_maxsize(dir->i_sb);
	358	offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
	359
	360	/* OK, now find the file whose name is in "dentry" in the
	361	* directory specified by "dir". */
	362
	363	name = dentry->d_name.name;
	364	len = dentry->d_name.len;
	365
	366	for(;;) {
	367	if (!offset \|\| offset >= maxoff)
4ebf8984	368	goto success; /* negative success */
1da177e4	369	if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
4ebf8984	370	goto error;
1da177e4 LT	371
	372	/* try to match the first 16 bytes of name */
	373	fslen = romfs_strnlen(dir, offset+ROMFH_SIZE, ROMFH_SIZE);
	374	if (len < ROMFH_SIZE) {
	375	if (len == fslen) {
	376	/* both are shorter, and same size */
	377	romfs_copyfrom(dir, fsname, offset+ROMFH_SIZE, len+1);
	378	if (strncmp (name, fsname, len) == 0)
	379	break;
	380	}
	381	} else if (fslen >= ROMFH_SIZE) {
	382	/* both are longer; XXX optimize max size */
	383	fslen = romfs_strnlen(dir, offset+ROMFH_SIZE, sizeof(fsname)-1);
	384	if (len == fslen) {
	385	romfs_copyfrom(dir, fsname, offset+ROMFH_SIZE, len+1);
	386	if (strncmp(name, fsname, len) == 0)
	387	break;
	388	}
	389	}
	390	/* next entry */
	391	offset = be32_to_cpu(ri.next) & ROMFH_MASK;
	392	}
	393
	394	/* Hard link handling */
	395	if ((be32_to_cpu(ri.next) & ROMFH_TYPE) == ROMFH_HRD)
	396	offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
	397
78cc9120 DH	398	inode = romfs_iget(dir->i_sb, offset);
	399	if (IS_ERR(inode)) {
	400	res = PTR_ERR(inode);
4ebf8984	401	goto error;
78cc9120	402	}
1da177e4	403
4ebf8984 DH	404	success:
4ebf8984 DH	405	d_add(dentry, inode);
78cc9120	406	res = 0;
4ebf8984 DH	407	error:
4ebf8984 DH	408	unlock_kernel();
1da177e4 LT	409	return ERR_PTR(res);
	410	}
	411
	412	/*
	413	* Ok, we do readpage, to be able to execute programs. Unfortunately,
	414	* we can't use bmap, since we may have looser alignments.
	415	*/
	416
	417	static int
	418	romfs_readpage(struct file file, struct page page)
	419	{
	420	struct inode *inode = page->mapping->host;
54b21a79	421	loff_t offset, avail, readlen;
1da177e4 LT	422	void *buf;
	423	int result = -EIO;
	424
	425	page_cache_get(page);
	426	lock_kernel();
	427	buf = kmap(page);
	428	if (!buf)
	429	goto err_out;
	430
	431	/* 32 bit warning -- but not for us :) */
54b21a79 AM	432	offset = page_offset(page);
54b21a79 AM	433	if (offset < i_size_read(inode)) {
1da177e4 LT	434	avail = inode->i_size-offset;
	435	readlen = min_t(unsigned long, avail, PAGE_SIZE);
	436	if (romfs_copyfrom(inode, buf, ROMFS_I(inode)->i_dataoffset+offset, readlen) == readlen) {
	437	if (readlen < PAGE_SIZE) {
	438	memset(buf + readlen,0,PAGE_SIZE-readlen);
	439	}
	440	SetPageUptodate(page);
	441	result = 0;
	442	}
	443	}
	444	if (result) {
	445	memset(buf, 0, PAGE_SIZE);
	446	SetPageError(page);
	447	}
	448	flush_dcache_page(page);
	449
	450	unlock_page(page);
	451
	452	kunmap(page);
	453	err_out:
	454	page_cache_release(page);
	455	unlock_kernel();
	456
	457	return result;
	458	}
	459
	460	/* Mapping from our types to the kernel */
	461
f5e54d6e	462	static const struct address_space_operations romfs_aops = {
1da177e4 LT	463	.readpage = romfs_readpage
	464	};
	465
4b6f5d20	466	static const struct file_operations romfs_dir_operations = {
1da177e4 LT	467	.read = generic_read_dir,
	468	.readdir = romfs_readdir,
	469	};
	470
c5ef1c42	471	static const struct inode_operations romfs_dir_inode_operations = {
1da177e4 LT	472	.lookup = romfs_lookup,
	473	};
	474
	475	static mode_t romfs_modemap[] =
	476	{
	477	0, S_IFDIR+0644, S_IFREG+0644, S_IFLNK+0777,
	478	S_IFBLK+0600, S_IFCHR+0600, S_IFSOCK+0644, S_IFIFO+0644
	479	};
	480
78cc9120 DH	481	static struct inode *
78cc9120 DH	482	romfs_iget(struct super_block *sb, unsigned long ino)
1da177e4	483	{
78cc9120	484	int nextfh;
1da177e4	485	struct romfs_inode ri;
78cc9120 DH	486	struct inode *i;
	487
	488	ino &= ROMFH_MASK;
	489	i = iget_locked(sb, ino);
	490	if (!i)
	491	return ERR_PTR(-ENOMEM);
	492	if (!(i->i_state & I_NEW))
	493	return i;
1da177e4	494
1da177e4 LT	495	i->i_mode = 0;
	496
	497	/* Loop for finding the real hard link */
	498	for(;;) {
	499	if (romfs_copyfrom(i, &ri, ino, ROMFH_SIZE) <= 0) {
78cc9120 DH	500	printk(KERN_ERR "romfs: read error for inode 0x%lx\n",
	501	ino);
	502	iget_failed(i);
	503	return ERR_PTR(-EIO);
1da177e4 LT	504	}
	505	/* XXX: do romfs_checksum here too (with name) */
	506
	507	nextfh = be32_to_cpu(ri.next);
	508	if ((nextfh & ROMFH_TYPE) != ROMFH_HRD)
	509	break;
	510
	511	ino = be32_to_cpu(ri.spec) & ROMFH_MASK;
	512	}
	513
	514	i->i_nlink = 1; /* Hard to decide.. */
	515	i->i_size = be32_to_cpu(ri.size);
	516	i->i_mtime.tv_sec = i->i_atime.tv_sec = i->i_ctime.tv_sec = 0;
	517	i->i_mtime.tv_nsec = i->i_atime.tv_nsec = i->i_ctime.tv_nsec = 0;
	518	i->i_uid = i->i_gid = 0;
	519
	520	/* Precalculate the data offset */
	521	ino = romfs_strnlen(i, ino+ROMFH_SIZE, ROMFS_MAXFN);
	522	if (ino >= 0)
	523	ino = ((ROMFH_SIZE+ino+1+ROMFH_PAD)&ROMFH_MASK);
	524	else
	525	ino = 0;
	526
	527	ROMFS_I(i)->i_metasize = ino;
	528	ROMFS_I(i)->i_dataoffset = ino+(i->i_ino&ROMFH_MASK);
	529
	530	/* Compute permissions */
	531	ino = romfs_modemap[nextfh & ROMFH_TYPE];
	532	/* only "normal" files have ops */
	533	switch (nextfh & ROMFH_TYPE) {
	534	case 1:
	535	i->i_size = ROMFS_I(i)->i_metasize;
	536	i->i_op = &romfs_dir_inode_operations;
	537	i->i_fop = &romfs_dir_operations;
	538	if (nextfh & ROMFH_EXEC)
	539	ino \|= S_IXUGO;
	540	i->i_mode = ino;
	541	break;
	542	case 2:
	543	i->i_fop = &generic_ro_fops;
	544	i->i_data.a_ops = &romfs_aops;
	545	if (nextfh & ROMFH_EXEC)
	546	ino \|= S_IXUGO;
	547	i->i_mode = ino;
	548	break;
	549	case 3:
	550	i->i_op = &page_symlink_inode_operations;
	551	i->i_data.a_ops = &romfs_aops;
	552	i->i_mode = ino \| S_IRWXUGO;
	553	break;
	554	default:
	555	/* depending on MBZ for sock/fifos */
	556	nextfh = be32_to_cpu(ri.spec);
	557	init_special_inode(i, ino,
	558	MKDEV(nextfh>>16,nextfh&0xffff));
	559	}
78cc9120 DH	560	unlock_new_inode(i);
78cc9120 DH	561	return i;
1da177e4 LT	562	}
1da177e4 LT	563
e18b890b	564	static struct kmem_cache * romfs_inode_cachep;
1da177e4 LT	565
	566	static struct inode romfs_alloc_inode(struct super_block sb)
	567	{
	568	struct romfs_inode_info *ei;
55ca3e79	569	ei = kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
1da177e4 LT	570	if (!ei)
	571	return NULL;
	572	return &ei->vfs_inode;
	573	}
	574
	575	static void romfs_destroy_inode(struct inode *inode)
	576	{
	577	kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
	578	}
	579
51cc5068	580	static void init_once(void *foo)
1da177e4	581	{
a35afb83	582	struct romfs_inode_info *ei = foo;
1da177e4	583
a35afb83	584	inode_init_once(&ei->vfs_inode);
1da177e4	585	}
20c2df83	586
1da177e4 LT	587	static int init_inodecache(void)
	588	{
	589	romfs_inode_cachep = kmem_cache_create("romfs_inode_cache",
	590	sizeof(struct romfs_inode_info),
fffb60f9 PJ	591	0, (SLAB_RECLAIM_ACCOUNT\|
fffb60f9 PJ	592	SLAB_MEM_SPREAD),
20c2df83	593	init_once);
1da177e4 LT	594	if (romfs_inode_cachep == NULL)
	595	return -ENOMEM;
	596	return 0;
	597	}
	598
	599	static void destroy_inodecache(void)
	600	{
1a1d92c1	601	kmem_cache_destroy(romfs_inode_cachep);
1da177e4 LT	602	}
	603
	604	static int romfs_remount(struct super_block sb, int flags, char *data)
	605	{
	606	*flags \|= MS_RDONLY;
	607	return 0;
	608	}
	609
ee9b6d61	610	static const struct super_operations romfs_ops = {
1da177e4 LT	611	.alloc_inode = romfs_alloc_inode,
1da177e4 LT	612	.destroy_inode = romfs_destroy_inode,
1da177e4 LT	613	.statfs = romfs_statfs,
	614	.remount_fs = romfs_remount,
	615	};
	616
454e2398 DH	617	static int romfs_get_sb(struct file_system_type *fs_type,
454e2398 DH	618	int flags, const char dev_name, void data, struct vfsmount *mnt)
1da177e4	619	{
454e2398 DH	620	return get_sb_bdev(fs_type, flags, dev_name, data, romfs_fill_super,
454e2398 DH	621	mnt);
1da177e4 LT	622	}
	623
	624	static struct file_system_type romfs_fs_type = {
	625	.owner = THIS_MODULE,
	626	.name = "romfs",
	627	.get_sb = romfs_get_sb,
	628	.kill_sb = kill_block_super,
	629	.fs_flags = FS_REQUIRES_DEV,
	630	};
	631
	632	static int __init init_romfs_fs(void)
	633	{
	634	int err = init_inodecache();
	635	if (err)
	636	goto out1;
	637	err = register_filesystem(&romfs_fs_type);
	638	if (err)
	639	goto out;
	640	return 0;
	641	out:
	642	destroy_inodecache();
	643	out1:
	644	return err;
	645	}
	646
	647	static void __exit exit_romfs_fs(void)
	648	{
	649	unregister_filesystem(&romfs_fs_type);
	650	destroy_inodecache();
	651	}
	652
	653	/* Yes, works even as a module... :) */
	654
	655	module_init(init_romfs_fs)
	656	module_exit(exit_romfs_fs)
	657	MODULE_LICENSE("GPL");