Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* drivers/atm/atmtcp.c - ATM over TCP "device" driver */
0003 
0004 /* Written 1997-2000 by Werner Almesberger, EPFL LRC/ICA */
0005 
0006 
0007 #include <linux/module.h>
0008 #include <linux/wait.h>
0009 #include <linux/atmdev.h>
0010 #include <linux/atm_tcp.h>
0011 #include <linux/bitops.h>
0012 #include <linux/init.h>
0013 #include <linux/slab.h>
0014 #include <linux/uaccess.h>
0015 #include <linux/atomic.h>
0016 
0017 
0018 extern int atm_init_aal5(struct atm_vcc *vcc); /* "raw" AAL5 transport */
0019 
0020 
0021 #define PRIV(dev) ((struct atmtcp_dev_data *) ((dev)->dev_data))
0022 
0023 
0024 struct atmtcp_dev_data {
0025     struct atm_vcc *vcc;    /* control VCC; NULL if detached */
0026     int persist;        /* non-zero if persistent */
0027 };
0028 
0029 
0030 #define DEV_LABEL    "atmtcp"
0031 
0032 #define MAX_VPI_BITS  8 /* simplifies life */
0033 #define MAX_VCI_BITS 16
0034 
0035 
0036 /*
0037  * Hairy code ahead: the control VCC may be closed while we're still
0038  * waiting for an answer, so we need to re-validate out_vcc every once
0039  * in a while.
0040  */
0041 
0042 
0043 static int atmtcp_send_control(struct atm_vcc *vcc,int type,
0044     const struct atmtcp_control *msg,int flag)
0045 {
0046     DECLARE_WAITQUEUE(wait,current);
0047     struct atm_vcc *out_vcc;
0048     struct sk_buff *skb;
0049     struct atmtcp_control *new_msg;
0050     int old_test;
0051     int error = 0;
0052 
0053     out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
0054     if (!out_vcc) return -EUNATCH;
0055     skb = alloc_skb(sizeof(*msg),GFP_KERNEL);
0056     if (!skb) return -ENOMEM;
0057     mb();
0058     out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
0059     if (!out_vcc) {
0060         dev_kfree_skb(skb);
0061         return -EUNATCH;
0062     }
0063     atm_force_charge(out_vcc,skb->truesize);
0064     new_msg = skb_put(skb, sizeof(*new_msg));
0065     *new_msg = *msg;
0066     new_msg->hdr.length = ATMTCP_HDR_MAGIC;
0067     new_msg->type = type;
0068     memset(&new_msg->vcc,0,sizeof(atm_kptr_t));
0069     *(struct atm_vcc **) &new_msg->vcc = vcc;
0070     old_test = test_bit(flag,&vcc->flags);
0071     out_vcc->push(out_vcc,skb);
0072     add_wait_queue(sk_sleep(sk_atm(vcc)), &wait);
0073     while (test_bit(flag,&vcc->flags) == old_test) {
0074         mb();
0075         out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
0076         if (!out_vcc) {
0077             error = -EUNATCH;
0078             break;
0079         }
0080         set_current_state(TASK_UNINTERRUPTIBLE);
0081         schedule();
0082     }
0083     set_current_state(TASK_RUNNING);
0084     remove_wait_queue(sk_sleep(sk_atm(vcc)), &wait);
0085     return error;
0086 }
0087 
0088 
0089 static int atmtcp_recv_control(const struct atmtcp_control *msg)
0090 {
0091     struct atm_vcc *vcc = *(struct atm_vcc **) &msg->vcc;
0092 
0093     vcc->vpi = msg->addr.sap_addr.vpi;
0094     vcc->vci = msg->addr.sap_addr.vci;
0095     vcc->qos = msg->qos;
0096     sk_atm(vcc)->sk_err = -msg->result;
0097     switch (msg->type) {
0098         case ATMTCP_CTRL_OPEN:
0099         change_bit(ATM_VF_READY,&vcc->flags);
0100         break;
0101         case ATMTCP_CTRL_CLOSE:
0102         change_bit(ATM_VF_ADDR,&vcc->flags);
0103         break;
0104         default:
0105         printk(KERN_ERR "atmtcp_recv_control: unknown type %d\n",
0106             msg->type);
0107         return -EINVAL;
0108     }
0109     wake_up(sk_sleep(sk_atm(vcc)));
0110     return 0;
0111 }
0112 
0113 
0114 static void atmtcp_v_dev_close(struct atm_dev *dev)
0115 {
0116     /* Nothing.... Isn't this simple :-)  -- REW */
0117 }
0118 
0119 
0120 static int atmtcp_v_open(struct atm_vcc *vcc)
0121 {
0122     struct atmtcp_control msg;
0123     int error;
0124     short vpi = vcc->vpi;
0125     int vci = vcc->vci;
0126 
0127     memset(&msg,0,sizeof(msg));
0128     msg.addr.sap_family = AF_ATMPVC;
0129     msg.hdr.vpi = htons(vpi);
0130     msg.addr.sap_addr.vpi = vpi;
0131     msg.hdr.vci = htons(vci);
0132     msg.addr.sap_addr.vci = vci;
0133     if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) return 0;
0134     msg.type = ATMTCP_CTRL_OPEN;
0135     msg.qos = vcc->qos;
0136     set_bit(ATM_VF_ADDR,&vcc->flags);
0137     clear_bit(ATM_VF_READY,&vcc->flags); /* just in case ... */
0138     error = atmtcp_send_control(vcc,ATMTCP_CTRL_OPEN,&msg,ATM_VF_READY);
0139     if (error) return error;
0140     return -sk_atm(vcc)->sk_err;
0141 }
0142 
0143 
0144 static void atmtcp_v_close(struct atm_vcc *vcc)
0145 {
0146     struct atmtcp_control msg;
0147 
0148     memset(&msg,0,sizeof(msg));
0149     msg.addr.sap_family = AF_ATMPVC;
0150     msg.addr.sap_addr.vpi = vcc->vpi;
0151     msg.addr.sap_addr.vci = vcc->vci;
0152     clear_bit(ATM_VF_READY,&vcc->flags);
0153     (void) atmtcp_send_control(vcc,ATMTCP_CTRL_CLOSE,&msg,ATM_VF_ADDR);
0154 }
0155 
0156 
0157 static int atmtcp_v_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
0158 {
0159     struct atm_cirange ci;
0160     struct atm_vcc *vcc;
0161     struct sock *s;
0162     int i;
0163 
0164     if (cmd != ATM_SETCIRANGE) return -ENOIOCTLCMD;
0165     if (copy_from_user(&ci, arg,sizeof(ci))) return -EFAULT;
0166     if (ci.vpi_bits == ATM_CI_MAX) ci.vpi_bits = MAX_VPI_BITS;
0167     if (ci.vci_bits == ATM_CI_MAX) ci.vci_bits = MAX_VCI_BITS;
0168     if (ci.vpi_bits > MAX_VPI_BITS || ci.vpi_bits < 0 ||
0169         ci.vci_bits > MAX_VCI_BITS || ci.vci_bits < 0) return -EINVAL;
0170     read_lock(&vcc_sklist_lock);
0171     for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
0172         struct hlist_head *head = &vcc_hash[i];
0173 
0174         sk_for_each(s, head) {
0175             vcc = atm_sk(s);
0176             if (vcc->dev != dev)
0177                 continue;
0178             if ((vcc->vpi >> ci.vpi_bits) ||
0179                 (vcc->vci >> ci.vci_bits)) {
0180                 read_unlock(&vcc_sklist_lock);
0181                 return -EBUSY;
0182             }
0183         }
0184     }
0185     read_unlock(&vcc_sklist_lock);
0186     dev->ci_range = ci;
0187     return 0;
0188 }
0189 
0190 
0191 static int atmtcp_v_send(struct atm_vcc *vcc,struct sk_buff *skb)
0192 {
0193     struct atmtcp_dev_data *dev_data;
0194     struct atm_vcc *out_vcc=NULL; /* Initializer quietens GCC warning */
0195     struct sk_buff *new_skb;
0196     struct atmtcp_hdr *hdr;
0197     int size;
0198 
0199     if (vcc->qos.txtp.traffic_class == ATM_NONE) {
0200         if (vcc->pop) vcc->pop(vcc,skb);
0201         else dev_kfree_skb(skb);
0202         return -EINVAL;
0203     }
0204     dev_data = PRIV(vcc->dev);
0205     if (dev_data) out_vcc = dev_data->vcc;
0206     if (!dev_data || !out_vcc) {
0207         if (vcc->pop) vcc->pop(vcc,skb);
0208         else dev_kfree_skb(skb);
0209         if (dev_data) return 0;
0210         atomic_inc(&vcc->stats->tx_err);
0211         return -ENOLINK;
0212     }
0213     size = skb->len+sizeof(struct atmtcp_hdr);
0214     new_skb = atm_alloc_charge(out_vcc,size,GFP_ATOMIC);
0215     if (!new_skb) {
0216         if (vcc->pop) vcc->pop(vcc,skb);
0217         else dev_kfree_skb(skb);
0218         atomic_inc(&vcc->stats->tx_err);
0219         return -ENOBUFS;
0220     }
0221     hdr = skb_put(new_skb, sizeof(struct atmtcp_hdr));
0222     hdr->vpi = htons(vcc->vpi);
0223     hdr->vci = htons(vcc->vci);
0224     hdr->length = htonl(skb->len);
0225     skb_copy_from_linear_data(skb, skb_put(new_skb, skb->len), skb->len);
0226     if (vcc->pop) vcc->pop(vcc,skb);
0227     else dev_kfree_skb(skb);
0228     out_vcc->push(out_vcc,new_skb);
0229     atomic_inc(&vcc->stats->tx);
0230     atomic_inc(&out_vcc->stats->rx);
0231     return 0;
0232 }
0233 
0234 
0235 static int atmtcp_v_proc(struct atm_dev *dev,loff_t *pos,char *page)
0236 {
0237     struct atmtcp_dev_data *dev_data = PRIV(dev);
0238 
0239     if (*pos) return 0;
0240     if (!dev_data->persist) return sprintf(page,"ephemeral\n");
0241     return sprintf(page,"persistent, %sconnected\n",
0242         dev_data->vcc ? "" : "dis");
0243 }
0244 
0245 
0246 static void atmtcp_c_close(struct atm_vcc *vcc)
0247 {
0248     struct atm_dev *atmtcp_dev;
0249     struct atmtcp_dev_data *dev_data;
0250 
0251     atmtcp_dev = (struct atm_dev *) vcc->dev_data;
0252     dev_data = PRIV(atmtcp_dev);
0253     dev_data->vcc = NULL;
0254     if (dev_data->persist) return;
0255     atmtcp_dev->dev_data = NULL;
0256     kfree(dev_data);
0257     atm_dev_deregister(atmtcp_dev);
0258     vcc->dev_data = NULL;
0259     module_put(THIS_MODULE);
0260 }
0261 
0262 
0263 static struct atm_vcc *find_vcc(struct atm_dev *dev, short vpi, int vci)
0264 {
0265         struct hlist_head *head;
0266         struct atm_vcc *vcc;
0267         struct sock *s;
0268 
0269         head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)];
0270 
0271     sk_for_each(s, head) {
0272                 vcc = atm_sk(s);
0273                 if (vcc->dev == dev &&
0274                     vcc->vci == vci && vcc->vpi == vpi &&
0275                     vcc->qos.rxtp.traffic_class != ATM_NONE) {
0276                                 return vcc;
0277                 }
0278         }
0279         return NULL;
0280 }
0281 
0282 
0283 static int atmtcp_c_send(struct atm_vcc *vcc,struct sk_buff *skb)
0284 {
0285     struct atm_dev *dev;
0286     struct atmtcp_hdr *hdr;
0287     struct atm_vcc *out_vcc;
0288     struct sk_buff *new_skb;
0289     int result = 0;
0290 
0291     if (!skb->len) return 0;
0292     dev = vcc->dev_data;
0293     hdr = (struct atmtcp_hdr *) skb->data;
0294     if (hdr->length == ATMTCP_HDR_MAGIC) {
0295         result = atmtcp_recv_control(
0296             (struct atmtcp_control *) skb->data);
0297         goto done;
0298     }
0299     read_lock(&vcc_sklist_lock);
0300     out_vcc = find_vcc(dev, ntohs(hdr->vpi), ntohs(hdr->vci));
0301     read_unlock(&vcc_sklist_lock);
0302     if (!out_vcc) {
0303         result = -EUNATCH;
0304         atomic_inc(&vcc->stats->tx_err);
0305         goto done;
0306     }
0307     skb_pull(skb,sizeof(struct atmtcp_hdr));
0308     new_skb = atm_alloc_charge(out_vcc,skb->len,GFP_KERNEL);
0309     if (!new_skb) {
0310         result = -ENOBUFS;
0311         goto done;
0312     }
0313     __net_timestamp(new_skb);
0314     skb_copy_from_linear_data(skb, skb_put(new_skb, skb->len), skb->len);
0315     out_vcc->push(out_vcc,new_skb);
0316     atomic_inc(&vcc->stats->tx);
0317     atomic_inc(&out_vcc->stats->rx);
0318 done:
0319     if (vcc->pop) vcc->pop(vcc,skb);
0320     else dev_kfree_skb(skb);
0321     return result;
0322 }
0323 
0324 
0325 /*
0326  * Device operations for the virtual ATM devices created by ATMTCP.
0327  */
0328 
0329 
0330 static const struct atmdev_ops atmtcp_v_dev_ops = {
0331     .dev_close  = atmtcp_v_dev_close,
0332     .open       = atmtcp_v_open,
0333     .close      = atmtcp_v_close,
0334     .ioctl      = atmtcp_v_ioctl,
0335     .send       = atmtcp_v_send,
0336     .proc_read  = atmtcp_v_proc,
0337     .owner      = THIS_MODULE
0338 };
0339 
0340 
0341 /*
0342  * Device operations for the ATMTCP control device.
0343  */
0344 
0345 
0346 static const struct atmdev_ops atmtcp_c_dev_ops = {
0347     .close      = atmtcp_c_close,
0348     .send       = atmtcp_c_send
0349 };
0350 
0351 
0352 static struct atm_dev atmtcp_control_dev = {
0353     .ops        = &atmtcp_c_dev_ops,
0354     .type       = "atmtcp",
0355     .number     = 999,
0356     .lock       = __SPIN_LOCK_UNLOCKED(atmtcp_control_dev.lock)
0357 };
0358 
0359 
0360 static int atmtcp_create(int itf,int persist,struct atm_dev **result)
0361 {
0362     struct atmtcp_dev_data *dev_data;
0363     struct atm_dev *dev;
0364 
0365     dev_data = kmalloc(sizeof(*dev_data),GFP_KERNEL);
0366     if (!dev_data)
0367         return -ENOMEM;
0368 
0369     dev = atm_dev_register(DEV_LABEL,NULL,&atmtcp_v_dev_ops,itf,NULL);
0370     if (!dev) {
0371         kfree(dev_data);
0372         return itf == -1 ? -ENOMEM : -EBUSY;
0373     }
0374     dev->ci_range.vpi_bits = MAX_VPI_BITS;
0375     dev->ci_range.vci_bits = MAX_VCI_BITS;
0376     dev->dev_data = dev_data;
0377     PRIV(dev)->vcc = NULL;
0378     PRIV(dev)->persist = persist;
0379     if (result) *result = dev;
0380     return 0;
0381 }
0382 
0383 
0384 static int atmtcp_attach(struct atm_vcc *vcc,int itf)
0385 {
0386     struct atm_dev *dev;
0387 
0388     dev = NULL;
0389     if (itf != -1) dev = atm_dev_lookup(itf);
0390     if (dev) {
0391         if (dev->ops != &atmtcp_v_dev_ops) {
0392             atm_dev_put(dev);
0393             return -EMEDIUMTYPE;
0394         }
0395         if (PRIV(dev)->vcc) {
0396             atm_dev_put(dev);
0397             return -EBUSY;
0398         }
0399     }
0400     else {
0401         int error;
0402 
0403         error = atmtcp_create(itf,0,&dev);
0404         if (error) return error;
0405     }
0406     PRIV(dev)->vcc = vcc;
0407     vcc->dev = &atmtcp_control_dev;
0408     vcc_insert_socket(sk_atm(vcc));
0409     set_bit(ATM_VF_META,&vcc->flags);
0410     set_bit(ATM_VF_READY,&vcc->flags);
0411     vcc->dev_data = dev;
0412     (void) atm_init_aal5(vcc); /* @@@ losing AAL in transit ... */
0413     vcc->stats = &atmtcp_control_dev.stats.aal5;
0414     return dev->number;
0415 }
0416 
0417 
0418 static int atmtcp_create_persistent(int itf)
0419 {
0420     return atmtcp_create(itf,1,NULL);
0421 }
0422 
0423 
0424 static int atmtcp_remove_persistent(int itf)
0425 {
0426     struct atm_dev *dev;
0427     struct atmtcp_dev_data *dev_data;
0428 
0429     dev = atm_dev_lookup(itf);
0430     if (!dev) return -ENODEV;
0431     if (dev->ops != &atmtcp_v_dev_ops) {
0432         atm_dev_put(dev);
0433         return -EMEDIUMTYPE;
0434     }
0435     dev_data = PRIV(dev);
0436     if (!dev_data->persist) {
0437         atm_dev_put(dev);
0438         return 0;
0439     }
0440     dev_data->persist = 0;
0441     if (PRIV(dev)->vcc) {
0442         atm_dev_put(dev);
0443         return 0;
0444     }
0445     kfree(dev_data);
0446     atm_dev_put(dev);
0447     atm_dev_deregister(dev);
0448     return 0;
0449 }
0450 
0451 static int atmtcp_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
0452 {
0453     int err = 0;
0454     struct atm_vcc *vcc = ATM_SD(sock);
0455 
0456     if (cmd != SIOCSIFATMTCP && cmd != ATMTCP_CREATE && cmd != ATMTCP_REMOVE)
0457         return -ENOIOCTLCMD;
0458 
0459     if (!capable(CAP_NET_ADMIN))
0460         return -EPERM;
0461 
0462     switch (cmd) {
0463         case SIOCSIFATMTCP:
0464             err = atmtcp_attach(vcc, (int) arg);
0465             if (err >= 0) {
0466                 sock->state = SS_CONNECTED;
0467                 __module_get(THIS_MODULE);
0468             }
0469             break;
0470         case ATMTCP_CREATE:
0471             err = atmtcp_create_persistent((int) arg);
0472             break;
0473         case ATMTCP_REMOVE:
0474             err = atmtcp_remove_persistent((int) arg);
0475             break;
0476     }
0477     return err;
0478 }
0479 
0480 static struct atm_ioctl atmtcp_ioctl_ops = {
0481     .owner  = THIS_MODULE,
0482     .ioctl  = atmtcp_ioctl,
0483 };
0484 
0485 static __init int atmtcp_init(void)
0486 {
0487     register_atm_ioctl(&atmtcp_ioctl_ops);
0488     return 0;
0489 }
0490 
0491 
0492 static void __exit atmtcp_exit(void)
0493 {
0494     deregister_atm_ioctl(&atmtcp_ioctl_ops);
0495 }
0496 
0497 MODULE_LICENSE("GPL");
0498 module_init(atmtcp_init);
0499 module_exit(atmtcp_exit);
[ 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!