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

/* inode.c: /proc/openprom handling routines
 *
 * Copyright (C) 1996-1999 Jakub Jelinek  (jakub@redhat.com)
 * Copyright (C) 1998      Eddie C. Dost  (ecd@skynet.be)
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/magic.h>

#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/uaccess.h>

static DEFINE_MUTEX(op_mutex);

#define OPENPROM_ROOT_INO	0

enum op_inode_type {
	op_inode_node,
	op_inode_prop,
};

union op_inode_data {
	struct device_node	*node;
	struct property		*prop;
};

struct op_inode_info {
	struct inode		vfs_inode;
	enum op_inode_type	type;
	union op_inode_data	u;
};

static inline struct op_inode_info *OP_I(struct inode *inode)
{
	return container_of(inode, struct op_inode_info, vfs_inode);
}

static int is_string(unsigned char *p, int len)
{
	int i;

	for (i = 0; i < len; i++) {
		unsigned char val = p[i];

		if ((i && !val) ||
		    (val >= ' ' && val <= '~'))
			continue;

		return 0;
	}

	return 1;
}

static int property_show(struct seq_file *f, void *v)
{
	struct property *prop = f->private;
	void *pval;
	int len;

	len = prop->length;
	pval = prop->value;

	if (is_string(pval, len)) {
		while (len > 0) {
			int n = strlen(pval);

			seq_printf(f, "%s", (char *) pval);

			/* Skip over the NULL byte too.  */
			pval += n + 1;
			len -= n + 1;

			if (len > 0)
				seq_printf(f, " + ");
		}
	} else {
		if (len & 3) {
			while (len) {
				len--;
				if (len)
					seq_printf(f, "%02x.",
						   *(unsigned char *) pval);
				else
					seq_printf(f, "%02x",
						   *(unsigned char *) pval);
				pval++;
			}
		} else {
			while (len >= 4) {
				len -= 4;

				if (len)
					seq_printf(f, "%08x.",
						   *(unsigned int *) pval);
				else
					seq_printf(f, "%08x",
						   *(unsigned int *) pval);
				pval += 4;
			}
		}
	}
	seq_printf(f, "\n");

	return 0;
}

static void *property_start(struct seq_file *f, loff_t *pos)
{
	if (*pos == 0)
		return pos;
	return NULL;
}

static void *property_next(struct seq_file *f, void *v, loff_t *pos)
{
	(*pos)++;
	return NULL;
}

static void property_stop(struct seq_file *f, void *v)
{
	/* Nothing to do */
}

static struct seq_operations property_op = {
	.start		= property_start,
	.next		= property_next,
	.stop		= property_stop,
	.show		= property_show
};

static int property_open(struct inode *inode, struct file *file)
{
	struct op_inode_info *oi = OP_I(inode);
	int ret;

	BUG_ON(oi->type != op_inode_prop);

	ret = seq_open(file, &property_op);
	if (!ret) {
		struct seq_file *m = file->private_data;
		m->private = oi->u.prop;
	}
	return ret;
}

static const struct file_operations openpromfs_prop_ops = {
	.open		= property_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

static int openpromfs_readdir(struct file *, void *, filldir_t);

static const struct file_operations openprom_operations = {
	.read		= generic_read_dir,
	.readdir	= openpromfs_readdir,
};

static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, struct nameidata *);

static const struct inode_operations openprom_inode_operations = {
	.lookup		= openpromfs_lookup,
};

static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	struct op_inode_info *ent_oi, *oi = OP_I(dir);
	struct device_node *dp, *child;
	struct property *prop;
	enum op_inode_type ent_type;
	union op_inode_data ent_data;
	const char *name;
	struct inode *inode;
	unsigned int ino;
	int len;
	
	BUG_ON(oi->type != op_inode_node);

	dp = oi->u.node;

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

	mutex_lock(&op_mutex);

	child = dp->child;
	while (child) {
		int n = strlen(child->path_component_name);

		if (len == n &&
		    !strncmp(child->path_component_name, name, len)) {
			ent_type = op_inode_node;
			ent_data.node = child;
			ino = child->unique_id;
			goto found;
		}
		child = child->sibling;
	}

	prop = dp->properties;
	while (prop) {
		int n = strlen(prop->name);

		if (len == n && !strncmp(prop->name, name, len)) {
			ent_type = op_inode_prop;
			ent_data.prop = prop;
			ino = prop->unique_id;
			goto found;
		}

		prop = prop->next;
	}

	mutex_unlock(&op_mutex);
	return ERR_PTR(-ENOENT);

found:
	inode = iget(dir->i_sb, ino);
	mutex_unlock(&op_mutex);
	if (!inode)
		return ERR_PTR(-EINVAL);
	ent_oi = OP_I(inode);
	ent_oi->type = ent_type;
	ent_oi->u = ent_data;

	switch (ent_type) {
	case op_inode_node:
		inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
		inode->i_op = &openprom_inode_operations;
		inode->i_fop = &openprom_operations;
		inode->i_nlink = 2;
		break;
	case op_inode_prop:
		if (!strcmp(dp->name, "options") && (len == 17) &&
		    !strncmp (name, "security-password", 17))
			inode->i_mode = S_IFREG | S_IRUSR | S_IWUSR;
		else
			inode->i_mode = S_IFREG | S_IRUGO;
		inode->i_fop = &openpromfs_prop_ops;
		inode->i_nlink = 1;
		inode->i_size = ent_oi->u.prop->length;
		break;
	}

	inode->i_gid = 0;
	inode->i_uid = 0;

	d_add(dentry, inode);
	return NULL;
}

static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	struct op_inode_info *oi = OP_I(inode);
	struct device_node *dp = oi->u.node;
	struct device_node *child;
	struct property *prop;
	unsigned int ino;
	int i;

	mutex_lock(&op_mutex);
	
	ino = inode->i_ino;
	i = filp->f_pos;
	switch (i) {
	case 0:
		if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
			goto out;
		i++;
		filp->f_pos++;
		/* fall thru */
	case 1:
		if (filldir(dirent, "..", 2, i,
			    (dp->parent == NULL ?
			     OPENPROM_ROOT_INO :
			     dp->parent->unique_id), DT_DIR) < 0) 
			goto out;
		i++;
		filp->f_pos++;
		/* fall thru */
	default:
		i -= 2;

		/* First, the children nodes as directories.  */
		child = dp->child;
		while (i && child) {
			child = child->sibling;
			i--;
		}
		while (child) {
			if (filldir(dirent,
				    child->path_component_name,
				    strlen(child->path_component_name),
				    filp->f_pos, child->unique_id, DT_DIR) < 0)
				goto out;

			filp->f_pos++;
			child = child->sibling;
		}

		/* Next, the properties as files.  */
		prop = dp->properties;
		while (i && prop) {
			prop = prop->next;
			i--;
		}
		while (prop) {
			if (filldir(dirent, prop->name, strlen(prop->name),
				    filp->f_pos, prop->unique_id, DT_REG) < 0)
				goto out;

			filp->f_pos++;
			prop = prop->next;
		}
	}
out:
	mutex_unlock(&op_mutex);
	return 0;
}

static struct kmem_cache *op_inode_cachep;

static struct inode *openprom_alloc_inode(struct super_block *sb)
{
	struct op_inode_info *oi;

	oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL);
	if (!oi)
		return NULL;

	return &oi->vfs_inode;
}

static void openprom_destroy_inode(struct inode *inode)
{
	kmem_cache_free(op_inode_cachep, OP_I(inode));
}

static void openprom_read_inode(struct inode * inode)
{
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	if (inode->i_ino == OPENPROM_ROOT_INO) {
		inode->i_op = &openprom_inode_operations;
		inode->i_fop = &openprom_operations;
		inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
	}
}

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

static const struct super_operations openprom_sops = {
	.alloc_inode	= openprom_alloc_inode,
	.destroy_inode	= openprom_destroy_inode,
	.read_inode	= openprom_read_inode,
	.statfs		= simple_statfs,
	.remount_fs	= openprom_remount,
};

static int openprom_fill_super(struct super_block *s, void *data, int silent)
{
	struct inode *root_inode;
	struct op_inode_info *oi;

	s->s_flags |= MS_NOATIME;
	s->s_blocksize = 1024;
	s->s_blocksize_bits = 10;
	s->s_magic = OPENPROM_SUPER_MAGIC;
	s->s_op = &openprom_sops;
	s->s_time_gran = 1;
	root_inode = iget(s, OPENPROM_ROOT_INO);
	if (!root_inode)
		goto out_no_root;

	oi = OP_I(root_inode);
	oi->type = op_inode_node;
	oi->u.node = of_find_node_by_path("/");

	s->s_root = d_alloc_root(root_inode);
	if (!s->s_root)
		goto out_no_root;
	return 0;

out_no_root:
	printk("openprom_fill_super: get root inode failed\n");
	iput(root_inode);
	return -ENOMEM;
}

static int openprom_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
	return get_sb_single(fs_type, flags, data, openprom_fill_super, mnt);
}

static struct file_system_type openprom_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "openpromfs",
	.get_sb		= openprom_get_sb,
	.kill_sb	= kill_anon_super,
};

static void op_inode_init_once(void *data, struct kmem_cache * cachep, unsigned long flags)
{
	struct op_inode_info *oi = (struct op_inode_info *) data;

	inode_init_once(&oi->vfs_inode);
}

static int __init init_openprom_fs(void)
{
	int err;

	op_inode_cachep = kmem_cache_create("op_inode_cache",
					    sizeof(struct op_inode_info),
					    0,
					    (SLAB_RECLAIM_ACCOUNT |
					     SLAB_MEM_SPREAD),
					    op_inode_init_once);
	if (!op_inode_cachep)
		return -ENOMEM;

	err = register_filesystem(&openprom_fs_type);
	if (err)
		kmem_cache_destroy(op_inode_cachep);

	return err;
}

static void __exit exit_openprom_fs(void)
{
	unregister_filesystem(&openprom_fs_type);
	kmem_cache_destroy(op_inode_cachep);
}

module_init(init_openprom_fs)
module_exit(exit_openprom_fs)
MODULE_LICENSE("GPL");
Commit	Line	Data
3d824a46	1	/* inode.c: /proc/openprom handling routines
1da177e4 LT	2	*
	3	* Copyright (C) 1996-1999 Jakub Jelinek (jakub@redhat.com)
	4	* Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
	5	*/
	6
	7	#include <linux/module.h>
	8	#include <linux/types.h>
	9	#include <linux/string.h>
	10	#include <linux/fs.h>
1da177e4 LT	11	#include <linux/init.h>
1da177e4 LT	12	#include <linux/slab.h>
3d824a46	13	#include <linux/seq_file.h>
e18fa700	14	#include <linux/magic.h>
1da177e4 LT	15
	16	#include <asm/openprom.h>
	17	#include <asm/oplib.h>
3d824a46	18	#include <asm/prom.h>
1da177e4 LT	19	#include <asm/uaccess.h>
1da177e4 LT	20
3d824a46	21	static DEFINE_MUTEX(op_mutex);
1da177e4	22
3d824a46	23	#define OPENPROM_ROOT_INO 0
a04ee146	24
3d824a46 DM	25	enum op_inode_type {
	26	op_inode_node,
	27	op_inode_prop,
	28	};
	29
	30	union op_inode_data {
	31	struct device_node *node;
	32	struct property *prop;
	33	};
	34
	35	struct op_inode_info {
	36	struct inode vfs_inode;
	37	enum op_inode_type type;
	38	union op_inode_data u;
	39	};
	40
	41	static inline struct op_inode_info OP_I(struct inode inode)
1da177e4	42	{
3d824a46	43	return container_of(inode, struct op_inode_info, vfs_inode);
1da177e4 LT	44	}
1da177e4 LT	45
3d824a46	46	static int is_string(unsigned char *p, int len)
1da177e4	47	{
3d824a46	48	int i;
1da177e4	49
3d824a46 DM	50	for (i = 0; i < len; i++) {
3d824a46 DM	51	unsigned char val = p[i];
1da177e4	52
3d824a46 DM	53	if ((i && !val) \|\|
	54	(val >= ' ' && val <= '~'))
	55	continue;
1da177e4	56
3d824a46 DM	57	return 0;
3d824a46 DM	58	}
1da177e4	59
3d824a46 DM	60	return 1;
3d824a46 DM	61	}
1da177e4	62
3d824a46 DM	63	static int property_show(struct seq_file f, void v)
	64	{
	65	struct property *prop = f->private;
	66	void *pval;
	67	int len;
1da177e4	68
3d824a46 DM	69	len = prop->length;
3d824a46 DM	70	pval = prop->value;
1da177e4	71
3d824a46 DM	72	if (is_string(pval, len)) {
	73	while (len > 0) {
	74	int n = strlen(pval);
1da177e4	75
3d824a46	76	seq_printf(f, "%s", (char *) pval);
1da177e4	77
3d824a46 DM	78	/* Skip over the NULL byte too. */
	79	pval += n + 1;
	80	len -= n + 1;
1da177e4	81
3d824a46 DM	82	if (len > 0)
3d824a46 DM	83	seq_printf(f, " + ");
1da177e4	84	}
3d824a46 DM	85	} else {
	86	if (len & 3) {
	87	while (len) {
	88	len--;
	89	if (len)
	90	seq_printf(f, "%02x.",
	91	(unsigned char ) pval);
	92	else
	93	seq_printf(f, "%02x",
	94	(unsigned char ) pval);
	95	pval++;
1da177e4 LT	96	}
1da177e4 LT	97	} else {
3d824a46 DM	98	while (len >= 4) {
	99	len -= 4;
	100
	101	if (len)
	102	seq_printf(f, "%08x.",
	103	(unsigned int ) pval);
	104	else
	105	seq_printf(f, "%08x",
	106	(unsigned int ) pval);
	107	pval += 4;
1da177e4	108	}
1da177e4 LT	109	}
1da177e4 LT	110	}
3d824a46 DM	111	seq_printf(f, "\n");
	112
	113	return 0;
1da177e4 LT	114	}
1da177e4 LT	115
3d824a46	116	static void property_start(struct seq_file f, loff_t *pos)
1da177e4	117	{
3d824a46 DM	118	if (*pos == 0)
	119	return pos;
	120	return NULL;
	121	}
	122
	123	static void property_next(struct seq_file f, void v, loff_t pos)
	124	{
	125	(*pos)++;
	126	return NULL;
	127	}
	128
	129	static void property_stop(struct seq_file f, void v)
	130	{
	131	/* Nothing to do */
	132	}
	133
	134	static struct seq_operations property_op = {
	135	.start = property_start,
	136	.next = property_next,
	137	.stop = property_stop,
	138	.show = property_show
	139	};
	140
	141	static int property_open(struct inode inode, struct file file)
	142	{
	143	struct op_inode_info *oi = OP_I(inode);
	144	int ret;
	145
	146	BUG_ON(oi->type != op_inode_prop);
	147
	148	ret = seq_open(file, &property_op);
	149	if (!ret) {
	150	struct seq_file *m = file->private_data;
	151	m->private = oi->u.prop;
1da177e4	152	}
3d824a46	153	return ret;
1da177e4 LT	154	}
1da177e4 LT	155
4b6f5d20	156	static const struct file_operations openpromfs_prop_ops = {
3d824a46 DM	157	.open = property_open,
	158	.read = seq_read,
	159	.llseek = seq_lseek,
	160	.release = seq_release,
1da177e4 LT	161	};
1da177e4 LT	162
3d824a46	163	static int openpromfs_readdir(struct file , void , filldir_t);
1da177e4	164
4b6f5d20	165	static const struct file_operations openprom_operations = {
1da177e4 LT	166	.read = generic_read_dir,
	167	.readdir = openpromfs_readdir,
	168	};
	169
3d824a46	170	static struct dentry openpromfs_lookup(struct inode , struct dentry , struct nameidata );
1da177e4	171
92e1d5be	172	static const struct inode_operations openprom_inode_operations = {
1da177e4 LT	173	.lookup = openpromfs_lookup,
	174	};
	175
3d824a46	176	static struct dentry openpromfs_lookup(struct inode dir, struct dentry dentry, struct nameidata nd)
1da177e4	177	{
3d824a46 DM	178	struct op_inode_info ent_oi, oi = OP_I(dir);
	179	struct device_node dp, child;
	180	struct property *prop;
	181	enum op_inode_type ent_type;
	182	union op_inode_data ent_data;
1da177e4	183	const char *name;
1da177e4	184	struct inode *inode;
3d824a46 DM	185	unsigned int ino;
3d824a46 DM	186	int len;
1da177e4	187
3d824a46 DM	188	BUG_ON(oi->type != op_inode_node);
	189
	190	dp = oi->u.node;
	191
1da177e4 LT	192	name = dentry->d_name.name;
1da177e4 LT	193	len = dentry->d_name.len;
3d824a46 DM	194
	195	mutex_lock(&op_mutex);
	196
	197	child = dp->child;
	198	while (child) {
	199	int n = strlen(child->path_component_name);
	200
	201	if (len == n &&
	202	!strncmp(child->path_component_name, name, len)) {
	203	ent_type = op_inode_node;
	204	ent_data.node = child;
	205	ino = child->unique_id;
	206	goto found;
1da177e4	207	}
3d824a46	208	child = child->sibling;
1da177e4	209	}
3d824a46 DM	210
	211	prop = dp->properties;
	212	while (prop) {
	213	int n = strlen(prop->name);
	214
	215	if (len == n && !strncmp(prop->name, name, len)) {
	216	ent_type = op_inode_prop;
	217	ent_data.prop = prop;
	218	ino = prop->unique_id;
	219	goto found;
1da177e4	220	}
3d824a46 DM	221
3d824a46 DM	222	prop = prop->next;
1da177e4	223	}
3d824a46 DM	224
	225	mutex_unlock(&op_mutex);
	226	return ERR_PTR(-ENOENT);
	227
	228	found:
	229	inode = iget(dir->i_sb, ino);
	230	mutex_unlock(&op_mutex);
1da177e4 LT	231	if (!inode)
1da177e4 LT	232	return ERR_PTR(-EINVAL);
3d824a46 DM	233	ent_oi = OP_I(inode);
	234	ent_oi->type = ent_type;
	235	ent_oi->u = ent_data;
	236
	237	switch (ent_type) {
	238	case op_inode_node:
1da177e4	239	inode->i_mode = S_IFDIR \| S_IRUGO \| S_IXUGO;
3d824a46	240	inode->i_op = &openprom_inode_operations;
1da177e4 LT	241	inode->i_fop = &openprom_operations;
	242	inode->i_nlink = 2;
	243	break;
3d824a46 DM	244	case op_inode_prop:
	245	if (!strcmp(dp->name, "options") && (len == 17) &&
	246	!strncmp (name, "security-password", 17))
1da177e4	247	inode->i_mode = S_IFREG \| S_IRUSR \| S_IWUSR;
3d824a46	248	else
1da177e4	249	inode->i_mode = S_IFREG \| S_IRUGO;
1da177e4 LT	250	inode->i_fop = &openpromfs_prop_ops;
1da177e4 LT	251	inode->i_nlink = 1;
3d824a46	252	inode->i_size = ent_oi->u.prop->length;
1da177e4 LT	253	break;
	254	}
	255
	256	inode->i_gid = 0;
	257	inode->i_uid = 0;
	258
	259	d_add(dentry, inode);
	260	return NULL;
	261	}
	262
	263	static int openpromfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
	264	{
80a06780	265	struct inode *inode = filp->f_path.dentry->d_inode;
3d824a46 DM	266	struct op_inode_info *oi = OP_I(inode);
	267	struct device_node *dp = oi->u.node;
	268	struct device_node *child;
	269	struct property *prop;
1da177e4	270	unsigned int ino;
3d824a46 DM	271	int i;
	272
	273	mutex_lock(&op_mutex);
1da177e4 LT	274
	275	ino = inode->i_ino;
	276	i = filp->f_pos;
	277	switch (i) {
	278	case 0:
3d824a46 DM	279	if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
3d824a46 DM	280	goto out;
1da177e4 LT	281	i++;
	282	filp->f_pos++;
	283	/* fall thru */
	284	case 1:
3d824a46 DM	285	if (filldir(dirent, "..", 2, i,
	286	(dp->parent == NULL ?
	287	OPENPROM_ROOT_INO :
	288	dp->parent->unique_id), DT_DIR) < 0)
1da177e4 LT	289	goto out;
	290	i++;
	291	filp->f_pos++;
	292	/* fall thru */
	293	default:
	294	i -= 2;
3d824a46 DM	295
	296	/* First, the children nodes as directories. */
	297	child = dp->child;
	298	while (i && child) {
	299	child = child->sibling;
1da177e4 LT	300	i--;
1da177e4 LT	301	}
3d824a46 DM	302	while (child) {
	303	if (filldir(dirent,
	304	child->path_component_name,
	305	strlen(child->path_component_name),
	306	filp->f_pos, child->unique_id, DT_DIR) < 0)
1da177e4	307	goto out;
3d824a46	308
1da177e4	309	filp->f_pos++;
3d824a46	310	child = child->sibling;
1da177e4	311	}
3d824a46 DM	312
	313	/* Next, the properties as files. */
	314	prop = dp->properties;
	315	while (i && prop) {
	316	prop = prop->next;
	317	i--;
	318	}
	319	while (prop) {
	320	if (filldir(dirent, prop->name, strlen(prop->name),
	321	filp->f_pos, prop->unique_id, DT_REG) < 0)
1da177e4	322	goto out;
3d824a46	323
1da177e4	324	filp->f_pos++;
3d824a46	325	prop = prop->next;
1da177e4 LT	326	}
	327	}
	328	out:
3d824a46	329	mutex_unlock(&op_mutex);
1da177e4 LT	330	return 0;
	331	}
	332
e18b890b	333	static struct kmem_cache *op_inode_cachep;
1da177e4	334
3d824a46	335	static struct inode openprom_alloc_inode(struct super_block sb)
1da177e4	336	{
3d824a46	337	struct op_inode_info *oi;
1da177e4	338
e94b1766	339	oi = kmem_cache_alloc(op_inode_cachep, GFP_KERNEL);
3d824a46 DM	340	if (!oi)
3d824a46 DM	341	return NULL;
1da177e4	342
3d824a46	343	return &oi->vfs_inode;
1da177e4 LT	344	}
1da177e4 LT	345
3d824a46	346	static void openprom_destroy_inode(struct inode *inode)
1da177e4	347	{
3d824a46	348	kmem_cache_free(op_inode_cachep, OP_I(inode));
1da177e4 LT	349	}
	350
	351	static void openprom_read_inode(struct inode * inode)
	352	{
	353	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	354	if (inode->i_ino == OPENPROM_ROOT_INO) {
	355	inode->i_op = &openprom_inode_operations;
	356	inode->i_fop = &openprom_operations;
	357	inode->i_mode = S_IFDIR \| S_IRUGO \| S_IXUGO;
	358	}
	359	}
	360
	361	static int openprom_remount(struct super_block sb, int flags, char *data)
	362	{
	363	*flags \|= MS_NOATIME;
	364	return 0;
	365	}
	366
ee9b6d61	367	static const struct super_operations openprom_sops = {
3d824a46 DM	368	.alloc_inode = openprom_alloc_inode,
3d824a46 DM	369	.destroy_inode = openprom_destroy_inode,
1da177e4 LT	370	.read_inode = openprom_read_inode,
	371	.statfs = simple_statfs,
	372	.remount_fs = openprom_remount,
	373	};
	374
	375	static int openprom_fill_super(struct super_block s, void data, int silent)
	376	{
3d824a46 DM	377	struct inode *root_inode;
3d824a46 DM	378	struct op_inode_info *oi;
1da177e4 LT	379
	380	s->s_flags \|= MS_NOATIME;
	381	s->s_blocksize = 1024;
	382	s->s_blocksize_bits = 10;
	383	s->s_magic = OPENPROM_SUPER_MAGIC;
	384	s->s_op = &openprom_sops;
	385	s->s_time_gran = 1;
	386	root_inode = iget(s, OPENPROM_ROOT_INO);
	387	if (!root_inode)
	388	goto out_no_root;
3d824a46 DM	389
	390	oi = OP_I(root_inode);
	391	oi->type = op_inode_node;
	392	oi->u.node = of_find_node_by_path("/");
	393
1da177e4 LT	394	s->s_root = d_alloc_root(root_inode);
	395	if (!s->s_root)
	396	goto out_no_root;
	397	return 0;
	398
	399	out_no_root:
	400	printk("openprom_fill_super: get root inode failed\n");
	401	iput(root_inode);
	402	return -ENOMEM;
	403	}
	404
454e2398 DH	405	static int openprom_get_sb(struct file_system_type *fs_type,
454e2398 DH	406	int flags, const char dev_name, void data, struct vfsmount *mnt)
1da177e4	407	{
454e2398	408	return get_sb_single(fs_type, flags, data, openprom_fill_super, mnt);
1da177e4 LT	409	}
	410
	411	static struct file_system_type openprom_fs_type = {
	412	.owner = THIS_MODULE,
	413	.name = "openpromfs",
	414	.get_sb = openprom_get_sb,
	415	.kill_sb = kill_anon_super,
	416	};
	417
e18b890b	418	static void op_inode_init_once(void data, struct kmem_cache cachep, unsigned long flags)
3d824a46 DM	419	{
	420	struct op_inode_info oi = (struct op_inode_info ) data;
	421
a35afb83	422	inode_init_once(&oi->vfs_inode);
3d824a46 DM	423	}
3d824a46 DM	424
1da177e4 LT	425	static int __init init_openprom_fs(void)
1da177e4 LT	426	{
3d824a46 DM	427	int err;
	428
	429	op_inode_cachep = kmem_cache_create("op_inode_cache",
	430	sizeof(struct op_inode_info),
	431	0,
	432	(SLAB_RECLAIM_ACCOUNT \|
	433	SLAB_MEM_SPREAD),
20c2df83	434	op_inode_init_once);
3d824a46 DM	435	if (!op_inode_cachep)
	436	return -ENOMEM;
	437
	438	err = register_filesystem(&openprom_fs_type);
	439	if (err)
	440	kmem_cache_destroy(op_inode_cachep);
	441
	442	return err;
1da177e4 LT	443	}
	444
	445	static void __exit exit_openprom_fs(void)
	446	{
1da177e4	447	unregister_filesystem(&openprom_fs_type);
3d824a46	448	kmem_cache_destroy(op_inode_cachep);
1da177e4 LT	449	}
	450
	451	module_init(init_openprom_fs)
	452	module_exit(exit_openprom_fs)
	453	MODULE_LICENSE("GPL");