OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [atm/] [atmtcp.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/* drivers/atm/atmtcp.c - ATM over TCP "device" driver */
2
 
3
/* Written 1997-2000 by Werner Almesberger, EPFL LRC/ICA */
4
 
5
 
6
#include <linux/module.h>
7
#include <linux/wait.h>
8
#include <linux/atmdev.h>
9
#include <linux/atm_tcp.h>
10
#include <linux/bitops.h>
11
#include <linux/init.h>
12
#include <asm/uaccess.h>
13
#include <asm/atomic.h>
14
 
15
 
16
extern int atm_init_aal5(struct atm_vcc *vcc); /* "raw" AAL5 transport */
17
 
18
 
19
#define PRIV(dev) ((struct atmtcp_dev_data *) ((dev)->dev_data))
20
 
21
 
22
struct atmtcp_dev_data {
23
        struct atm_vcc *vcc;    /* control VCC; NULL if detached */
24
        int persist;            /* non-zero if persistent */
25
};
26
 
27
 
28
#define DEV_LABEL    "atmtcp"
29
 
30
#define MAX_VPI_BITS  8 /* simplifies life */
31
#define MAX_VCI_BITS 16
32
 
33
 
34
/*
35
 * Hairy code ahead: the control VCC may be closed while we're still
36
 * waiting for an answer, so we need to re-validate out_vcc every once
37
 * in a while.
38
 */
39
 
40
 
41
static int atmtcp_send_control(struct atm_vcc *vcc,int type,
42
    const struct atmtcp_control *msg,int flag)
43
{
44
        DECLARE_WAITQUEUE(wait,current);
45
        struct atm_vcc *out_vcc;
46
        struct sk_buff *skb;
47
        struct atmtcp_control *new_msg;
48
        int old_test;
49
        int error = 0;
50
 
51
        out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
52
        if (!out_vcc) return -EUNATCH;
53
        skb = alloc_skb(sizeof(*msg),GFP_KERNEL);
54
        if (!skb) return -ENOMEM;
55
        mb();
56
        out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
57
        if (!out_vcc) {
58
                dev_kfree_skb(skb);
59
                return -EUNATCH;
60
        }
61
        atm_force_charge(out_vcc,skb->truesize);
62
        new_msg = (struct atmtcp_control *) skb_put(skb,sizeof(*new_msg));
63
        *new_msg = *msg;
64
        new_msg->hdr.length = ATMTCP_HDR_MAGIC;
65
        new_msg->type = type;
66
        memset(&new_msg->vcc,0,sizeof(atm_kptr_t));
67
        *(struct atm_vcc **) &new_msg->vcc = vcc;
68
        old_test = test_bit(flag,&vcc->flags);
69
        out_vcc->push(out_vcc,skb);
70
        add_wait_queue(sk_atm(vcc)->sk_sleep, &wait);
71
        while (test_bit(flag,&vcc->flags) == old_test) {
72
                mb();
73
                out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
74
                if (!out_vcc) {
75
                        error = -EUNATCH;
76
                        break;
77
                }
78
                set_current_state(TASK_UNINTERRUPTIBLE);
79
                schedule();
80
        }
81
        set_current_state(TASK_RUNNING);
82
        remove_wait_queue(sk_atm(vcc)->sk_sleep, &wait);
83
        return error;
84
}
85
 
86
 
87
static int atmtcp_recv_control(const struct atmtcp_control *msg)
88
{
89
        struct atm_vcc *vcc = *(struct atm_vcc **) &msg->vcc;
90
 
91
        vcc->vpi = msg->addr.sap_addr.vpi;
92
        vcc->vci = msg->addr.sap_addr.vci;
93
        vcc->qos = msg->qos;
94
        sk_atm(vcc)->sk_err = -msg->result;
95
        switch (msg->type) {
96
            case ATMTCP_CTRL_OPEN:
97
                change_bit(ATM_VF_READY,&vcc->flags);
98
                break;
99
            case ATMTCP_CTRL_CLOSE:
100
                change_bit(ATM_VF_ADDR,&vcc->flags);
101
                break;
102
            default:
103
                printk(KERN_ERR "atmtcp_recv_control: unknown type %d\n",
104
                    msg->type);
105
                return -EINVAL;
106
        }
107
        wake_up(sk_atm(vcc)->sk_sleep);
108
        return 0;
109
}
110
 
111
 
112
static void atmtcp_v_dev_close(struct atm_dev *dev)
113
{
114
        /* Nothing.... Isn't this simple :-)  -- REW */
115
}
116
 
117
 
118
static int atmtcp_v_open(struct atm_vcc *vcc)
119
{
120
        struct atmtcp_control msg;
121
        int error;
122
        short vpi = vcc->vpi;
123
        int vci = vcc->vci;
124
 
125
        memset(&msg,0,sizeof(msg));
126
        msg.addr.sap_family = AF_ATMPVC;
127
        msg.hdr.vpi = htons(vpi);
128
        msg.addr.sap_addr.vpi = vpi;
129
        msg.hdr.vci = htons(vci);
130
        msg.addr.sap_addr.vci = vci;
131
        if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) return 0;
132
        msg.type = ATMTCP_CTRL_OPEN;
133
        msg.qos = vcc->qos;
134
        set_bit(ATM_VF_ADDR,&vcc->flags);
135
        clear_bit(ATM_VF_READY,&vcc->flags); /* just in case ... */
136
        error = atmtcp_send_control(vcc,ATMTCP_CTRL_OPEN,&msg,ATM_VF_READY);
137
        if (error) return error;
138
        return -sk_atm(vcc)->sk_err;
139
}
140
 
141
 
142
static void atmtcp_v_close(struct atm_vcc *vcc)
143
{
144
        struct atmtcp_control msg;
145
 
146
        memset(&msg,0,sizeof(msg));
147
        msg.addr.sap_family = AF_ATMPVC;
148
        msg.addr.sap_addr.vpi = vcc->vpi;
149
        msg.addr.sap_addr.vci = vcc->vci;
150
        clear_bit(ATM_VF_READY,&vcc->flags);
151
        (void) atmtcp_send_control(vcc,ATMTCP_CTRL_CLOSE,&msg,ATM_VF_ADDR);
152
}
153
 
154
 
155
static int atmtcp_v_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
156
{
157
        struct atm_cirange ci;
158
        struct atm_vcc *vcc;
159
        struct hlist_node *node;
160
        struct sock *s;
161
        int i;
162
 
163
        if (cmd != ATM_SETCIRANGE) return -ENOIOCTLCMD;
164
        if (copy_from_user(&ci, arg,sizeof(ci))) return -EFAULT;
165
        if (ci.vpi_bits == ATM_CI_MAX) ci.vpi_bits = MAX_VPI_BITS;
166
        if (ci.vci_bits == ATM_CI_MAX) ci.vci_bits = MAX_VCI_BITS;
167
        if (ci.vpi_bits > MAX_VPI_BITS || ci.vpi_bits < 0 ||
168
            ci.vci_bits > MAX_VCI_BITS || ci.vci_bits < 0) return -EINVAL;
169
        read_lock(&vcc_sklist_lock);
170
        for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
171
                struct hlist_head *head = &vcc_hash[i];
172
 
173
                sk_for_each(s, node, head) {
174
                        vcc = atm_sk(s);
175
                        if (vcc->dev != dev)
176
                                continue;
177
                        if ((vcc->vpi >> ci.vpi_bits) ||
178
                            (vcc->vci >> ci.vci_bits)) {
179
                                read_unlock(&vcc_sklist_lock);
180
                                return -EBUSY;
181
                        }
182
                }
183
        }
184
        read_unlock(&vcc_sklist_lock);
185
        dev->ci_range = ci;
186
        return 0;
187
}
188
 
189
 
190
static int atmtcp_v_send(struct atm_vcc *vcc,struct sk_buff *skb)
191
{
192
        struct atmtcp_dev_data *dev_data;
193
        struct atm_vcc *out_vcc=NULL; /* Initializer quietens GCC warning */
194
        struct sk_buff *new_skb;
195
        struct atmtcp_hdr *hdr;
196
        int size;
197
 
198
        if (vcc->qos.txtp.traffic_class == ATM_NONE) {
199
                if (vcc->pop) vcc->pop(vcc,skb);
200
                else dev_kfree_skb(skb);
201
                return -EINVAL;
202
        }
203
        dev_data = PRIV(vcc->dev);
204
        if (dev_data) out_vcc = dev_data->vcc;
205
        if (!dev_data || !out_vcc) {
206
                if (vcc->pop) vcc->pop(vcc,skb);
207
                else dev_kfree_skb(skb);
208
                if (dev_data) return 0;
209
                atomic_inc(&vcc->stats->tx_err);
210
                return -ENOLINK;
211
        }
212
        size = skb->len+sizeof(struct atmtcp_hdr);
213
        new_skb = atm_alloc_charge(out_vcc,size,GFP_ATOMIC);
214
        if (!new_skb) {
215
                if (vcc->pop) vcc->pop(vcc,skb);
216
                else dev_kfree_skb(skb);
217
                atomic_inc(&vcc->stats->tx_err);
218
                return -ENOBUFS;
219
        }
220
        hdr = (void *) skb_put(new_skb,sizeof(struct atmtcp_hdr));
221
        hdr->vpi = htons(vcc->vpi);
222
        hdr->vci = htons(vcc->vci);
223
        hdr->length = htonl(skb->len);
224
        skb_copy_from_linear_data(skb, skb_put(new_skb, skb->len), skb->len);
225
        if (vcc->pop) vcc->pop(vcc,skb);
226
        else dev_kfree_skb(skb);
227
        out_vcc->push(out_vcc,new_skb);
228
        atomic_inc(&vcc->stats->tx);
229
        atomic_inc(&out_vcc->stats->rx);
230
        return 0;
231
}
232
 
233
 
234
static int atmtcp_v_proc(struct atm_dev *dev,loff_t *pos,char *page)
235
{
236
        struct atmtcp_dev_data *dev_data = PRIV(dev);
237
 
238
        if (*pos) return 0;
239
        if (!dev_data->persist) return sprintf(page,"ephemeral\n");
240
        return sprintf(page,"persistent, %sconnected\n",
241
            dev_data->vcc ? "" : "dis");
242
}
243
 
244
 
245
static void atmtcp_c_close(struct atm_vcc *vcc)
246
{
247
        struct atm_dev *atmtcp_dev;
248
        struct atmtcp_dev_data *dev_data;
249
 
250
        atmtcp_dev = (struct atm_dev *) vcc->dev_data;
251
        dev_data = PRIV(atmtcp_dev);
252
        dev_data->vcc = NULL;
253
        if (dev_data->persist) return;
254
        atmtcp_dev->dev_data = NULL;
255
        kfree(dev_data);
256
        atm_dev_deregister(atmtcp_dev);
257
        vcc->dev_data = NULL;
258
        module_put(THIS_MODULE);
259
}
260
 
261
 
262
static struct atm_vcc *find_vcc(struct atm_dev *dev, short vpi, int vci)
263
{
264
        struct hlist_head *head;
265
        struct atm_vcc *vcc;
266
        struct hlist_node *node;
267
        struct sock *s;
268
 
269
        head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)];
270
 
271
        sk_for_each(s, node, head) {
272
                vcc = atm_sk(s);
273
                if (vcc->dev == dev &&
274
                    vcc->vci == vci && vcc->vpi == vpi &&
275
                    vcc->qos.rxtp.traffic_class != ATM_NONE) {
276
                                return vcc;
277
                }
278
        }
279
        return NULL;
280
}
281
 
282
 
283
static int atmtcp_c_send(struct atm_vcc *vcc,struct sk_buff *skb)
284
{
285
        struct atm_dev *dev;
286
        struct atmtcp_hdr *hdr;
287
        struct atm_vcc *out_vcc;
288
        struct sk_buff *new_skb;
289
        int result = 0;
290
 
291
        if (!skb->len) return 0;
292
        dev = vcc->dev_data;
293
        hdr = (struct atmtcp_hdr *) skb->data;
294
        if (hdr->length == ATMTCP_HDR_MAGIC) {
295
                result = atmtcp_recv_control(
296
                    (struct atmtcp_control *) skb->data);
297
                goto done;
298
        }
299
        read_lock(&vcc_sklist_lock);
300
        out_vcc = find_vcc(dev, ntohs(hdr->vpi), ntohs(hdr->vci));
301
        read_unlock(&vcc_sklist_lock);
302
        if (!out_vcc) {
303
                atomic_inc(&vcc->stats->tx_err);
304
                goto done;
305
        }
306
        skb_pull(skb,sizeof(struct atmtcp_hdr));
307
        new_skb = atm_alloc_charge(out_vcc,skb->len,GFP_KERNEL);
308
        if (!new_skb) {
309
                result = -ENOBUFS;
310
                goto done;
311
        }
312
        __net_timestamp(new_skb);
313
        skb_copy_from_linear_data(skb, skb_put(new_skb, skb->len), skb->len);
314
        out_vcc->push(out_vcc,new_skb);
315
        atomic_inc(&vcc->stats->tx);
316
        atomic_inc(&out_vcc->stats->rx);
317
done:
318
        if (vcc->pop) vcc->pop(vcc,skb);
319
        else dev_kfree_skb(skb);
320
        return result;
321
}
322
 
323
 
324
/*
325
 * Device operations for the virtual ATM devices created by ATMTCP.
326
 */
327
 
328
 
329
static struct atmdev_ops atmtcp_v_dev_ops = {
330
        .dev_close      = atmtcp_v_dev_close,
331
        .open           = atmtcp_v_open,
332
        .close          = atmtcp_v_close,
333
        .ioctl          = atmtcp_v_ioctl,
334
        .send           = atmtcp_v_send,
335
        .proc_read      = atmtcp_v_proc,
336
        .owner          = THIS_MODULE
337
};
338
 
339
 
340
/*
341
 * Device operations for the ATMTCP control device.
342
 */
343
 
344
 
345
static struct atmdev_ops atmtcp_c_dev_ops = {
346
        .close          = atmtcp_c_close,
347
        .send           = atmtcp_c_send
348
};
349
 
350
 
351
static struct atm_dev atmtcp_control_dev = {
352
        .ops            = &atmtcp_c_dev_ops,
353
        .type           = "atmtcp",
354
        .number         = 999,
355
        .lock           = __SPIN_LOCK_UNLOCKED(atmtcp_control_dev.lock)
356
};
357
 
358
 
359
static int atmtcp_create(int itf,int persist,struct atm_dev **result)
360
{
361
        struct atmtcp_dev_data *dev_data;
362
        struct atm_dev *dev;
363
 
364
        dev_data = kmalloc(sizeof(*dev_data),GFP_KERNEL);
365
        if (!dev_data)
366
                return -ENOMEM;
367
 
368
        dev = atm_dev_register(DEV_LABEL,&atmtcp_v_dev_ops,itf,NULL);
369
        if (!dev) {
370
                kfree(dev_data);
371
                return itf == -1 ? -ENOMEM : -EBUSY;
372
        }
373
        dev->ci_range.vpi_bits = MAX_VPI_BITS;
374
        dev->ci_range.vci_bits = MAX_VCI_BITS;
375
        dev->dev_data = dev_data;
376
        PRIV(dev)->vcc = NULL;
377
        PRIV(dev)->persist = persist;
378
        if (result) *result = dev;
379
        return 0;
380
}
381
 
382
 
383
static int atmtcp_attach(struct atm_vcc *vcc,int itf)
384
{
385
        struct atm_dev *dev;
386
 
387
        dev = NULL;
388
        if (itf != -1) dev = atm_dev_lookup(itf);
389
        if (dev) {
390
                if (dev->ops != &atmtcp_v_dev_ops) {
391
                        atm_dev_put(dev);
392
                        return -EMEDIUMTYPE;
393
                }
394
                if (PRIV(dev)->vcc) return -EBUSY;
395
        }
396
        else {
397
                int error;
398
 
399
                error = atmtcp_create(itf,0,&dev);
400
                if (error) return error;
401
        }
402
        PRIV(dev)->vcc = vcc;
403
        vcc->dev = &atmtcp_control_dev;
404
        vcc_insert_socket(sk_atm(vcc));
405
        set_bit(ATM_VF_META,&vcc->flags);
406
        set_bit(ATM_VF_READY,&vcc->flags);
407
        vcc->dev_data = dev;
408
        (void) atm_init_aal5(vcc); /* @@@ losing AAL in transit ... */
409
        vcc->stats = &atmtcp_control_dev.stats.aal5;
410
        return dev->number;
411
}
412
 
413
 
414
static int atmtcp_create_persistent(int itf)
415
{
416
        return atmtcp_create(itf,1,NULL);
417
}
418
 
419
 
420
static int atmtcp_remove_persistent(int itf)
421
{
422
        struct atm_dev *dev;
423
        struct atmtcp_dev_data *dev_data;
424
 
425
        dev = atm_dev_lookup(itf);
426
        if (!dev) return -ENODEV;
427
        if (dev->ops != &atmtcp_v_dev_ops) {
428
                atm_dev_put(dev);
429
                return -EMEDIUMTYPE;
430
        }
431
        dev_data = PRIV(dev);
432
        if (!dev_data->persist) return 0;
433
        dev_data->persist = 0;
434
        if (PRIV(dev)->vcc) return 0;
435
        kfree(dev_data);
436
        atm_dev_put(dev);
437
        atm_dev_deregister(dev);
438
        return 0;
439
}
440
 
441
static int atmtcp_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
442
{
443
        int err = 0;
444
        struct atm_vcc *vcc = ATM_SD(sock);
445
 
446
        if (cmd != SIOCSIFATMTCP && cmd != ATMTCP_CREATE && cmd != ATMTCP_REMOVE)
447
                return -ENOIOCTLCMD;
448
 
449
        if (!capable(CAP_NET_ADMIN))
450
                return -EPERM;
451
 
452
        switch (cmd) {
453
                case SIOCSIFATMTCP:
454
                        err = atmtcp_attach(vcc, (int) arg);
455
                        if (err >= 0) {
456
                                sock->state = SS_CONNECTED;
457
                                __module_get(THIS_MODULE);
458
                        }
459
                        break;
460
                case ATMTCP_CREATE:
461
                        err = atmtcp_create_persistent((int) arg);
462
                        break;
463
                case ATMTCP_REMOVE:
464
                        err = atmtcp_remove_persistent((int) arg);
465
                        break;
466
        }
467
        return err;
468
}
469
 
470
static struct atm_ioctl atmtcp_ioctl_ops = {
471
        .owner  = THIS_MODULE,
472
        .ioctl  = atmtcp_ioctl,
473
};
474
 
475
static __init int atmtcp_init(void)
476
{
477
        register_atm_ioctl(&atmtcp_ioctl_ops);
478
        return 0;
479
}
480
 
481
 
482
static void __exit atmtcp_exit(void)
483
{
484
        deregister_atm_ioctl(&atmtcp_ioctl_ops);
485
}
486
 
487
MODULE_LICENSE("GPL");
488
module_init(atmtcp_init);
489
module_exit(atmtcp_exit);

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.