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