net/atm/common.c

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