path: root/fs/promfs/promfs.c

/*
 * promfs.c - generic inode/dentry functions for IEEE 1275-based filesystems.
 *
 * This is based heavily upon prior ieee1275 and other virtual filesystems
 * implementations; openpromfs, proc_devtree.c, oprofilefs, procfs, ...
 * 
 * Copyright (C) 2007 Andres Salomon <dilinger@debian.org>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/fs.h>
//#include <linux/promfs.h>
#include <asm/prom.h>

#define PROMFS_MAGIC 0x1f2f3fff

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andres Salomon");

struct promfs_inode
{
	struct inode ino;
	struct property *prop;
};

static inline struct promfs_inode *to_promfs_inode(struct inode *inode)
{
	return container_of(inode, struct promfs_inode, ino);
}

#if 0
static DEFINE_SPINLOCK(promfs_lock);

static struct of_node *of_tree = NULL;
static DEFINE_RWLOCK(of_tree_lock);

void __init of_build_tree(void)
{


}
#endif

static int promfs_open_file(struct inode *inode, struct file *file)
{
	struct promfs_inode *ino;

	ino = to_promfs_inode(inode);
	if (!ino->prop)
		return -EIO;
	file->private_data = ino->prop;

	return 0;
}

static ssize_t promfs_read_file(struct file *file, char __user *data,
		size_t len, loff_t *ppos)
{
	struct property *prop = (struct property *) file->private_data;
	return simple_read_from_buffer(data, len, ppos, prop->value,
			prop->length);
}

static ssize_t promfs_write_file(struct file *file, char const __user *buf,
		size_t count, loff_t * offset)
{
	/* TODO.... 'cause, y'know, it would be nice. */
	return -EIO;
}

static struct file_operations promfs_file_ops = {
	.open = promfs_open_file,
	.read = promfs_read_file,
	.write = promfs_write_file,
};

static struct kmem_cache *promfs_inode_cachep;

static struct inode *promfs_alloc_inode(struct super_block *sb)
{
	struct promfs_inode *pr_ino;

	pr_ino = kmem_cache_alloc(promfs_inode_cachep, GFP_KERNEL);
	if (!pr_ino)
		return NULL;
	pr_ino->prop = NULL;

	return &pr_ino->ino;
}

static void promfs_destroy_inode(struct inode *inode)
{
	kmem_cache_free(promfs_inode_cachep, to_promfs_inode(inode));
}

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

static struct super_operations promfs_s_ops = {
	.alloc_inode = promfs_alloc_inode,
	.destroy_inode = promfs_destroy_inode,
	.statfs = simple_statfs,
	.drop_inode = generic_delete_inode,
	.remount_fs = promfs_remount,
};

static struct inode *promfs_get_inode(struct super_block *sb, int mode)
{
	struct inode *inode = new_inode(sb);

	if (inode) {
		inode->i_mode = mode;
		inode->i_uid = 0;
		inode->i_gid = 0;
		inode->i_blocks = 0;
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	}

	return inode;
}

static int promfs_create_file(struct super_block *sb, struct dentry *root,
		struct property *prop, const struct file_operations *fops)
{
	struct dentry *dentry;
	struct inode *inode;
	struct promfs_inode *ino;

	dentry = d_alloc_name(root, prop->name);
	if (!dentry)
		goto err;

	inode = promfs_get_inode(sb, S_IFREG | 0644);
	if (!inode)
		goto err_dput;
	inode->i_fop = fops;
	ino = to_promfs_inode(inode);
	ino->prop = prop;
	d_add(dentry, inode);

	return 0;

err_dput:
	dput(dentry);
err:
	return -EFAULT;
}

struct dentry *promfs_create_dir(struct super_block *sb, struct dentry *root,
		char const *name)
{
	struct dentry *dentry;
	struct inode *inode;

	dentry = d_alloc_name(root, name);
	if (!dentry)
		goto err;

	inode = promfs_get_inode(sb, S_IFDIR | 0755);
	if (!inode)
		goto err_dput;
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
	d_add(dentry, inode);
	return dentry;

err_dput:
	dput(dentry);
err:
	return NULL;
}

void promfs_populate(struct super_block *sb, struct dentry *root,
		struct device_node *node)
{
	struct dentry *dentry;
	struct device_node *child;
	struct property *prop;

	if (!node)
		return;

	for (child = node->child; child; child = child->sibling) {
		dentry = promfs_create_dir(sb, root, child->path_component_name);
		promfs_populate(sb, dentry, child);
	}
	for (prop = node->properties; prop; prop = prop->next)
		promfs_create_file(sb, root, prop, &promfs_file_ops);
}

static int promfs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode *root_inode;
	struct dentry *root_dentry;
	struct promfs_inode *inode;

	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = PROMFS_MAGIC;
	sb->s_op = &promfs_s_ops;
	sb->s_time_gran = 1;
	sb->s_flags |= MS_NOATIME;

	root_inode = promfs_get_inode(sb, S_IFDIR | 0755);
	if (!root_inode)
		goto err;
	root_inode->i_op = &simple_dir_inode_operations;
	root_inode->i_fop = &simple_dir_operations;

	inode = to_promfs_inode(root_inode);

	root_dentry = d_alloc_root(root_inode);
	if (!root_dentry)
		goto err_iput;
	sb->s_root = root_dentry;

	promfs_populate(sb, root_dentry, of_find_node_by_path("/"));
	return 0;

err_iput:
	iput(root_inode);
err:
	return -ENOMEM;
}

static int promfs_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, promfs_fill_super, mnt);
}

static struct file_system_type promfs_fs_type = {
	.owner = THIS_MODULE,
	.name = "promfs",
	.get_sb = promfs_get_sb,
	.kill_sb = kill_litter_super,
};

static void init_once(struct kmem_cache *cachep, void *i)
{
	struct promfs_inode *inode = (struct promfs_inode *) i;
	inode_init_once(&inode->ino);
}

static int __init init_promfs(void)
{
	int err;

	prom_build_devicetree();
	promfs_inode_cachep = kmem_cache_create("promfs_inode_cache",
			sizeof(struct promfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, init_once);
	if (!promfs_inode_cachep)
		return -ENOMEM;

	err = register_filesystem(&promfs_fs_type);
	if (err)
		kmem_cache_destroy(promfs_inode_cachep);
		
	return err;
}

static void __exit exit_promfs(void)
{
	unregister_filesystem(&promfs_fs_type);
	kmem_cache_destroy(promfs_inode_cachep);
}

module_init(init_promfs);
module_exit(exit_promfs);