Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
svc.c
Go to the documentation of this file.
1 /* net/atm/svc.c - ATM SVC sockets */
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/string.h>
8 #include <linux/net.h> /* struct socket, struct proto_ops */
9 #include <linux/errno.h> /* error codes */
10 #include <linux/kernel.h> /* printk */
11 #include <linux/skbuff.h>
12 #include <linux/wait.h>
13 #include <linux/sched.h> /* jiffies and HZ */
14 #include <linux/fcntl.h> /* O_NONBLOCK */
15 #include <linux/init.h>
16 #include <linux/atm.h> /* ATM stuff */
17 #include <linux/atmsap.h>
18 #include <linux/atmsvc.h>
19 #include <linux/atmdev.h>
20 #include <linux/bitops.h>
21 #include <net/sock.h> /* for sock_no_* */
22 #include <linux/uaccess.h>
23 #include <linux/export.h>
24 
25 #include "resources.h"
26 #include "common.h" /* common for PVCs and SVCs */
27 #include "signaling.h"
28 #include "addr.h"
29 
30 static int svc_create(struct net *net, struct socket *sock, int protocol,
31  int kern);
32 
33 /*
34  * Note: since all this is still nicely synchronized with the signaling demon,
35  * there's no need to protect sleep loops with clis. If signaling is
36  * moved into the kernel, that would change.
37  */
38 
39 
40 static int svc_shutdown(struct socket *sock, int how)
41 {
42  return 0;
43 }
44 
45 static void svc_disconnect(struct atm_vcc *vcc)
46 {
47  DEFINE_WAIT(wait);
48  struct sk_buff *skb;
49  struct sock *sk = sk_atm(vcc);
50 
51  pr_debug("%p\n", vcc);
52  if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
53  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
54  sigd_enq(vcc, as_close, NULL, NULL, NULL);
55  while (!test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) {
56  schedule();
57  prepare_to_wait(sk_sleep(sk), &wait,
58  TASK_UNINTERRUPTIBLE);
59  }
60  finish_wait(sk_sleep(sk), &wait);
61  }
62  /* beware - socket is still in use by atmsigd until the last
63  as_indicate has been answered */
64  while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
65  atm_return(vcc, skb->truesize);
66  pr_debug("LISTEN REL\n");
67  sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0);
68  dev_kfree_skb(skb);
69  }
70  clear_bit(ATM_VF_REGIS, &vcc->flags);
71  /* ... may retry later */
72 }
73 
74 static int svc_release(struct socket *sock)
75 {
76  struct sock *sk = sock->sk;
77  struct atm_vcc *vcc;
78 
79  if (sk) {
80  vcc = ATM_SD(sock);
81  pr_debug("%p\n", vcc);
82  clear_bit(ATM_VF_READY, &vcc->flags);
83  /*
84  * VCC pointer is used as a reference,
85  * so we must not free it (thereby subjecting it to re-use)
86  * before all pending connections are closed
87  */
88  svc_disconnect(vcc);
89  vcc_release(sock);
90  }
91  return 0;
92 }
93 
94 static int svc_bind(struct socket *sock, struct sockaddr *sockaddr,
95  int sockaddr_len)
96 {
97  DEFINE_WAIT(wait);
98  struct sock *sk = sock->sk;
99  struct sockaddr_atmsvc *addr;
100  struct atm_vcc *vcc;
101  int error;
102 
103  if (sockaddr_len != sizeof(struct sockaddr_atmsvc))
104  return -EINVAL;
105  lock_sock(sk);
106  if (sock->state == SS_CONNECTED) {
107  error = -EISCONN;
108  goto out;
109  }
110  if (sock->state != SS_UNCONNECTED) {
111  error = -EINVAL;
112  goto out;
113  }
114  vcc = ATM_SD(sock);
115  addr = (struct sockaddr_atmsvc *) sockaddr;
116  if (addr->sas_family != AF_ATMSVC) {
117  error = -EAFNOSUPPORT;
118  goto out;
119  }
120  clear_bit(ATM_VF_BOUND, &vcc->flags);
121  /* failing rebind will kill old binding */
122  /* @@@ check memory (de)allocation on rebind */
123  if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
124  error = -EBADFD;
125  goto out;
126  }
127  vcc->local = *addr;
128  set_bit(ATM_VF_WAITING, &vcc->flags);
129  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
130  sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local);
131  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
132  schedule();
133  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
134  }
135  finish_wait(sk_sleep(sk), &wait);
136  clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */
137  if (!sigd) {
138  error = -EUNATCH;
139  goto out;
140  }
141  if (!sk->sk_err)
142  set_bit(ATM_VF_BOUND, &vcc->flags);
143  error = -sk->sk_err;
144 out:
145  release_sock(sk);
146  return error;
147 }
148 
149 static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
150  int sockaddr_len, int flags)
151 {
152  DEFINE_WAIT(wait);
153  struct sock *sk = sock->sk;
154  struct sockaddr_atmsvc *addr;
155  struct atm_vcc *vcc = ATM_SD(sock);
156  int error;
157 
158  pr_debug("%p\n", vcc);
159  lock_sock(sk);
160  if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) {
161  error = -EINVAL;
162  goto out;
163  }
164 
165  switch (sock->state) {
166  default:
167  error = -EINVAL;
168  goto out;
169  case SS_CONNECTED:
170  error = -EISCONN;
171  goto out;
172  case SS_CONNECTING:
173  if (test_bit(ATM_VF_WAITING, &vcc->flags)) {
174  error = -EALREADY;
175  goto out;
176  }
177  sock->state = SS_UNCONNECTED;
178  if (sk->sk_err) {
179  error = -sk->sk_err;
180  goto out;
181  }
182  break;
183  case SS_UNCONNECTED:
184  addr = (struct sockaddr_atmsvc *) sockaddr;
185  if (addr->sas_family != AF_ATMSVC) {
186  error = -EAFNOSUPPORT;
187  goto out;
188  }
189  if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
190  error = -EBADFD;
191  goto out;
192  }
193  if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
194  vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) {
195  error = -EINVAL;
196  goto out;
197  }
198  if (!vcc->qos.txtp.traffic_class &&
199  !vcc->qos.rxtp.traffic_class) {
200  error = -EINVAL;
201  goto out;
202  }
203  vcc->remote = *addr;
204  set_bit(ATM_VF_WAITING, &vcc->flags);
205  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
206  sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote);
207  if (flags & O_NONBLOCK) {
208  finish_wait(sk_sleep(sk), &wait);
209  sock->state = SS_CONNECTING;
210  error = -EINPROGRESS;
211  goto out;
212  }
213  error = 0;
214  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
215  schedule();
216  if (!signal_pending(current)) {
217  prepare_to_wait(sk_sleep(sk), &wait,
218  TASK_INTERRUPTIBLE);
219  continue;
220  }
221  pr_debug("*ABORT*\n");
222  /*
223  * This is tricky:
224  * Kernel ---close--> Demon
225  * Kernel <--close--- Demon
226  * or
227  * Kernel ---close--> Demon
228  * Kernel <--error--- Demon
229  * or
230  * Kernel ---close--> Demon
231  * Kernel <--okay---- Demon
232  * Kernel <--close--- Demon
233  */
234  sigd_enq(vcc, as_close, NULL, NULL, NULL);
235  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
236  prepare_to_wait(sk_sleep(sk), &wait,
237  TASK_INTERRUPTIBLE);
238  schedule();
239  }
240  if (!sk->sk_err)
241  while (!test_bit(ATM_VF_RELEASED, &vcc->flags) &&
242  sigd) {
243  prepare_to_wait(sk_sleep(sk), &wait,
244  TASK_INTERRUPTIBLE);
245  schedule();
246  }
247  clear_bit(ATM_VF_REGIS, &vcc->flags);
248  clear_bit(ATM_VF_RELEASED, &vcc->flags);
249  clear_bit(ATM_VF_CLOSE, &vcc->flags);
250  /* we're gone now but may connect later */
251  error = -EINTR;
252  break;
253  }
254  finish_wait(sk_sleep(sk), &wait);
255  if (error)
256  goto out;
257  if (!sigd) {
258  error = -EUNATCH;
259  goto out;
260  }
261  if (sk->sk_err) {
262  error = -sk->sk_err;
263  goto out;
264  }
265  }
266 /*
267  * Not supported yet
268  *
269  * #ifndef CONFIG_SINGLE_SIGITF
270  */
271  vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp);
272  vcc->qos.txtp.pcr = 0;
273  vcc->qos.txtp.min_pcr = 0;
274 /*
275  * #endif
276  */
277  error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci);
278  if (!error)
279  sock->state = SS_CONNECTED;
280  else
281  (void)svc_disconnect(vcc);
282 out:
283  release_sock(sk);
284  return error;
285 }
286 
287 static int svc_listen(struct socket *sock, int backlog)
288 {
289  DEFINE_WAIT(wait);
290  struct sock *sk = sock->sk;
291  struct atm_vcc *vcc = ATM_SD(sock);
292  int error;
293 
294  pr_debug("%p\n", vcc);
295  lock_sock(sk);
296  /* let server handle listen on unbound sockets */
297  if (test_bit(ATM_VF_SESSION, &vcc->flags)) {
298  error = -EINVAL;
299  goto out;
300  }
301  if (test_bit(ATM_VF_LISTEN, &vcc->flags)) {
302  error = -EADDRINUSE;
303  goto out;
304  }
305  set_bit(ATM_VF_WAITING, &vcc->flags);
306  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
307  sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local);
308  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
309  schedule();
310  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
311  }
312  finish_wait(sk_sleep(sk), &wait);
313  if (!sigd) {
314  error = -EUNATCH;
315  goto out;
316  }
317  set_bit(ATM_VF_LISTEN, &vcc->flags);
318  vcc_insert_socket(sk);
319  sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
320  error = -sk->sk_err;
321 out:
322  release_sock(sk);
323  return error;
324 }
325 
326 static int svc_accept(struct socket *sock, struct socket *newsock, int flags)
327 {
328  struct sock *sk = sock->sk;
329  struct sk_buff *skb;
330  struct atmsvc_msg *msg;
331  struct atm_vcc *old_vcc = ATM_SD(sock);
332  struct atm_vcc *new_vcc;
333  int error;
334 
335  lock_sock(sk);
336 
337  error = svc_create(sock_net(sk), newsock, 0, 0);
338  if (error)
339  goto out;
340 
341  new_vcc = ATM_SD(newsock);
342 
343  pr_debug("%p -> %p\n", old_vcc, new_vcc);
344  while (1) {
345  DEFINE_WAIT(wait);
346 
347  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
348  while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
349  sigd) {
350  if (test_bit(ATM_VF_RELEASED, &old_vcc->flags))
351  break;
352  if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) {
353  error = -sk->sk_err;
354  break;
355  }
356  if (flags & O_NONBLOCK) {
357  error = -EAGAIN;
358  break;
359  }
360  release_sock(sk);
361  schedule();
362  lock_sock(sk);
363  if (signal_pending(current)) {
364  error = -ERESTARTSYS;
365  break;
366  }
367  prepare_to_wait(sk_sleep(sk), &wait,
368  TASK_INTERRUPTIBLE);
369  }
370  finish_wait(sk_sleep(sk), &wait);
371  if (error)
372  goto out;
373  if (!skb) {
374  error = -EUNATCH;
375  goto out;
376  }
377  msg = (struct atmsvc_msg *)skb->data;
378  new_vcc->qos = msg->qos;
379  set_bit(ATM_VF_HASQOS, &new_vcc->flags);
380  new_vcc->remote = msg->svc;
381  new_vcc->local = msg->local;
382  new_vcc->sap = msg->sap;
383  error = vcc_connect(newsock, msg->pvc.sap_addr.itf,
384  msg->pvc.sap_addr.vpi,
385  msg->pvc.sap_addr.vci);
386  dev_kfree_skb(skb);
387  sk->sk_ack_backlog--;
388  if (error) {
389  sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL,
390  &old_vcc->qos, error);
391  error = error == -EAGAIN ? -EBUSY : error;
392  goto out;
393  }
394  /* wait should be short, so we ignore the non-blocking flag */
395  set_bit(ATM_VF_WAITING, &new_vcc->flags);
396  prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
397  TASK_UNINTERRUPTIBLE);
398  sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL);
399  while (test_bit(ATM_VF_WAITING, &new_vcc->flags) && sigd) {
400  release_sock(sk);
401  schedule();
402  lock_sock(sk);
403  prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
404  TASK_UNINTERRUPTIBLE);
405  }
406  finish_wait(sk_sleep(sk_atm(new_vcc)), &wait);
407  if (!sigd) {
408  error = -EUNATCH;
409  goto out;
410  }
411  if (!sk_atm(new_vcc)->sk_err)
412  break;
413  if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {
414  error = -sk_atm(new_vcc)->sk_err;
415  goto out;
416  }
417  }
418  newsock->state = SS_CONNECTED;
419 out:
420  release_sock(sk);
421  return error;
422 }
423 
424 static int svc_getname(struct socket *sock, struct sockaddr *sockaddr,
425  int *sockaddr_len, int peer)
426 {
427  struct sockaddr_atmsvc *addr;
428 
429  *sockaddr_len = sizeof(struct sockaddr_atmsvc);
430  addr = (struct sockaddr_atmsvc *) sockaddr;
431  memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local,
432  sizeof(struct sockaddr_atmsvc));
433  return 0;
434 }
435 
436 int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
437 {
438  struct sock *sk = sk_atm(vcc);
439  DEFINE_WAIT(wait);
440 
441  set_bit(ATM_VF_WAITING, &vcc->flags);
442  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
443  sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0);
444  while (test_bit(ATM_VF_WAITING, &vcc->flags) &&
445  !test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) {
446  schedule();
447  prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
448  }
449  finish_wait(sk_sleep(sk), &wait);
450  if (!sigd)
451  return -EUNATCH;
452  return -sk->sk_err;
453 }
454 
455 static int svc_setsockopt(struct socket *sock, int level, int optname,
456  char __user *optval, unsigned int optlen)
457 {
458  struct sock *sk = sock->sk;
459  struct atm_vcc *vcc = ATM_SD(sock);
460  int value, error = 0;
461 
462  lock_sock(sk);
463  switch (optname) {
464  case SO_ATMSAP:
465  if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) {
466  error = -EINVAL;
467  goto out;
468  }
469  if (copy_from_user(&vcc->sap, optval, optlen)) {
470  error = -EFAULT;
471  goto out;
472  }
473  set_bit(ATM_VF_HASSAP, &vcc->flags);
474  break;
475  case SO_MULTIPOINT:
476  if (level != SOL_ATM || optlen != sizeof(int)) {
477  error = -EINVAL;
478  goto out;
479  }
480  if (get_user(value, (int __user *)optval)) {
481  error = -EFAULT;
482  goto out;
483  }
484  if (value == 1)
485  set_bit(ATM_VF_SESSION, &vcc->flags);
486  else if (value == 0)
487  clear_bit(ATM_VF_SESSION, &vcc->flags);
488  else
489  error = -EINVAL;
490  break;
491  default:
492  error = vcc_setsockopt(sock, level, optname, optval, optlen);
493  }
494 
495 out:
496  release_sock(sk);
497  return error;
498 }
499 
500 static int svc_getsockopt(struct socket *sock, int level, int optname,
501  char __user *optval, int __user *optlen)
502 {
503  struct sock *sk = sock->sk;
504  int error = 0, len;
505 
506  lock_sock(sk);
507  if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) {
508  error = vcc_getsockopt(sock, level, optname, optval, optlen);
509  goto out;
510  }
511  if (get_user(len, optlen)) {
512  error = -EFAULT;
513  goto out;
514  }
515  if (len != sizeof(struct atm_sap)) {
516  error = -EINVAL;
517  goto out;
518  }
519  if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) {
520  error = -EFAULT;
521  goto out;
522  }
523 out:
524  release_sock(sk);
525  return error;
526 }
527 
528 static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr,
529  int sockaddr_len, int flags)
530 {
531  DEFINE_WAIT(wait);
532  struct sock *sk = sock->sk;
533  struct atm_vcc *vcc = ATM_SD(sock);
534  int error;
535 
536  lock_sock(sk);
537  set_bit(ATM_VF_WAITING, &vcc->flags);
538  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
539  sigd_enq(vcc, as_addparty, NULL, NULL,
540  (struct sockaddr_atmsvc *) sockaddr);
541  if (flags & O_NONBLOCK) {
542  finish_wait(sk_sleep(sk), &wait);
543  error = -EINPROGRESS;
544  goto out;
545  }
546  pr_debug("added wait queue\n");
547  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
548  schedule();
549  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
550  }
551  finish_wait(sk_sleep(sk), &wait);
552  error = xchg(&sk->sk_err_soft, 0);
553 out:
554  release_sock(sk);
555  return error;
556 }
557 
558 static int svc_dropparty(struct socket *sock, int ep_ref)
559 {
560  DEFINE_WAIT(wait);
561  struct sock *sk = sock->sk;
562  struct atm_vcc *vcc = ATM_SD(sock);
563  int error;
564 
565  lock_sock(sk);
566  set_bit(ATM_VF_WAITING, &vcc->flags);
567  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
568  sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
569  while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
570  schedule();
571  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
572  }
573  finish_wait(sk_sleep(sk), &wait);
574  if (!sigd) {
575  error = -EUNATCH;
576  goto out;
577  }
578  error = xchg(&sk->sk_err_soft, 0);
579 out:
580  release_sock(sk);
581  return error;
582 }
583 
584 static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
585 {
586  int error, ep_ref;
587  struct sockaddr_atmsvc sa;
588  struct atm_vcc *vcc = ATM_SD(sock);
589 
590  switch (cmd) {
591  case ATM_ADDPARTY:
592  if (!test_bit(ATM_VF_SESSION, &vcc->flags))
593  return -EINVAL;
594  if (copy_from_user(&sa, (void __user *) arg, sizeof(sa)))
595  return -EFAULT;
596  error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa),
597  0);
598  break;
599  case ATM_DROPPARTY:
600  if (!test_bit(ATM_VF_SESSION, &vcc->flags))
601  return -EINVAL;
602  if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int)))
603  return -EFAULT;
604  error = svc_dropparty(sock, ep_ref);
605  break;
606  default:
607  error = vcc_ioctl(sock, cmd, arg);
608  }
609 
610  return error;
611 }
612 
613 #ifdef CONFIG_COMPAT
614 static int svc_compat_ioctl(struct socket *sock, unsigned int cmd,
615  unsigned long arg)
616 {
617  /* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf.
618  But actually it takes a struct sockaddr_atmsvc, which doesn't need
619  compat handling. So all we have to do is fix up cmd... */
620  if (cmd == COMPAT_ATM_ADDPARTY)
621  cmd = ATM_ADDPARTY;
622 
623  if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY)
624  return svc_ioctl(sock, cmd, arg);
625  else
626  return vcc_compat_ioctl(sock, cmd, arg);
627 }
628 #endif /* CONFIG_COMPAT */
629 
630 static const struct proto_ops svc_proto_ops = {
631  .family = PF_ATMSVC,
632  .owner = THIS_MODULE,
633 
634  .release = svc_release,
635  .bind = svc_bind,
636  .connect = svc_connect,
637  .socketpair = sock_no_socketpair,
638  .accept = svc_accept,
639  .getname = svc_getname,
640  .poll = vcc_poll,
641  .ioctl = svc_ioctl,
642 #ifdef CONFIG_COMPAT
643  .compat_ioctl = svc_compat_ioctl,
644 #endif
645  .listen = svc_listen,
646  .shutdown = svc_shutdown,
647  .setsockopt = svc_setsockopt,
648  .getsockopt = svc_getsockopt,
649  .sendmsg = vcc_sendmsg,
650  .recvmsg = vcc_recvmsg,
651  .mmap = sock_no_mmap,
652  .sendpage = sock_no_sendpage,
653 };
654 
655 
656 static int svc_create(struct net *net, struct socket *sock, int protocol,
657  int kern)
658 {
659  int error;
660 
661  if (!net_eq(net, &init_net))
662  return -EAFNOSUPPORT;
663 
664  sock->ops = &svc_proto_ops;
665  error = vcc_create(net, sock, protocol, AF_ATMSVC);
666  if (error)
667  return error;
668  ATM_SD(sock)->local.sas_family = AF_ATMSVC;
669  ATM_SD(sock)->remote.sas_family = AF_ATMSVC;
670  return 0;
671 }
672 
673 static const struct net_proto_family svc_family_ops = {
674  .family = PF_ATMSVC,
675  .create = svc_create,
676  .owner = THIS_MODULE,
677 };
678 
679 
680 /*
681  * Initialize the ATM SVC protocol family
682  */
683 
684 int __init atmsvc_init(void)
685 {
686  return sock_register(&svc_family_ops);
687 }
688 
689 void atmsvc_exit(void)
690 {
691  sock_unregister(PF_ATMSVC);
692 }
Generated on Thu Jan 10 2013 14:47:59 for Linux Kernel by   doxygen 1.8.2