[net-next-2.6.git] / net / atm / resources.c

/* net/atm/resources.c - Statically allocated resources */

/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

/* Fixes
 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 * 2002/01 - don't free the whole struct sock on sk->destruct time,
 * 	     use the default destruct function initialized by sock_init_data */


#include <linux/config.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/atmdev.h>
#include <linux/sonet.h>
#include <linux/kernel.h> /* for barrier */
#include <linux/module.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <net/sock.h>	 /* for struct sock */

#include "common.h"
#include "resources.h"
#include "addr.h"


LIST_HEAD(atm_devs);
DEFINE_SPINLOCK(atm_dev_lock);

static struct atm_dev *__alloc_atm_dev(const char *type)
{
	struct atm_dev *dev;

	dev = kmalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return NULL;
	memset(dev, 0, sizeof(*dev));
	dev->type = type;
	dev->signal = ATM_PHY_SIG_UNKNOWN;
	dev->link_rate = ATM_OC3_PCR;
	spin_lock_init(&dev->lock);
	INIT_LIST_HEAD(&dev->local);
	INIT_LIST_HEAD(&dev->lecs);

	return dev;
}

static struct atm_dev *__atm_dev_lookup(int number)
{
	struct atm_dev *dev;
	struct list_head *p;

	list_for_each(p, &atm_devs) {
		dev = list_entry(p, struct atm_dev, dev_list);
		if ((dev->ops) && (dev->number == number)) {
			atm_dev_hold(dev);
			return dev;
		}
	}
	return NULL;
}

struct atm_dev *atm_dev_lookup(int number)
{
	struct atm_dev *dev;

	spin_lock(&atm_dev_lock);
	dev = __atm_dev_lookup(number);
	spin_unlock(&atm_dev_lock);
	return dev;
}

struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops,
				 int number, unsigned long *flags)
{
	struct atm_dev *dev, *inuse;

	dev = __alloc_atm_dev(type);
	if (!dev) {
		printk(KERN_ERR "atm_dev_register: no space for dev %s\n",
		    type);
		return NULL;
	}
	spin_lock(&atm_dev_lock);
	if (number != -1) {
		if ((inuse = __atm_dev_lookup(number))) {
			atm_dev_put(inuse);
			spin_unlock(&atm_dev_lock);
			kfree(dev);
			return NULL;
		}
		dev->number = number;
	} else {
		dev->number = 0;
		while ((inuse = __atm_dev_lookup(dev->number))) {
			atm_dev_put(inuse);
			dev->number++;
		}
	}

	dev->ops = ops;
	if (flags)
		dev->flags = *flags;
	else
		memset(&dev->flags, 0, sizeof(dev->flags));
	memset(&dev->stats, 0, sizeof(dev->stats));
	atomic_set(&dev->refcnt, 1);
	list_add_tail(&dev->dev_list, &atm_devs);
	spin_unlock(&atm_dev_lock);

	if (atm_proc_dev_register(dev) < 0) {
		printk(KERN_ERR "atm_dev_register: "
		       "atm_proc_dev_register failed for dev %s\n",
		       type);
		spin_lock(&atm_dev_lock);
		list_del(&dev->dev_list);
		spin_unlock(&atm_dev_lock);
		kfree(dev);
		return NULL;
	}

	return dev;
}


void atm_dev_deregister(struct atm_dev *dev)
{
	unsigned long warning_time;

	atm_proc_dev_deregister(dev);

	spin_lock(&atm_dev_lock);
	list_del(&dev->dev_list);
	spin_unlock(&atm_dev_lock);

        warning_time = jiffies;
        while (atomic_read(&dev->refcnt) != 1) {
                msleep(250);
                if ((jiffies - warning_time) > 10 * HZ) {
                        printk(KERN_EMERG "atm_dev_deregister: waiting for "
                               "dev %d to become free. Usage count = %d\n",
                               dev->number, atomic_read(&dev->refcnt));
                        warning_time = jiffies;
                }
        }

	kfree(dev);
}

void shutdown_atm_dev(struct atm_dev *dev)
{
	if (atomic_read(&dev->refcnt) > 1) {
		set_bit(ATM_DF_CLOSE, &dev->flags);
		return;
	}
	if (dev->ops->dev_close)
		dev->ops->dev_close(dev);
	atm_dev_deregister(dev);
}


static void copy_aal_stats(struct k_atm_aal_stats *from,
    struct atm_aal_stats *to)
{
#define __HANDLE_ITEM(i) to->i = atomic_read(&from->i)
	__AAL_STAT_ITEMS
#undef __HANDLE_ITEM
}


static void subtract_aal_stats(struct k_atm_aal_stats *from,
    struct atm_aal_stats *to)
{
#define __HANDLE_ITEM(i) atomic_sub(to->i, &from->i)
	__AAL_STAT_ITEMS
#undef __HANDLE_ITEM
}


static int fetch_stats(struct atm_dev *dev, struct atm_dev_stats __user *arg, int zero)
{
	struct atm_dev_stats tmp;
	int error = 0;

	copy_aal_stats(&dev->stats.aal0, &tmp.aal0);
	copy_aal_stats(&dev->stats.aal34, &tmp.aal34);
	copy_aal_stats(&dev->stats.aal5, &tmp.aal5);
	if (arg)
		error = copy_to_user(arg, &tmp, sizeof(tmp));
	if (zero && !error) {
		subtract_aal_stats(&dev->stats.aal0, &tmp.aal0);
		subtract_aal_stats(&dev->stats.aal34, &tmp.aal34);
		subtract_aal_stats(&dev->stats.aal5, &tmp.aal5);
	}
	return error ? -EFAULT : 0;
}


int atm_dev_ioctl(unsigned int cmd, void __user *arg)
{
	void __user *buf;
	int error, len, number, size = 0;
	struct atm_dev *dev;
	struct list_head *p;
	int *tmp_buf, *tmp_p;
	struct atm_iobuf __user *iobuf = arg;
	struct atmif_sioc __user *sioc = arg;
	switch (cmd) {
		case ATM_GETNAMES:
			if (get_user(buf, &iobuf->buffer))
				return -EFAULT;
			if (get_user(len, &iobuf->length))
				return -EFAULT;
			spin_lock(&atm_dev_lock);
			list_for_each(p, &atm_devs)
				size += sizeof(int);
			if (size > len) {
				spin_unlock(&atm_dev_lock);
				return -E2BIG;
			}
			tmp_buf = kmalloc(size, GFP_ATOMIC);
			if (!tmp_buf) {
				spin_unlock(&atm_dev_lock);
				return -ENOMEM;
			}
			tmp_p = tmp_buf;
			list_for_each(p, &atm_devs) {
				dev = list_entry(p, struct atm_dev, dev_list);
				*tmp_p++ = dev->number;
			}
			spin_unlock(&atm_dev_lock);
		        error = ((copy_to_user(buf, tmp_buf, size)) ||
					put_user(size, &iobuf->length))
						? -EFAULT : 0;
			kfree(tmp_buf);
			return error;
		default:
			break;
	}

	if (get_user(buf, &sioc->arg))
		return -EFAULT;
	if (get_user(len, &sioc->length))
		return -EFAULT;
	if (get_user(number, &sioc->number))
		return -EFAULT;

	if (!(dev = try_then_request_module(atm_dev_lookup(number),
					    "atm-device-%d", number)))
		return -ENODEV;
	
	switch (cmd) {
		case ATM_GETTYPE:
			size = strlen(dev->type) + 1;
			if (copy_to_user(buf, dev->type, size)) {
				error = -EFAULT;
				goto done;
			}
			break;
		case ATM_GETESI:
			size = ESI_LEN;
			if (copy_to_user(buf, dev->esi, size)) {
				error = -EFAULT;
				goto done;
			}
			break;
		case ATM_SETESI:
			{
				int i;

				for (i = 0; i < ESI_LEN; i++)
					if (dev->esi[i]) {
						error = -EEXIST;
						goto done;
					}
			}
			/* fall through */
		case ATM_SETESIF:
			{
				unsigned char esi[ESI_LEN];

				if (!capable(CAP_NET_ADMIN)) {
					error = -EPERM;
					goto done;
				}
				if (copy_from_user(esi, buf, ESI_LEN)) {
					error = -EFAULT;
					goto done;
				}
				memcpy(dev->esi, esi, ESI_LEN);
				error =  ESI_LEN;
				goto done;
			}
		case ATM_GETSTATZ:
			if (!capable(CAP_NET_ADMIN)) {
				error = -EPERM;
				goto done;
			}
			/* fall through */
		case ATM_GETSTAT:
			size = sizeof(struct atm_dev_stats);
			error = fetch_stats(dev, buf, cmd == ATM_GETSTATZ);
			if (error)
				goto done;
			break;
		case ATM_GETCIRANGE:
			size = sizeof(struct atm_cirange);
			if (copy_to_user(buf, &dev->ci_range, size)) {
				error = -EFAULT;
				goto done;
			}
			break;
		case ATM_GETLINKRATE:
			size = sizeof(int);
			if (copy_to_user(buf, &dev->link_rate, size)) {
				error = -EFAULT;
				goto done;
			}
			break;
		case ATM_RSTADDR:
			if (!capable(CAP_NET_ADMIN)) {
				error = -EPERM;
				goto done;
			}
			atm_reset_addr(dev, ATM_ADDR_LOCAL);
			break;
		case ATM_ADDADDR:
		case ATM_DELADDR:
		case ATM_ADDLECSADDR:
		case ATM_DELLECSADDR:
			if (!capable(CAP_NET_ADMIN)) {
				error = -EPERM;
				goto done;
			}
			{
				struct sockaddr_atmsvc addr;

				if (copy_from_user(&addr, buf, sizeof(addr))) {
					error = -EFAULT;
					goto done;
				}
				if (cmd == ATM_ADDADDR || cmd == ATM_ADDLECSADDR)
					error = atm_add_addr(dev, &addr,
							     (cmd == ATM_ADDADDR ?
							      ATM_ADDR_LOCAL : ATM_ADDR_LECS));
				else
					error = atm_del_addr(dev, &addr,
							     (cmd == ATM_DELADDR ?
							      ATM_ADDR_LOCAL : ATM_ADDR_LECS));
				goto done;
			}
		case ATM_GETADDR:
		case ATM_GETLECSADDR:
			error = atm_get_addr(dev, buf, len,
					     (cmd == ATM_GETADDR ?
					      ATM_ADDR_LOCAL : ATM_ADDR_LECS));
			if (error < 0)
				goto done;
			size = error;
			/* may return 0, but later on size == 0 means "don't
			   write the length" */
			error = put_user(size, &sioc->length)
				? -EFAULT : 0;
			goto done;
		case ATM_SETLOOP:
			if (__ATM_LM_XTRMT((int) (unsigned long) buf) &&
			    __ATM_LM_XTLOC((int) (unsigned long) buf) >
			    __ATM_LM_XTRMT((int) (unsigned long) buf)) {
				error = -EINVAL;
				goto done;
			}
			/* fall through */
		case ATM_SETCIRANGE:
		case SONET_GETSTATZ:
		case SONET_SETDIAG:
		case SONET_CLRDIAG:
		case SONET_SETFRAMING:
			if (!capable(CAP_NET_ADMIN)) {
				error = -EPERM;
				goto done;
			}
			/* fall through */
		default:
			if (!dev->ops->ioctl) {
				error = -EINVAL;
				goto done;
			}
			size = dev->ops->ioctl(dev, cmd, buf);
			if (size < 0) {
				error = (size == -ENOIOCTLCMD ? -EINVAL : size);
				goto done;
			}
	}
	
	if (size)
		error = put_user(size, &sioc->length)
			? -EFAULT : 0;
	else
		error = 0;
done:
	atm_dev_put(dev);
	return error;
}

static __inline__ void *dev_get_idx(loff_t left)
{
	struct list_head *p;

	list_for_each(p, &atm_devs) {
		if (!--left)
			break;
	}
	return (p != &atm_devs) ? p : NULL;
}

void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos)
{
 	spin_lock(&atm_dev_lock);
	return *pos ? dev_get_idx(*pos) : (void *) 1;
}

void atm_dev_seq_stop(struct seq_file *seq, void *v)
{
 	spin_unlock(&atm_dev_lock);
}
 
void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	++*pos;
	v = (v == (void *)1) ? atm_devs.next : ((struct list_head *)v)->next;
	return (v == &atm_devs) ? NULL : v;
}


EXPORT_SYMBOL(atm_dev_register);
EXPORT_SYMBOL(atm_dev_deregister);
EXPORT_SYMBOL(atm_dev_lookup);
EXPORT_SYMBOL(shutdown_atm_dev);
Commit	Line	Data
1da177e4 LT	1	/* net/atm/resources.c - Statically allocated resources */
	2
	3	/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
	4
	5	/* Fixes
	6	* Arnaldo Carvalho de Melo <acme@conectiva.com.br>
	7	* 2002/01 - don't free the whole struct sock on sk->destruct time,
	8	* use the default destruct function initialized by sock_init_data */
	9
	10
	11	#include <linux/config.h>
	12	#include <linux/ctype.h>
	13	#include <linux/string.h>
	14	#include <linux/atmdev.h>
	15	#include <linux/sonet.h>
	16	#include <linux/kernel.h> /* for barrier */
	17	#include <linux/module.h>
	18	#include <linux/bitops.h>
	19	#include <linux/delay.h>
	20	#include <net/sock.h> /* for struct sock */
	21
	22	#include "common.h"
	23	#include "resources.h"
	24	#include "addr.h"
	25
	26
	27	LIST_HEAD(atm_devs);
	28	DEFINE_SPINLOCK(atm_dev_lock);
	29
	30	static struct atm_dev __alloc_atm_dev(const char type)
	31	{
	32	struct atm_dev *dev;
	33
	34	dev = kmalloc(sizeof(*dev), GFP_KERNEL);
	35	if (!dev)
	36	return NULL;
	37	memset(dev, 0, sizeof(*dev));
	38	dev->type = type;
	39	dev->signal = ATM_PHY_SIG_UNKNOWN;
	40	dev->link_rate = ATM_OC3_PCR;
	41	spin_lock_init(&dev->lock);
	42	INIT_LIST_HEAD(&dev->local);
0f21ba7c	43	INIT_LIST_HEAD(&dev->lecs);
1da177e4 LT	44
	45	return dev;
	46	}
	47
1da177e4 LT	48	static struct atm_dev *__atm_dev_lookup(int number)
	49	{
	50	struct atm_dev *dev;
	51	struct list_head *p;
	52
	53	list_for_each(p, &atm_devs) {
	54	dev = list_entry(p, struct atm_dev, dev_list);
	55	if ((dev->ops) && (dev->number == number)) {
	56	atm_dev_hold(dev);
	57	return dev;
	58	}
	59	}
	60	return NULL;
	61	}
	62
	63	struct atm_dev *atm_dev_lookup(int number)
	64	{
	65	struct atm_dev *dev;
	66
	67	spin_lock(&atm_dev_lock);
	68	dev = __atm_dev_lookup(number);
	69	spin_unlock(&atm_dev_lock);
	70	return dev;
	71	}
	72
	73	struct atm_dev atm_dev_register(const char type, const struct atmdev_ops *ops,
	74	int number, unsigned long *flags)
	75	{
	76	struct atm_dev dev, inuse;
	77
	78	dev = __alloc_atm_dev(type);
	79	if (!dev) {
	80	printk(KERN_ERR "atm_dev_register: no space for dev %s\n",
	81	type);
	82	return NULL;
	83	}
	84	spin_lock(&atm_dev_lock);
	85	if (number != -1) {
	86	if ((inuse = __atm_dev_lookup(number))) {
	87	atm_dev_put(inuse);
	88	spin_unlock(&atm_dev_lock);
ebc37b61	89	kfree(dev);
1da177e4 LT	90	return NULL;
	91	}
	92	dev->number = number;
	93	} else {
	94	dev->number = 0;
	95	while ((inuse = __atm_dev_lookup(dev->number))) {
	96	atm_dev_put(inuse);
	97	dev->number++;
	98	}
	99	}
	100
	101	dev->ops = ops;
	102	if (flags)
	103	dev->flags = *flags;
	104	else
	105	memset(&dev->flags, 0, sizeof(dev->flags));
	106	memset(&dev->stats, 0, sizeof(dev->stats));
	107	atomic_set(&dev->refcnt, 1);
	108	list_add_tail(&dev->dev_list, &atm_devs);
	109	spin_unlock(&atm_dev_lock);
	110
	111	if (atm_proc_dev_register(dev) < 0) {
	112	printk(KERN_ERR "atm_dev_register: "
	113	"atm_proc_dev_register failed for dev %s\n",
	114	type);
	115	spin_lock(&atm_dev_lock);
	116	list_del(&dev->dev_list);
	117	spin_unlock(&atm_dev_lock);
ebc37b61	118	kfree(dev);
1da177e4 LT	119	return NULL;
	120	}
	121
	122	return dev;
	123	}
	124
	125
	126	void atm_dev_deregister(struct atm_dev *dev)
	127	{
	128	unsigned long warning_time;
	129
	130	atm_proc_dev_deregister(dev);
	131
	132	spin_lock(&atm_dev_lock);
	133	list_del(&dev->dev_list);
	134	spin_unlock(&atm_dev_lock);
	135
	136	warning_time = jiffies;
	137	while (atomic_read(&dev->refcnt) != 1) {
	138	msleep(250);
	139	if ((jiffies - warning_time) > 10 * HZ) {
	140	printk(KERN_EMERG "atm_dev_deregister: waiting for "
	141	"dev %d to become free. Usage count = %d\n",
	142	dev->number, atomic_read(&dev->refcnt));
	143	warning_time = jiffies;
	144	}
	145	}
	146
ebc37b61	147	kfree(dev);
1da177e4 LT	148	}
	149
	150	void shutdown_atm_dev(struct atm_dev *dev)
	151	{
	152	if (atomic_read(&dev->refcnt) > 1) {
	153	set_bit(ATM_DF_CLOSE, &dev->flags);
	154	return;
	155	}
	156	if (dev->ops->dev_close)
	157	dev->ops->dev_close(dev);
	158	atm_dev_deregister(dev);
	159	}
	160
	161
	162	static void copy_aal_stats(struct k_atm_aal_stats *from,
	163	struct atm_aal_stats *to)
	164	{
	165	#define __HANDLE_ITEM(i) to->i = atomic_read(&from->i)
	166	__AAL_STAT_ITEMS
	167	#undef __HANDLE_ITEM
	168	}
	169
	170
	171	static void subtract_aal_stats(struct k_atm_aal_stats *from,
	172	struct atm_aal_stats *to)
	173	{
	174	#define __HANDLE_ITEM(i) atomic_sub(to->i, &from->i)
	175	__AAL_STAT_ITEMS
	176	#undef __HANDLE_ITEM
	177	}
	178
	179
	180	static int fetch_stats(struct atm_dev dev, struct atm_dev_stats __user arg, int zero)
	181	{
	182	struct atm_dev_stats tmp;
	183	int error = 0;
	184
	185	copy_aal_stats(&dev->stats.aal0, &tmp.aal0);
	186	copy_aal_stats(&dev->stats.aal34, &tmp.aal34);
	187	copy_aal_stats(&dev->stats.aal5, &tmp.aal5);
	188	if (arg)
	189	error = copy_to_user(arg, &tmp, sizeof(tmp));
	190	if (zero && !error) {
	191	subtract_aal_stats(&dev->stats.aal0, &tmp.aal0);
	192	subtract_aal_stats(&dev->stats.aal34, &tmp.aal34);
	193	subtract_aal_stats(&dev->stats.aal5, &tmp.aal5);
	194	}
	195	return error ? -EFAULT : 0;
	196	}
	197
	198
	199	int atm_dev_ioctl(unsigned int cmd, void __user *arg)
	200	{
	201	void __user *buf;
	202	int error, len, number, size = 0;
	203	struct atm_dev *dev;
	204	struct list_head *p;
	205	int tmp_buf, tmp_p;
	206	struct atm_iobuf __user *iobuf = arg;
	207	struct atmif_sioc __user *sioc = arg;
	208	switch (cmd) {
	209	case ATM_GETNAMES:
	210	if (get_user(buf, &iobuf->buffer))
	211	return -EFAULT;
212	if (get_user(len, &iobuf->length))
213	return -EFAULT;
214	spin_lock(&atm_dev_lock);
215	list_for_each(p, &atm_devs)
216	size += sizeof(int);
217	if (size > len) {
218	spin_unlock(&atm_dev_lock);
219	return -E2BIG;
220	}
221	tmp_buf = kmalloc(size, GFP_ATOMIC);
222	if (!tmp_buf) {
223	spin_unlock(&atm_dev_lock);
224	return -ENOMEM;
225	}
226	tmp_p = tmp_buf;
227	list_for_each(p, &atm_devs) {
228	dev = list_entry(p, struct atm_dev, dev_list);
229	*tmp_p++ = dev->number;
230	}
231	spin_unlock(&atm_dev_lock);
232	error = ((copy_to_user(buf, tmp_buf, size)) \|\|
233	put_user(size, &iobuf->length))
234	? -EFAULT : 0;
235	kfree(tmp_buf);
236	return error;
237	default:
238	break;
239	}
240
241	if (get_user(buf, &sioc->arg))
242	return -EFAULT;
243	if (get_user(len, &sioc->length))
244	return -EFAULT;
245	if (get_user(number, &sioc->number))
246	return -EFAULT;
247
50accc9c MBJ	248	if (!(dev = try_then_request_module(atm_dev_lookup(number),
50accc9c MBJ	249	"atm-device-%d", number)))
1da177e4 LT	250	return -ENODEV;
	251
	252	switch (cmd) {
	253	case ATM_GETTYPE:
	254	size = strlen(dev->type) + 1;
	255	if (copy_to_user(buf, dev->type, size)) {
	256	error = -EFAULT;
	257	goto done;
	258	}
	259	break;
	260	case ATM_GETESI:
	261	size = ESI_LEN;
	262	if (copy_to_user(buf, dev->esi, size)) {
	263	error = -EFAULT;
	264	goto done;
	265	}
	266	break;
	267	case ATM_SETESI:
	268	{
	269	int i;
	270
	271	for (i = 0; i < ESI_LEN; i++)
	272	if (dev->esi[i]) {
	273	error = -EEXIST;
	274	goto done;
	275	}
	276	}
	277	/* fall through */
	278	case ATM_SETESIF:
	279	{
	280	unsigned char esi[ESI_LEN];
	281
	282	if (!capable(CAP_NET_ADMIN)) {
	283	error = -EPERM;
	284	goto done;
	285	}
	286	if (copy_from_user(esi, buf, ESI_LEN)) {
	287	error = -EFAULT;
	288	goto done;
	289	}
	290	memcpy(dev->esi, esi, ESI_LEN);
	291	error = ESI_LEN;
	292	goto done;
	293	}
	294	case ATM_GETSTATZ:
	295	if (!capable(CAP_NET_ADMIN)) {
	296	error = -EPERM;
	297	goto done;
	298	}
	299	/* fall through */
	300	case ATM_GETSTAT:
	301	size = sizeof(struct atm_dev_stats);
	302	error = fetch_stats(dev, buf, cmd == ATM_GETSTATZ);
	303	if (error)
	304	goto done;
	305	break;
	306	case ATM_GETCIRANGE:
	307	size = sizeof(struct atm_cirange);
	308	if (copy_to_user(buf, &dev->ci_range, size)) {
	309	error = -EFAULT;
	310	goto done;
	311	}
	312	break;
	313	case ATM_GETLINKRATE:
314	size = sizeof(int);
315	if (copy_to_user(buf, &dev->link_rate, size)) {
316	error = -EFAULT;
317	goto done;
318	}
319	break;
320	case ATM_RSTADDR:
321	if (!capable(CAP_NET_ADMIN)) {
322	error = -EPERM;
323	goto done;
324	}
0f21ba7c	325	atm_reset_addr(dev, ATM_ADDR_LOCAL);
1da177e4 LT	326	break;
	327	case ATM_ADDADDR:
	328	case ATM_DELADDR:
0f21ba7c EK	329	case ATM_ADDLECSADDR:
0f21ba7c EK	330	case ATM_DELLECSADDR:
1da177e4 LT	331	if (!capable(CAP_NET_ADMIN)) {
	332	error = -EPERM;
	333	goto done;
	334	}
	335	{
	336	struct sockaddr_atmsvc addr;
	337
	338	if (copy_from_user(&addr, buf, sizeof(addr))) {
	339	error = -EFAULT;
	340	goto done;
	341	}
0f21ba7c EK	342	if (cmd == ATM_ADDADDR \|\| cmd == ATM_ADDLECSADDR)
	343	error = atm_add_addr(dev, &addr,
	344	(cmd == ATM_ADDADDR ?
	345	ATM_ADDR_LOCAL : ATM_ADDR_LECS));
1da177e4	346	else
0f21ba7c EK	347	error = atm_del_addr(dev, &addr,
	348	(cmd == ATM_DELADDR ?
	349	ATM_ADDR_LOCAL : ATM_ADDR_LECS));
1da177e4 LT	350	goto done;
	351	}
	352	case ATM_GETADDR:
0f21ba7c EK	353	case ATM_GETLECSADDR:
	354	error = atm_get_addr(dev, buf, len,
	355	(cmd == ATM_GETADDR ?
	356	ATM_ADDR_LOCAL : ATM_ADDR_LECS));
1da177e4 LT	357	if (error < 0)
	358	goto done;
	359	size = error;
	360	/* may return 0, but later on size == 0 means "don't
	361	write the length" */
	362	error = put_user(size, &sioc->length)
	363	? -EFAULT : 0;
	364	goto done;
	365	case ATM_SETLOOP:
	366	if (__ATM_LM_XTRMT((int) (unsigned long) buf) &&
	367	__ATM_LM_XTLOC((int) (unsigned long) buf) >
	368	__ATM_LM_XTRMT((int) (unsigned long) buf)) {
	369	error = -EINVAL;
	370	goto done;
	371	}
	372	/* fall through */
	373	case ATM_SETCIRANGE:
	374	case SONET_GETSTATZ:
	375	case SONET_SETDIAG:
	376	case SONET_CLRDIAG:
	377	case SONET_SETFRAMING:
	378	if (!capable(CAP_NET_ADMIN)) {
	379	error = -EPERM;
	380	goto done;
	381	}
	382	/* fall through */
	383	default:
	384	if (!dev->ops->ioctl) {
	385	error = -EINVAL;
	386	goto done;
	387	}
	388	size = dev->ops->ioctl(dev, cmd, buf);
	389	if (size < 0) {
	390	error = (size == -ENOIOCTLCMD ? -EINVAL : size);
	391	goto done;
	392	}
	393	}
	394
	395	if (size)
	396	error = put_user(size, &sioc->length)
	397	? -EFAULT : 0;
	398	else
	399	error = 0;
	400	done:
	401	atm_dev_put(dev);
	402	return error;
	403	}
	404
	405	static __inline__ void *dev_get_idx(loff_t left)
	406	{
	407	struct list_head *p;
	408
	409	list_for_each(p, &atm_devs) {
	410	if (!--left)
	411	break;
	412	}
	413	return (p != &atm_devs) ? p : NULL;
	414	}
	415
	416	void atm_dev_seq_start(struct seq_file seq, loff_t *pos)
	417	{
	418	spin_lock(&atm_dev_lock);
	419	return pos ? dev_get_idx(pos) : (void *) 1;
	420	}
421
422	void atm_dev_seq_stop(struct seq_file seq, void v)
423	{
424	spin_unlock(&atm_dev_lock);
425	}
426
427	void atm_dev_seq_next(struct seq_file seq, void v, loff_t pos)
428	{
429	++*pos;
430	v = (v == (void )1) ? atm_devs.next : ((struct list_head )v)->next;
431	return (v == &atm_devs) ? NULL : v;
432	}
433
434
435	EXPORT_SYMBOL(atm_dev_register);
436	EXPORT_SYMBOL(atm_dev_deregister);
437	EXPORT_SYMBOL(atm_dev_lookup);
438	EXPORT_SYMBOL(shutdown_atm_dev);