[linux-2.6-block.git] / fs / afs / proc.c

/* /proc interface for AFS
 *
 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * 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 <linux/uaccess.h>
#include "internal.h"

static inline struct afs_net *afs_proc2net(struct file *f)
{
	return &__afs_net;
}

static inline struct afs_net *afs_seq2net(struct seq_file *m)
{
	return &__afs_net; // TODO: use seq_file_net(m)
}

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(struct afs_net *net)
{
	_enter("");

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

	if (!proc_create("cells", 0644, net->proc_afs, &afs_proc_cells_fops) ||
	    !proc_create("rootcell", 0644, net->proc_afs, &afs_proc_rootcell_fops))
		goto error_tree;

	_leave(" = 0");
	return 0;

error_tree:
	proc_remove(net->proc_afs);
error_dir:
	_leave(" = -ENOMEM");
	return -ENOMEM;
}

/*
 * clean up the /proc/fs/afs/ directory
 */
void afs_proc_cleanup(struct afs_net *net)
{
	proc_remove(net->proc_afs);
	net->proc_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)
{
	struct afs_net *net = afs_seq2net(m);

	rcu_read_lock();
	return seq_list_start_head(&net->proc_cells, *_pos);
}

/*
 * move to next cell in cells list
 */
static void *afs_proc_cells_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct afs_net *net = afs_seq2net(m);

	return seq_list_next(v, &net->proc_cells, pos);
}

/*
 * clean up after reading from the cells list
 */
static void afs_proc_cells_stop(struct seq_file *m, void *v)
{
	rcu_read_unlock();
}

/*
 * 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);
	struct afs_net *net = afs_seq2net(m);

	if (v == &net->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, "%3u %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)
{
	struct afs_net *net = afs_proc2net(file);
	char *kbuf, *name, *args;
	int ret;

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

	kbuf = memdup_user_nul(buf, size);
	if (IS_ERR(kbuf))
		return PTR_ERR(kbuf);

	/* 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_lookup_cell(net, name, strlen(name), args, true);
		if (IS_ERR(cell)) {
			ret = PTR_ERR(cell);
			goto done;
		}

		set_bit(AFS_CELL_FL_NO_GC, &cell->flags);
		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)
{
	struct afs_net *net = afs_proc2net(file);
	char *kbuf, *s;
	int ret;

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

	kbuf = memdup_user_nul(buf, size);
	if (IS_ERR(kbuf))
		return PTR_ERR(kbuf);

	/* 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(net, kbuf);
	if (ret >= 0)
		ret = size;	/* consume everything, always */

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

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

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

	dir = proc_mkdir(cell->name, net->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, net->proc_afs);
error_dir:
	_leave(" = -ENOMEM");
	return -ENOMEM;
}

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

	remove_proc_subtree(cell->name, net->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 sockaddr_rxrpc *addr = v;

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

	/* display one cell per line on subsequent lines */
	seq_printf(m, "%pISp\n", &addr->transport);
	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[64];

	/* 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, "%pISp", &server->addr.transport);
	seq_printf(m, "%3d %-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 (dhowells@redhat.com)
	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>
7c0f6ba6	17	#include <linux/uaccess.h>
1da177e4 LT	18	#include "internal.h"
1da177e4 LT	19
f044c884 DH	20	static inline struct afs_net afs_proc2net(struct file f)
	21	{
	22	return &__afs_net;
	23	}
1da177e4	24
f044c884 DH	25	static inline struct afs_net afs_seq2net(struct seq_file m)
	26	{
	27	return &__afs_net; // TODO: use seq_file_net(m)
	28	}
1da177e4 LT	29
	30	static int afs_proc_cells_open(struct inode inode, struct file file);
	31	static void afs_proc_cells_start(struct seq_file p, loff_t *pos);
	32	static void afs_proc_cells_next(struct seq_file p, void v, loff_t pos);
	33	static void afs_proc_cells_stop(struct seq_file p, void v);
	34	static int afs_proc_cells_show(struct seq_file m, void v);
	35	static ssize_t afs_proc_cells_write(struct file file, const char __user buf,
	36	size_t size, loff_t *_pos);
	37
88e9d34c	38	static const struct seq_operations afs_proc_cells_ops = {
1da177e4 LT	39	.start = afs_proc_cells_start,
	40	.next = afs_proc_cells_next,
	41	.stop = afs_proc_cells_stop,
	42	.show = afs_proc_cells_show,
	43	};
	44
4b6f5d20	45	static const struct file_operations afs_proc_cells_fops = {
1da177e4 LT	46	.open = afs_proc_cells_open,
	47	.read = seq_read,
	48	.write = afs_proc_cells_write,
	49	.llseek = seq_lseek,
	50	.release = seq_release,
	51	};
	52
1da177e4 LT	53	static ssize_t afs_proc_rootcell_read(struct file file, char __user buf,
	54	size_t size, loff_t *_pos);
	55	static ssize_t afs_proc_rootcell_write(struct file *file,
	56	const char __user *buf,
	57	size_t size, loff_t *_pos);
	58
4b6f5d20	59	static const struct file_operations afs_proc_rootcell_fops = {
1da177e4 LT	60	.read = afs_proc_rootcell_read,
	61	.write = afs_proc_rootcell_write,
	62	.llseek = no_llseek,
1da177e4 LT	63	};
	64
	65	static int afs_proc_cell_volumes_open(struct inode inode, struct file file);
1da177e4 LT	66	static void afs_proc_cell_volumes_start(struct seq_file p, loff_t *pos);
	67	static void afs_proc_cell_volumes_next(struct seq_file p, void *v,
	68	loff_t *pos);
	69	static void afs_proc_cell_volumes_stop(struct seq_file p, void v);
	70	static int afs_proc_cell_volumes_show(struct seq_file m, void v);
	71
88e9d34c	72	static const struct seq_operations afs_proc_cell_volumes_ops = {
1da177e4 LT	73	.start = afs_proc_cell_volumes_start,
	74	.next = afs_proc_cell_volumes_next,
	75	.stop = afs_proc_cell_volumes_stop,
	76	.show = afs_proc_cell_volumes_show,
	77	};
	78
4b6f5d20	79	static const struct file_operations afs_proc_cell_volumes_fops = {
1da177e4 LT	80	.open = afs_proc_cell_volumes_open,
	81	.read = seq_read,
	82	.llseek = seq_lseek,
b42d570c	83	.release = seq_release,
1da177e4 LT	84	};
	85
	86	static int afs_proc_cell_vlservers_open(struct inode *inode,
	87	struct file *file);
1da177e4 LT	88	static void afs_proc_cell_vlservers_start(struct seq_file p, loff_t *pos);
	89	static void afs_proc_cell_vlservers_next(struct seq_file p, void *v,
	90	loff_t *pos);
	91	static void afs_proc_cell_vlservers_stop(struct seq_file p, void v);
	92	static int afs_proc_cell_vlservers_show(struct seq_file m, void v);
	93
88e9d34c	94	static const struct seq_operations afs_proc_cell_vlservers_ops = {
1da177e4 LT	95	.start = afs_proc_cell_vlservers_start,
	96	.next = afs_proc_cell_vlservers_next,
	97	.stop = afs_proc_cell_vlservers_stop,
	98	.show = afs_proc_cell_vlservers_show,
	99	};
	100
4b6f5d20	101	static const struct file_operations afs_proc_cell_vlservers_fops = {
1da177e4 LT	102	.open = afs_proc_cell_vlservers_open,
	103	.read = seq_read,
	104	.llseek = seq_lseek,
b42d570c	105	.release = seq_release,
1da177e4 LT	106	};
	107
	108	static int afs_proc_cell_servers_open(struct inode inode, struct file file);
1da177e4 LT	109	static void afs_proc_cell_servers_start(struct seq_file p, loff_t *pos);
	110	static void afs_proc_cell_servers_next(struct seq_file p, void *v,
	111	loff_t *pos);
	112	static void afs_proc_cell_servers_stop(struct seq_file p, void v);
	113	static int afs_proc_cell_servers_show(struct seq_file m, void v);
	114
88e9d34c	115	static const struct seq_operations afs_proc_cell_servers_ops = {
1da177e4 LT	116	.start = afs_proc_cell_servers_start,
	117	.next = afs_proc_cell_servers_next,
	118	.stop = afs_proc_cell_servers_stop,
	119	.show = afs_proc_cell_servers_show,
	120	};
	121
4b6f5d20	122	static const struct file_operations afs_proc_cell_servers_fops = {
1da177e4 LT	123	.open = afs_proc_cell_servers_open,
	124	.read = seq_read,
	125	.llseek = seq_lseek,
b42d570c	126	.release = seq_release,
1da177e4 LT	127	};
1da177e4 LT	128
1da177e4 LT	129	/*
	130	* initialise the /proc/fs/afs/ directory
	131	*/
f044c884	132	int afs_proc_init(struct afs_net *net)
1da177e4	133	{
1da177e4 LT	134	_enter("");
1da177e4 LT	135
f044c884 DH	136	net->proc_afs = proc_mkdir("fs/afs", NULL);
f044c884 DH	137	if (!net->proc_afs)
ec26815a	138	goto error_dir;
1da177e4	139
f044c884 DH	140	if (!proc_create("cells", 0644, net->proc_afs, &afs_proc_cells_fops) \|\|
f044c884 DH	141	!proc_create("rootcell", 0644, net->proc_afs, &afs_proc_rootcell_fops))
b42d570c	142	goto error_tree;
1da177e4 LT	143
	144	_leave(" = 0");
	145	return 0;
	146
b42d570c	147	error_tree:
f044c884	148	proc_remove(net->proc_afs);
ec26815a	149	error_dir:
1da177e4 LT	150	_leave(" = -ENOMEM");
1da177e4 LT	151	return -ENOMEM;
ec26815a	152	}
1da177e4	153
1da177e4 LT	154	/*
	155	* clean up the /proc/fs/afs/ directory
	156	*/
f044c884	157	void afs_proc_cleanup(struct afs_net *net)
1da177e4	158	{
f044c884 DH	159	proc_remove(net->proc_afs);
f044c884 DH	160	net->proc_afs = NULL;
ec26815a	161	}
1da177e4	162
1da177e4 LT	163	/*
	164	* open "/proc/fs/afs/cells" which provides a summary of extant cells
	165	*/
	166	static int afs_proc_cells_open(struct inode inode, struct file file)
	167	{
	168	struct seq_file *m;
	169	int ret;
	170
	171	ret = seq_open(file, &afs_proc_cells_ops);
	172	if (ret < 0)
	173	return ret;
	174
	175	m = file->private_data;
d9dda78b	176	m->private = PDE_DATA(inode);
1da177e4 LT	177
1da177e4 LT	178	return 0;
ec26815a	179	}
1da177e4	180
1da177e4 LT	181	/*
	182	* set up the iterator to start reading from the cells list and return the
	183	* first item
	184	*/
	185	static void afs_proc_cells_start(struct seq_file m, loff_t *_pos)
	186	{
f044c884 DH	187	struct afs_net *net = afs_seq2net(m);
f044c884 DH	188
989782dc	189	rcu_read_lock();
f044c884	190	return seq_list_start_head(&net->proc_cells, *_pos);
ec26815a	191	}
1da177e4	192
1da177e4 LT	193	/*
	194	* move to next cell in cells list
	195	*/
f044c884	196	static void afs_proc_cells_next(struct seq_file m, void v, loff_t pos)
1da177e4	197	{
f044c884 DH	198	struct afs_net *net = afs_seq2net(m);
	199
	200	return seq_list_next(v, &net->proc_cells, pos);
ec26815a	201	}
1da177e4	202
1da177e4 LT	203	/*
	204	* clean up after reading from the cells list
	205	*/
f044c884	206	static void afs_proc_cells_stop(struct seq_file m, void v)
1da177e4	207	{
989782dc	208	rcu_read_unlock();
ec26815a	209	}
1da177e4	210
1da177e4 LT	211	/*
	212	* display a header line followed by a load of cell lines
	213	*/
	214	static int afs_proc_cells_show(struct seq_file m, void v)
	215	{
	216	struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
f044c884	217	struct afs_net *net = afs_seq2net(m);
1da177e4	218
f044c884	219	if (v == &net->proc_cells) {
ec26815a	220	/* display header on line 1 */
1da177e4 LT	221	seq_puts(m, "USE NAME\n");
	222	return 0;
	223	}
	224
	225	/* display one cell per line on subsequent lines */
989782dc	226	seq_printf(m, "%3u %s\n", atomic_read(&cell->usage), cell->name);
1da177e4	227	return 0;
ec26815a	228	}
1da177e4	229
1da177e4 LT	230	/*
	231	* handle writes to /proc/fs/afs/cells
	232	* - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
	233	*/
	234	static ssize_t afs_proc_cells_write(struct file file, const char __user buf,
	235	size_t size, loff_t *_pos)
	236	{
f044c884	237	struct afs_net *net = afs_proc2net(file);
1da177e4 LT	238	char kbuf, name, *args;
	239	int ret;
	240
	241	/* start by dragging the command into memory */
	242	if (size <= 1 \|\| size >= PAGE_SIZE)
	243	return -EINVAL;
	244
16e5c1fc AV	245	kbuf = memdup_user_nul(buf, size);
	246	if (IS_ERR(kbuf))
	247	return PTR_ERR(kbuf);
1da177e4 LT	248
	249	/* trim to first NL */
	250	name = memchr(kbuf, '\n', size);
	251	if (name)
	252	*name = 0;
	253
	254	/* split into command, name and argslist */
	255	name = strchr(kbuf, ' ');
	256	if (!name)
	257	goto inval;
	258	do {
	259	*name++ = 0;
	260	} while(*name == ' ');
	261	if (!*name)
	262	goto inval;
	263
	264	args = strchr(name, ' ');
	265	if (!args)
	266	goto inval;
	267	do {
	268	*args++ = 0;
	269	} while(*args == ' ');
	270	if (!*args)
	271	goto inval;
	272
	273	/* determine command to perform */
	274	_debug("cmd=%s name=%s args=%s", kbuf, name, args);
	275
	276	if (strcmp(kbuf, "add") == 0) {
	277	struct afs_cell *cell;
08e0e7c8	278
989782dc	279	cell = afs_lookup_cell(net, name, strlen(name), args, true);
08e0e7c8 DH	280	if (IS_ERR(cell)) {
08e0e7c8 DH	281	ret = PTR_ERR(cell);
1da177e4	282	goto done;
08e0e7c8	283	}
1da177e4	284
989782dc	285	set_bit(AFS_CELL_FL_NO_GC, &cell->flags);
1da177e4	286	printk("kAFS: Added new cell '%s'\n", name);
ec26815a	287	} else {
1da177e4 LT	288	goto inval;
	289	}
	290
	291	ret = size;
	292
ec26815a	293	done:
1da177e4 LT	294	kfree(kbuf);
	295	_leave(" = %d", ret);
	296	return ret;
	297
ec26815a	298	inval:
1da177e4 LT	299	ret = -EINVAL;
	300	printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
	301	goto done;
ec26815a	302	}
1da177e4	303
1da177e4 LT	304	static ssize_t afs_proc_rootcell_read(struct file file, char __user buf,
	305	size_t size, loff_t *_pos)
	306	{
	307	return 0;
	308	}
	309
1da177e4 LT	310	/*
	311	* handle writes to /proc/fs/afs/rootcell
	312	* - to initialize rootcell: echo "cell.name:192.168.231.14"
	313	*/
	314	static ssize_t afs_proc_rootcell_write(struct file *file,
	315	const char __user *buf,
	316	size_t size, loff_t *_pos)
	317	{
f044c884	318	struct afs_net *net = afs_proc2net(file);
1da177e4 LT	319	char kbuf, s;
	320	int ret;
	321
	322	/* start by dragging the command into memory */
	323	if (size <= 1 \|\| size >= PAGE_SIZE)
	324	return -EINVAL;
	325
16e5c1fc AV	326	kbuf = memdup_user_nul(buf, size);
	327	if (IS_ERR(kbuf))
	328	return PTR_ERR(kbuf);
1da177e4 LT	329
	330	/* trim to first NL */
	331	s = memchr(kbuf, '\n', size);
	332	if (s)
	333	*s = 0;
	334
	335	/* determine command to perform */
	336	_debug("rootcell=%s", kbuf);
	337
f044c884	338	ret = afs_cell_init(net, kbuf);
1da177e4 LT	339	if (ret >= 0)
	340	ret = size; /* consume everything, always */
	341
1da177e4	342	kfree(kbuf);
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	*/
f044c884	350	int afs_proc_cell_setup(struct afs_net net, struct afs_cell cell)
1da177e4	351	{
b42d570c	352	struct proc_dir_entry *dir;
1da177e4	353
989782dc	354	_enter("%p{%s},%p", cell, cell->name, net->proc_afs);
1da177e4	355
f044c884	356	dir = proc_mkdir(cell->name, net->proc_afs);
b42d570c	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	371	error_tree:
f044c884	372	remove_proc_subtree(cell->name, net->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	*/
f044c884	381	void afs_proc_cell_remove(struct afs_net net, struct afs_cell cell)
1da177e4 LT	382	{
	383	_enter("");
	384
f044c884	385	remove_proc_subtree(cell->name, net->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	{
4d9df986	570	struct sockaddr_rxrpc *addr = v;
1da177e4 LT	571
1da177e4 LT	572	/* display header on line 1 */
4d9df986	573	if (v == (void *)1) {
1da177e4 LT	574	seq_puts(m, "ADDRESS\n");
	575	return 0;
	576	}
	577
	578	/* display one cell per line on subsequent lines */
4d9df986	579	seq_printf(m, "%pISp\n", &addr->transport);
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	651	struct afs_server *server = list_entry(v, struct afs_server, link);
4d9df986	652	char ipaddr[64];
1da177e4 LT	653
1da177e4 LT	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 */
4d9df986	661	sprintf(ipaddr, "%pISp", &server->addr.transport);
3838d3ec	662	seq_printf(m, "%3d %-15s %5d\n",
ec26815a	663	atomic_read(&server->usage), ipaddr, server->fs_state);
1da177e4 LT	664
1da177e4 LT	665	return 0;
ec26815a	666	}