[mirror_ubuntu-bionic-kernel.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_servers_open(struct inode *inode, struct file *file);
static void *afs_proc_servers_start(struct seq_file *p, loff_t *pos);
static void *afs_proc_servers_next(struct seq_file *p, void *v,
					loff_t *pos);
static void afs_proc_servers_stop(struct seq_file *p, void *v);
static int afs_proc_servers_show(struct seq_file *m, void *v);

static const struct seq_operations afs_proc_servers_ops = {
	.start	= afs_proc_servers_start,
	.next	= afs_proc_servers_next,
	.stop	= afs_proc_servers_stop,
	.show	= afs_proc_servers_show,
};

static const struct file_operations afs_proc_servers_fops = {
	.open		= afs_proc_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) ||
	    !proc_create("servers", 0644, net->proc_afs, &afs_proc_servers_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("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);

	read_lock(&cell->proc_lock);
	return seq_list_start_head(&cell->proc_volumes, *_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->proc_volumes, _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;

	read_unlock(&cell->proc_lock);
}

static const char afs_vol_types[3][3] = {
	[AFSVL_RWVOL]	= "RW",
	[AFSVL_ROVOL]	= "RO",
	[AFSVL_BACKVOL]	= "BK",
};

/*
 * 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_volume *vol = list_entry(v, struct afs_volume, proc_link);

	/* Display header on line 1 */
	if (v == &cell->proc_volumes) {
		seq_puts(m, "USE VID      TY\n");
		return 0;
	}

	seq_printf(m, "%3d %08x %s\n",
		   atomic_read(&vol->usage), vol->vid,
		   afs_vol_types[vol->type]);

	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_addr_list *alist;
	struct afs_cell *cell = m->private;
	loff_t pos = *_pos;

	rcu_read_lock();

	alist = rcu_dereference(cell->vl_addrs);

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

	if (!alist || pos >= alist->nr_addrs)
		return NULL;

	return alist->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_addr_list *alist;
	struct afs_cell *cell = p->private;
	loff_t pos;

	alist = rcu_dereference(cell->vl_addrs);

	pos = *_pos;
	(*_pos)++;
	if (!alist || pos >= alist->nr_addrs)
		return NULL;

	return alist->addrs + pos;
}

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

/*
 * 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/servers" which provides a summary of active
 * servers
 */
static int afs_proc_servers_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &afs_proc_servers_ops);
}

/*
 * Set up the iterator to start reading from the server list and return the
 * first item.
 */
static void *afs_proc_servers_start(struct seq_file *m, loff_t *_pos)
{
	struct afs_net *net = afs_seq2net(m);

	rcu_read_lock();
	return seq_hlist_start_head_rcu(&net->fs_proc, *_pos);
}

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

	return seq_hlist_next_rcu(v, &net->fs_proc, _pos);
}

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

/*
 * display a header line followed by a load of volume lines
 */
static int afs_proc_servers_show(struct seq_file *m, void *v)
{
	struct afs_server *server;
	struct afs_addr_list *alist;

	if (v == SEQ_START_TOKEN) {
		seq_puts(m, "UUID                                 USE ADDR\n");
		return 0;
	}

	server = list_entry(v, struct afs_server, proc_link);
	alist = rcu_dereference(server->addresses);
	seq_printf(m, "%pU %3d %pISp\n",
		   &server->uuid,
		   atomic_read(&server->usage),
		   &alist->addrs[alist->index].transport);
	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	};
1da177e4 LT	107
d2ddc776 DH	108	static int afs_proc_servers_open(struct inode inode, struct file file);
	109	static void afs_proc_servers_start(struct seq_file p, loff_t *pos);
	110	static void afs_proc_servers_next(struct seq_file p, void *v,
1da177e4	111	loff_t *pos);
d2ddc776 DH	112	static void afs_proc_servers_stop(struct seq_file p, void v);
	113	static int afs_proc_servers_show(struct seq_file m, void v);
	114
	115	static const struct seq_operations afs_proc_servers_ops = {
	116	.start = afs_proc_servers_start,
	117	.next = afs_proc_servers_next,
	118	.stop = afs_proc_servers_stop,
	119	.show = afs_proc_servers_show,
1da177e4 LT	120	};
1da177e4 LT	121
d2ddc776 DH	122	static const struct file_operations afs_proc_servers_fops = {
d2ddc776 DH	123	.open = afs_proc_servers_open,
1da177e4 LT	124	.read = seq_read,
1da177e4 LT	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	140	if (!proc_create("cells", 0644, net->proc_afs, &afs_proc_cells_fops) \|\|
d2ddc776 DH	141	!proc_create("rootcell", 0644, net->proc_afs, &afs_proc_rootcell_fops) \|\|
d2ddc776 DH	142	!proc_create("servers", 0644, net->proc_afs, &afs_proc_servers_fops))
b42d570c	143	goto error_tree;
1da177e4 LT	144
	145	_leave(" = 0");
	146	return 0;
	147
b42d570c	148	error_tree:
f044c884	149	proc_remove(net->proc_afs);
ec26815a	150	error_dir:
1da177e4 LT	151	_leave(" = -ENOMEM");
1da177e4 LT	152	return -ENOMEM;
ec26815a	153	}
1da177e4	154
1da177e4 LT	155	/*
	156	* clean up the /proc/fs/afs/ directory
	157	*/
f044c884	158	void afs_proc_cleanup(struct afs_net *net)
1da177e4	159	{
f044c884 DH	160	proc_remove(net->proc_afs);
f044c884 DH	161	net->proc_afs = NULL;
ec26815a	162	}
1da177e4	163
1da177e4 LT	164	/*
	165	* open "/proc/fs/afs/cells" which provides a summary of extant cells
	166	*/
	167	static int afs_proc_cells_open(struct inode inode, struct file file)
	168	{
	169	struct seq_file *m;
	170	int ret;
	171
	172	ret = seq_open(file, &afs_proc_cells_ops);
	173	if (ret < 0)
	174	return ret;
	175
	176	m = file->private_data;
d9dda78b	177	m->private = PDE_DATA(inode);
1da177e4	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
d2ddc776 DH	360	if (!proc_create_data("vlservers", 0, dir,
d2ddc776 DH	361	&afs_proc_cell_vlservers_fops, cell) \|\|
b42d570c	362	!proc_create_data("volumes", 0, dir,
d2ddc776	363	&afs_proc_cell_volumes_fops, cell))
b42d570c	364	goto error_tree;
1da177e4 LT	365
	366	_leave(" = 0");
	367	return 0;
	368
b42d570c	369	error_tree:
f044c884	370	remove_proc_subtree(cell->name, net->proc_afs);
ec26815a	371	error_dir:
1da177e4 LT	372	_leave(" = -ENOMEM");
1da177e4 LT	373	return -ENOMEM;
ec26815a	374	}
1da177e4	375
1da177e4 LT	376	/*
	377	* remove /proc/fs/afs/<cell>/
	378	*/
f044c884	379	void afs_proc_cell_remove(struct afs_net net, struct afs_cell cell)
1da177e4 LT	380	{
	381	_enter("");
	382
f044c884	383	remove_proc_subtree(cell->name, net->proc_afs);
1da177e4 LT	384
1da177e4 LT	385	_leave("");
ec26815a	386	}
1da177e4	387
1da177e4 LT	388	/*
	389	* open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
	390	*/
	391	static int afs_proc_cell_volumes_open(struct inode inode, struct file file)
	392	{
	393	struct afs_cell *cell;
	394	struct seq_file *m;
	395	int ret;
	396
d9dda78b	397	cell = PDE_DATA(inode);
1da177e4 LT	398	if (!cell)
	399	return -ENOENT;
	400
	401	ret = seq_open(file, &afs_proc_cell_volumes_ops);
	402	if (ret < 0)
	403	return ret;
	404
	405	m = file->private_data;
	406	m->private = cell;
	407
	408	return 0;
ec26815a	409	}
1da177e4	410
1da177e4 LT	411	/*
	412	* set up the iterator to start reading from the cells list and return the
	413	* first item
	414	*/
	415	static void afs_proc_cell_volumes_start(struct seq_file m, loff_t *_pos)
	416	{
1da177e4	417	struct afs_cell *cell = m->private;
1da177e4 LT	418
	419	_enter("cell=%p pos=%Ld", cell, *_pos);
	420
d2ddc776 DH	421	read_lock(&cell->proc_lock);
d2ddc776 DH	422	return seq_list_start_head(&cell->proc_volumes, *_pos);
ec26815a	423	}
1da177e4	424
1da177e4 LT	425	/*
	426	* move to next cell in cells list
	427	*/
	428	static void afs_proc_cell_volumes_next(struct seq_file p, void *v,
	429	loff_t *_pos)
	430	{
1da177e4 LT	431	struct afs_cell *cell = p->private;
	432
	433	_enter("cell=%p pos=%Ld", cell, *_pos);
d2ddc776	434	return seq_list_next(v, &cell->proc_volumes, _pos);
ec26815a	435	}
1da177e4	436
1da177e4 LT	437	/*
	438	* clean up after reading from the cells list
	439	*/
	440	static void afs_proc_cell_volumes_stop(struct seq_file p, void v)
	441	{
	442	struct afs_cell *cell = p->private;
	443
d2ddc776	444	read_unlock(&cell->proc_lock);
ec26815a	445	}
1da177e4	446
d2ddc776 DH	447	static const char afs_vol_types[3][3] = {
	448	[AFSVL_RWVOL] = "RW",
	449	[AFSVL_ROVOL] = "RO",
	450	[AFSVL_BACKVOL] = "BK",
08e0e7c8 DH	451	};
08e0e7c8 DH	452
1da177e4 LT	453	/*
	454	* display a header line followed by a load of volume lines
	455	*/
	456	static int afs_proc_cell_volumes_show(struct seq_file m, void v)
	457	{
a6a8bd6d	458	struct afs_cell *cell = m->private;
d2ddc776	459	struct afs_volume *vol = list_entry(v, struct afs_volume, proc_link);
1da177e4	460
d2ddc776 DH	461	/* Display header on line 1 */
	462	if (v == &cell->proc_volumes) {
	463	seq_puts(m, "USE VID TY\n");
1da177e4 LT	464	return 0;
	465	}
	466
d2ddc776 DH	467	seq_printf(m, "%3d %08x %s\n",
	468	atomic_read(&vol->usage), vol->vid,
	469	afs_vol_types[vol->type]);
1da177e4 LT	470
1da177e4 LT	471	return 0;
ec26815a	472	}
1da177e4	473
1da177e4 LT	474	/*
	475	* open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
	476	* location server
	477	*/
	478	static int afs_proc_cell_vlservers_open(struct inode inode, struct file file)
	479	{
	480	struct afs_cell *cell;
	481	struct seq_file *m;
	482	int ret;
	483
d9dda78b	484	cell = PDE_DATA(inode);
1da177e4 LT	485	if (!cell)
	486	return -ENOENT;
	487
08e0e7c8	488	ret = seq_open(file, &afs_proc_cell_vlservers_ops);
1da177e4 LT	489	if (ret<0)
	490	return ret;
	491
	492	m = file->private_data;
	493	m->private = cell;
	494
	495	return 0;
ec26815a	496	}
1da177e4	497
1da177e4 LT	498	/*
	499	* set up the iterator to start reading from the cells list and return the
	500	* first item
	501	*/
	502	static void afs_proc_cell_vlservers_start(struct seq_file m, loff_t *_pos)
	503	{
8b2a464c	504	struct afs_addr_list *alist;
1da177e4 LT	505	struct afs_cell *cell = m->private;
	506	loff_t pos = *_pos;
	507
8b2a464c	508	rcu_read_lock();
1da177e4	509
8b2a464c	510	alist = rcu_dereference(cell->vl_addrs);
1da177e4 LT	511
	512	/* allow for the header line */
	513	if (!pos)
	514	return (void *) 1;
	515	pos--;
	516
8b2a464c	517	if (!alist \|\| pos >= alist->nr_addrs)
1da177e4 LT	518	return NULL;
1da177e4 LT	519
8b2a464c	520	return alist->addrs + pos;
ec26815a	521	}
1da177e4	522
1da177e4 LT	523	/*
	524	* move to next cell in cells list
	525	*/
	526	static void afs_proc_cell_vlservers_next(struct seq_file p, void *v,
	527	loff_t *_pos)
	528	{
8b2a464c	529	struct afs_addr_list *alist;
1da177e4 LT	530	struct afs_cell *cell = p->private;
	531	loff_t pos;
	532
8b2a464c	533	alist = rcu_dereference(cell->vl_addrs);
1da177e4 LT	534
	535	pos = *_pos;
	536	(*_pos)++;
8b2a464c	537	if (!alist \|\| pos >= alist->nr_addrs)
1da177e4 LT	538	return NULL;
1da177e4 LT	539
8b2a464c	540	return alist->addrs + pos;
ec26815a	541	}
1da177e4	542
1da177e4 LT	543	/*
	544	* clean up after reading from the cells list
	545	*/
	546	static void afs_proc_cell_vlservers_stop(struct seq_file p, void v)
	547	{
8b2a464c	548	rcu_read_unlock();
ec26815a	549	}
1da177e4	550
1da177e4 LT	551	/*
	552	* display a header line followed by a load of volume lines
	553	*/
	554	static int afs_proc_cell_vlservers_show(struct seq_file m, void v)
	555	{
4d9df986	556	struct sockaddr_rxrpc *addr = v;
1da177e4 LT	557
1da177e4 LT	558	/* display header on line 1 */
4d9df986	559	if (v == (void *)1) {
1da177e4 LT	560	seq_puts(m, "ADDRESS\n");
	561	return 0;
	562	}
	563
	564	/* display one cell per line on subsequent lines */
4d9df986	565	seq_printf(m, "%pISp\n", &addr->transport);
1da177e4	566	return 0;
ec26815a	567	}
1da177e4	568
1da177e4	569	/*
d2ddc776	570	* open "/proc/fs/afs/servers" which provides a summary of active
1da177e4 LT	571	* servers
1da177e4 LT	572	*/
d2ddc776	573	static int afs_proc_servers_open(struct inode inode, struct file file)
1da177e4	574	{
d2ddc776	575	return seq_open(file, &afs_proc_servers_ops);
ec26815a	576	}
1da177e4	577
1da177e4	578	/*
d2ddc776 DH	579	* Set up the iterator to start reading from the server list and return the
d2ddc776 DH	580	* first item.
1da177e4	581	*/
d2ddc776	582	static void afs_proc_servers_start(struct seq_file m, loff_t *_pos)
1da177e4	583	{
d2ddc776	584	struct afs_net *net = afs_seq2net(m);
1da177e4	585
d2ddc776 DH	586	rcu_read_lock();
d2ddc776 DH	587	return seq_hlist_start_head_rcu(&net->fs_proc, *_pos);
ec26815a	588	}
1da177e4	589
1da177e4 LT	590	/*
	591	* move to next cell in cells list
	592	*/
d2ddc776	593	static void afs_proc_servers_next(struct seq_file m, void v, loff_t _pos)
1da177e4	594	{
d2ddc776	595	struct afs_net *net = afs_seq2net(m);
1da177e4	596
d2ddc776	597	return seq_hlist_next_rcu(v, &net->fs_proc, _pos);
ec26815a	598	}
1da177e4	599
1da177e4 LT	600	/*
	601	* clean up after reading from the cells list
	602	*/
d2ddc776	603	static void afs_proc_servers_stop(struct seq_file p, void v)
1da177e4	604	{
d2ddc776	605	rcu_read_unlock();
ec26815a	606	}
1da177e4	607
1da177e4 LT	608	/*
	609	* display a header line followed by a load of volume lines
	610	*/
d2ddc776	611	static int afs_proc_servers_show(struct seq_file m, void v)
1da177e4	612	{
d2ddc776 DH	613	struct afs_server *server;
d2ddc776 DH	614	struct afs_addr_list *alist;
1da177e4	615
d2ddc776 DH	616	if (v == SEQ_START_TOKEN) {
d2ddc776 DH	617	seq_puts(m, "UUID USE ADDR\n");
1da177e4 LT	618	return 0;
	619	}
	620
d2ddc776 DH	621	server = list_entry(v, struct afs_server, proc_link);
	622	alist = rcu_dereference(server->addresses);
	623	seq_printf(m, "%pU %3d %pISp\n",
	624	&server->uuid,
	625	atomic_read(&server->usage),
	626	&alist->addrs[alist->index].transport);
1da177e4	627	return 0;
ec26815a	628	}