1 /* net/atm/svc.c - ATM SVC sockets */
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
6 #include <linux/string.h>
7 #include <linux/net.h> /* struct socket, struct proto_ops */
8 #include <linux/errno.h> /* error codes */
9 #include <linux/kernel.h> /* printk */
10 #include <linux/skbuff.h>
11 #include <linux/wait.h>
12 #include <linux/sched.h> /* jiffies and HZ */
13 #include <linux/fcntl.h> /* O_NONBLOCK */
14 #include <linux/init.h>
15 #include <linux/atm.h> /* ATM stuff */
16 #include <linux/atmsap.h>
17 #include <linux/atmsvc.h>
18 #include <linux/atmdev.h>
19 #include <linux/bitops.h>
20 #include <net/sock.h> /* for sock_no_* */
21 #include <asm/uaccess.h>
23 #include "resources.h"
24 #include "common.h" /* common for PVCs and SVCs */
25 #include "signaling.h"
30 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
32 #define DPRINTK(format,args...)
36 static int svc_create(struct socket
*sock
,int protocol
);
40 * Note: since all this is still nicely synchronized with the signaling demon,
41 * there's no need to protect sleep loops with clis. If signaling is
42 * moved into the kernel, that would change.
46 static int svc_shutdown(struct socket
*sock
,int how
)
52 static void svc_disconnect(struct atm_vcc
*vcc
)
57 DPRINTK("svc_disconnect %p\n",vcc
);
58 if (test_bit(ATM_VF_REGIS
,&vcc
->flags
)) {
59 prepare_to_wait(vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
60 sigd_enq(vcc
,as_close
,NULL
,NULL
,NULL
);
61 while (!test_bit(ATM_VF_RELEASED
,&vcc
->flags
) && sigd
) {
63 prepare_to_wait(vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
65 finish_wait(vcc
->sk
->sk_sleep
, &wait
);
67 /* beware - socket is still in use by atmsigd until the last
68 as_indicate has been answered */
69 while ((skb
= skb_dequeue(&vcc
->sk
->sk_receive_queue
))) {
70 DPRINTK("LISTEN REL\n");
71 sigd_enq2(NULL
,as_reject
,vcc
,NULL
,NULL
,&vcc
->qos
,0);
74 clear_bit(ATM_VF_REGIS
,&vcc
->flags
);
75 clear_bit(ATM_VF_RELEASED
,&vcc
->flags
);
76 clear_bit(ATM_VF_CLOSE
,&vcc
->flags
);
77 /* ... may retry later */
81 static int svc_release(struct socket
*sock
)
83 struct sock
*sk
= sock
->sk
;
88 DPRINTK("svc_release %p\n", vcc
);
89 clear_bit(ATM_VF_READY
, &vcc
->flags
);
90 /* VCC pointer is used as a reference, so we must not free it
91 (thereby subjecting it to re-use) before all pending connections
102 static int svc_bind(struct socket
*sock
,struct sockaddr
*sockaddr
,
106 struct sock
*sk
= sock
->sk
;
107 struct sockaddr_atmsvc
*addr
;
111 if (sockaddr_len
!= sizeof(struct sockaddr_atmsvc
))
114 if (sock
->state
== SS_CONNECTED
) {
118 if (sock
->state
!= SS_UNCONNECTED
) {
123 if (test_bit(ATM_VF_SESSION
, &vcc
->flags
)) {
127 addr
= (struct sockaddr_atmsvc
*) sockaddr
;
128 if (addr
->sas_family
!= AF_ATMSVC
) {
129 error
= -EAFNOSUPPORT
;
132 clear_bit(ATM_VF_BOUND
,&vcc
->flags
);
133 /* failing rebind will kill old binding */
134 /* @@@ check memory (de)allocation on rebind */
135 if (!test_bit(ATM_VF_HASQOS
,&vcc
->flags
)) {
140 set_bit(ATM_VF_WAITING
, &vcc
->flags
);
141 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
142 sigd_enq(vcc
,as_bind
,NULL
,NULL
,&vcc
->local
);
143 while (test_bit(ATM_VF_WAITING
, &vcc
->flags
) && sigd
) {
145 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
147 finish_wait(sk
->sk_sleep
, &wait
);
148 clear_bit(ATM_VF_REGIS
,&vcc
->flags
); /* doesn't count */
154 set_bit(ATM_VF_BOUND
,&vcc
->flags
);
162 static int svc_connect(struct socket
*sock
,struct sockaddr
*sockaddr
,
163 int sockaddr_len
,int flags
)
166 struct sock
*sk
= sock
->sk
;
167 struct sockaddr_atmsvc
*addr
;
168 struct atm_vcc
*vcc
= ATM_SD(sock
);
171 DPRINTK("svc_connect %p\n",vcc
);
173 if (sockaddr_len
!= sizeof(struct sockaddr_atmsvc
)) {
178 switch (sock
->state
) {
186 if (test_bit(ATM_VF_WAITING
, &vcc
->flags
)) {
190 sock
->state
= SS_UNCONNECTED
;
197 if (test_bit(ATM_VF_SESSION
, &vcc
->flags
)) {
201 addr
= (struct sockaddr_atmsvc
*) sockaddr
;
202 if (addr
->sas_family
!= AF_ATMSVC
) {
203 error
= -EAFNOSUPPORT
;
206 if (!test_bit(ATM_VF_HASQOS
, &vcc
->flags
)) {
210 if (vcc
->qos
.txtp
.traffic_class
== ATM_ANYCLASS
||
211 vcc
->qos
.rxtp
.traffic_class
== ATM_ANYCLASS
) {
215 if (!vcc
->qos
.txtp
.traffic_class
&&
216 !vcc
->qos
.rxtp
.traffic_class
) {
221 set_bit(ATM_VF_WAITING
, &vcc
->flags
);
222 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
223 sigd_enq(vcc
,as_connect
,NULL
,NULL
,&vcc
->remote
);
224 if (flags
& O_NONBLOCK
) {
225 finish_wait(sk
->sk_sleep
, &wait
);
226 sock
->state
= SS_CONNECTING
;
227 error
= -EINPROGRESS
;
231 while (test_bit(ATM_VF_WAITING
, &vcc
->flags
) && sigd
) {
233 if (!signal_pending(current
)) {
234 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
237 DPRINTK("*ABORT*\n");
240 * Kernel ---close--> Demon
241 * Kernel <--close--- Demon
243 * Kernel ---close--> Demon
244 * Kernel <--error--- Demon
246 * Kernel ---close--> Demon
247 * Kernel <--okay---- Demon
248 * Kernel <--close--- Demon
250 sigd_enq(vcc
,as_close
,NULL
,NULL
,NULL
);
251 while (test_bit(ATM_VF_WAITING
, &vcc
->flags
) && sigd
) {
252 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
256 while (!test_bit(ATM_VF_RELEASED
,&vcc
->flags
)
258 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
261 clear_bit(ATM_VF_REGIS
,&vcc
->flags
);
262 clear_bit(ATM_VF_RELEASED
,&vcc
->flags
);
263 clear_bit(ATM_VF_CLOSE
,&vcc
->flags
);
264 /* we're gone now but may connect later */
268 finish_wait(sk
->sk_sleep
, &wait
);
283 * #ifndef CONFIG_SINGLE_SIGITF
285 vcc
->qos
.txtp
.max_pcr
= SELECT_TOP_PCR(vcc
->qos
.txtp
);
286 vcc
->qos
.txtp
.pcr
= 0;
287 vcc
->qos
.txtp
.min_pcr
= 0;
291 if (!(error
= vcc_connect(sock
, vcc
->itf
, vcc
->vpi
, vcc
->vci
)))
292 sock
->state
= SS_CONNECTED
;
293 else (void) svc_disconnect(vcc
);
300 static int svc_listen(struct socket
*sock
,int backlog
)
303 struct sock
*sk
= sock
->sk
;
304 struct atm_vcc
*vcc
= ATM_SD(sock
);
307 DPRINTK("svc_listen %p\n",vcc
);
309 /* let server handle listen on unbound sockets */
310 if (test_bit(ATM_VF_SESSION
,&vcc
->flags
)) {
314 set_bit(ATM_VF_WAITING
, &vcc
->flags
);
315 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
316 sigd_enq(vcc
,as_listen
,NULL
,NULL
,&vcc
->local
);
317 while (test_bit(ATM_VF_WAITING
, &vcc
->flags
) && sigd
) {
319 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
321 finish_wait(sk
->sk_sleep
, &wait
);
326 set_bit(ATM_VF_LISTEN
,&vcc
->flags
);
327 vcc
->sk
->sk_max_ack_backlog
= backlog
> 0 ? backlog
:
336 static int svc_accept(struct socket
*sock
,struct socket
*newsock
,int flags
)
338 struct sock
*sk
= sock
->sk
;
340 struct atmsvc_msg
*msg
;
341 struct atm_vcc
*old_vcc
= ATM_SD(sock
);
342 struct atm_vcc
*new_vcc
;
347 error
= svc_create(newsock
,0);
351 new_vcc
= ATM_SD(newsock
);
353 DPRINTK("svc_accept %p -> %p\n",old_vcc
,new_vcc
);
357 prepare_to_wait(old_vcc
->sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
358 while (!(skb
= skb_dequeue(&old_vcc
->sk
->sk_receive_queue
)) &&
360 if (test_bit(ATM_VF_RELEASED
,&old_vcc
->flags
)) break;
361 if (test_bit(ATM_VF_CLOSE
,&old_vcc
->flags
)) {
365 if (flags
& O_NONBLOCK
) {
372 if (signal_pending(current
)) {
373 error
= -ERESTARTSYS
;
376 prepare_to_wait(old_vcc
->sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
378 finish_wait(old_vcc
->sk
->sk_sleep
, &wait
);
385 msg
= (struct atmsvc_msg
*) skb
->data
;
386 new_vcc
->qos
= msg
->qos
;
387 set_bit(ATM_VF_HASQOS
,&new_vcc
->flags
);
388 new_vcc
->remote
= msg
->svc
;
389 new_vcc
->local
= msg
->local
;
390 new_vcc
->sap
= msg
->sap
;
391 error
= vcc_connect(newsock
, msg
->pvc
.sap_addr
.itf
,
392 msg
->pvc
.sap_addr
.vpi
, msg
->pvc
.sap_addr
.vci
);
394 old_vcc
->sk
->sk_ack_backlog
--;
396 sigd_enq2(NULL
,as_reject
,old_vcc
,NULL
,NULL
,
397 &old_vcc
->qos
,error
);
398 error
= error
== -EAGAIN
? -EBUSY
: error
;
401 /* wait should be short, so we ignore the non-blocking flag */
402 set_bit(ATM_VF_WAITING
, &new_vcc
->flags
);
403 prepare_to_wait(new_vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
404 sigd_enq(new_vcc
,as_accept
,old_vcc
,NULL
,NULL
);
405 while (test_bit(ATM_VF_WAITING
, &new_vcc
->flags
) && sigd
) {
409 prepare_to_wait(new_vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
411 finish_wait(new_vcc
->sk
->sk_sleep
, &wait
);
416 if (!new_vcc
->sk
->sk_err
)
418 if (new_vcc
->sk
->sk_err
!= ERESTARTSYS
) {
419 error
= -new_vcc
->sk
->sk_err
;
423 newsock
->state
= SS_CONNECTED
;
430 static int svc_getname(struct socket
*sock
,struct sockaddr
*sockaddr
,
431 int *sockaddr_len
,int peer
)
433 struct sockaddr_atmsvc
*addr
;
435 *sockaddr_len
= sizeof(struct sockaddr_atmsvc
);
436 addr
= (struct sockaddr_atmsvc
*) sockaddr
;
437 memcpy(addr
,peer
? &ATM_SD(sock
)->remote
: &ATM_SD(sock
)->local
,
438 sizeof(struct sockaddr_atmsvc
));
443 int svc_change_qos(struct atm_vcc
*vcc
,struct atm_qos
*qos
)
447 set_bit(ATM_VF_WAITING
, &vcc
->flags
);
448 prepare_to_wait(vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
449 sigd_enq2(vcc
,as_modify
,NULL
,NULL
,&vcc
->local
,qos
,0);
450 while (test_bit(ATM_VF_WAITING
, &vcc
->flags
) &&
451 !test_bit(ATM_VF_RELEASED
, &vcc
->flags
) && sigd
) {
453 prepare_to_wait(vcc
->sk
->sk_sleep
, &wait
, TASK_UNINTERRUPTIBLE
);
455 finish_wait(vcc
->sk
->sk_sleep
, &wait
);
456 if (!sigd
) return -EUNATCH
;
457 return -vcc
->sk
->sk_err
;
461 static int svc_setsockopt(struct socket
*sock
,int level
,int optname
,
462 char *optval
,int optlen
)
464 struct sock
*sk
= sock
->sk
;
468 if (!__SO_LEVEL_MATCH(optname
, level
) || optname
!= SO_ATMSAP
||
469 optlen
!= sizeof(struct atm_sap
)) {
470 error
= vcc_setsockopt(sock
, level
, optname
, optval
, optlen
);
474 if (copy_from_user(&vcc
->sap
, optval
, optlen
)) {
478 set_bit(ATM_VF_HASSAP
, &vcc
->flags
);
485 static int svc_getsockopt(struct socket
*sock
,int level
,int optname
,
486 char *optval
,int *optlen
)
488 struct sock
*sk
= sock
->sk
;
492 if (!__SO_LEVEL_MATCH(optname
, level
) || optname
!= SO_ATMSAP
) {
493 error
= vcc_getsockopt(sock
, level
, optname
, optval
, optlen
);
496 if (get_user(len
, optlen
)) {
500 if (len
!= sizeof(struct atm_sap
)) {
504 if (copy_to_user(optval
, &ATM_SD(sock
)->sap
, sizeof(struct atm_sap
))) {
514 static struct proto_ops svc_proto_ops
= {
516 .owner
= THIS_MODULE
,
518 .release
= svc_release
,
520 .connect
= svc_connect
,
521 .socketpair
= sock_no_socketpair
,
522 .accept
= svc_accept
,
523 .getname
= svc_getname
,
526 .listen
= svc_listen
,
527 .shutdown
= svc_shutdown
,
528 .setsockopt
= svc_setsockopt
,
529 .getsockopt
= svc_getsockopt
,
530 .sendmsg
= vcc_sendmsg
,
531 .recvmsg
= vcc_recvmsg
,
532 .mmap
= sock_no_mmap
,
533 .sendpage
= sock_no_sendpage
,
537 static int svc_create(struct socket
*sock
,int protocol
)
541 sock
->ops
= &svc_proto_ops
;
542 error
= vcc_create(sock
, protocol
, AF_ATMSVC
);
543 if (error
) return error
;
544 ATM_SD(sock
)->local
.sas_family
= AF_ATMSVC
;
545 ATM_SD(sock
)->remote
.sas_family
= AF_ATMSVC
;
550 static struct net_proto_family svc_family_ops
= {
552 .create
= svc_create
,
553 .owner
= THIS_MODULE
,
558 * Initialize the ATM SVC protocol family
561 int __init
atmsvc_init(void)
563 return sock_register(&svc_family_ops
);
566 void atmsvc_exit(void)
568 sock_unregister(PF_ATMSVC
);