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