net/atm/lec.c: Add __lec_arp_check_expire and other cleanups
[linux-2.6.git] / net / atm / common.c
1 /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
2
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4
5 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
6
7 #include <linux/module.h>
8 #include <linux/kmod.h>
9 #include <linux/net.h>          /* struct socket, struct proto_ops */
10 #include <linux/atm.h>          /* ATM stuff */
11 #include <linux/atmdev.h>
12 #include <linux/socket.h>       /* SOL_SOCKET */
13 #include <linux/errno.h>        /* error codes */
14 #include <linux/capability.h>
15 #include <linux/mm.h>
16 #include <linux/sched.h>
17 #include <linux/time.h>         /* struct timeval */
18 #include <linux/skbuff.h>
19 #include <linux/bitops.h>
20 #include <linux/init.h>
21 #include <net/sock.h>           /* struct sock */
22 #include <linux/uaccess.h>
23 #include <linux/poll.h>
24
25 #include <asm/atomic.h>
26
27 #include "resources.h"          /* atm_find_dev */
28 #include "common.h"             /* prototypes */
29 #include "protocols.h"          /* atm_init_<transport> */
30 #include "addr.h"               /* address registry */
31 #include "signaling.h"          /* for WAITING and sigd_attach */
32
33 struct hlist_head vcc_hash[VCC_HTABLE_SIZE];
34 EXPORT_SYMBOL(vcc_hash);
35
36 DEFINE_RWLOCK(vcc_sklist_lock);
37 EXPORT_SYMBOL(vcc_sklist_lock);
38
39 static void __vcc_insert_socket(struct sock *sk)
40 {
41         struct atm_vcc *vcc = atm_sk(sk);
42         struct hlist_head *head = &vcc_hash[vcc->vci & (VCC_HTABLE_SIZE - 1)];
43         sk->sk_hash = vcc->vci & (VCC_HTABLE_SIZE - 1);
44         sk_add_node(sk, head);
45 }
46
47 void vcc_insert_socket(struct sock *sk)
48 {
49         write_lock_irq(&vcc_sklist_lock);
50         __vcc_insert_socket(sk);
51         write_unlock_irq(&vcc_sklist_lock);
52 }
53 EXPORT_SYMBOL(vcc_insert_socket);
54
55 static void vcc_remove_socket(struct sock *sk)
56 {
57         write_lock_irq(&vcc_sklist_lock);
58         sk_del_node_init(sk);
59         write_unlock_irq(&vcc_sklist_lock);
60 }
61
62 static struct sk_buff *alloc_tx(struct atm_vcc *vcc, unsigned int size)
63 {
64         struct sk_buff *skb;
65         struct sock *sk = sk_atm(vcc);
66
67         if (sk_wmem_alloc_get(sk) && !atm_may_send(vcc, size)) {
68                 pr_debug("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n",
69                          sk_wmem_alloc_get(sk), size, sk->sk_sndbuf);
70                 return NULL;
71         }
72         while (!(skb = alloc_skb(size, GFP_KERNEL)))
73                 schedule();
74         pr_debug("%d += %d\n", sk_wmem_alloc_get(sk), skb->truesize);
75         atomic_add(skb->truesize, &sk->sk_wmem_alloc);
76         return skb;
77 }
78
79 static void vcc_sock_destruct(struct sock *sk)
80 {
81         if (atomic_read(&sk->sk_rmem_alloc))
82                 printk(KERN_DEBUG "%s: rmem leakage (%d bytes) detected.\n",
83                        __func__, atomic_read(&sk->sk_rmem_alloc));
84
85         if (atomic_read(&sk->sk_wmem_alloc))
86                 printk(KERN_DEBUG "%s: wmem leakage (%d bytes) detected.\n",
87                        __func__, atomic_read(&sk->sk_wmem_alloc));
88 }
89
90 static void vcc_def_wakeup(struct sock *sk)
91 {
92         read_lock(&sk->sk_callback_lock);
93         if (sk_has_sleeper(sk))
94                 wake_up(sk->sk_sleep);
95         read_unlock(&sk->sk_callback_lock);
96 }
97
98 static inline int vcc_writable(struct sock *sk)
99 {
100         struct atm_vcc *vcc = atm_sk(sk);
101
102         return (vcc->qos.txtp.max_sdu +
103                 atomic_read(&sk->sk_wmem_alloc)) <= sk->sk_sndbuf;
104 }
105
106 static void vcc_write_space(struct sock *sk)
107 {
108         read_lock(&sk->sk_callback_lock);
109
110         if (vcc_writable(sk)) {
111                 if (sk_has_sleeper(sk))
112                         wake_up_interruptible(sk->sk_sleep);
113
114                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
115         }
116
117         read_unlock(&sk->sk_callback_lock);
118 }
119
120 static struct proto vcc_proto = {
121         .name     = "VCC",
122         .owner    = THIS_MODULE,
123         .obj_size = sizeof(struct atm_vcc),
124 };
125
126 int vcc_create(struct net *net, struct socket *sock, int protocol, int family)
127 {
128         struct sock *sk;
129         struct atm_vcc *vcc;
130
131         sock->sk = NULL;
132         if (sock->type == SOCK_STREAM)
133                 return -EINVAL;
134         sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto);
135         if (!sk)
136                 return -ENOMEM;
137         sock_init_data(sock, sk);
138         sk->sk_state_change = vcc_def_wakeup;
139         sk->sk_write_space = vcc_write_space;
140
141         vcc = atm_sk(sk);
142         vcc->dev = NULL;
143         memset(&vcc->local, 0, sizeof(struct sockaddr_atmsvc));
144         memset(&vcc->remote, 0, sizeof(struct sockaddr_atmsvc));
145         vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
146         atomic_set(&sk->sk_wmem_alloc, 1);
147         atomic_set(&sk->sk_rmem_alloc, 0);
148         vcc->push = NULL;
149         vcc->pop = NULL;
150         vcc->push_oam = NULL;
151         vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
152         vcc->atm_options = vcc->aal_options = 0;
153         sk->sk_destruct = vcc_sock_destruct;
154         return 0;
155 }
156
157 static void vcc_destroy_socket(struct sock *sk)
158 {
159         struct atm_vcc *vcc = atm_sk(sk);
160         struct sk_buff *skb;
161
162         set_bit(ATM_VF_CLOSE, &vcc->flags);
163         clear_bit(ATM_VF_READY, &vcc->flags);
164         if (vcc->dev) {
165                 if (vcc->dev->ops->close)
166                         vcc->dev->ops->close(vcc);
167                 if (vcc->push)
168                         vcc->push(vcc, NULL); /* atmarpd has no push */
169
170                 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
171                         atm_return(vcc, skb->truesize);
172                         kfree_skb(skb);
173                 }
174
175                 module_put(vcc->dev->ops->owner);
176                 atm_dev_put(vcc->dev);
177         }
178
179         vcc_remove_socket(sk);
180 }
181
182 int vcc_release(struct socket *sock)
183 {
184         struct sock *sk = sock->sk;
185
186         if (sk) {
187                 lock_sock(sk);
188                 vcc_destroy_socket(sock->sk);
189                 release_sock(sk);
190                 sock_put(sk);
191         }
192
193         return 0;
194 }
195
196 void vcc_release_async(struct atm_vcc *vcc, int reply)
197 {
198         struct sock *sk = sk_atm(vcc);
199
200         set_bit(ATM_VF_CLOSE, &vcc->flags);
201         sk->sk_shutdown |= RCV_SHUTDOWN;
202         sk->sk_err = -reply;
203         clear_bit(ATM_VF_WAITING, &vcc->flags);
204         sk->sk_state_change(sk);
205 }
206 EXPORT_SYMBOL(vcc_release_async);
207
208
209 void atm_dev_release_vccs(struct atm_dev *dev)
210 {
211         int i;
212
213         write_lock_irq(&vcc_sklist_lock);
214         for (i = 0; i < VCC_HTABLE_SIZE; i++) {
215                 struct hlist_head *head = &vcc_hash[i];
216                 struct hlist_node *node, *tmp;
217                 struct sock *s;
218                 struct atm_vcc *vcc;
219
220                 sk_for_each_safe(s, node, tmp, head) {
221                         vcc = atm_sk(s);
222                         if (vcc->dev == dev) {
223                                 vcc_release_async(vcc, -EPIPE);
224                                 sk_del_node_init(s);
225                         }
226                 }
227         }
228         write_unlock_irq(&vcc_sklist_lock);
229 }
230
231 static int adjust_tp(struct atm_trafprm *tp, unsigned char aal)
232 {
233         int max_sdu;
234
235         if (!tp->traffic_class)
236                 return 0;
237         switch (aal) {
238         case ATM_AAL0:
239                 max_sdu = ATM_CELL_SIZE-1;
240                 break;
241         case ATM_AAL34:
242                 max_sdu = ATM_MAX_AAL34_PDU;
243                 break;
244         default:
245                 pr_warning("AAL problems ... (%d)\n", aal);
246                 /* fall through */
247         case ATM_AAL5:
248                 max_sdu = ATM_MAX_AAL5_PDU;
249         }
250         if (!tp->max_sdu)
251                 tp->max_sdu = max_sdu;
252         else if (tp->max_sdu > max_sdu)
253                 return -EINVAL;
254         if (!tp->max_cdv)
255                 tp->max_cdv = ATM_MAX_CDV;
256         return 0;
257 }
258
259 static int check_ci(const struct atm_vcc *vcc, short vpi, int vci)
260 {
261         struct hlist_head *head = &vcc_hash[vci & (VCC_HTABLE_SIZE - 1)];
262         struct hlist_node *node;
263         struct sock *s;
264         struct atm_vcc *walk;
265
266         sk_for_each(s, node, head) {
267                 walk = atm_sk(s);
268                 if (walk->dev != vcc->dev)
269                         continue;
270                 if (test_bit(ATM_VF_ADDR, &walk->flags) && walk->vpi == vpi &&
271                     walk->vci == vci && ((walk->qos.txtp.traffic_class !=
272                     ATM_NONE && vcc->qos.txtp.traffic_class != ATM_NONE) ||
273                     (walk->qos.rxtp.traffic_class != ATM_NONE &&
274                     vcc->qos.rxtp.traffic_class != ATM_NONE)))
275                         return -EADDRINUSE;
276         }
277
278         /* allow VCCs with same VPI/VCI iff they don't collide on
279            TX/RX (but we may refuse such sharing for other reasons,
280            e.g. if protocol requires to have both channels) */
281
282         return 0;
283 }
284
285 static int find_ci(const struct atm_vcc *vcc, short *vpi, int *vci)
286 {
287         static short p;        /* poor man's per-device cache */
288         static int c;
289         short old_p;
290         int old_c;
291         int err;
292
293         if (*vpi != ATM_VPI_ANY && *vci != ATM_VCI_ANY) {
294                 err = check_ci(vcc, *vpi, *vci);
295                 return err;
296         }
297         /* last scan may have left values out of bounds for current device */
298         if (*vpi != ATM_VPI_ANY)
299                 p = *vpi;
300         else if (p >= 1 << vcc->dev->ci_range.vpi_bits)
301                 p = 0;
302         if (*vci != ATM_VCI_ANY)
303                 c = *vci;
304         else if (c < ATM_NOT_RSV_VCI || c >= 1 << vcc->dev->ci_range.vci_bits)
305                         c = ATM_NOT_RSV_VCI;
306         old_p = p;
307         old_c = c;
308         do {
309                 if (!check_ci(vcc, p, c)) {
310                         *vpi = p;
311                         *vci = c;
312                         return 0;
313                 }
314                 if (*vci == ATM_VCI_ANY) {
315                         c++;
316                         if (c >= 1 << vcc->dev->ci_range.vci_bits)
317                                 c = ATM_NOT_RSV_VCI;
318                 }
319                 if ((c == ATM_NOT_RSV_VCI || *vci != ATM_VCI_ANY) &&
320                     *vpi == ATM_VPI_ANY) {
321                         p++;
322                         if (p >= 1 << vcc->dev->ci_range.vpi_bits)
323                                 p = 0;
324                 }
325         } while (old_p != p || old_c != c);
326         return -EADDRINUSE;
327 }
328
329 static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, short vpi,
330                          int vci)
331 {
332         struct sock *sk = sk_atm(vcc);
333         int error;
334
335         if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
336             vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
337             vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
338                 return -EINVAL;
339         if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
340                 return -EPERM;
341         error = -ENODEV;
342         if (!try_module_get(dev->ops->owner))
343                 return error;
344         vcc->dev = dev;
345         write_lock_irq(&vcc_sklist_lock);
346         if (test_bit(ATM_DF_REMOVED, &dev->flags) ||
347             (error = find_ci(vcc, &vpi, &vci))) {
348                 write_unlock_irq(&vcc_sklist_lock);
349                 goto fail_module_put;
350         }
351         vcc->vpi = vpi;
352         vcc->vci = vci;
353         __vcc_insert_socket(sk);
354         write_unlock_irq(&vcc_sklist_lock);
355         switch (vcc->qos.aal) {
356         case ATM_AAL0:
357                 error = atm_init_aal0(vcc);
358                 vcc->stats = &dev->stats.aal0;
359                 break;
360         case ATM_AAL34:
361                 error = atm_init_aal34(vcc);
362                 vcc->stats = &dev->stats.aal34;
363                 break;
364         case ATM_NO_AAL:
365                 /* ATM_AAL5 is also used in the "0 for default" case */
366                 vcc->qos.aal = ATM_AAL5;
367                 /* fall through */
368         case ATM_AAL5:
369                 error = atm_init_aal5(vcc);
370                 vcc->stats = &dev->stats.aal5;
371                 break;
372         default:
373                 error = -EPROTOTYPE;
374         }
375         if (!error)
376                 error = adjust_tp(&vcc->qos.txtp, vcc->qos.aal);
377         if (!error)
378                 error = adjust_tp(&vcc->qos.rxtp, vcc->qos.aal);
379         if (error)
380                 goto fail;
381         pr_debug("VCC %d.%d, AAL %d\n", vpi, vci, vcc->qos.aal);
382         pr_debug("  TX: %d, PCR %d..%d, SDU %d\n",
383                  vcc->qos.txtp.traffic_class,
384                  vcc->qos.txtp.min_pcr,
385                  vcc->qos.txtp.max_pcr,
386                  vcc->qos.txtp.max_sdu);
387         pr_debug("  RX: %d, PCR %d..%d, SDU %d\n",
388                  vcc->qos.rxtp.traffic_class,
389                  vcc->qos.rxtp.min_pcr,
390                  vcc->qos.rxtp.max_pcr,
391                  vcc->qos.rxtp.max_sdu);
392
393         if (dev->ops->open) {
394                 error = dev->ops->open(vcc);
395                 if (error)
396                         goto fail;
397         }
398         return 0;
399
400 fail:
401         vcc_remove_socket(sk);
402 fail_module_put:
403         module_put(dev->ops->owner);
404         /* ensure we get dev module ref count correct */
405         vcc->dev = NULL;
406         return error;
407 }
408
409 int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
410 {
411         struct atm_dev *dev;
412         struct atm_vcc *vcc = ATM_SD(sock);
413         int error;
414
415         pr_debug("(vpi %d, vci %d)\n", vpi, vci);
416         if (sock->state == SS_CONNECTED)
417                 return -EISCONN;
418         if (sock->state != SS_UNCONNECTED)
419                 return -EINVAL;
420         if (!(vpi || vci))
421                 return -EINVAL;
422
423         if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
424                 clear_bit(ATM_VF_PARTIAL, &vcc->flags);
425         else
426                 if (test_bit(ATM_VF_PARTIAL, &vcc->flags))
427                         return -EINVAL;
428         pr_debug("(TX: cl %d,bw %d-%d,sdu %d; "
429                  "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n",
430                  vcc->qos.txtp.traffic_class, vcc->qos.txtp.min_pcr,
431                  vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_sdu,
432                  vcc->qos.rxtp.traffic_class, vcc->qos.rxtp.min_pcr,
433                  vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_sdu,
434                  vcc->qos.aal == ATM_AAL5 ? "" :
435                  vcc->qos.aal == ATM_AAL0 ? "" : " ??? code ",
436                  vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
437         if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
438                 return -EBADFD;
439         if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
440             vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
441                 return -EINVAL;
442         if (likely(itf != ATM_ITF_ANY)) {
443                 dev = try_then_request_module(atm_dev_lookup(itf),
444                                               "atm-device-%d", itf);
445         } else {
446                 dev = NULL;
447                 mutex_lock(&atm_dev_mutex);
448                 if (!list_empty(&atm_devs)) {
449                         dev = list_entry(atm_devs.next,
450                                          struct atm_dev, dev_list);
451                         atm_dev_hold(dev);
452                 }
453                 mutex_unlock(&atm_dev_mutex);
454         }
455         if (!dev)
456                 return -ENODEV;
457         error = __vcc_connect(vcc, dev, vpi, vci);
458         if (error) {
459                 atm_dev_put(dev);
460                 return error;
461         }
462         if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
463                 set_bit(ATM_VF_PARTIAL, &vcc->flags);
464         if (test_bit(ATM_VF_READY, &ATM_SD(sock)->flags))
465                 sock->state = SS_CONNECTED;
466         return 0;
467 }
468
469 int vcc_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
470                 size_t size, int flags)
471 {
472         struct sock *sk = sock->sk;
473         struct atm_vcc *vcc;
474         struct sk_buff *skb;
475         int copied, error = -EINVAL;
476
477         if (sock->state != SS_CONNECTED)
478                 return -ENOTCONN;
479         if (flags & ~MSG_DONTWAIT)              /* only handle MSG_DONTWAIT */
480                 return -EOPNOTSUPP;
481         vcc = ATM_SD(sock);
482         if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
483             test_bit(ATM_VF_CLOSE, &vcc->flags) ||
484             !test_bit(ATM_VF_READY, &vcc->flags))
485                 return 0;
486
487         skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error);
488         if (!skb)
489                 return error;
490
491         copied = skb->len;
492         if (copied > size) {
493                 copied = size;
494                 msg->msg_flags |= MSG_TRUNC;
495         }
496
497         error = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
498         if (error)
499                 return error;
500         sock_recv_ts_and_drops(msg, sk, skb);
501         pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc), skb->truesize);
502         atm_return(vcc, skb->truesize);
503         skb_free_datagram(sk, skb);
504         return copied;
505 }
506
507 int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
508                 size_t total_len)
509 {
510         struct sock *sk = sock->sk;
511         DEFINE_WAIT(wait);
512         struct atm_vcc *vcc;
513         struct sk_buff *skb;
514         int eff, error;
515         const void __user *buff;
516         int size;
517
518         lock_sock(sk);
519         if (sock->state != SS_CONNECTED) {
520                 error = -ENOTCONN;
521                 goto out;
522         }
523         if (m->msg_name) {
524                 error = -EISCONN;
525                 goto out;
526         }
527         if (m->msg_iovlen != 1) {
528                 error = -ENOSYS; /* fix this later @@@ */
529                 goto out;
530         }
531         buff = m->msg_iov->iov_base;
532         size = m->msg_iov->iov_len;
533         vcc = ATM_SD(sock);
534         if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
535             test_bit(ATM_VF_CLOSE, &vcc->flags) ||
536             !test_bit(ATM_VF_READY, &vcc->flags)) {
537                 error = -EPIPE;
538                 send_sig(SIGPIPE, current, 0);
539                 goto out;
540         }
541         if (!size) {
542                 error = 0;
543                 goto out;
544         }
545         if (size < 0 || size > vcc->qos.txtp.max_sdu) {
546                 error = -EMSGSIZE;
547                 goto out;
548         }
549
550         eff = (size+3) & ~3; /* align to word boundary */
551         prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
552         error = 0;
553         while (!(skb = alloc_tx(vcc, eff))) {
554                 if (m->msg_flags & MSG_DONTWAIT) {
555                         error = -EAGAIN;
556                         break;
557                 }
558                 schedule();
559                 if (signal_pending(current)) {
560                         error = -ERESTARTSYS;
561                         break;
562                 }
563                 if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
564                     test_bit(ATM_VF_CLOSE, &vcc->flags) ||
565                     !test_bit(ATM_VF_READY, &vcc->flags)) {
566                         error = -EPIPE;
567                         send_sig(SIGPIPE, current, 0);
568                         break;
569                 }
570                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
571         }
572         finish_wait(sk->sk_sleep, &wait);
573         if (error)
574                 goto out;
575         skb->dev = NULL; /* for paths shared with net_device interfaces */
576         ATM_SKB(skb)->atm_options = vcc->atm_options;
577         if (copy_from_user(skb_put(skb, size), buff, size)) {
578                 kfree_skb(skb);
579                 error = -EFAULT;
580                 goto out;
581         }
582         if (eff != size)
583                 memset(skb->data + size, 0, eff-size);
584         error = vcc->dev->ops->send(vcc, skb);
585         error = error ? error : size;
586 out:
587         release_sock(sk);
588         return error;
589 }
590
591 unsigned int vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
592 {
593         struct sock *sk = sock->sk;
594         struct atm_vcc *vcc;
595         unsigned int mask;
596
597         sock_poll_wait(file, sk->sk_sleep, wait);
598         mask = 0;
599
600         vcc = ATM_SD(sock);
601
602         /* exceptional events */
603         if (sk->sk_err)
604                 mask = POLLERR;
605
606         if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
607             test_bit(ATM_VF_CLOSE, &vcc->flags))
608                 mask |= POLLHUP;
609
610         /* readable? */
611         if (!skb_queue_empty(&sk->sk_receive_queue))
612                 mask |= POLLIN | POLLRDNORM;
613
614         /* writable? */
615         if (sock->state == SS_CONNECTING &&
616             test_bit(ATM_VF_WAITING, &vcc->flags))
617                 return mask;
618
619         if (vcc->qos.txtp.traffic_class != ATM_NONE &&
620             vcc_writable(sk))
621                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
622
623         return mask;
624 }
625
626 static int atm_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
627 {
628         int error;
629
630         /*
631          * Don't let the QoS change the already connected AAL type nor the
632          * traffic class.
633          */
634         if (qos->aal != vcc->qos.aal ||
635             qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
636             qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
637                 return -EINVAL;
638         error = adjust_tp(&qos->txtp, qos->aal);
639         if (!error)
640                 error = adjust_tp(&qos->rxtp, qos->aal);
641         if (error)
642                 return error;
643         if (!vcc->dev->ops->change_qos)
644                 return -EOPNOTSUPP;
645         if (sk_atm(vcc)->sk_family == AF_ATMPVC)
646                 return vcc->dev->ops->change_qos(vcc, qos, ATM_MF_SET);
647         return svc_change_qos(vcc, qos);
648 }
649
650 static int check_tp(const struct atm_trafprm *tp)
651 {
652         /* @@@ Should be merged with adjust_tp */
653         if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS)
654                 return 0;
655         if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
656             !tp->max_pcr)
657                 return -EINVAL;
658         if (tp->min_pcr == ATM_MAX_PCR)
659                 return -EINVAL;
660         if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
661             tp->min_pcr > tp->max_pcr)
662                 return -EINVAL;
663         /*
664          * We allow pcr to be outside [min_pcr,max_pcr], because later
665          * adjustment may still push it in the valid range.
666          */
667         return 0;
668 }
669
670 static int check_qos(const struct atm_qos *qos)
671 {
672         int error;
673
674         if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
675                 return -EINVAL;
676         if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
677             qos->txtp.traffic_class && qos->rxtp.traffic_class &&
678             qos->txtp.traffic_class != ATM_ANYCLASS &&
679             qos->rxtp.traffic_class != ATM_ANYCLASS)
680                 return -EINVAL;
681         error = check_tp(&qos->txtp);
682         if (error)
683                 return error;
684         return check_tp(&qos->rxtp);
685 }
686
687 int vcc_setsockopt(struct socket *sock, int level, int optname,
688                    char __user *optval, unsigned int optlen)
689 {
690         struct atm_vcc *vcc;
691         unsigned long value;
692         int error;
693
694         if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
695                 return -EINVAL;
696
697         vcc = ATM_SD(sock);
698         switch (optname) {
699         case SO_ATMQOS:
700         {
701                 struct atm_qos qos;
702
703                 if (copy_from_user(&qos, optval, sizeof(qos)))
704                         return -EFAULT;
705                 error = check_qos(&qos);
706                 if (error)
707                         return error;
708                 if (sock->state == SS_CONNECTED)
709                         return atm_change_qos(vcc, &qos);
710                 if (sock->state != SS_UNCONNECTED)
711                         return -EBADFD;
712                 vcc->qos = qos;
713                 set_bit(ATM_VF_HASQOS, &vcc->flags);
714                 return 0;
715         }
716         case SO_SETCLP:
717                 if (get_user(value, (unsigned long __user *)optval))
718                         return -EFAULT;
719                 if (value)
720                         vcc->atm_options |= ATM_ATMOPT_CLP;
721                 else
722                         vcc->atm_options &= ~ATM_ATMOPT_CLP;
723                 return 0;
724         default:
725                 if (level == SOL_SOCKET)
726                         return -EINVAL;
727                 break;
728         }
729         if (!vcc->dev || !vcc->dev->ops->setsockopt)
730                 return -EINVAL;
731         return vcc->dev->ops->setsockopt(vcc, level, optname, optval, optlen);
732 }
733
734 int vcc_getsockopt(struct socket *sock, int level, int optname,
735                    char __user *optval, int __user *optlen)
736 {
737         struct atm_vcc *vcc;
738         int len;
739
740         if (get_user(len, optlen))
741                 return -EFAULT;
742         if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
743                 return -EINVAL;
744
745         vcc = ATM_SD(sock);
746         switch (optname) {
747         case SO_ATMQOS:
748                 if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
749                         return -EINVAL;
750                 return copy_to_user(optval, &vcc->qos, sizeof(vcc->qos))
751                         ? -EFAULT : 0;
752         case SO_SETCLP:
753                 return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 : 0,
754                                 (unsigned long __user *)optval) ? -EFAULT : 0;
755         case SO_ATMPVC:
756         {
757                 struct sockaddr_atmpvc pvc;
758
759                 if (!vcc->dev || !test_bit(ATM_VF_ADDR, &vcc->flags))
760                         return -ENOTCONN;
761                 pvc.sap_family = AF_ATMPVC;
762                 pvc.sap_addr.itf = vcc->dev->number;
763                 pvc.sap_addr.vpi = vcc->vpi;
764                 pvc.sap_addr.vci = vcc->vci;
765                 return copy_to_user(optval, &pvc, sizeof(pvc)) ? -EFAULT : 0;
766         }
767         default:
768                 if (level == SOL_SOCKET)
769                         return -EINVAL;
770                         break;
771         }
772         if (!vcc->dev || !vcc->dev->ops->getsockopt)
773                 return -EINVAL;
774         return vcc->dev->ops->getsockopt(vcc, level, optname, optval, len);
775 }
776
777 static int __init atm_init(void)
778 {
779         int error;
780
781         error = proto_register(&vcc_proto, 0);
782         if (error < 0)
783                 goto out;
784         error = atmpvc_init();
785         if (error < 0) {
786                 pr_err("atmpvc_init() failed with %d\n", error);
787                 goto out_unregister_vcc_proto;
788         }
789         error = atmsvc_init();
790         if (error < 0) {
791                 pr_err("atmsvc_init() failed with %d\n", error);
792                 goto out_atmpvc_exit;
793         }
794         error = atm_proc_init();
795         if (error < 0) {
796                 pr_err("atm_proc_init() failed with %d\n", error);
797                 goto out_atmsvc_exit;
798         }
799         error = atm_sysfs_init();
800         if (error < 0) {
801                 pr_err("atm_sysfs_init() failed with %d\n", error);
802                 goto out_atmproc_exit;
803         }
804 out:
805         return error;
806 out_atmproc_exit:
807         atm_proc_exit();
808 out_atmsvc_exit:
809         atmsvc_exit();
810 out_atmpvc_exit:
811         atmsvc_exit();
812 out_unregister_vcc_proto:
813         proto_unregister(&vcc_proto);
814         goto out;
815 }
816
817 static void __exit atm_exit(void)
818 {
819         atm_proc_exit();
820         atm_sysfs_exit();
821         atmsvc_exit();
822         atmpvc_exit();
823         proto_unregister(&vcc_proto);
824 }
825
826 subsys_initcall(atm_init);
827
828 module_exit(atm_exit);
829
830 MODULE_LICENSE("GPL");
831 MODULE_ALIAS_NETPROTO(PF_ATMPVC);
832 MODULE_ALIAS_NETPROTO(PF_ATMSVC);