[linux.git] / fs / afs / proc.c

/* /proc interface for AFS
 *
 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * 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.
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/sched.h>
#include <asm/uaccess.h>
#include "internal.h"

static struct proc_dir_entry *proc_afs;


static int afs_proc_cells_open(struct inode *inode, struct file *file);
static void *afs_proc_cells_start(struct seq_file *p, loff_t *pos);
static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
static void afs_proc_cells_stop(struct seq_file *p, void *v);
static int afs_proc_cells_show(struct seq_file *m, void *v);
static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
				    size_t size, loff_t *_pos);

static const struct seq_operations afs_proc_cells_ops = {
	.start	= afs_proc_cells_start,
	.next	= afs_proc_cells_next,
	.stop	= afs_proc_cells_stop,
	.show	= afs_proc_cells_show,
};

static const struct file_operations afs_proc_cells_fops = {
	.open		= afs_proc_cells_open,
	.read		= seq_read,
	.write		= afs_proc_cells_write,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
				      size_t size, loff_t *_pos);
static ssize_t afs_proc_rootcell_write(struct file *file,
				       const char __user *buf,
				       size_t size, loff_t *_pos);

static const struct file_operations afs_proc_rootcell_fops = {
	.read		= afs_proc_rootcell_read,
	.write		= afs_proc_rootcell_write,
	.llseek		= no_llseek,
};

static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
					loff_t *pos);
static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);

static const struct seq_operations afs_proc_cell_volumes_ops = {
	.start	= afs_proc_cell_volumes_start,
	.next	= afs_proc_cell_volumes_next,
	.stop	= afs_proc_cell_volumes_stop,
	.show	= afs_proc_cell_volumes_show,
};

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

static int afs_proc_cell_vlservers_open(struct inode *inode,
					struct file *file);
static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
					  loff_t *pos);
static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);

static const struct seq_operations afs_proc_cell_vlservers_ops = {
	.start	= afs_proc_cell_vlservers_start,
	.next	= afs_proc_cell_vlservers_next,
	.stop	= afs_proc_cell_vlservers_stop,
	.show	= afs_proc_cell_vlservers_show,
};

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

static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
					loff_t *pos);
static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
static int afs_proc_cell_servers_show(struct seq_file *m, void *v);

static const struct seq_operations afs_proc_cell_servers_ops = {
	.start	= afs_proc_cell_servers_start,
	.next	= afs_proc_cell_servers_next,
	.stop	= afs_proc_cell_servers_stop,
	.show	= afs_proc_cell_servers_show,
};

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

/*
 * initialise the /proc/fs/afs/ directory
 */
int afs_proc_init(void)
{
	_enter("");

	proc_afs = proc_mkdir("fs/afs", NULL);
	if (!proc_afs)
		goto error_dir;

	if (!proc_create("cells", 0, proc_afs, &afs_proc_cells_fops) ||
	    !proc_create("rootcell", 0, proc_afs, &afs_proc_rootcell_fops))
		goto error_tree;

	_leave(" = 0");
	return 0;

error_tree:
	remove_proc_subtree("fs/afs", NULL);
error_dir:
	_leave(" = -ENOMEM");
	return -ENOMEM;
}

/*
 * clean up the /proc/fs/afs/ directory
 */
void afs_proc_cleanup(void)
{
	remove_proc_subtree("fs/afs", NULL);
}

/*
 * open "/proc/fs/afs/cells" which provides a summary of extant cells
 */
static int afs_proc_cells_open(struct inode *inode, struct file *file)
{
	struct seq_file *m;
	int ret;

	ret = seq_open(file, &afs_proc_cells_ops);
	if (ret < 0)
		return ret;

	m = file->private_data;
	m->private = PDE_DATA(inode);

	return 0;
}

/*
 * set up the iterator to start reading from the cells list and return the
 * first item
 */
static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
{
	/* lock the list against modification */
	down_read(&afs_proc_cells_sem);
	return seq_list_start_head(&afs_proc_cells, *_pos);
}

/*
 * move to next cell in cells list
 */
static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
{
	return seq_list_next(v, &afs_proc_cells, pos);
}

/*
 * clean up after reading from the cells list
 */
static void afs_proc_cells_stop(struct seq_file *p, void *v)
{
	up_read(&afs_proc_cells_sem);
}

/*
 * display a header line followed by a load of cell lines
 */
static int afs_proc_cells_show(struct seq_file *m, void *v)
{
	struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);

	if (v == &afs_proc_cells) {
		/* display header on line 1 */
		seq_puts(m, "USE NAME\n");
		return 0;
	}

	/* display one cell per line on subsequent lines */
	seq_printf(m, "%3d %s\n",
		   atomic_read(&cell->usage), cell->name);
	return 0;
}

/*
 * handle writes to /proc/fs/afs/cells
 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
 */
static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
				    size_t size, loff_t *_pos)
{
	char *kbuf, *name, *args;
	int ret;

	/* start by dragging the command into memory */
	if (size <= 1 || size >= PAGE_SIZE)
		return -EINVAL;

	kbuf = kmalloc(size + 1, GFP_KERNEL);
	if (!kbuf)
		return -ENOMEM;

	ret = -EFAULT;
	if (copy_from_user(kbuf, buf, size) != 0)
		goto done;
	kbuf[size] = 0;

	/* trim to first NL */
	name = memchr(kbuf, '\n', size);
	if (name)
		*name = 0;

	/* split into command, name and argslist */
	name = strchr(kbuf, ' ');
	if (!name)
		goto inval;
	do {
		*name++ = 0;
	} while(*name == ' ');
	if (!*name)
		goto inval;

	args = strchr(name, ' ');
	if (!args)
		goto inval;
	do {
		*args++ = 0;
	} while(*args == ' ');
	if (!*args)
		goto inval;

	/* determine command to perform */
	_debug("cmd=%s name=%s args=%s", kbuf, name, args);

	if (strcmp(kbuf, "add") == 0) {
		struct afs_cell *cell;

		cell = afs_cell_create(name, strlen(name), args, false);
		if (IS_ERR(cell)) {
			ret = PTR_ERR(cell);
			goto done;
		}

		afs_put_cell(cell);
		printk("kAFS: Added new cell '%s'\n", name);
	} else {
		goto inval;
	}

	ret = size;

done:
	kfree(kbuf);
	_leave(" = %d", ret);
	return ret;

inval:
	ret = -EINVAL;
	printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
	goto done;
}

static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
				      size_t size, loff_t *_pos)
{
	return 0;
}

/*
 * handle writes to /proc/fs/afs/rootcell
 * - to initialize rootcell: echo "cell.name:192.168.231.14"
 */
static ssize_t afs_proc_rootcell_write(struct file *file,
				       const char __user *buf,
				       size_t size, loff_t *_pos)
{
	char *kbuf, *s;
	int ret;

	/* start by dragging the command into memory */
	if (size <= 1 || size >= PAGE_SIZE)
		return -EINVAL;

	ret = -ENOMEM;
	kbuf = kmalloc(size + 1, GFP_KERNEL);
	if (!kbuf)
		goto nomem;

	ret = -EFAULT;
	if (copy_from_user(kbuf, buf, size) != 0)
		goto infault;
	kbuf[size] = 0;

	/* trim to first NL */
	s = memchr(kbuf, '\n', size);
	if (s)
		*s = 0;

	/* determine command to perform */
	_debug("rootcell=%s", kbuf);

	ret = afs_cell_init(kbuf);
	if (ret >= 0)
		ret = size;	/* consume everything, always */

infault:
	kfree(kbuf);
nomem:
	_leave(" = %d", ret);
	return ret;
}

/*
 * initialise /proc/fs/afs/<cell>/
 */
int afs_proc_cell_setup(struct afs_cell *cell)
{
	struct proc_dir_entry *dir;

	_enter("%p{%s}", cell, cell->name);

	dir = proc_mkdir(cell->name, proc_afs);
	if (!dir)
		goto error_dir;

	if (!proc_create_data("servers", 0, dir,
			     &afs_proc_cell_servers_fops, cell) ||
	    !proc_create_data("vlservers", 0, dir,
			     &afs_proc_cell_vlservers_fops, cell) ||
	    !proc_create_data("volumes", 0, dir,
			     &afs_proc_cell_volumes_fops, cell))
		goto error_tree;

	_leave(" = 0");
	return 0;

error_tree:
	remove_proc_subtree(cell->name, proc_afs);
error_dir:
	_leave(" = -ENOMEM");
	return -ENOMEM;
}

/*
 * remove /proc/fs/afs/<cell>/
 */
void afs_proc_cell_remove(struct afs_cell *cell)
{
	_enter("");

	remove_proc_subtree(cell->name, proc_afs);

	_leave("");
}

/*
 * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
 */
static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
{
	struct afs_cell *cell;
	struct seq_file *m;
	int ret;

	cell = PDE_DATA(inode);
	if (!cell)
		return -ENOENT;

	ret = seq_open(file, &afs_proc_cell_volumes_ops);
	if (ret < 0)
		return ret;

	m = file->private_data;
	m->private = cell;

	return 0;
}

/*
 * set up the iterator to start reading from the cells list and return the
 * first item
 */
static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
{
	struct afs_cell *cell = m->private;

	_enter("cell=%p pos=%Ld", cell, *_pos);

	/* lock the list against modification */
	down_read(&cell->vl_sem);
	return seq_list_start_head(&cell->vl_list, *_pos);
}

/*
 * move to next cell in cells list
 */
static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
					loff_t *_pos)
{
	struct afs_cell *cell = p->private;

	_enter("cell=%p pos=%Ld", cell, *_pos);
	return seq_list_next(v, &cell->vl_list, _pos);
}

/*
 * clean up after reading from the cells list
 */
static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
{
	struct afs_cell *cell = p->private;

	up_read(&cell->vl_sem);
}

static const char afs_vlocation_states[][4] = {
	[AFS_VL_NEW]			= "New",
	[AFS_VL_CREATING]		= "Crt",
	[AFS_VL_VALID]			= "Val",
	[AFS_VL_NO_VOLUME]		= "NoV",
	[AFS_VL_UPDATING]		= "Upd",
	[AFS_VL_VOLUME_DELETED]		= "Del",
	[AFS_VL_UNCERTAIN]		= "Unc",
};

/*
 * display a header line followed by a load of volume lines
 */
static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
{
	struct afs_cell *cell = m->private;
	struct afs_vlocation *vlocation =
		list_entry(v, struct afs_vlocation, link);

	/* display header on line 1 */
	if (v == &cell->vl_list) {
		seq_puts(m, "USE STT VLID[0]  VLID[1]  VLID[2]  NAME\n");
		return 0;
	}

	/* display one cell per line on subsequent lines */
	seq_printf(m, "%3d %s %08x %08x %08x %s\n",
		   atomic_read(&vlocation->usage),
		   afs_vlocation_states[vlocation->state],
		   vlocation->vldb.vid[0],
		   vlocation->vldb.vid[1],
		   vlocation->vldb.vid[2],
		   vlocation->vldb.name);

	return 0;
}

/*
 * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
 * location server
 */
static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
{
	struct afs_cell *cell;
	struct seq_file *m;
	int ret;

	cell = PDE_DATA(inode);
	if (!cell)
		return -ENOENT;

	ret = seq_open(file, &afs_proc_cell_vlservers_ops);
	if (ret<0)
		return ret;

	m = file->private_data;
	m->private = cell;

	return 0;
}

/*
 * set up the iterator to start reading from the cells list and return the
 * first item
 */
static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
{
	struct afs_cell *cell = m->private;
	loff_t pos = *_pos;

	_enter("cell=%p pos=%Ld", cell, *_pos);

	/* lock the list against modification */
	down_read(&cell->vl_sem);

	/* allow for the header line */
	if (!pos)
		return (void *) 1;
	pos--;

	if (pos >= cell->vl_naddrs)
		return NULL;

	return &cell->vl_addrs[pos];
}

/*
 * move to next cell in cells list
 */
static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
					  loff_t *_pos)
{
	struct afs_cell *cell = p->private;
	loff_t pos;

	_enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);

	pos = *_pos;
	(*_pos)++;
	if (pos >= cell->vl_naddrs)
		return NULL;

	return &cell->vl_addrs[pos];
}

/*
 * clean up after reading from the cells list
 */
static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
{
	struct afs_cell *cell = p->private;

	up_read(&cell->vl_sem);
}

/*
 * display a header line followed by a load of volume lines
 */
static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
{
	struct in_addr *addr = v;

	/* display header on line 1 */
	if (v == (struct in_addr *) 1) {
		seq_puts(m, "ADDRESS\n");
		return 0;
	}

	/* display one cell per line on subsequent lines */
	seq_printf(m, "%pI4\n", &addr->s_addr);
	return 0;
}

/*
 * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
 * servers
 */
static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
{
	struct afs_cell *cell;
	struct seq_file *m;
	int ret;

	cell = PDE_DATA(inode);
	if (!cell)
		return -ENOENT;

	ret = seq_open(file, &afs_proc_cell_servers_ops);
	if (ret < 0)
		return ret;

	m = file->private_data;
	m->private = cell;
	return 0;
}

/*
 * set up the iterator to start reading from the cells list and return the
 * first item
 */
static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
	__acquires(m->private->servers_lock)
{
	struct afs_cell *cell = m->private;

	_enter("cell=%p pos=%Ld", cell, *_pos);

	/* lock the list against modification */
	read_lock(&cell->servers_lock);
	return seq_list_start_head(&cell->servers, *_pos);
}

/*
 * move to next cell in cells list
 */
static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
					loff_t *_pos)
{
	struct afs_cell *cell = p->private;

	_enter("cell=%p pos=%Ld", cell, *_pos);
	return seq_list_next(v, &cell->servers, _pos);
}

/*
 * clean up after reading from the cells list
 */
static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
	__releases(p->private->servers_lock)
{
	struct afs_cell *cell = p->private;

	read_unlock(&cell->servers_lock);
}

/*
 * display a header line followed by a load of volume lines
 */
static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
{
	struct afs_cell *cell = m->private;
	struct afs_server *server = list_entry(v, struct afs_server, link);
	char ipaddr[20];

	/* display header on line 1 */
	if (v == &cell->servers) {
		seq_puts(m, "USE ADDR            STATE\n");
		return 0;
	}

	/* display one cell per line on subsequent lines */
	sprintf(ipaddr, "%pI4", &server->addr);
	seq_printf(m, "%3d %-15.15s %5d\n",
		   atomic_read(&server->usage), ipaddr, server->fs_state);

	return 0;
}
Commit	Line	Data
ec26815a	1	/* /proc interface for AFS
1da177e4 LT	2	*
	3	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
1da177e4 LT	12	#include <linux/slab.h>
	13	#include <linux/module.h>
	14	#include <linux/proc_fs.h>
	15	#include <linux/seq_file.h>
e8edc6e0	16	#include <linux/sched.h>
1da177e4 LT	17	#include <asm/uaccess.h>
	18	#include "internal.h"
	19
	20	static struct proc_dir_entry *proc_afs;
	21
	22
	23	static int afs_proc_cells_open(struct inode inode, struct file file);
	24	static void afs_proc_cells_start(struct seq_file p, loff_t *pos);
	25	static void afs_proc_cells_next(struct seq_file p, void v, loff_t pos);
	26	static void afs_proc_cells_stop(struct seq_file p, void v);
	27	static int afs_proc_cells_show(struct seq_file m, void v);
	28	static ssize_t afs_proc_cells_write(struct file file, const char __user buf,
	29	size_t size, loff_t *_pos);
	30
88e9d34c	31	static const struct seq_operations afs_proc_cells_ops = {
1da177e4 LT	32	.start = afs_proc_cells_start,
	33	.next = afs_proc_cells_next,
	34	.stop = afs_proc_cells_stop,
	35	.show = afs_proc_cells_show,
	36	};
	37
4b6f5d20	38	static const struct file_operations afs_proc_cells_fops = {
1da177e4 LT	39	.open = afs_proc_cells_open,
	40	.read = seq_read,
	41	.write = afs_proc_cells_write,
	42	.llseek = seq_lseek,
	43	.release = seq_release,
	44	};
	45
1da177e4 LT	46	static ssize_t afs_proc_rootcell_read(struct file file, char __user buf,
	47	size_t size, loff_t *_pos);
	48	static ssize_t afs_proc_rootcell_write(struct file *file,
	49	const char __user *buf,
	50	size_t size, loff_t *_pos);
	51
4b6f5d20	52	static const struct file_operations afs_proc_rootcell_fops = {
1da177e4 LT	53	.read = afs_proc_rootcell_read,
	54	.write = afs_proc_rootcell_write,
	55	.llseek = no_llseek,
1da177e4 LT	56	};
	57
	58	static int afs_proc_cell_volumes_open(struct inode inode, struct file file);
1da177e4 LT	59	static void afs_proc_cell_volumes_start(struct seq_file p, loff_t *pos);
	60	static void afs_proc_cell_volumes_next(struct seq_file p, void *v,
	61	loff_t *pos);
	62	static void afs_proc_cell_volumes_stop(struct seq_file p, void v);
	63	static int afs_proc_cell_volumes_show(struct seq_file m, void v);
	64
88e9d34c	65	static const struct seq_operations afs_proc_cell_volumes_ops = {
1da177e4 LT	66	.start = afs_proc_cell_volumes_start,
	67	.next = afs_proc_cell_volumes_next,
	68	.stop = afs_proc_cell_volumes_stop,
	69	.show = afs_proc_cell_volumes_show,
	70	};
	71
4b6f5d20	72	static const struct file_operations afs_proc_cell_volumes_fops = {
1da177e4 LT	73	.open = afs_proc_cell_volumes_open,
	74	.read = seq_read,
	75	.llseek = seq_lseek,
b42d570c	76	.release = seq_release,
1da177e4 LT	77	};
	78
	79	static int afs_proc_cell_vlservers_open(struct inode *inode,
	80	struct file *file);
1da177e4 LT	81	static void afs_proc_cell_vlservers_start(struct seq_file p, loff_t *pos);
	82	static void afs_proc_cell_vlservers_next(struct seq_file p, void *v,
	83	loff_t *pos);
	84	static void afs_proc_cell_vlservers_stop(struct seq_file p, void v);
	85	static int afs_proc_cell_vlservers_show(struct seq_file m, void v);
	86
88e9d34c	87	static const struct seq_operations afs_proc_cell_vlservers_ops = {
1da177e4 LT	88	.start = afs_proc_cell_vlservers_start,
	89	.next = afs_proc_cell_vlservers_next,
	90	.stop = afs_proc_cell_vlservers_stop,
	91	.show = afs_proc_cell_vlservers_show,
	92	};
	93
4b6f5d20	94	static const struct file_operations afs_proc_cell_vlservers_fops = {
1da177e4 LT	95	.open = afs_proc_cell_vlservers_open,
	96	.read = seq_read,
	97	.llseek = seq_lseek,
b42d570c	98	.release = seq_release,
1da177e4 LT	99	};
	100
	101	static int afs_proc_cell_servers_open(struct inode inode, struct file file);
1da177e4 LT	102	static void afs_proc_cell_servers_start(struct seq_file p, loff_t *pos);
	103	static void afs_proc_cell_servers_next(struct seq_file p, void *v,
	104	loff_t *pos);
	105	static void afs_proc_cell_servers_stop(struct seq_file p, void v);
	106	static int afs_proc_cell_servers_show(struct seq_file m, void v);
	107
88e9d34c	108	static const struct seq_operations afs_proc_cell_servers_ops = {
1da177e4 LT	109	.start = afs_proc_cell_servers_start,
	110	.next = afs_proc_cell_servers_next,
	111	.stop = afs_proc_cell_servers_stop,
	112	.show = afs_proc_cell_servers_show,
	113	};
	114
4b6f5d20	115	static const struct file_operations afs_proc_cell_servers_fops = {
1da177e4 LT	116	.open = afs_proc_cell_servers_open,
	117	.read = seq_read,
	118	.llseek = seq_lseek,
b42d570c	119	.release = seq_release,
1da177e4 LT	120	};
1da177e4 LT	121
1da177e4 LT	122	/*
	123	* initialise the /proc/fs/afs/ directory
	124	*/
	125	int afs_proc_init(void)
	126	{
1da177e4 LT	127	_enter("");
	128
	129	proc_afs = proc_mkdir("fs/afs", NULL);
	130	if (!proc_afs)
ec26815a	131	goto error_dir;
1da177e4	132
b42d570c AV	133	if (!proc_create("cells", 0, proc_afs, &afs_proc_cells_fops) \|\|
	134	!proc_create("rootcell", 0, proc_afs, &afs_proc_rootcell_fops))
	135	goto error_tree;
1da177e4 LT	136
	137	_leave(" = 0");
	138	return 0;
	139
b42d570c AV	140	error_tree:
b42d570c AV	141	remove_proc_subtree("fs/afs", NULL);
ec26815a	142	error_dir:
1da177e4 LT	143	_leave(" = -ENOMEM");
1da177e4 LT	144	return -ENOMEM;
ec26815a	145	}
1da177e4	146
1da177e4 LT	147	/*
	148	* clean up the /proc/fs/afs/ directory
	149	*/
	150	void afs_proc_cleanup(void)
	151	{
b42d570c	152	remove_proc_subtree("fs/afs", NULL);
ec26815a	153	}
1da177e4	154
1da177e4 LT	155	/*
	156	* open "/proc/fs/afs/cells" which provides a summary of extant cells
	157	*/
	158	static int afs_proc_cells_open(struct inode inode, struct file file)
	159	{
	160	struct seq_file *m;
	161	int ret;
	162
	163	ret = seq_open(file, &afs_proc_cells_ops);
	164	if (ret < 0)
	165	return ret;
	166
	167	m = file->private_data;
d9dda78b	168	m->private = PDE_DATA(inode);
1da177e4 LT	169
1da177e4 LT	170	return 0;
ec26815a	171	}
1da177e4	172
1da177e4 LT	173	/*
	174	* set up the iterator to start reading from the cells list and return the
	175	* first item
	176	*/
	177	static void afs_proc_cells_start(struct seq_file m, loff_t *_pos)
	178	{
1da177e4 LT	179	/* lock the list against modification */
1da177e4 LT	180	down_read(&afs_proc_cells_sem);
a6a8bd6d	181	return seq_list_start_head(&afs_proc_cells, *_pos);
ec26815a	182	}
1da177e4	183
1da177e4 LT	184	/*
	185	* move to next cell in cells list
	186	*/
	187	static void afs_proc_cells_next(struct seq_file p, void v, loff_t pos)
	188	{
a6a8bd6d	189	return seq_list_next(v, &afs_proc_cells, pos);
ec26815a	190	}
1da177e4	191
1da177e4 LT	192	/*
	193	* clean up after reading from the cells list
	194	*/
	195	static void afs_proc_cells_stop(struct seq_file p, void v)
	196	{
	197	up_read(&afs_proc_cells_sem);
ec26815a	198	}
1da177e4	199
1da177e4 LT	200	/*
	201	* display a header line followed by a load of cell lines
	202	*/
	203	static int afs_proc_cells_show(struct seq_file m, void v)
	204	{
	205	struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
	206
a6a8bd6d	207	if (v == &afs_proc_cells) {
ec26815a	208	/* display header on line 1 */
1da177e4 LT	209	seq_puts(m, "USE NAME\n");
	210	return 0;
	211	}
	212
	213	/* display one cell per line on subsequent lines */
ec26815a DH	214	seq_printf(m, "%3d %s\n",
ec26815a DH	215	atomic_read(&cell->usage), cell->name);
1da177e4	216	return 0;
ec26815a	217	}
1da177e4	218
1da177e4 LT	219	/*
	220	* handle writes to /proc/fs/afs/cells
	221	* - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
	222	*/
	223	static ssize_t afs_proc_cells_write(struct file file, const char __user buf,
	224	size_t size, loff_t *_pos)
	225	{
	226	char kbuf, name, *args;
	227	int ret;
	228
	229	/* start by dragging the command into memory */
	230	if (size <= 1 \|\| size >= PAGE_SIZE)
	231	return -EINVAL;
	232
	233	kbuf = kmalloc(size + 1, GFP_KERNEL);
	234	if (!kbuf)
	235	return -ENOMEM;
	236
	237	ret = -EFAULT;
	238	if (copy_from_user(kbuf, buf, size) != 0)
	239	goto done;
	240	kbuf[size] = 0;
	241
	242	/* trim to first NL */
	243	name = memchr(kbuf, '\n', size);
	244	if (name)
	245	*name = 0;
	246
	247	/* split into command, name and argslist */
	248	name = strchr(kbuf, ' ');
	249	if (!name)
	250	goto inval;
	251	do {
	252	*name++ = 0;
	253	} while(*name == ' ');
	254	if (!*name)
	255	goto inval;
	256
	257	args = strchr(name, ' ');
	258	if (!args)
	259	goto inval;
	260	do {
	261	*args++ = 0;
	262	} while(*args == ' ');
	263	if (!*args)
	264	goto inval;
	265
	266	/* determine command to perform */
	267	_debug("cmd=%s name=%s args=%s", kbuf, name, args);
	268
	269	if (strcmp(kbuf, "add") == 0) {
	270	struct afs_cell *cell;
08e0e7c8	271
bec5eb61	272	cell = afs_cell_create(name, strlen(name), args, false);
08e0e7c8 DH	273	if (IS_ERR(cell)) {
08e0e7c8 DH	274	ret = PTR_ERR(cell);
1da177e4	275	goto done;
08e0e7c8	276	}
1da177e4	277
08e0e7c8	278	afs_put_cell(cell);
1da177e4	279	printk("kAFS: Added new cell '%s'\n", name);
ec26815a	280	} else {
1da177e4 LT	281	goto inval;
	282	}
	283
	284	ret = size;
	285
ec26815a	286	done:
1da177e4 LT	287	kfree(kbuf);
	288	_leave(" = %d", ret);
	289	return ret;
	290
ec26815a	291	inval:
1da177e4 LT	292	ret = -EINVAL;
	293	printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
	294	goto done;
ec26815a	295	}
1da177e4	296
1da177e4 LT	297	static ssize_t afs_proc_rootcell_read(struct file file, char __user buf,
	298	size_t size, loff_t *_pos)
	299	{
	300	return 0;
	301	}
	302
1da177e4 LT	303	/*
	304	* handle writes to /proc/fs/afs/rootcell
	305	* - to initialize rootcell: echo "cell.name:192.168.231.14"
	306	*/
	307	static ssize_t afs_proc_rootcell_write(struct file *file,
	308	const char __user *buf,
	309	size_t size, loff_t *_pos)
	310	{
	311	char kbuf, s;
	312	int ret;
	313
	314	/* start by dragging the command into memory */
	315	if (size <= 1 \|\| size >= PAGE_SIZE)
	316	return -EINVAL;
	317
	318	ret = -ENOMEM;
	319	kbuf = kmalloc(size + 1, GFP_KERNEL);
	320	if (!kbuf)
	321	goto nomem;
	322
	323	ret = -EFAULT;
	324	if (copy_from_user(kbuf, buf, size) != 0)
	325	goto infault;
	326	kbuf[size] = 0;
	327
	328	/* trim to first NL */
	329	s = memchr(kbuf, '\n', size);
	330	if (s)
	331	*s = 0;
	332
	333	/* determine command to perform */
	334	_debug("rootcell=%s", kbuf);
	335
	336	ret = afs_cell_init(kbuf);
	337	if (ret >= 0)
	338	ret = size; /* consume everything, always */
	339
ec26815a	340	infault:
1da177e4	341	kfree(kbuf);
ec26815a	342	nomem:
1da177e4 LT	343	_leave(" = %d", ret);
1da177e4 LT	344	return ret;
ec26815a	345	}
1da177e4	346
1da177e4 LT	347	/*
	348	* initialise /proc/fs/afs/<cell>/
	349	*/
	350	int afs_proc_cell_setup(struct afs_cell *cell)
	351	{
b42d570c	352	struct proc_dir_entry *dir;
1da177e4 LT	353
	354	_enter("%p{%s}", cell, cell->name);
	355
b42d570c AV	356	dir = proc_mkdir(cell->name, proc_afs);
b42d570c AV	357	if (!dir)
ec26815a	358	goto error_dir;
1da177e4	359
b42d570c AV	360	if (!proc_create_data("servers", 0, dir,
	361	&afs_proc_cell_servers_fops, cell) \|\|
	362	!proc_create_data("vlservers", 0, dir,
	363	&afs_proc_cell_vlservers_fops, cell) \|\|
	364	!proc_create_data("volumes", 0, dir,
	365	&afs_proc_cell_volumes_fops, cell))
	366	goto error_tree;
1da177e4 LT	367
	368	_leave(" = 0");
	369	return 0;
	370
b42d570c AV	371	error_tree:
b42d570c AV	372	remove_proc_subtree(cell->name, proc_afs);
ec26815a	373	error_dir:
1da177e4 LT	374	_leave(" = -ENOMEM");
1da177e4 LT	375	return -ENOMEM;
ec26815a	376	}
1da177e4	377
1da177e4 LT	378	/*
	379	* remove /proc/fs/afs/<cell>/
	380	*/
	381	void afs_proc_cell_remove(struct afs_cell *cell)
	382	{
	383	_enter("");
	384
b42d570c	385	remove_proc_subtree(cell->name, proc_afs);
1da177e4 LT	386
1da177e4 LT	387	_leave("");
ec26815a	388	}
1da177e4	389
1da177e4 LT	390	/*
	391	* open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
	392	*/
	393	static int afs_proc_cell_volumes_open(struct inode inode, struct file file)
	394	{
	395	struct afs_cell *cell;
	396	struct seq_file *m;
	397	int ret;
	398
d9dda78b	399	cell = PDE_DATA(inode);
1da177e4 LT	400	if (!cell)
	401	return -ENOENT;
	402
	403	ret = seq_open(file, &afs_proc_cell_volumes_ops);
	404	if (ret < 0)
	405	return ret;
	406
	407	m = file->private_data;
	408	m->private = cell;
	409
	410	return 0;
ec26815a	411	}
1da177e4	412
1da177e4 LT	413	/*
	414	* set up the iterator to start reading from the cells list and return the
	415	* first item
	416	*/
	417	static void afs_proc_cell_volumes_start(struct seq_file m, loff_t *_pos)
	418	{
1da177e4	419	struct afs_cell *cell = m->private;
1da177e4 LT	420
	421	_enter("cell=%p pos=%Ld", cell, *_pos);
	422
	423	/* lock the list against modification */
	424	down_read(&cell->vl_sem);
a6a8bd6d	425	return seq_list_start_head(&cell->vl_list, *_pos);
ec26815a	426	}
1da177e4	427
1da177e4 LT	428	/*
	429	* move to next cell in cells list
	430	*/
	431	static void afs_proc_cell_volumes_next(struct seq_file p, void *v,
	432	loff_t *_pos)
	433	{
1da177e4 LT	434	struct afs_cell *cell = p->private;
	435
	436	_enter("cell=%p pos=%Ld", cell, *_pos);
a6a8bd6d	437	return seq_list_next(v, &cell->vl_list, _pos);
ec26815a	438	}
1da177e4	439
1da177e4 LT	440	/*
	441	* clean up after reading from the cells list
	442	*/
	443	static void afs_proc_cell_volumes_stop(struct seq_file p, void v)
	444	{
	445	struct afs_cell *cell = p->private;
	446
	447	up_read(&cell->vl_sem);
ec26815a	448	}
1da177e4	449
c1206a2c	450	static const char afs_vlocation_states[][4] = {
08e0e7c8 DH	451	[AFS_VL_NEW] = "New",
	452	[AFS_VL_CREATING] = "Crt",
	453	[AFS_VL_VALID] = "Val",
	454	[AFS_VL_NO_VOLUME] = "NoV",
	455	[AFS_VL_UPDATING] = "Upd",
	456	[AFS_VL_VOLUME_DELETED] = "Del",
	457	[AFS_VL_UNCERTAIN] = "Unc",
	458	};
	459
1da177e4 LT	460	/*
	461	* display a header line followed by a load of volume lines
	462	*/
	463	static int afs_proc_cell_volumes_show(struct seq_file m, void v)
	464	{
a6a8bd6d	465	struct afs_cell *cell = m->private;
1da177e4 LT	466	struct afs_vlocation *vlocation =
	467	list_entry(v, struct afs_vlocation, link);
	468
	469	/* display header on line 1 */
a6a8bd6d	470	if (v == &cell->vl_list) {
08e0e7c8	471	seq_puts(m, "USE STT VLID[0] VLID[1] VLID[2] NAME\n");
1da177e4 LT	472	return 0;
	473	}
	474
	475	/* display one cell per line on subsequent lines */
08e0e7c8	476	seq_printf(m, "%3d %s %08x %08x %08x %s\n",
1da177e4	477	atomic_read(&vlocation->usage),
08e0e7c8	478	afs_vlocation_states[vlocation->state],
1da177e4 LT	479	vlocation->vldb.vid[0],
	480	vlocation->vldb.vid[1],
	481	vlocation->vldb.vid[2],
ec26815a	482	vlocation->vldb.name);
1da177e4 LT	483
1da177e4 LT	484	return 0;
ec26815a	485	}
1da177e4	486
1da177e4 LT	487	/*
	488	* open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
	489	* location server
	490	*/
	491	static int afs_proc_cell_vlservers_open(struct inode inode, struct file file)
	492	{
	493	struct afs_cell *cell;
	494	struct seq_file *m;
	495	int ret;
	496
d9dda78b	497	cell = PDE_DATA(inode);
1da177e4 LT	498	if (!cell)
	499	return -ENOENT;
	500
08e0e7c8	501	ret = seq_open(file, &afs_proc_cell_vlservers_ops);
1da177e4 LT	502	if (ret<0)
	503	return ret;
	504
	505	m = file->private_data;
	506	m->private = cell;
	507
	508	return 0;
ec26815a	509	}
1da177e4	510
1da177e4 LT	511	/*
	512	* set up the iterator to start reading from the cells list and return the
	513	* first item
	514	*/
	515	static void afs_proc_cell_vlservers_start(struct seq_file m, loff_t *_pos)
	516	{
	517	struct afs_cell *cell = m->private;
	518	loff_t pos = *_pos;
	519
	520	_enter("cell=%p pos=%Ld", cell, *_pos);
	521
	522	/* lock the list against modification */
	523	down_read(&cell->vl_sem);
	524
	525	/* allow for the header line */
	526	if (!pos)
	527	return (void *) 1;
	528	pos--;
	529
	530	if (pos >= cell->vl_naddrs)
	531	return NULL;
	532
	533	return &cell->vl_addrs[pos];
ec26815a	534	}
1da177e4	535
1da177e4 LT	536	/*
	537	* move to next cell in cells list
	538	*/
	539	static void afs_proc_cell_vlservers_next(struct seq_file p, void *v,
	540	loff_t *_pos)
	541	{
	542	struct afs_cell *cell = p->private;
	543	loff_t pos;
	544
	545	_enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
	546
	547	pos = *_pos;
	548	(*_pos)++;
	549	if (pos >= cell->vl_naddrs)
	550	return NULL;
	551
	552	return &cell->vl_addrs[pos];
ec26815a	553	}
1da177e4	554
1da177e4 LT	555	/*
	556	* clean up after reading from the cells list
	557	*/
	558	static void afs_proc_cell_vlservers_stop(struct seq_file p, void v)
	559	{
	560	struct afs_cell *cell = p->private;
	561
	562	up_read(&cell->vl_sem);
ec26815a	563	}
1da177e4	564
1da177e4 LT	565	/*
	566	* display a header line followed by a load of volume lines
	567	*/
	568	static int afs_proc_cell_vlservers_show(struct seq_file m, void v)
	569	{
	570	struct in_addr *addr = v;
	571
	572	/* display header on line 1 */
	573	if (v == (struct in_addr *) 1) {
	574	seq_puts(m, "ADDRESS\n");
	575	return 0;
	576	}
	577
	578	/* display one cell per line on subsequent lines */
be859405	579	seq_printf(m, "%pI4\n", &addr->s_addr);
1da177e4	580	return 0;
ec26815a	581	}
1da177e4	582
1da177e4 LT	583	/*
	584	* open "/proc/fs/afs/<cell>/servers" which provides a summary of active
	585	* servers
	586	*/
	587	static int afs_proc_cell_servers_open(struct inode inode, struct file file)
	588	{
	589	struct afs_cell *cell;
	590	struct seq_file *m;
	591	int ret;
	592
d9dda78b	593	cell = PDE_DATA(inode);
1da177e4 LT	594	if (!cell)
	595	return -ENOENT;
	596
	597	ret = seq_open(file, &afs_proc_cell_servers_ops);
	598	if (ret < 0)
	599	return ret;
	600
	601	m = file->private_data;
	602	m->private = cell;
1da177e4	603	return 0;
ec26815a	604	}
1da177e4	605
1da177e4 LT	606	/*
	607	* set up the iterator to start reading from the cells list and return the
	608	* first item
	609	*/
	610	static void afs_proc_cell_servers_start(struct seq_file m, loff_t *_pos)
08e0e7c8	611	__acquires(m->private->servers_lock)
1da177e4	612	{
1da177e4	613	struct afs_cell *cell = m->private;
1da177e4 LT	614
	615	_enter("cell=%p pos=%Ld", cell, *_pos);
	616
	617	/* lock the list against modification */
08e0e7c8	618	read_lock(&cell->servers_lock);
a6a8bd6d	619	return seq_list_start_head(&cell->servers, *_pos);
ec26815a	620	}
1da177e4	621
1da177e4 LT	622	/*
	623	* move to next cell in cells list
	624	*/
	625	static void afs_proc_cell_servers_next(struct seq_file p, void *v,
	626	loff_t *_pos)
	627	{
1da177e4 LT	628	struct afs_cell *cell = p->private;
	629
	630	_enter("cell=%p pos=%Ld", cell, *_pos);
a6a8bd6d	631	return seq_list_next(v, &cell->servers, _pos);
ec26815a	632	}
1da177e4	633
1da177e4 LT	634	/*
	635	* clean up after reading from the cells list
	636	*/
	637	static void afs_proc_cell_servers_stop(struct seq_file p, void v)
08e0e7c8	638	__releases(p->private->servers_lock)
1da177e4 LT	639	{
	640	struct afs_cell *cell = p->private;
	641
08e0e7c8	642	read_unlock(&cell->servers_lock);
ec26815a	643	}
1da177e4	644
1da177e4 LT	645	/*
	646	* display a header line followed by a load of volume lines
	647	*/
	648	static int afs_proc_cell_servers_show(struct seq_file m, void v)
	649	{
a6a8bd6d	650	struct afs_cell *cell = m->private;
1da177e4 LT	651	struct afs_server *server = list_entry(v, struct afs_server, link);
	652	char ipaddr[20];
	653
	654	/* display header on line 1 */
a6a8bd6d	655	if (v == &cell->servers) {
1da177e4 LT	656	seq_puts(m, "USE ADDR STATE\n");
	657	return 0;
	658	}
	659
	660	/* display one cell per line on subsequent lines */
be859405	661	sprintf(ipaddr, "%pI4", &server->addr);
1da177e4	662	seq_printf(m, "%3d %-15.15s %5d\n",
ec26815a	663	atomic_read(&server->usage), ipaddr, server->fs_state);
1da177e4 LT	664
1da177e4 LT	665	return 0;
ec26815a	666	}