chiark / gitweb /
Setting the maximum interface count now does the right thing.
[unet] / unet.c
CommitLineData
4e3819cf 1/* -*-c-*-
2 *
88613db4 3 * $Id: unet.c,v 1.2 2001/02/03 18:39:59 mdw Exp $
4e3819cf 4 *
5 * User-space network device support.
6 *
7 * (c) 1998 Mark Wooding
8 */
9
10/*----- Licensing notice --------------------------------------------------*
11 *
12 * This file is part of Usernet.
13 *
14 * Usernet is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * Usernet is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with Usernet; if not, write to the Free Software Foundation,
26 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 */
28
29/*----- Revision history --------------------------------------------------*
30 *
31 * $Log: unet.c,v $
88613db4 32 * Revision 1.2 2001/02/03 18:39:59 mdw
33 * Setting the maximum interface count now does the right thing.
34 *
4e3819cf 35 * Revision 1.1 2001/01/25 22:03:39 mdw
36 * Initial check-in (somewhat belated).
37 *
38 */
39
40/*----- Include files -----------------------------------------------------*/
41
42#include <linux/module.h>
43
44#include <asm/byteorder.h>
45#include <asm/segment.h>
46
47#include <linux/types.h>
48#include <linux/kernel.h>
49#include <linux/wait.h>
50#include <linux/sched.h>
51#include <linux/fs.h>
52#include <linux/poll.h>
53#include <linux/netdevice.h>
54#include <linux/etherdevice.h>
55#include <linux/if_arp.h>
56#include <linux/malloc.h>
57#include <linux/errno.h>
58#include <linux/init.h>
59
60#include "unetconf.h"
61#include "unet.h"
62
63MODULE_AUTHOR("Mark Wooding");
64MODULE_DESCRIPTION("Allows userland handling of a network interface");
65
66/*----- Debugging macros --------------------------------------------------*/
67
68#define UNET_DEBUGALWAYS 1
69#define UNET_DEBUGRUNTIME 0
70#define UNET_DEBUGNEVER -1
71
72/* --- If the macro isn't defined then be switchable at runtime --- */
73
74#ifndef UNET_DEBUG
75# define UNET_DEBUG UNET_DEBUGRUNTIME
76#endif
77
78/* --- Define the base macro @D@ according to the debug setting --- */
79
80#if UNET_DEBUG == UNET_DEBUGALWAYS
81# define D(x) { x }
82# define DIF(u, x) if ((u)->f & UNIF_DEBUG) { x }
83#elif UNET_DEBUG == UNET_DEBUGRUNTIME
84# define D(x) if (unet_debug) { x }
85# define DIF(u, x) if ((u)->f & UNIF_DEBUG) { x }
86#elif UNET_DEBUG == UNET_DEBUGNEVER
87# define D(x)
88# define DIF(u, x)
89#elif
90# error UNET_DEBUG set to invalid value (bug in configure script?)
91#endif
92
93/*----- Type definitions --------------------------------------------------*/
94
95/* --- Unet connection status --- *
96 *
97 * Records are stored in a slightly strange doubly linked list. The list
98 * exists so that I can find the next unused sequence number when creating
99 * new connections. It's odd because of the type of the @prev@ node;
100 * rather than being the address of the previous item, it's the address of
101 * the previous item's pointer to me, which among other good things means
102 * that it works on the list head too.
103 */
104
105struct unet {
106 struct unet *next, **prev; /* List of unet blocks */
107 struct device nif; /* Network interface block */
108 int seq; /* Sequence number for connection */
109 char name[UNET_NAMEMAX]; /* Buffer for my interface name */
110 struct wait_queue *q; /* Wait list for device reads */
111 struct sk_buff_head skbq; /* Queue of packets waiting */
112 struct enet_statistics e; /* Pointer to statistics block */
113 unsigned short protocol; /* Protocol for outgoing packets */
114 unsigned f; /* Userful flags */
115};
116
117/*----- Static variables --------------------------------------------------*/
118
119#if UNET_DEBUG == UNET_DEBUGRUNTIME
120static int unet_debug = 0;
121MODULE_PARM(unet_debug, "i");
122#endif
123
124static int unet_npersist = UNET_NPERSIST;
125static int unet_maxif = UNET_MAXIF;
126static struct unet *unet_persistent;
127static struct unet *unet_list = 0;
88613db4 128static int unet_nif = 0;
4e3819cf 129
130MODULE_PARM(unet_npersist, "i");
131MODULE_PARM(unet_maxif, "i");
132
133/*----- Debugging code ----------------------------------------------------*/
134
135#if UNET_DEBUG != UNET_DEBUGNEVER
136
137/* --- @unet_dumpBlock@ --- *
138 *
139 * Arguments: @struct unet *u@ = pointer to block to dump
140 *
141 * Returns: ---
142 *
143 * Use: Dumps a unet object to syslogd.
144 */
145
146static void unet_dumpBlock(struct unet *u)
147{
148 printk(KERN_DEBUG "unet: dumping unet block at %p\n", u);
149 printk(KERN_DEBUG " sequence number = %d\n", u->seq);
150 printk(KERN_DEBUG " interface name = `%s'\n", u->name);
151 printk(KERN_DEBUG " flags =%s%s%s\n",
152 u->f & UNIF_TRANS ? " TRANS" : "",
153 u->f & UNIF_OPEN ? " OPEN" : "",
154 u->f & UNIF_DEBUG ? " DEBUG" : "");
155 printk(KERN_DEBUG " interface type = %d\n", u->nif.type);
156 printk(KERN_DEBUG " header len = %d\n", u->nif.hard_header_len);
157 printk(KERN_DEBUG " mtu = %d\n", u->nif.mtu);
158 printk(KERN_DEBUG " protocol = %d\n", ntohs(u->protocol));
159 printk(KERN_DEBUG " address len = %d\n", u->nif.addr_len);
160}
161
162/* --- @unet_dump@ --- *
163 *
164 * Arguments: ---
165 *
166 * Returns: ---
167 *
168 * Use: Dumps the entire unet state to syslogd.
169 */
170
171static void unet_dump(void)
172{
173 int i;
174 struct unet *u;
175
176 for (i = 0; i < unet_npersist; i++)
177 unet_dumpBlock(&unet_persistent[i]);
178 for (u = unet_list; u; u = u->next)
179 unet_dumpBlock(u);
180}
181
182/* --- @unet_hexdump@ --- *
183 *
184 * Arguments: @const char *prefix@ = prefix to print on output lines
185 * @const void *b@ = pointer to block to dump
186 * @size_t sz@ = size of block to dump
187 *
188 * Returns: ---
189 *
190 * Use: Dumps a hex block to the kernel log.
191 */
192
193#define UNET_HEXROWSZ 16
194
195static void unet_hexdump(const char *prefix, const char *b, size_t sz)
196{
197 const unsigned char *p = b;
198 size_t i;
199 unsigned long o = 0;
200 size_t c;
201
202 char buf[256], *q;
203
204 /* --- Now start work --- */
205
206 while (sz) {
207 q = buf;
208 q += sprintf(q, "%s%08lx : ", prefix, o);
209 for (i = 0; i < UNET_HEXROWSZ; i++) {
210 if (i < sz)
211 q += sprintf(q, "%02x ", p[i]);
212 else
213 q += sprintf(q, "** ");
214 }
215 *q++ = ':'; *q++ = ' ';
216 for (i = 0; i < UNET_HEXROWSZ; i++) {
217 if (i < sz)
218 *q++ = (p[i] >= 32 && p[i] < 127) ? p[i] : '.';
219 else
220 *q++ = '*';
221 }
222 *q++ = '\n';
223 *q++ = 0;
224 printk("%s", buf);
225 c = (sz >= UNET_HEXROWSZ) ? UNET_HEXROWSZ : sz;
226 sz -= c, p += c, o += c;
227 }
228}
229
230#endif
231
232/*----- The unet network interfaces ---------------------------------------*/
233
234/* --- @unet_ifopen@ --- *
235 *
236 * Arguments: @struct device *nif@ = pointer to network interface
237 *
238 * Returns: Zero or error condition.
239 *
240 * Use: Turns on the network interface ready for action. Oh, yes.
241 */
242
243static int unet_ifopen(struct device *nif)
244{
245 D( struct unet *u = nif->priv;
246 if (u->f & UNIF_DEBUG)
247 printk(KERN_DEBUG "unet: opening interface %s\n", u->name); )
248 MOD_INC_USE_COUNT;
249 return (0);
250}
251
252/* --- @unet_ifclose@ --- *
253 *
254 * Arguments: @struct device *nif@ = pointer to network interface
255 *
256 * Returns: Zero or error condition.
257 *
258 * Use: Turns off the network interface.
259 */
260
261static int unet_ifclose(struct device *nif)
262{
263 D( struct unet *u = nif->priv;
264 if (u->f & UNIF_DEBUG)
265 printk(KERN_DEBUG "unet: closing interface %d\n", u->seq); )
266 MOD_DEC_USE_COUNT;
267 return (0);
268}
269
270/* --- @unet_iftx@ --- *
271 *
272 * Arguments: @struct sk_buff *skb@ = incoming network packet
273 * @struct device *nif@ = pointer to network interface
274 *
275 * Returns: Zero or error condition.
276 *
277 * Use: Queues a network packet ready for collection by the user
278 * end of the business.
279 */
280
281static int unet_iftx(struct sk_buff *skb, struct device *nif)
282{
283 struct unet *u = nif->priv;
284 int qed;
285
286 DIF(u,
287 printk(KERN_DEBUG "unet: packet received on if %s\n", u->name);
288 unet_hexdump(KERN_DEBUG " ", skb->data, skb->len); )
289
290 /* --- Discard packets when nobody's listening --- */
291
292 if ((u->f & UNIF_OPEN) == 0) {
293 DIF(u, printk(KERN_DEBUG "unet: dropped packet: nobody's listening\n"); )
294 dev_kfree_skb(skb);
295 u->e.tx_dropped++;
296 return (0);
297 }
298
299 /* --- Discard packets when the queue's too long --- */
300
301 if (u->skbq.qlen >= UNET_QMAXLEN) {
302 DIF(u, printk(KERN_DEBUG "unet: refused packet: queue overflow\n"); )
303 return (-1);
304 }
305
306 /* --- Attach the buffer to the waiting list --- */
307
308 qed = u->skbq.qlen;
309 skb_queue_tail(&u->skbq, skb);
310 u->e.tx_packets++;
311 DIF(u, printk(KERN_DEBUG "unet: queued packet OK\n"); )
312
313 /* --- If there are waiting processes, give 'em a kick --- */
314
315 if (qed == 0) {
316 DIF(u, printk(KERN_DEBUG "unet: waking up sleeping listeners\n"); )
317 wake_up_interruptible(&u->q);
318 }
319 return (0);
320}
321
322/* --- @unet_ifgetstats@ --- *
323 *
324 * Arguments: @struct device *nif@ = pointer to network interface
325 *
326 * Returns: Pointer to a statistics buffer.
327 *
328 * Use: Returns a block of interface statistics.
329 */
330
331static struct enet_statistics *unet_ifgetstats(struct device *nif)
332{
333 struct unet *u = nif->priv;
334 DIF(u, printk(KERN_DEBUG "unet: stats request for if %s\n", u->name); )
335 return (&u->e);
336}
337
338/* --- @unet_ifinit@ --- *
339 *
340 * Arguments: @struct device *nif@ = pointer to network interface
341 *
342 * Returns: Zero or error condition.
343 *
344 * Use: Initialises a unet network interface.
345 */
346
347static int unet_ifinit(struct device *nif)
348{
349 struct unet *u = nif->priv;
350
351 DIF(u, printk(KERN_DEBUG "unet: initialise interface %s\n", u->name); )
352
353 /* --- Initialise statistics gathering --- */
354
355 memset(&u->e, 0, sizeof(u->e));
356 u->nif.get_stats = unet_ifgetstats;
357
358 /* --- Opening and closing interfaces --- */
359
360 u->nif.open = unet_ifopen;
361 u->nif.stop = unet_ifclose;
362
363 /* --- Sending packets to the `outside world' --- */
364
365 u->nif.hard_start_xmit = unet_iftx;
366
367 /* --- Some initialisation magic --- */
368
369#ifdef notdef
370 for (i = 0; i < DEV_NUMBUFFS; i++)
371 skb_queue_head_init(&u->nif.buffs[i]);
372#endif
373
374 /* --- Configure other grotty bits of the interface --- */
375
376 u->nif.hard_header = 0;
377 u->nif.rebuild_header = 0;
378 u->nif.set_mac_address = 0;
379
380 u->nif.type = ARPHRD_LOOPBACK; /* Got a better idea? */
381 u->nif.hard_header_len = 0;
382 u->nif.mtu = 1500 - MAX_HEADER;
383 u->nif.addr_len = 0;
384 u->nif.tx_queue_len = 16; /* I keep my own queue */
385
386 memset(u->nif.broadcast, 0xFFu, MAX_ADDR_LEN);
387
388 u->nif.flags = IFF_NOARP;
389
390 /* --- Finished! --- */
391
392 return (0);
393}
394
395/*----- Attachment management ---------------------------------------------*/
396
397/* --- @unet_setup@ --- *
398 *
399 * Arguments: @struct unet *u@ = pointer to a unet block
400 * @int seq@ = sequence number to allocate
401 *
402 * Returns: Zero or error condition.
403 *
404 * Use: Initialises a unet block ready for action.
405 */
406
407static int unet_setup(struct unet *u, int seq)
408{
409 static struct device tpl;
410 int e;
411
412 D( printk(KERN_DEBUG "unet: setting up unet block %d\n", seq); )
413
414 /* --- A little bit of initialisation --- */
415
416 u->seq = seq;
417 u->f = 0;
418 u->q = 0;
419
420 /* --- Inherit device debug flag from global flag --- */
421
422#if UNET_DEBUG == UNET_DEBUGRUNTIME
423 if (unet_debug)
424 u->f |= UNIF_DEBUG;
425#elif UNET_DEBUG == UNET_DEBUGALWAYS
426 u->f |= UNIF_DEBUG;
427#endif
428
429 /* --- Set up the network device --- */
430
431 u->nif = tpl;
432 sprintf(u->name, "unet%d", seq);
433 u->nif.name = u->name;
434 u->nif.priv = u;
435 u->nif.init = unet_ifinit;
436 u->protocol = htons(ETH_P_IP);
437
438 if ((e = register_netdev(&u->nif)) != 0) {
439 printk(KERN_ERR "unet: couldn't register net interface\n");
440 return (e);
441 }
442
443 /* --- Empty the skbuff list --- */
444
445 skb_queue_head_init(&u->skbq);
446
447 /* --- We're only finished, that's all --- */
448
449 return (0);
450}
451
452/* --- @unet_flush@ --- *
453 *
454 * Arguments: @struct unet *u@ = pointer to a unet block
455 *
456 * Returns: ---
457 *
458 * Use: Releases all the packets waiting for transmission.
459 */
460
461static void unet_flush(struct unet *u)
462{
463 struct sk_buff *skb;
464
465#if UNET_DEBUG != UNET_DEBUGNEVER
466 int i = 0;
467#endif
468
469 DIF(u, printk(KERN_DEBUG "unet: flushing packets on %s\n", u->name); )
470
471 while ((skb = skb_dequeue(&u->skbq)) != 0) {
472 dev_kfree_skb(skb);
473 D( i++; )
474 }
475 DIF(u, printk(KERN_DEBUG "unet: released %d waiting packets\n", i); )
476}
477
478/* --- @unet_kill@ --- *
479 *
480 * Arguments: @struct unet *u@ = pointer to a unet block
481 *
482 * Returns: ---
483 *
484 * Use: Kills and decommissions a Usernet block.
485 */
486
487static void unet_kill(struct unet *u)
488{
489 unet_flush(u);
490 unregister_netdev(&u->nif);
491}
492
493/*----- Handling the unet device ------------------------------------------*/
494
495/* --- @unet_devopen@ --- *
496 *
497 * Arguments: @struct inode *ino@ = inode block to open
498 * @struct file *f@ = file block to play with
499 *
500 * Returns: Zero or error condition.
501 *
502 * Use: Handles the opening of a unet device.
503 */
504
505static int unet_devopen(struct inode *ino, struct file *f)
506{
507 struct unet *u, **up;
508 int seq;
509 int e = 0;
510
511 D( printk(KERN_DEBUG "unet: device open request\n"); )
512
513 /* --- Decide whether this is a persistent unet --- */
514
515 if ((seq = MINOR(ino->i_rdev)) < unet_npersist) {
516 u = &unet_persistent[seq];
517 if (u->f & UNIF_OPEN) {
518 e = -EBUSY;
519 goto tidy_0;
520 }
521 D( printk(KERN_DEBUG "unet: opened persistent %s\n", u->name); )
522 }
523
524 /* --- Otherwise we've got to create a new one --- */
525
88613db4 526 else if (seq == UNET_TRANSMINOR) {
4e3819cf 527
528 /* --- Try to find a spare sequence number --- */
529
88613db4 530 if (unet_nif >= unet_maxif) {
531 printk(KERN_NOTICE "unet: no interfaces left\n");
532 e = -ENFILE;
533 goto tidy_0;
534 }
4e3819cf 535 for (seq = unet_npersist, up = &unet_list; *up != 0;
536 seq++, up = &(*up)->next) {
537 if ((*up)->seq > seq)
538 break;
4e3819cf 539 }
4e3819cf 540 D( printk(KERN_DEBUG "unet: allocated sequence number %d\n", seq); )
541
542 /* --- Allocate a new block --- */
543
544 if ((u = kmalloc(sizeof(*u), GFP_KERNEL)) == 0) {
545 printk(KERN_ERR "unet: couldn't allocate a unet block\n");
546 e = -ENOMEM;
547 goto tidy_0;
548 }
549
550 /* --- Initialise the block --- */
551
552 if ((e = unet_setup(u, seq)) != 0)
553 goto tidy_1;
554 u->f |= UNIF_TRANS;
88613db4 555 unet_nif++;
4e3819cf 556
557 /* --- Link the block into the list --- */
558
559 u->next = *up;
560 u->prev = up;
561 if (*up)
562 (*up)->prev = &u->next;
563 *up = u;
564
565 D( printk(KERN_DEBUG "unet: opened transient %d\n", seq);
566 unet_dumpBlock(u); )
88613db4 567 } else
568 return (-ENODEV);
4e3819cf 569
570 /* --- Done --- */
571
572 u->f |= UNIF_OPEN;
573 f->private_data = u;
574 MOD_INC_USE_COUNT;
575 return (0);
576
577 /* --- Tidy up after little disasters --- */
578
579tidy_1:
580 kfree(u);
581tidy_0:
582 return (e);
583}
584
585/* --- @unet_devclose@ --- *
586 *
587 * Arguments: @struct inode *ino@ = pointer to inode block
588 * @struct file *f@ = pointer to file block
589 *
590 * Returns: ---
591 *
592 * Use: Frees up a unet connection.
593 */
594
595static int unet_devclose(struct inode *ino, struct file *f)
596{
597 struct unet *u = f->private_data;
598
599 DIF(u, printk(KERN_DEBUG "unet: closing %s\n", u->name); )
600
601 /* --- A transient unet needs to be destroyed --- */
602
603 if (u->f & UNIF_TRANS) {
88613db4 604 int seq = u->seq;
4e3819cf 605 *u->prev = u->next;
606 if (u->next)
607 u->next->prev = u->prev;
608 unet_kill(u);
609 kfree(u);
88613db4 610 unet_nif--;
611 D( printk(KERN_DEBUG "unet: released transient %d\n", seq); )
4e3819cf 612 }
613
614 /* --- A persistent unet needs to be shutdown --- */
615
616 else {
617 u->f &= ~UNIF_OPEN;
618 unet_flush(u);
619 DIF(u, printk(KERN_DEBUG "unet: unblocked persistent unet\n"); )
620 }
621
622 MOD_DEC_USE_COUNT;
623 return (0);
624}
625
626/* --- @unet_devpoll@ --- *
627 *
628 * Arguments: @struct file *f@ = pointer to my file block
629 * @struct poll_table_struct *p@ = poll table to wait on
630 *
631 * Returns: Nonzero if OK to continue, zero if waiting.
632 *
633 * Use: Plays a unet device's part in a @poll@(2) call.
634 */
635
636static unsigned unet_devpoll(struct file *f, struct poll_table_struct *p)
637{
638 struct unet *u = f->private_data;
639 unsigned m = 0;
640
641 DIF(u, printk(KERN_DEBUG "unet: poll request for %s\n", u->name); )
642
643 poll_wait(f, &u->q, p);
644 if (skb_peek(&u->skbq))
645 m |= POLLIN | POLLRDNORM;
646 m |= POLLOUT | POLLWRNORM;
647 return (m);
648}
649
650/* --- @unet_devwrite@ --- *
651 *
652 * Arguments: @struct file *f@ = pointer to the file block
653 * @char *buf@ = pointer to caller's buffer
654 * @size_t sz@ = size of data to send
655 * @loff_t *off@ = offset to set (ignored)
656 *
657 * Returns: Number of bytes written, or error condition.
658 *
659 * Use: Sends a packet of data. No buffering is done.
660 */
661
662static ssize_t unet_devwrite(struct file *f, const char *buf, size_t sz,
663 loff_t *off)
664{
665 struct unet *u = f->private_data;
666 struct sk_buff *skb;
667
668 DIF(u, printk(KERN_DEBUG "unet: write request for %s\n", u->name); )
669
670 /* --- Dump the packet we're meant to send --- */
671
672#ifdef UNET_DEBUG
673 if (u->f & UNIF_DEBUG) {
674 void *b = kmalloc(sz, GFP_KERNEL);
675 if (b) {
676 copy_from_user(b, buf, sz);
677 unet_hexdump(KERN_DEBUG " ", b, sz);
678 kfree(b);
679 } else
680 printk(KERN_NOTICE "unet: not enough memory to dump block");
681 }
682#endif
683
684 /* --- Allocate an skbuff for the block --- */
685
686 if ((skb = dev_alloc_skb(sz)) == 0) {
687 printk(KERN_ERR "unet: failed to allocate skbuff\n");
688 u->e.rx_dropped++;
689 return (-ENOSR);
690 }
691
692 /* --- Copy my data into the skbuff --- */
693
694 copy_from_user(skb_put(skb, sz), buf, sz);
695 skb->dev = &u->nif;
696 skb->mac.raw = skb->data;
697 skb->protocol = u->protocol;
698 netif_rx(skb);
699 u->e.rx_packets++;
700 return (sz);
701}
702
703/* --- @unet_devread@ --- *
704 *
705 * Arguments: @struct file *f@ = pointer to the file block
706 * @char *buf@ = pointer to caller's buffer
707 * @size_t sz@ = size of caller's buffer
708 * @loff_t *off@ = offset to set (ignored)
709 *
710 * Returns: Number of bytes read, or error condition.
711 *
712 * Use: Reads the next packet waiting for the device.
713 */
714
715static ssize_t unet_devread(struct file *f, char *buf, size_t sz,
716 loff_t *off)
717{
718 struct unet *u = f->private_data;
719 struct sk_buff *skb;
720
721 DIF(u, printk(KERN_DEBUG "unet: read request for %s\n", u->name); )
722
723 /* --- Is the user sane? --- *
724 *
725 * The UDP protocol returns immediately in response to a zero-length read,
726 * and following this behaviour seems to cause `least surprise'.
727 */
728
729 if (!sz)
730 return (0);
731
732 /* --- Make sure there's a packet waiting for me --- */
733
734 if ((skb = skb_dequeue(&u->skbq)) == 0) {
735 struct wait_queue wq = { current, 0 };
736
737 DIF(u, printk(KERN_DEBUG "unet: no packets waiting\n"); )
738
739 /* --- Check for nonblocking I/O --- */
740
741 if (f->f_flags & O_NONBLOCK) {
742 DIF(u, printk(KERN_DEBUG "unet: nonblocking read: fail\n"); )
743 return (-EWOULDBLOCK);
744 }
745
746 /* --- Otherwise block until there's a packet --- */
747
748 current->state = TASK_INTERRUPTIBLE;
749 add_wait_queue(&u->q, &wq);
750
751 do {
752
753 if (signal_pending(current)) {
754
755 DIF(u, printk(KERN_DEBUG "unet: interrupted by signal\n"); )
756
757 remove_wait_queue(&u->q, &wq);
758 current->state = TASK_RUNNING;
759 return (-ERESTARTSYS);
760 }
761
762 DIF(u, printk(KERN_DEBUG "unet: blocking until packet arrives\n"); )
763
764 schedule();
765
766 } while ((skb = skb_dequeue(&u->skbq)) == 0);
767
768 remove_wait_queue(&u->q, &wq);
769 current->state = TASK_RUNNING;
770 }
771
772 DIF(u, printk(KERN_DEBUG "unet: found a packet\n"); )
773
774 /* --- There is now a packet waiting --- */
775
776 if (sz > skb->len)
777 sz = skb->len;
778 copy_to_user(buf, skb->data, sz);
779 dev_kfree_skb(skb);
780
781 DIF(u, printk(KERN_DEBUG "unet: passed packet on to user\n"); )
782
783 return (sz);
784}
785
786/* --- @unet_devioctl@ --- *
787 *
788 * Arguments: @struct inode *ino@ = pointer to inode block
789 * @struct file *f@ = pointer to file block
790 * @unsigned int c@ = command code to execute
791 * @unsigned long arg@ = argument passed to me
792 *
793 * Returns: Positive return value, or negative error condition.
794 *
795 * Use: Performs miscellaneous operations on a unet device.
796 */
797
798static int unet_devioctl(struct inode *ino,
799 struct file *f,
800 unsigned int c,
801 unsigned long arg)
802{
803 struct unet *u = f->private_data;
804 int e = 0;
805
806 DIF(u, printk(KERN_DEBUG "unet: ioctl request for %s\n", u->name); )
807
808 switch (c) {
809
810 /* --- @FIONREAD@ --- *
811 *
812 * Caller wants to know how big the next packet will be. Don't
813 * disappoint.
814 */
815
816 case FIONREAD: {
817 struct sk_buff *skb = skb_peek(&u->skbq);
818
819 DIF(u, printk(KERN_DEBUG "unet: FIONREAD found %d bytes\n",
820 skb ? skb->len : 0); )
821
822 if (skb)
823 e = skb->len;
824 } break;
825
826 /* --- @UNIOCGINFO@ --- *
827 *
828 * Caller wants information about me.
829 */
830
831 case UNIOCGINFO: {
832 struct unet_info uni, *unip;
833
834 DIF(u, printk(KERN_DEBUG "unet: UNIOCGINFO called\n"); )
835
836 unip = (struct unet_info *)arg;
837
838 /* --- Special case --- *
839 *
840 * If the pointer is null, this call means `are you there?' and can
841 * be used to check for a Usernet attachment.
842 */
843
844 if (!unip)
845 break;
846
847 /* --- Ensure that the area can be written to --- */
848
849 if ((e = verify_area(VERIFY_WRITE, unip, sizeof(*unip))) != 0)
850 return (e);
851
852 /* --- Build the information block in memory --- */
853
854 memset(&uni, 0, sizeof(uni)); /* Paranoia */
855 strncpy(uni.uni_ifname, u->name, UNET_NAMEMAX);
856 uni.uni_mtu = u->nif.mtu;
857 uni.uni_family = AF_INET;
858 uni.uni_proto = ntohs(u->protocol);
859 uni.uni_flags = u->f;
860
861 /* --- Copy it to the user and return --- */
862
863 copy_to_user(unip, &uni, sizeof(uni));
864 } break;
865
866 /* --- @UNIOCSDEBUG@ --- */
867
868#if UNET_DEBUG != UNET_DEBUGNEVER
869 case UNIOCSDEBUG: {
870 int n = !!arg;
871 int o = !!(u->f & UNIF_DEBUG);
872
88613db4 873 if (!capable(CAP_SYS_ADMIN))
874 return (-EPERM);
4e3819cf 875 if (n || o) {
876 printk(KERN_DEBUG "unet: UNIOCSDEBUG on %s: %s\n", u->name,
877 (o && n) ? "debugging still on" :
878 (!o && n) ? "debugging turned on" :
879 (o && !n) ? "debugging turned off" :
880 (!o && !n) ? "you can't see this message" :
881 "Logic failure: universe exploding");
882 }
883 if (n)
884 u->f |= UNIF_DEBUG;
885 else
886 u->f &= ~UNIF_DEBUG;
887 } break;
888#endif
889
890 /* --- @UNIOCGPROTO@ and @UNIOCSPROTO@ --- */
891
892 case UNIOCGPROTO:
893 D( printk(KERN_DEBUG "unet: UNIOCGPROTO on %s: read protocol: %d\n",
894 u->name, ntohs(u->protocol)); )
895 e = ntohs(u->protocol);
896 break;
897 case UNIOCSPROTO:
898 D( printk(KERN_DEBUG "unet: UNIOCSPROTO on %s: set protocol: %d\n",
899 u->name, (int)arg); )
900 u->protocol = htons(arg);
901 break;
902
903 /* --- @UNIOCGGDEBUG@ and @UNIOCSGDEBUG@ --- */
904
905 case UNIOCGGDEBUG:
906 D( printk(KERN_DEBUG "unet: UNIOCGGDEBUG: get global debug: on\n"); )
907#if UNET_DEBUG == UNET_DEBUGRUNTIME
908 e = unet_debug;
909#elif UNET_DEBUG == UNET_DEBUGALWAYS
910 e = 1;
911#elif UNET_DEBUG == UNET_DEBUGNEVER
912 e = 0;
913#endif
914 break;
915
916#if UNET_DEBUG == UNET_DEBUGRUNTIME
917 case UNIOCSGDEBUG:
88613db4 918 if (!capable(CAP_SYS_ADMIN))
919 return (-EPERM);
920 if (arg || unet_debug) {
921 printk(KERN_DEBUG "unet: UNIOCSGDEBUG: set global debug: %s\n",
922 (arg && unet_debug) ? "debugging still on" :
923 (!arg && unet_debug) ? "debugging turned off" :
924 (arg && !unet_debug) ? "debugging turned on" :
925 (!arg && !unet_debug) ? "you can't see this message" :
926 "Logic failure: universe exploding");
927 }
4e3819cf 928 unet_debug = !!arg;
929 break;
930#endif
931
932 /* --- @UNIOCDUMP@ --- */
933
934#if UNET_DEBUG != UNET_DEBUGNEVER
935 case UNIOCDUMP:
936 D( unet_dumpBlock(u); )
937 break;
938#endif
939
940 /* --- @UNIOCGMAXIF@ --- */
941
942 case UNIOCGMAXIF:
943 D( printk(KERN_DEBUG "unet: UNIOCGMAXIF: unet_maxif = %d\n",
944 unet_maxif); )
945 e = unet_maxif;
946 break;
947
948 /* --- @UNIOCSMAXIF@ --- */
949
950 case UNIOCSMAXIF:
88613db4 951 if (!capable(CAP_SYS_ADMIN))
952 return (-EPERM);
953 D( printk(KERN_DEBUG "unet: UNIOCSMAXIF: "
954 "arg = %ld; npersist = %d; nif = %d\n",
955 arg, unet_npersist, unet_nif); )
4e3819cf 956 if (arg < unet_npersist || arg > INT_MAX)
957 return (-EINVAL);
88613db4 958 if (arg < unet_nif)
959 return (-EBUSY);
4e3819cf 960 unet_maxif = arg;
88613db4 961 e = 0;
962 D( printk(KERN_DEBUG "unet: UNIOCSMAXIF: set unet_maxif = %d\n",
4e3819cf 963 unet_maxif); )
964 break;
965
966 /* --- Everything else --- *
967 *
968 * You lose.
969 */
970
971 default:
972 D( printk(KERN_DEBUG "unet: unknown ioctl %08x\n", c); )
973 e = -EINVAL;
974 }
975
976 return (e);
977}
978
979/*----- The unet device ---------------------------------------------------*/
980
981/* --- Device operations --- */
982
983struct file_operations unet_fops = {
984 0, /* unet_devlseek */
985 unet_devread,
986 unet_devwrite,
987 0, /* unet_devreaddir */
988 unet_devpoll,
989 unet_devioctl,
990 0, /* unet_devmmap */
991 unet_devopen,
992 0, /* unet_flush */
993 unet_devclose
994};
995
996/*----- Initaliseation and shutdown ---------------------------------------*/
997
998/* --- @unet_init@ --- *
999 *
1000 * Arguments: ---
1001 *
1002 * Returns: Zero or error condition.
1003 *
1004 * Use: Registers the unet device.
1005 */
1006
1007__initfunc(int unet_init(void))
1008{
1009 int e = 0;
1010 int i = 0;
1011
1012 /* --- Register my character device --- */
1013
1014 if ((e = register_chrdev(UNET_MAJOR, "unet", &unet_fops)) != 0) {
1015 printk(KERN_ERR "unet: can't claim major device %d\n", UNET_MAJOR);
1016 goto tidy_0;
1017 }
1018
1019 /* --- Make the persistent unet devices --- */
1020
1021 if ((unet_persistent = kmalloc(unet_npersist * sizeof(struct unet),
1022 GFP_KERNEL)) == 0) {
1023 printk(KERN_ERR "unet: can't allocate %i persistent unet blocks",
1024 unet_npersist);
1025 e = -ENOMEM;
1026 goto tidy_1;
1027 }
1028
1029 for (i = 0; i < unet_npersist; i++) {
1030 if ((e = unet_setup(&unet_persistent[i], i)) != 0) {
1031 printk(KERN_ERR "unet: can't create persistent unet %d\n", i);
1032 goto tidy_2;
1033 }
1034 }
88613db4 1035 unet_nif = unet_npersist;
4e3819cf 1036
1037 /* --- Done --- */
1038
1039 D( unet_dump(); )
1040 return (0);
1041
1042 /* --- Some bad stuff happened --- */
1043
1044tidy_2:
1045 while (i > 0) {
1046 i--;
1047 unregister_netdev(&unet_persistent[i].nif);
1048 }
1049 kfree(unet_persistent);
1050
1051tidy_1:
1052 unregister_chrdev(UNET_MAJOR, "unet");
1053
1054tidy_0:
1055 return (e);
1056}
1057
1058#ifdef MODULE
1059
1060/* --- @init_module@ --- *
1061 *
1062 * Arguments: ---
1063 *
1064 * Returns: Zero or error condition.
1065 *
1066 * Use: Initialises the unet kernel module.
1067 */
1068
1069int init_module(void)
1070{
1071 if (unet_npersist < 0 || unet_maxif < unet_npersist
1072#if UNET_DEBUG == UNET_DEBUGRUNTIME
1073 || (unet_debug != 0 && unet_debug != 1)
1074#endif
1075 )
1076 return (-EINVAL);
1077 return (unet_init());
1078}
1079
1080/* --- @cleanup_module@ --- *
1081 *
1082 * Arguments: ---
1083 *
1084 * Returns: ---
1085 *
1086 * Use: Tidies up the unet module ready for it to be killed.
1087 */
1088
1089void cleanup_module(void)
1090{
1091 int i;
1092
1093 for (i = 0; i < unet_npersist; i++) {
1094 D( printk(KERN_DEBUG "unet: releasing persistent unet %d\n", i); )
1095 unet_kill(&unet_persistent[i]);
1096 }
1097 kfree(unet_persistent);
1098
1099 unregister_chrdev(UNET_MAJOR, "unet");
1100}
1101
1102#endif
1103
1104/*----- That's all, folks -------------------------------------------------*/