Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
0003 
0004 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
0005 
0006 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
0007 
0008 #include <linux/module.h>
0009 #include <linux/kmod.h>
0010 #include <linux/net.h>      /* struct socket, struct proto_ops */
0011 #include <linux/atm.h>      /* ATM stuff */
0012 #include <linux/atmdev.h>
0013 #include <linux/socket.h>   /* SOL_SOCKET */
0014 #include <linux/errno.h>    /* error codes */
0015 #include <linux/capability.h>
0016 #include <linux/mm.h>
0017 #include <linux/sched/signal.h>
0018 #include <linux/time64.h>   /* 64-bit time for seconds */
0019 #include <linux/skbuff.h>
0020 #include <linux/bitops.h>
0021 #include <linux/init.h>
0022 #include <linux/slab.h>
0023 #include <net/sock.h>       /* struct sock */
0024 #include <linux/uaccess.h>
0025 #include <linux/poll.h>
0026 
0027 #include <linux/atomic.h>
0028 
0029 #include "resources.h"      /* atm_find_dev */
0030 #include "common.h"     /* prototypes */
0031 #include "protocols.h"      /* atm_init_<transport> */
0032 #include "addr.h"       /* address registry */
0033 #include "signaling.h"      /* for WAITING and sigd_attach */
0034 
0035 struct hlist_head vcc_hash[VCC_HTABLE_SIZE];
0036 EXPORT_SYMBOL(vcc_hash);
0037 
0038 DEFINE_RWLOCK(vcc_sklist_lock);
0039 EXPORT_SYMBOL(vcc_sklist_lock);
0040 
0041 static ATOMIC_NOTIFIER_HEAD(atm_dev_notify_chain);
0042 
0043 static void __vcc_insert_socket(struct sock *sk)
0044 {
0045     struct atm_vcc *vcc = atm_sk(sk);
0046     struct hlist_head *head = &vcc_hash[vcc->vci & (VCC_HTABLE_SIZE - 1)];
0047     sk->sk_hash = vcc->vci & (VCC_HTABLE_SIZE - 1);
0048     sk_add_node(sk, head);
0049 }
0050 
0051 void vcc_insert_socket(struct sock *sk)
0052 {
0053     write_lock_irq(&vcc_sklist_lock);
0054     __vcc_insert_socket(sk);
0055     write_unlock_irq(&vcc_sklist_lock);
0056 }
0057 EXPORT_SYMBOL(vcc_insert_socket);
0058 
0059 static void vcc_remove_socket(struct sock *sk)
0060 {
0061     write_lock_irq(&vcc_sklist_lock);
0062     sk_del_node_init(sk);
0063     write_unlock_irq(&vcc_sklist_lock);
0064 }
0065 
0066 static bool vcc_tx_ready(struct atm_vcc *vcc, unsigned int size)
0067 {
0068     struct sock *sk = sk_atm(vcc);
0069 
0070     if (sk_wmem_alloc_get(sk) && !atm_may_send(vcc, size)) {
0071         pr_debug("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n",
0072              sk_wmem_alloc_get(sk), size, sk->sk_sndbuf);
0073         return false;
0074     }
0075     return true;
0076 }
0077 
0078 static void vcc_sock_destruct(struct sock *sk)
0079 {
0080     if (atomic_read(&sk->sk_rmem_alloc))
0081         printk(KERN_DEBUG "%s: rmem leakage (%d bytes) detected.\n",
0082                __func__, atomic_read(&sk->sk_rmem_alloc));
0083 
0084     if (refcount_read(&sk->sk_wmem_alloc))
0085         printk(KERN_DEBUG "%s: wmem leakage (%d bytes) detected.\n",
0086                __func__, refcount_read(&sk->sk_wmem_alloc));
0087 }
0088 
0089 static void vcc_def_wakeup(struct sock *sk)
0090 {
0091     struct socket_wq *wq;
0092 
0093     rcu_read_lock();
0094     wq = rcu_dereference(sk->sk_wq);
0095     if (skwq_has_sleeper(wq))
0096         wake_up(&wq->wait);
0097     rcu_read_unlock();
0098 }
0099 
0100 static inline int vcc_writable(struct sock *sk)
0101 {
0102     struct atm_vcc *vcc = atm_sk(sk);
0103 
0104     return (vcc->qos.txtp.max_sdu +
0105         refcount_read(&sk->sk_wmem_alloc)) <= sk->sk_sndbuf;
0106 }
0107 
0108 static void vcc_write_space(struct sock *sk)
0109 {
0110     struct socket_wq *wq;
0111 
0112     rcu_read_lock();
0113 
0114     if (vcc_writable(sk)) {
0115         wq = rcu_dereference(sk->sk_wq);
0116         if (skwq_has_sleeper(wq))
0117             wake_up_interruptible(&wq->wait);
0118 
0119         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
0120     }
0121 
0122     rcu_read_unlock();
0123 }
0124 
0125 static void vcc_release_cb(struct sock *sk)
0126 {
0127     struct atm_vcc *vcc = atm_sk(sk);
0128 
0129     if (vcc->release_cb)
0130         vcc->release_cb(vcc);
0131 }
0132 
0133 static struct proto vcc_proto = {
0134     .name     = "VCC",
0135     .owner    = THIS_MODULE,
0136     .obj_size = sizeof(struct atm_vcc),
0137     .release_cb = vcc_release_cb,
0138 };
0139 
0140 int vcc_create(struct net *net, struct socket *sock, int protocol, int family, int kern)
0141 {
0142     struct sock *sk;
0143     struct atm_vcc *vcc;
0144 
0145     sock->sk = NULL;
0146     if (sock->type == SOCK_STREAM)
0147         return -EINVAL;
0148     sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto, kern);
0149     if (!sk)
0150         return -ENOMEM;
0151     sock_init_data(sock, sk);
0152     sk->sk_state_change = vcc_def_wakeup;
0153     sk->sk_write_space = vcc_write_space;
0154 
0155     vcc = atm_sk(sk);
0156     vcc->dev = NULL;
0157     memset(&vcc->local, 0, sizeof(struct sockaddr_atmsvc));
0158     memset(&vcc->remote, 0, sizeof(struct sockaddr_atmsvc));
0159     vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
0160     refcount_set(&sk->sk_wmem_alloc, 1);
0161     atomic_set(&sk->sk_rmem_alloc, 0);
0162     vcc->push = NULL;
0163     vcc->pop = NULL;
0164     vcc->owner = NULL;
0165     vcc->push_oam = NULL;
0166     vcc->release_cb = NULL;
0167     vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
0168     vcc->atm_options = vcc->aal_options = 0;
0169     sk->sk_destruct = vcc_sock_destruct;
0170     return 0;
0171 }
0172 
0173 static void vcc_destroy_socket(struct sock *sk)
0174 {
0175     struct atm_vcc *vcc = atm_sk(sk);
0176     struct sk_buff *skb;
0177 
0178     set_bit(ATM_VF_CLOSE, &vcc->flags);
0179     clear_bit(ATM_VF_READY, &vcc->flags);
0180     if (vcc->dev && vcc->dev->ops->close)
0181         vcc->dev->ops->close(vcc);
0182     if (vcc->push)
0183         vcc->push(vcc, NULL); /* atmarpd has no push */
0184     module_put(vcc->owner);
0185 
0186     while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
0187         atm_return(vcc, skb->truesize);
0188         kfree_skb(skb);
0189     }
0190 
0191     if (vcc->dev && vcc->dev->ops->owner) {
0192         module_put(vcc->dev->ops->owner);
0193         atm_dev_put(vcc->dev);
0194     }
0195 
0196     vcc_remove_socket(sk);
0197 }
0198 
0199 int vcc_release(struct socket *sock)
0200 {
0201     struct sock *sk = sock->sk;
0202 
0203     if (sk) {
0204         lock_sock(sk);
0205         vcc_destroy_socket(sock->sk);
0206         release_sock(sk);
0207         sock_put(sk);
0208     }
0209 
0210     return 0;
0211 }
0212 
0213 void vcc_release_async(struct atm_vcc *vcc, int reply)
0214 {
0215     struct sock *sk = sk_atm(vcc);
0216 
0217     set_bit(ATM_VF_CLOSE, &vcc->flags);
0218     sk->sk_shutdown |= RCV_SHUTDOWN;
0219     sk->sk_err = -reply;
0220     clear_bit(ATM_VF_WAITING, &vcc->flags);
0221     sk->sk_state_change(sk);
0222 }
0223 EXPORT_SYMBOL(vcc_release_async);
0224 
0225 void vcc_process_recv_queue(struct atm_vcc *vcc)
0226 {
0227     struct sk_buff_head queue, *rq;
0228     struct sk_buff *skb, *tmp;
0229     unsigned long flags;
0230 
0231     __skb_queue_head_init(&queue);
0232     rq = &sk_atm(vcc)->sk_receive_queue;
0233 
0234     spin_lock_irqsave(&rq->lock, flags);
0235     skb_queue_splice_init(rq, &queue);
0236     spin_unlock_irqrestore(&rq->lock, flags);
0237 
0238     skb_queue_walk_safe(&queue, skb, tmp) {
0239         __skb_unlink(skb, &queue);
0240         vcc->push(vcc, skb);
0241     }
0242 }
0243 EXPORT_SYMBOL(vcc_process_recv_queue);
0244 
0245 void atm_dev_signal_change(struct atm_dev *dev, char signal)
0246 {
0247     pr_debug("%s signal=%d dev=%p number=%d dev->signal=%d\n",
0248         __func__, signal, dev, dev->number, dev->signal);
0249 
0250     /* atm driver sending invalid signal */
0251     WARN_ON(signal < ATM_PHY_SIG_LOST || signal > ATM_PHY_SIG_FOUND);
0252 
0253     if (dev->signal == signal)
0254         return; /* no change */
0255 
0256     dev->signal = signal;
0257 
0258     atomic_notifier_call_chain(&atm_dev_notify_chain, signal, dev);
0259 }
0260 EXPORT_SYMBOL(atm_dev_signal_change);
0261 
0262 void atm_dev_release_vccs(struct atm_dev *dev)
0263 {
0264     int i;
0265 
0266     write_lock_irq(&vcc_sklist_lock);
0267     for (i = 0; i < VCC_HTABLE_SIZE; i++) {
0268         struct hlist_head *head = &vcc_hash[i];
0269         struct hlist_node *tmp;
0270         struct sock *s;
0271         struct atm_vcc *vcc;
0272 
0273         sk_for_each_safe(s, tmp, head) {
0274             vcc = atm_sk(s);
0275             if (vcc->dev == dev) {
0276                 vcc_release_async(vcc, -EPIPE);
0277                 sk_del_node_init(s);
0278             }
0279         }
0280     }
0281     write_unlock_irq(&vcc_sklist_lock);
0282 }
0283 EXPORT_SYMBOL(atm_dev_release_vccs);
0284 
0285 static int adjust_tp(struct atm_trafprm *tp, unsigned char aal)
0286 {
0287     int max_sdu;
0288 
0289     if (!tp->traffic_class)
0290         return 0;
0291     switch (aal) {
0292     case ATM_AAL0:
0293         max_sdu = ATM_CELL_SIZE-1;
0294         break;
0295     case ATM_AAL34:
0296         max_sdu = ATM_MAX_AAL34_PDU;
0297         break;
0298     default:
0299         pr_warn("AAL problems ... (%d)\n", aal);
0300         fallthrough;
0301     case ATM_AAL5:
0302         max_sdu = ATM_MAX_AAL5_PDU;
0303     }
0304     if (!tp->max_sdu)
0305         tp->max_sdu = max_sdu;
0306     else if (tp->max_sdu > max_sdu)
0307         return -EINVAL;
0308     if (!tp->max_cdv)
0309         tp->max_cdv = ATM_MAX_CDV;
0310     return 0;
0311 }
0312 
0313 static int check_ci(const struct atm_vcc *vcc, short vpi, int vci)
0314 {
0315     struct hlist_head *head = &vcc_hash[vci & (VCC_HTABLE_SIZE - 1)];
0316     struct sock *s;
0317     struct atm_vcc *walk;
0318 
0319     sk_for_each(s, head) {
0320         walk = atm_sk(s);
0321         if (walk->dev != vcc->dev)
0322             continue;
0323         if (test_bit(ATM_VF_ADDR, &walk->flags) && walk->vpi == vpi &&
0324             walk->vci == vci && ((walk->qos.txtp.traffic_class !=
0325             ATM_NONE && vcc->qos.txtp.traffic_class != ATM_NONE) ||
0326             (walk->qos.rxtp.traffic_class != ATM_NONE &&
0327             vcc->qos.rxtp.traffic_class != ATM_NONE)))
0328             return -EADDRINUSE;
0329     }
0330 
0331     /* allow VCCs with same VPI/VCI iff they don't collide on
0332        TX/RX (but we may refuse such sharing for other reasons,
0333        e.g. if protocol requires to have both channels) */
0334 
0335     return 0;
0336 }
0337 
0338 static int find_ci(const struct atm_vcc *vcc, short *vpi, int *vci)
0339 {
0340     static short p;        /* poor man's per-device cache */
0341     static int c;
0342     short old_p;
0343     int old_c;
0344     int err;
0345 
0346     if (*vpi != ATM_VPI_ANY && *vci != ATM_VCI_ANY) {
0347         err = check_ci(vcc, *vpi, *vci);
0348         return err;
0349     }
0350     /* last scan may have left values out of bounds for current device */
0351     if (*vpi != ATM_VPI_ANY)
0352         p = *vpi;
0353     else if (p >= 1 << vcc->dev->ci_range.vpi_bits)
0354         p = 0;
0355     if (*vci != ATM_VCI_ANY)
0356         c = *vci;
0357     else if (c < ATM_NOT_RSV_VCI || c >= 1 << vcc->dev->ci_range.vci_bits)
0358             c = ATM_NOT_RSV_VCI;
0359     old_p = p;
0360     old_c = c;
0361     do {
0362         if (!check_ci(vcc, p, c)) {
0363             *vpi = p;
0364             *vci = c;
0365             return 0;
0366         }
0367         if (*vci == ATM_VCI_ANY) {
0368             c++;
0369             if (c >= 1 << vcc->dev->ci_range.vci_bits)
0370                 c = ATM_NOT_RSV_VCI;
0371         }
0372         if ((c == ATM_NOT_RSV_VCI || *vci != ATM_VCI_ANY) &&
0373             *vpi == ATM_VPI_ANY) {
0374             p++;
0375             if (p >= 1 << vcc->dev->ci_range.vpi_bits)
0376                 p = 0;
0377         }
0378     } while (old_p != p || old_c != c);
0379     return -EADDRINUSE;
0380 }
0381 
0382 static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, short vpi,
0383              int vci)
0384 {
0385     struct sock *sk = sk_atm(vcc);
0386     int error;
0387 
0388     if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
0389         vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
0390         vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
0391         return -EINVAL;
0392     if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
0393         return -EPERM;
0394     error = -ENODEV;
0395     if (!try_module_get(dev->ops->owner))
0396         return error;
0397     vcc->dev = dev;
0398     write_lock_irq(&vcc_sklist_lock);
0399     if (test_bit(ATM_DF_REMOVED, &dev->flags) ||
0400         (error = find_ci(vcc, &vpi, &vci))) {
0401         write_unlock_irq(&vcc_sklist_lock);
0402         goto fail_module_put;
0403     }
0404     vcc->vpi = vpi;
0405     vcc->vci = vci;
0406     __vcc_insert_socket(sk);
0407     write_unlock_irq(&vcc_sklist_lock);
0408     switch (vcc->qos.aal) {
0409     case ATM_AAL0:
0410         error = atm_init_aal0(vcc);
0411         vcc->stats = &dev->stats.aal0;
0412         break;
0413     case ATM_AAL34:
0414         error = atm_init_aal34(vcc);
0415         vcc->stats = &dev->stats.aal34;
0416         break;
0417     case ATM_NO_AAL:
0418         /* ATM_AAL5 is also used in the "0 for default" case */
0419         vcc->qos.aal = ATM_AAL5;
0420         fallthrough;
0421     case ATM_AAL5:
0422         error = atm_init_aal5(vcc);
0423         vcc->stats = &dev->stats.aal5;
0424         break;
0425     default:
0426         error = -EPROTOTYPE;
0427     }
0428     if (!error)
0429         error = adjust_tp(&vcc->qos.txtp, vcc->qos.aal);
0430     if (!error)
0431         error = adjust_tp(&vcc->qos.rxtp, vcc->qos.aal);
0432     if (error)
0433         goto fail;
0434     pr_debug("VCC %d.%d, AAL %d\n", vpi, vci, vcc->qos.aal);
0435     pr_debug("  TX: %d, PCR %d..%d, SDU %d\n",
0436          vcc->qos.txtp.traffic_class,
0437          vcc->qos.txtp.min_pcr,
0438          vcc->qos.txtp.max_pcr,
0439          vcc->qos.txtp.max_sdu);
0440     pr_debug("  RX: %d, PCR %d..%d, SDU %d\n",
0441          vcc->qos.rxtp.traffic_class,
0442          vcc->qos.rxtp.min_pcr,
0443          vcc->qos.rxtp.max_pcr,
0444          vcc->qos.rxtp.max_sdu);
0445 
0446     if (dev->ops->open) {
0447         error = dev->ops->open(vcc);
0448         if (error)
0449             goto fail;
0450     }
0451     return 0;
0452 
0453 fail:
0454     vcc_remove_socket(sk);
0455 fail_module_put:
0456     module_put(dev->ops->owner);
0457     /* ensure we get dev module ref count correct */
0458     vcc->dev = NULL;
0459     return error;
0460 }
0461 
0462 int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
0463 {
0464     struct atm_dev *dev;
0465     struct atm_vcc *vcc = ATM_SD(sock);
0466     int error;
0467 
0468     pr_debug("(vpi %d, vci %d)\n", vpi, vci);
0469     if (sock->state == SS_CONNECTED)
0470         return -EISCONN;
0471     if (sock->state != SS_UNCONNECTED)
0472         return -EINVAL;
0473     if (!(vpi || vci))
0474         return -EINVAL;
0475 
0476     if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
0477         clear_bit(ATM_VF_PARTIAL, &vcc->flags);
0478     else
0479         if (test_bit(ATM_VF_PARTIAL, &vcc->flags))
0480             return -EINVAL;
0481     pr_debug("(TX: cl %d,bw %d-%d,sdu %d; "
0482          "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n",
0483          vcc->qos.txtp.traffic_class, vcc->qos.txtp.min_pcr,
0484          vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_sdu,
0485          vcc->qos.rxtp.traffic_class, vcc->qos.rxtp.min_pcr,
0486          vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_sdu,
0487          vcc->qos.aal == ATM_AAL5 ? "" :
0488          vcc->qos.aal == ATM_AAL0 ? "" : " ??? code ",
0489          vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
0490     if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
0491         return -EBADFD;
0492     if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
0493         vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
0494         return -EINVAL;
0495     if (likely(itf != ATM_ITF_ANY)) {
0496         dev = try_then_request_module(atm_dev_lookup(itf),
0497                           "atm-device-%d", itf);
0498     } else {
0499         dev = NULL;
0500         mutex_lock(&atm_dev_mutex);
0501         if (!list_empty(&atm_devs)) {
0502             dev = list_entry(atm_devs.next,
0503                      struct atm_dev, dev_list);
0504             atm_dev_hold(dev);
0505         }
0506         mutex_unlock(&atm_dev_mutex);
0507     }
0508     if (!dev)
0509         return -ENODEV;
0510     error = __vcc_connect(vcc, dev, vpi, vci);
0511     if (error) {
0512         atm_dev_put(dev);
0513         return error;
0514     }
0515     if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
0516         set_bit(ATM_VF_PARTIAL, &vcc->flags);
0517     if (test_bit(ATM_VF_READY, &ATM_SD(sock)->flags))
0518         sock->state = SS_CONNECTED;
0519     return 0;
0520 }
0521 
0522 int vcc_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
0523         int flags)
0524 {
0525     struct sock *sk = sock->sk;
0526     struct atm_vcc *vcc;
0527     struct sk_buff *skb;
0528     int copied, error = -EINVAL;
0529 
0530     if (sock->state != SS_CONNECTED)
0531         return -ENOTCONN;
0532 
0533     /* only handle MSG_DONTWAIT and MSG_PEEK */
0534     if (flags & ~(MSG_DONTWAIT | MSG_PEEK))
0535         return -EOPNOTSUPP;
0536 
0537     vcc = ATM_SD(sock);
0538     if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
0539         test_bit(ATM_VF_CLOSE, &vcc->flags) ||
0540         !test_bit(ATM_VF_READY, &vcc->flags))
0541         return 0;
0542 
0543     skb = skb_recv_datagram(sk, flags, &error);
0544     if (!skb)
0545         return error;
0546 
0547     copied = skb->len;
0548     if (copied > size) {
0549         copied = size;
0550         msg->msg_flags |= MSG_TRUNC;
0551     }
0552 
0553     error = skb_copy_datagram_msg(skb, 0, msg, copied);
0554     if (error)
0555         return error;
0556     sock_recv_cmsgs(msg, sk, skb);
0557 
0558     if (!(flags & MSG_PEEK)) {
0559         pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc),
0560              skb->truesize);
0561         atm_return(vcc, skb->truesize);
0562     }
0563 
0564     skb_free_datagram(sk, skb);
0565     return copied;
0566 }
0567 
0568 int vcc_sendmsg(struct socket *sock, struct msghdr *m, size_t size)
0569 {
0570     struct sock *sk = sock->sk;
0571     DEFINE_WAIT(wait);
0572     struct atm_vcc *vcc;
0573     struct sk_buff *skb;
0574     int eff, error;
0575 
0576     lock_sock(sk);
0577     if (sock->state != SS_CONNECTED) {
0578         error = -ENOTCONN;
0579         goto out;
0580     }
0581     if (m->msg_name) {
0582         error = -EISCONN;
0583         goto out;
0584     }
0585     vcc = ATM_SD(sock);
0586     if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
0587         test_bit(ATM_VF_CLOSE, &vcc->flags) ||
0588         !test_bit(ATM_VF_READY, &vcc->flags)) {
0589         error = -EPIPE;
0590         send_sig(SIGPIPE, current, 0);
0591         goto out;
0592     }
0593     if (!size) {
0594         error = 0;
0595         goto out;
0596     }
0597     if (size > vcc->qos.txtp.max_sdu) {
0598         error = -EMSGSIZE;
0599         goto out;
0600     }
0601 
0602     eff = (size+3) & ~3; /* align to word boundary */
0603     prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0604     error = 0;
0605     while (!vcc_tx_ready(vcc, eff)) {
0606         if (m->msg_flags & MSG_DONTWAIT) {
0607             error = -EAGAIN;
0608             break;
0609         }
0610         schedule();
0611         if (signal_pending(current)) {
0612             error = -ERESTARTSYS;
0613             break;
0614         }
0615         if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
0616             test_bit(ATM_VF_CLOSE, &vcc->flags) ||
0617             !test_bit(ATM_VF_READY, &vcc->flags)) {
0618             error = -EPIPE;
0619             send_sig(SIGPIPE, current, 0);
0620             break;
0621         }
0622         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0623     }
0624     finish_wait(sk_sleep(sk), &wait);
0625     if (error)
0626         goto out;
0627 
0628     skb = alloc_skb(eff, GFP_KERNEL);
0629     if (!skb) {
0630         error = -ENOMEM;
0631         goto out;
0632     }
0633     pr_debug("%d += %d\n", sk_wmem_alloc_get(sk), skb->truesize);
0634     atm_account_tx(vcc, skb);
0635 
0636     skb->dev = NULL; /* for paths shared with net_device interfaces */
0637     if (!copy_from_iter_full(skb_put(skb, size), size, &m->msg_iter)) {
0638         kfree_skb(skb);
0639         error = -EFAULT;
0640         goto out;
0641     }
0642     if (eff != size)
0643         memset(skb->data + size, 0, eff-size);
0644     error = vcc->dev->ops->send(vcc, skb);
0645     error = error ? error : size;
0646 out:
0647     release_sock(sk);
0648     return error;
0649 }
0650 
0651 __poll_t vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
0652 {
0653     struct sock *sk = sock->sk;
0654     struct atm_vcc *vcc;
0655     __poll_t mask;
0656 
0657     sock_poll_wait(file, sock, wait);
0658     mask = 0;
0659 
0660     vcc = ATM_SD(sock);
0661 
0662     /* exceptional events */
0663     if (sk->sk_err)
0664         mask = EPOLLERR;
0665 
0666     if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
0667         test_bit(ATM_VF_CLOSE, &vcc->flags))
0668         mask |= EPOLLHUP;
0669 
0670     /* readable? */
0671     if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
0672         mask |= EPOLLIN | EPOLLRDNORM;
0673 
0674     /* writable? */
0675     if (sock->state == SS_CONNECTING &&
0676         test_bit(ATM_VF_WAITING, &vcc->flags))
0677         return mask;
0678 
0679     if (vcc->qos.txtp.traffic_class != ATM_NONE &&
0680         vcc_writable(sk))
0681         mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
0682 
0683     return mask;
0684 }
0685 
0686 static int atm_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
0687 {
0688     int error;
0689 
0690     /*
0691      * Don't let the QoS change the already connected AAL type nor the
0692      * traffic class.
0693      */
0694     if (qos->aal != vcc->qos.aal ||
0695         qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
0696         qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
0697         return -EINVAL;
0698     error = adjust_tp(&qos->txtp, qos->aal);
0699     if (!error)
0700         error = adjust_tp(&qos->rxtp, qos->aal);
0701     if (error)
0702         return error;
0703     if (!vcc->dev->ops->change_qos)
0704         return -EOPNOTSUPP;
0705     if (sk_atm(vcc)->sk_family == AF_ATMPVC)
0706         return vcc->dev->ops->change_qos(vcc, qos, ATM_MF_SET);
0707     return svc_change_qos(vcc, qos);
0708 }
0709 
0710 static int check_tp(const struct atm_trafprm *tp)
0711 {
0712     /* @@@ Should be merged with adjust_tp */
0713     if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS)
0714         return 0;
0715     if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
0716         !tp->max_pcr)
0717         return -EINVAL;
0718     if (tp->min_pcr == ATM_MAX_PCR)
0719         return -EINVAL;
0720     if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
0721         tp->min_pcr > tp->max_pcr)
0722         return -EINVAL;
0723     /*
0724      * We allow pcr to be outside [min_pcr,max_pcr], because later
0725      * adjustment may still push it in the valid range.
0726      */
0727     return 0;
0728 }
0729 
0730 static int check_qos(const struct atm_qos *qos)
0731 {
0732     int error;
0733 
0734     if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
0735         return -EINVAL;
0736     if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
0737         qos->txtp.traffic_class && qos->rxtp.traffic_class &&
0738         qos->txtp.traffic_class != ATM_ANYCLASS &&
0739         qos->rxtp.traffic_class != ATM_ANYCLASS)
0740         return -EINVAL;
0741     error = check_tp(&qos->txtp);
0742     if (error)
0743         return error;
0744     return check_tp(&qos->rxtp);
0745 }
0746 
0747 int vcc_setsockopt(struct socket *sock, int level, int optname,
0748            sockptr_t optval, unsigned int optlen)
0749 {
0750     struct atm_vcc *vcc;
0751     unsigned long value;
0752     int error;
0753 
0754     if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
0755         return -EINVAL;
0756 
0757     vcc = ATM_SD(sock);
0758     switch (optname) {
0759     case SO_ATMQOS:
0760     {
0761         struct atm_qos qos;
0762 
0763         if (copy_from_sockptr(&qos, optval, sizeof(qos)))
0764             return -EFAULT;
0765         error = check_qos(&qos);
0766         if (error)
0767             return error;
0768         if (sock->state == SS_CONNECTED)
0769             return atm_change_qos(vcc, &qos);
0770         if (sock->state != SS_UNCONNECTED)
0771             return -EBADFD;
0772         vcc->qos = qos;
0773         set_bit(ATM_VF_HASQOS, &vcc->flags);
0774         return 0;
0775     }
0776     case SO_SETCLP:
0777         if (copy_from_sockptr(&value, optval, sizeof(value)))
0778             return -EFAULT;
0779         if (value)
0780             vcc->atm_options |= ATM_ATMOPT_CLP;
0781         else
0782             vcc->atm_options &= ~ATM_ATMOPT_CLP;
0783         return 0;
0784     default:
0785         return -EINVAL;
0786     }
0787 }
0788 
0789 int vcc_getsockopt(struct socket *sock, int level, int optname,
0790            char __user *optval, int __user *optlen)
0791 {
0792     struct atm_vcc *vcc;
0793     int len;
0794 
0795     if (get_user(len, optlen))
0796         return -EFAULT;
0797     if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
0798         return -EINVAL;
0799 
0800     vcc = ATM_SD(sock);
0801     switch (optname) {
0802     case SO_ATMQOS:
0803         if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
0804             return -EINVAL;
0805         return copy_to_user(optval, &vcc->qos, sizeof(vcc->qos))
0806             ? -EFAULT : 0;
0807     case SO_SETCLP:
0808         return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 : 0,
0809                 (unsigned long __user *)optval) ? -EFAULT : 0;
0810     case SO_ATMPVC:
0811     {
0812         struct sockaddr_atmpvc pvc;
0813 
0814         if (!vcc->dev || !test_bit(ATM_VF_ADDR, &vcc->flags))
0815             return -ENOTCONN;
0816         memset(&pvc, 0, sizeof(pvc));
0817         pvc.sap_family = AF_ATMPVC;
0818         pvc.sap_addr.itf = vcc->dev->number;
0819         pvc.sap_addr.vpi = vcc->vpi;
0820         pvc.sap_addr.vci = vcc->vci;
0821         return copy_to_user(optval, &pvc, sizeof(pvc)) ? -EFAULT : 0;
0822     }
0823     default:
0824         return -EINVAL;
0825     }
0826 }
0827 
0828 int register_atmdevice_notifier(struct notifier_block *nb)
0829 {
0830     return atomic_notifier_chain_register(&atm_dev_notify_chain, nb);
0831 }
0832 EXPORT_SYMBOL_GPL(register_atmdevice_notifier);
0833 
0834 void unregister_atmdevice_notifier(struct notifier_block *nb)
0835 {
0836     atomic_notifier_chain_unregister(&atm_dev_notify_chain, nb);
0837 }
0838 EXPORT_SYMBOL_GPL(unregister_atmdevice_notifier);
0839 
0840 static int __init atm_init(void)
0841 {
0842     int error;
0843 
0844     error = proto_register(&vcc_proto, 0);
0845     if (error < 0)
0846         goto out;
0847     error = atmpvc_init();
0848     if (error < 0) {
0849         pr_err("atmpvc_init() failed with %d\n", error);
0850         goto out_unregister_vcc_proto;
0851     }
0852     error = atmsvc_init();
0853     if (error < 0) {
0854         pr_err("atmsvc_init() failed with %d\n", error);
0855         goto out_atmpvc_exit;
0856     }
0857     error = atm_proc_init();
0858     if (error < 0) {
0859         pr_err("atm_proc_init() failed with %d\n", error);
0860         goto out_atmsvc_exit;
0861     }
0862     error = atm_sysfs_init();
0863     if (error < 0) {
0864         pr_err("atm_sysfs_init() failed with %d\n", error);
0865         goto out_atmproc_exit;
0866     }
0867 out:
0868     return error;
0869 out_atmproc_exit:
0870     atm_proc_exit();
0871 out_atmsvc_exit:
0872     atmsvc_exit();
0873 out_atmpvc_exit:
0874     atmsvc_exit();
0875 out_unregister_vcc_proto:
0876     proto_unregister(&vcc_proto);
0877     goto out;
0878 }
0879 
0880 static void __exit atm_exit(void)
0881 {
0882     atm_proc_exit();
0883     atm_sysfs_exit();
0884     atmsvc_exit();
0885     atmpvc_exit();
0886     proto_unregister(&vcc_proto);
0887 }
0888 
0889 subsys_initcall(atm_init);
0890 
0891 module_exit(atm_exit);
0892 
0893 MODULE_LICENSE("GPL");
0894 MODULE_ALIAS_NETPROTO(PF_ATMPVC);
0895 MODULE_ALIAS_NETPROTO(PF_ATMSVC);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!