1 /* net/atm/resources.c - Statically allocated resources */
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
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 */
11 #include <linux/ctype.h>
12 #include <linux/string.h>
13 #include <linux/atmdev.h>
14 #include <linux/sonet.h>
15 #include <linux/kernel.h> /* for barrier */
16 #include <linux/module.h>
17 #include <linux/bitops.h>
18 #include <linux/capability.h>
19 #include <linux/delay.h>
20 #include <linux/mutex.h>
22 #include <net/sock.h> /* for struct sock */
25 #include "resources.h"
30 DEFINE_MUTEX(atm_dev_mutex
);
32 static struct atm_dev
*__alloc_atm_dev(const char *type
)
36 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
40 dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
41 dev
->link_rate
= ATM_OC3_PCR
;
42 spin_lock_init(&dev
->lock
);
43 INIT_LIST_HEAD(&dev
->local
);
44 INIT_LIST_HEAD(&dev
->lecs
);
49 static struct atm_dev
*__atm_dev_lookup(int number
)
54 list_for_each(p
, &atm_devs
) {
55 dev
= list_entry(p
, struct atm_dev
, dev_list
);
56 if (dev
->number
== number
) {
64 struct atm_dev
*atm_dev_lookup(int number
)
68 mutex_lock(&atm_dev_mutex
);
69 dev
= __atm_dev_lookup(number
);
70 mutex_unlock(&atm_dev_mutex
);
75 struct atm_dev
*atm_dev_register(const char *type
, const struct atmdev_ops
*ops
,
76 int number
, unsigned long *flags
)
78 struct atm_dev
*dev
, *inuse
;
80 dev
= __alloc_atm_dev(type
);
82 printk(KERN_ERR
"atm_dev_register: no space for dev %s\n",
86 mutex_lock(&atm_dev_mutex
);
88 if ((inuse
= __atm_dev_lookup(number
))) {
90 mutex_unlock(&atm_dev_mutex
);
97 while ((inuse
= __atm_dev_lookup(dev
->number
))) {
107 memset(&dev
->flags
, 0, sizeof(dev
->flags
));
108 memset(&dev
->stats
, 0, sizeof(dev
->stats
));
109 atomic_set(&dev
->refcnt
, 1);
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",
118 if (atm_register_sysfs(dev
) < 0) {
119 printk(KERN_ERR
"atm_dev_register: "
120 "atm_register_sysfs failed for dev %s\n",
122 atm_proc_dev_deregister(dev
);
126 list_add_tail(&dev
->dev_list
, &atm_devs
);
129 mutex_unlock(&atm_dev_mutex
);
139 void atm_dev_deregister(struct atm_dev
*dev
)
141 BUG_ON(test_bit(ATM_DF_REMOVED
, &dev
->flags
));
142 set_bit(ATM_DF_REMOVED
, &dev
->flags
);
145 * if we remove current device from atm_devs list, new device
146 * with same number can appear, such we need deregister proc,
147 * release async all vccs and remove them from vccs list too
149 mutex_lock(&atm_dev_mutex
);
150 list_del(&dev
->dev_list
);
151 mutex_unlock(&atm_dev_mutex
);
153 atm_dev_release_vccs(dev
);
154 atm_unregister_sysfs(dev
);
155 atm_proc_dev_deregister(dev
);
161 static void copy_aal_stats(struct k_atm_aal_stats
*from
,
162 struct atm_aal_stats
*to
)
164 #define __HANDLE_ITEM(i) to->i = atomic_read(&from->i)
170 static void subtract_aal_stats(struct k_atm_aal_stats
*from
,
171 struct atm_aal_stats
*to
)
173 #define __HANDLE_ITEM(i) atomic_sub(to->i, &from->i)
179 static int fetch_stats(struct atm_dev
*dev
, struct atm_dev_stats __user
*arg
, int zero
)
181 struct atm_dev_stats tmp
;
184 copy_aal_stats(&dev
->stats
.aal0
, &tmp
.aal0
);
185 copy_aal_stats(&dev
->stats
.aal34
, &tmp
.aal34
);
186 copy_aal_stats(&dev
->stats
.aal5
, &tmp
.aal5
);
188 error
= copy_to_user(arg
, &tmp
, sizeof(tmp
));
189 if (zero
&& !error
) {
190 subtract_aal_stats(&dev
->stats
.aal0
, &tmp
.aal0
);
191 subtract_aal_stats(&dev
->stats
.aal34
, &tmp
.aal34
);
192 subtract_aal_stats(&dev
->stats
.aal5
, &tmp
.aal5
);
194 return error
? -EFAULT
: 0;
198 int atm_dev_ioctl(unsigned int cmd
, void __user
*arg
, int compat
)
201 int error
, len
, number
, size
= 0;
204 int *tmp_buf
, *tmp_p
;
205 int __user
*sioc_len
;
206 int __user
*iobuf_len
;
208 #ifndef CONFIG_COMPAT
209 compat
= 0; /* Just so the compiler _knows_ */
217 struct compat_atm_iobuf __user
*ciobuf
= arg
;
219 iobuf_len
= &ciobuf
->length
;
220 if (get_user(cbuf
, &ciobuf
->buffer
))
222 buf
= compat_ptr(cbuf
);
225 struct atm_iobuf __user
*iobuf
= arg
;
226 iobuf_len
= &iobuf
->length
;
227 if (get_user(buf
, &iobuf
->buffer
))
230 if (get_user(len
, iobuf_len
))
232 mutex_lock(&atm_dev_mutex
);
233 list_for_each(p
, &atm_devs
)
236 mutex_unlock(&atm_dev_mutex
);
239 tmp_buf
= kmalloc(size
, GFP_ATOMIC
);
241 mutex_unlock(&atm_dev_mutex
);
245 list_for_each(p
, &atm_devs
) {
246 dev
= list_entry(p
, struct atm_dev
, dev_list
);
247 *tmp_p
++ = dev
->number
;
249 mutex_unlock(&atm_dev_mutex
);
250 error
= ((copy_to_user(buf
, tmp_buf
, size
)) ||
251 put_user(size
, iobuf_len
))
261 struct compat_atmif_sioc __user
*csioc
= arg
;
264 sioc_len
= &csioc
->length
;
265 if (get_user(carg
, &csioc
->arg
))
267 buf
= compat_ptr(carg
);
269 if (get_user(len
, &csioc
->length
))
271 if (get_user(number
, &csioc
->number
))
275 struct atmif_sioc __user
*sioc
= arg
;
277 sioc_len
= &sioc
->length
;
278 if (get_user(buf
, &sioc
->arg
))
280 if (get_user(len
, &sioc
->length
))
282 if (get_user(number
, &sioc
->number
))
285 if (!(dev
= try_then_request_module(atm_dev_lookup(number
),
286 "atm-device-%d", number
)))
291 size
= strlen(dev
->type
) + 1;
292 if (copy_to_user(buf
, dev
->type
, size
)) {
299 if (copy_to_user(buf
, dev
->esi
, size
)) {
308 for (i
= 0; i
< ESI_LEN
; i
++)
317 unsigned char esi
[ESI_LEN
];
319 if (!capable(CAP_NET_ADMIN
)) {
323 if (copy_from_user(esi
, buf
, ESI_LEN
)) {
327 memcpy(dev
->esi
, esi
, ESI_LEN
);
332 if (!capable(CAP_NET_ADMIN
)) {
338 size
= sizeof(struct atm_dev_stats
);
339 error
= fetch_stats(dev
, buf
, cmd
== ATM_GETSTATZ
);
344 size
= sizeof(struct atm_cirange
);
345 if (copy_to_user(buf
, &dev
->ci_range
, size
)) {
350 case ATM_GETLINKRATE
:
352 if (copy_to_user(buf
, &dev
->link_rate
, size
)) {
358 if (!capable(CAP_NET_ADMIN
)) {
362 atm_reset_addr(dev
, ATM_ADDR_LOCAL
);
366 case ATM_ADDLECSADDR
:
367 case ATM_DELLECSADDR
:
368 if (!capable(CAP_NET_ADMIN
)) {
373 struct sockaddr_atmsvc addr
;
375 if (copy_from_user(&addr
, buf
, sizeof(addr
))) {
379 if (cmd
== ATM_ADDADDR
|| cmd
== ATM_ADDLECSADDR
)
380 error
= atm_add_addr(dev
, &addr
,
381 (cmd
== ATM_ADDADDR
?
382 ATM_ADDR_LOCAL
: ATM_ADDR_LECS
));
384 error
= atm_del_addr(dev
, &addr
,
385 (cmd
== ATM_DELADDR
?
386 ATM_ADDR_LOCAL
: ATM_ADDR_LECS
));
390 case ATM_GETLECSADDR
:
391 error
= atm_get_addr(dev
, buf
, len
,
392 (cmd
== ATM_GETADDR
?
393 ATM_ADDR_LOCAL
: ATM_ADDR_LECS
));
397 /* may return 0, but later on size == 0 means "don't
399 error
= put_user(size
, sioc_len
)
403 if (__ATM_LM_XTRMT((int) (unsigned long) buf
) &&
404 __ATM_LM_XTLOC((int) (unsigned long) buf
) >
405 __ATM_LM_XTRMT((int) (unsigned long) buf
)) {
414 case SONET_SETFRAMING
:
415 if (!capable(CAP_NET_ADMIN
)) {
423 if (!dev
->ops
->compat_ioctl
) {
427 size
= dev
->ops
->compat_ioctl(dev
, cmd
, buf
);
430 if (!dev
->ops
->ioctl
) {
434 size
= dev
->ops
->ioctl(dev
, cmd
, buf
);
437 error
= (size
== -ENOIOCTLCMD
? -EINVAL
: size
);
443 error
= put_user(size
, sioc_len
)
452 static __inline__
void *dev_get_idx(loff_t left
)
456 list_for_each(p
, &atm_devs
) {
460 return (p
!= &atm_devs
) ? p
: NULL
;
463 void *atm_dev_seq_start(struct seq_file
*seq
, loff_t
*pos
)
465 mutex_lock(&atm_dev_mutex
);
466 return *pos
? dev_get_idx(*pos
) : SEQ_START_TOKEN
;
469 void atm_dev_seq_stop(struct seq_file
*seq
, void *v
)
471 mutex_unlock(&atm_dev_mutex
);
474 void *atm_dev_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
477 v
= (v
== SEQ_START_TOKEN
)
478 ? atm_devs
.next
: ((struct list_head
*)v
)->next
;
479 return (v
== &atm_devs
) ? NULL
: v
;
483 EXPORT_SYMBOL(atm_dev_register
);
484 EXPORT_SYMBOL(atm_dev_deregister
);
485 EXPORT_SYMBOL(atm_dev_lookup
);
This page took 0.040225 seconds and 5 git commands to generate.