2 * slip.c This module implements the SLIP protocol for kernel-based
3 * devices like TTY. It interfaces between a raw TTY, and the
4 * kernel's INET protocol layers.
6 * Version: @(#)slip.c 0.8.3 12/24/94
8 * Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
9 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
12 * Alan Cox : Sanity checks and avoid tx overruns.
13 * Has a new sl->mtu field.
14 * Alan Cox : Found cause of overrun. ifconfig sl0
15 * mtu upwards. Driver now spots this
16 * and grows/shrinks its buffers(hack!).
17 * Memory leak if you run out of memory
18 * setting up a slip driver fixed.
19 * Matt Dillon : Printable slip (borrowed from NET2E)
20 * Pauline Middelink : Slip driver fixes.
21 * Alan Cox : Honours the old SL_COMPRESSED flag
22 * Alan Cox : KISS AX.25 and AXUI IP support
23 * Michael Riepe : Automatic CSLIP recognition added
24 * Charles Hedrick : CSLIP header length problem fix.
25 * Alan Cox : Corrected non-IP cases of the above.
26 * Alan Cox : Now uses hardware type as per FvK.
27 * Alan Cox : Default to 192.168.0.0 (RFC 1597)
28 * A.N.Kuznetsov : dev_tint() recursion fix.
29 * Dmitry Gorodchanin : SLIP memory leaks
30 * Dmitry Gorodchanin : Code cleanup. Reduce tty driver
31 * buffering from 4096 to 256 bytes.
32 * Improving SLIP response time.
33 * CONFIG_SLIP_MODE_SLIP6.
34 * ifconfig sl? up & down now works
37 * Alan Cox : Oops - fix AX.25 buffer lengths
38 * Dmitry Gorodchanin : Even more cleanups. Preserve CSLIP
39 * statistics. Include CSLIP code only
40 * if it really needed.
41 * Alan Cox : Free slhc buffers in the right place.
42 * Alan Cox : Allow for digipeated IP over AX.25
43 * Matti Aarnio : Dynamic SLIP devices, with ideas taken
44 * from Jim Freeman's <jfree@caldera.com>
45 * dynamic PPP devices. We do NOT kfree()
46 * device entries, just reg./unreg. them
47 * as they are needed. We kfree() them
49 * With MODULE-loading ``insmod'', user
50 * can issue parameter: slip_maxdev=1024
51 * (Or how much he/she wants.. Default
53 * Stanislav Voronyi : Slip line checking, with ideas taken
54 * from multislip BSDI driver which was
55 * written by Igor Chechik, RELCOM Corp.
56 * Only algorithms have been ported to
58 * Vitaly E. Lavrov : Sane behaviour on tty hangup.
59 * Alexey Kuznetsov : Cleanup interfaces to tty & netdevice
63 #define SL_CHECK_TRANSMIT
64 #include <linux/module.h>
65 #include <linux/moduleparam.h>
67 #include <asm/system.h>
68 #include <asm/uaccess.h>
69 #include <linux/bitops.h>
70 #include <linux/string.h>
72 #include <linux/interrupt.h>
74 #include <linux/tty.h>
75 #include <linux/errno.h>
76 #include <linux/netdevice.h>
77 #include <linux/etherdevice.h>
78 #include <linux/skbuff.h>
79 #include <linux/rtnetlink.h>
80 #include <linux/if_arp.h>
81 #include <linux/if_slip.h>
82 #include <linux/delay.h>
83 #include <linux/init.h>
87 #include <linux/tcp.h>
88 #include <net/slhc_vj.h>
91 #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
93 static struct net_device
**slip_devs
;
95 static int slip_maxdev
= SL_NRUNIT
;
96 module_param(slip_maxdev
, int, 0);
97 MODULE_PARM_DESC(slip_maxdev
, "Maximum number of slip devices");
99 static int slip_esc(unsigned char *p
, unsigned char *d
, int len
);
100 static void slip_unesc(struct slip
*sl
, unsigned char c
);
101 #ifdef CONFIG_SLIP_MODE_SLIP6
102 static int slip_esc6(unsigned char *p
, unsigned char *d
, int len
);
103 static void slip_unesc6(struct slip
*sl
, unsigned char c
);
105 #ifdef CONFIG_SLIP_SMART
106 static void sl_keepalive(unsigned long sls
);
107 static void sl_outfill(unsigned long sls
);
108 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
111 /********************************
112 * Buffer administration routines:
117 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
118 * sl_realloc_bufs provides strong atomicity and reallocation
119 * on actively running device.
120 *********************************/
123 Allocate channel buffers.
126 static int sl_alloc_bufs(struct slip
*sl
, int mtu
)
132 #ifdef SL_INCLUDE_CSLIP
134 struct slcompress
*slcomp
= NULL
;
138 * Allocate the SLIP frame buffers:
140 * rbuff Receive buffer.
141 * xbuff Transmit buffer.
142 * cbuff Temporary compression buffer.
147 * allow for arrival of larger UDP packets, even if we say not to
148 * also fixes a bug in which SunOS sends 512-byte packets even with
153 rbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
156 xbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
159 #ifdef SL_INCLUDE_CSLIP
160 cbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
163 slcomp
= slhc_init(16, 16);
167 spin_lock_bh(&sl
->lock
);
168 if (sl
->tty
== NULL
) {
169 spin_unlock_bh(&sl
->lock
);
177 rbuff
= xchg(&sl
->rbuff
, rbuff
);
178 xbuff
= xchg(&sl
->xbuff
, xbuff
);
179 #ifdef SL_INCLUDE_CSLIP
180 cbuff
= xchg(&sl
->cbuff
, cbuff
);
181 slcomp
= xchg(&sl
->slcomp
, slcomp
);
182 #ifdef CONFIG_SLIP_MODE_SLIP6
187 spin_unlock_bh(&sl
->lock
);
192 #ifdef SL_INCLUDE_CSLIP
202 /* Free a SLIP channel buffers. */
203 static void sl_free_bufs(struct slip
*sl
)
205 /* Free all SLIP frame buffers. */
206 kfree(xchg(&sl
->rbuff
, NULL
));
207 kfree(xchg(&sl
->xbuff
, NULL
));
208 #ifdef SL_INCLUDE_CSLIP
209 kfree(xchg(&sl
->cbuff
, NULL
));
210 slhc_free(xchg(&sl
->slcomp
, NULL
));
215 Reallocate slip channel buffers.
218 static int sl_realloc_bufs(struct slip
*sl
, int mtu
)
221 struct net_device
*dev
= sl
->dev
;
222 unsigned char *xbuff
, *rbuff
;
223 #ifdef SL_INCLUDE_CSLIP
224 unsigned char *cbuff
;
229 * allow for arrival of larger UDP packets, even if we say not to
230 * also fixes a bug in which SunOS sends 512-byte packets even with
236 xbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
237 rbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
238 #ifdef SL_INCLUDE_CSLIP
239 cbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
243 #ifdef SL_INCLUDE_CSLIP
244 if (xbuff
== NULL
|| rbuff
== NULL
|| cbuff
== NULL
) {
246 if (xbuff
== NULL
|| rbuff
== NULL
) {
248 if (mtu
>= sl
->mtu
) {
249 printk(KERN_WARNING
"%s: unable to grow slip buffers, MTU change cancelled.\n",
255 spin_lock_bh(&sl
->lock
);
261 xbuff
= xchg(&sl
->xbuff
, xbuff
);
262 rbuff
= xchg(&sl
->rbuff
, rbuff
);
263 #ifdef SL_INCLUDE_CSLIP
264 cbuff
= xchg(&sl
->cbuff
, cbuff
);
267 if (sl
->xleft
<= len
) {
268 memcpy(sl
->xbuff
, sl
->xhead
, sl
->xleft
);
274 sl
->xhead
= sl
->xbuff
;
277 if (sl
->rcount
<= len
) {
278 memcpy(sl
->rbuff
, rbuff
, sl
->rcount
);
281 sl
->rx_over_errors
++;
282 set_bit(SLF_ERROR
, &sl
->flags
);
291 spin_unlock_bh(&sl
->lock
);
296 #ifdef SL_INCLUDE_CSLIP
303 /* Set the "sending" flag. This must be atomic hence the set_bit. */
304 static inline void sl_lock(struct slip
*sl
)
306 netif_stop_queue(sl
->dev
);
310 /* Clear the "sending" flag. This must be atomic, hence the ASM. */
311 static inline void sl_unlock(struct slip
*sl
)
313 netif_wake_queue(sl
->dev
);
316 /* Send one completely decapsulated IP datagram to the IP layer. */
317 static void sl_bump(struct slip
*sl
)
323 #ifdef SL_INCLUDE_CSLIP
324 if (sl
->mode
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) {
325 unsigned char c
= sl
->rbuff
[0];
326 if (c
& SL_TYPE_COMPRESSED_TCP
) {
327 /* ignore compressed packets when CSLIP is off */
328 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
329 printk(KERN_WARNING
"%s: compressed packet ignored\n", sl
->dev
->name
);
332 /* make sure we've reserved enough space for uncompress
334 if (count
+ 80 > sl
->buffsize
) {
335 sl
->rx_over_errors
++;
338 count
= slhc_uncompress(sl
->slcomp
, sl
->rbuff
, count
);
341 } else if (c
>= SL_TYPE_UNCOMPRESSED_TCP
) {
342 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
343 /* turn on header compression */
344 sl
->mode
|= SL_MODE_CSLIP
;
345 sl
->mode
&= ~SL_MODE_ADAPTIVE
;
346 printk(KERN_INFO
"%s: header compression turned on\n", sl
->dev
->name
);
348 sl
->rbuff
[0] &= 0x4f;
349 if (slhc_remember(sl
->slcomp
, sl
->rbuff
, count
) <= 0)
353 #endif /* SL_INCLUDE_CSLIP */
355 sl
->rx_bytes
+= count
;
357 skb
= dev_alloc_skb(count
);
359 printk(KERN_WARNING
"%s: memory squeeze, dropping packet.\n", sl
->dev
->name
);
364 memcpy(skb_put(skb
, count
), sl
->rbuff
, count
);
365 skb_reset_mac_header(skb
);
366 skb
->protocol
= htons(ETH_P_IP
);
371 /* Encapsulate one IP datagram and stuff into a TTY queue. */
372 static void sl_encaps(struct slip
*sl
, unsigned char *icp
, int len
)
377 if (len
> sl
->mtu
) { /* Sigh, shouldn't occur BUT ... */
378 printk(KERN_WARNING
"%s: truncating oversized transmit packet!\n", sl
->dev
->name
);
385 #ifdef SL_INCLUDE_CSLIP
386 if (sl
->mode
& SL_MODE_CSLIP
)
387 len
= slhc_compress(sl
->slcomp
, p
, len
, sl
->cbuff
, &p
, 1);
389 #ifdef CONFIG_SLIP_MODE_SLIP6
390 if (sl
->mode
& SL_MODE_SLIP6
)
391 count
= slip_esc6(p
, (unsigned char *) sl
->xbuff
, len
);
394 count
= slip_esc(p
, (unsigned char *) sl
->xbuff
, len
);
396 /* Order of next two lines is *very* important.
397 * When we are sending a little amount of data,
398 * the transfer may be completed inside the ops->write()
399 * routine, because it's running with interrupts enabled.
400 * In this case we *never* got WRITE_WAKEUP event,
401 * if we did not request it before write operation.
402 * 14 Oct 1994 Dmitry Gorodchanin.
404 set_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
405 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xbuff
, count
);
406 #ifdef SL_CHECK_TRANSMIT
407 sl
->dev
->trans_start
= jiffies
;
409 sl
->xleft
= count
- actual
;
410 sl
->xhead
= sl
->xbuff
+ actual
;
411 #ifdef CONFIG_SLIP_SMART
413 clear_bit(SLF_OUTWAIT
, &sl
->flags
); /* reset outfill flag */
418 * Called by the driver when there's room for more data. If we have
419 * more packets to send, we send them here.
421 static void slip_write_wakeup(struct tty_struct
*tty
)
424 struct slip
*sl
= tty
->disc_data
;
426 /* First make sure we're connected. */
427 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
430 if (sl
->xleft
<= 0) {
431 /* Now serial buffer is almost free & we can start
432 * transmission of another packet */
434 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
439 actual
= tty
->ops
->write(tty
, sl
->xhead
, sl
->xleft
);
444 static void sl_tx_timeout(struct net_device
*dev
)
446 struct slip
*sl
= netdev_priv(dev
);
448 spin_lock(&sl
->lock
);
450 if (netif_queue_stopped(dev
)) {
451 if (!netif_running(dev
))
454 /* May be we must check transmitter timeout here ?
455 * 14 Oct 1994 Dmitry Gorodchanin.
457 #ifdef SL_CHECK_TRANSMIT
458 if (time_before(jiffies
, dev
->trans_start
+ 20 * HZ
)) {
459 /* 20 sec timeout not reached */
462 printk(KERN_WARNING
"%s: transmit timed out, %s?\n",
464 (tty_chars_in_buffer(sl
->tty
) || sl
->xleft
) ?
465 "bad line quality" : "driver error");
467 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
472 spin_unlock(&sl
->lock
);
476 /* Encapsulate an IP datagram and kick it into a TTY queue. */
478 sl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
480 struct slip
*sl
= netdev_priv(dev
);
482 spin_lock(&sl
->lock
);
483 if (!netif_running(dev
)) {
484 spin_unlock(&sl
->lock
);
485 printk(KERN_WARNING
"%s: xmit call when iface is down\n", dev
->name
);
489 if (sl
->tty
== NULL
) {
490 spin_unlock(&sl
->lock
);
496 sl
->tx_bytes
+= skb
->len
;
497 sl_encaps(sl
, skb
->data
, skb
->len
);
498 spin_unlock(&sl
->lock
);
505 /******************************************
506 * Routines looking at netdevice side.
507 ******************************************/
509 /* Netdevice UP -> DOWN routine */
512 sl_close(struct net_device
*dev
)
514 struct slip
*sl
= netdev_priv(dev
);
516 spin_lock_bh(&sl
->lock
);
518 /* TTY discipline is running. */
519 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
520 netif_stop_queue(dev
);
523 spin_unlock_bh(&sl
->lock
);
528 /* Netdevice DOWN -> UP routine */
530 static int sl_open(struct net_device
*dev
)
532 struct slip
*sl
= netdev_priv(dev
);
537 sl
->flags
&= (1 << SLF_INUSE
);
538 netif_start_queue(dev
);
542 /* Netdevice change MTU request */
544 static int sl_change_mtu(struct net_device
*dev
, int new_mtu
)
546 struct slip
*sl
= netdev_priv(dev
);
548 if (new_mtu
< 68 || new_mtu
> 65534)
551 if (new_mtu
!= dev
->mtu
)
552 return sl_realloc_bufs(sl
, new_mtu
);
556 /* Netdevice get statistics request */
558 static struct net_device_stats
*
559 sl_get_stats(struct net_device
*dev
)
561 static struct net_device_stats stats
;
562 struct slip
*sl
= netdev_priv(dev
);
563 #ifdef SL_INCLUDE_CSLIP
564 struct slcompress
*comp
;
567 memset(&stats
, 0, sizeof(struct net_device_stats
));
569 stats
.rx_packets
= sl
->rx_packets
;
570 stats
.tx_packets
= sl
->tx_packets
;
571 stats
.rx_bytes
= sl
->rx_bytes
;
572 stats
.tx_bytes
= sl
->tx_bytes
;
573 stats
.rx_dropped
= sl
->rx_dropped
;
574 stats
.tx_dropped
= sl
->tx_dropped
;
575 stats
.tx_errors
= sl
->tx_errors
;
576 stats
.rx_errors
= sl
->rx_errors
;
577 stats
.rx_over_errors
= sl
->rx_over_errors
;
578 #ifdef SL_INCLUDE_CSLIP
579 stats
.rx_fifo_errors
= sl
->rx_compressed
;
580 stats
.tx_fifo_errors
= sl
->tx_compressed
;
581 stats
.collisions
= sl
->tx_misses
;
584 stats
.rx_fifo_errors
+= comp
->sls_i_compressed
;
585 stats
.rx_dropped
+= comp
->sls_i_tossed
;
586 stats
.tx_fifo_errors
+= comp
->sls_o_compressed
;
587 stats
.collisions
+= comp
->sls_o_misses
;
589 #endif /* CONFIG_INET */
593 /* Netdevice register callback */
595 static int sl_init(struct net_device
*dev
)
597 struct slip
*sl
= netdev_priv(dev
);
600 * Finish setting up the DEVICE info.
604 dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
605 #ifdef SL_CHECK_TRANSMIT
606 dev
->tx_timeout
= sl_tx_timeout
;
607 dev
->watchdog_timeo
= 20*HZ
;
613 static void sl_uninit(struct net_device
*dev
)
615 struct slip
*sl
= netdev_priv(dev
);
620 static void sl_setup(struct net_device
*dev
)
623 dev
->uninit
= sl_uninit
;
625 dev
->destructor
= free_netdev
;
626 dev
->stop
= sl_close
;
627 dev
->get_stats
= sl_get_stats
;
628 dev
->change_mtu
= sl_change_mtu
;
629 dev
->hard_start_xmit
= sl_xmit
;
630 #ifdef CONFIG_SLIP_SMART
631 dev
->do_ioctl
= sl_ioctl
;
633 dev
->hard_header_len
= 0;
635 dev
->tx_queue_len
= 10;
637 /* New-style flags. */
638 dev
->flags
= IFF_NOARP
|IFF_POINTOPOINT
|IFF_MULTICAST
;
641 /******************************************
642 Routines looking at TTY side.
643 ******************************************/
647 * Handle the 'receiver data ready' interrupt.
648 * This function is called by the 'tty_io' module in the kernel when
649 * a block of SLIP data has been received, which can now be decapsulated
650 * and sent on to some IP layer for further processing. This will not
651 * be re-entered while running but other ldisc functions may be called
655 static void slip_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
658 struct slip
*sl
= tty
->disc_data
;
660 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
663 /* Read the characters out of the buffer */
666 if (!test_and_set_bit(SLF_ERROR
, &sl
->flags
))
671 #ifdef CONFIG_SLIP_MODE_SLIP6
672 if (sl
->mode
& SL_MODE_SLIP6
)
673 slip_unesc6(sl
, *cp
++);
676 slip_unesc(sl
, *cp
++);
680 /************************************
681 * slip_open helper routines.
682 ************************************/
684 /* Collect hanged up channels */
685 static void sl_sync(void)
688 struct net_device
*dev
;
691 for (i
= 0; i
< slip_maxdev
; i
++) {
696 sl
= netdev_priv(dev
);
697 if (sl
->tty
|| sl
->leased
)
699 if (dev
->flags
& IFF_UP
)
705 /* Find a free SLIP channel, and link in this `tty' line. */
706 static struct slip
*sl_alloc(dev_t line
)
711 struct net_device
*dev
= NULL
;
714 if (slip_devs
== NULL
)
715 return NULL
; /* Master array missing ! */
717 for (i
= 0; i
< slip_maxdev
; i
++) {
722 sl
= netdev_priv(dev
);
724 if (sl
->line
!= line
)
729 /* Clear ESCAPE & ERROR flags */
730 sl
->flags
&= (1 << SLF_INUSE
);
737 if (current
->pid
== sl
->pid
) {
738 if (sl
->line
== line
&& score
< 3) {
749 if (sl
->line
== line
&& score
< 1) {
764 sl
= netdev_priv(dev
);
765 sl
->flags
&= (1 << SLF_INUSE
);
770 /* Sorry, too many, all slots in use */
771 if (i
>= slip_maxdev
)
775 sl
= netdev_priv(dev
);
776 if (test_bit(SLF_INUSE
, &sl
->flags
)) {
777 unregister_netdevice(dev
);
785 sprintf(name
, "sl%d", i
);
787 dev
= alloc_netdev(sizeof(*sl
), name
, sl_setup
);
793 sl
= netdev_priv(dev
);
795 /* Initialize channel control data */
796 sl
->magic
= SLIP_MAGIC
;
798 spin_lock_init(&sl
->lock
);
799 sl
->mode
= SL_MODE_DEFAULT
;
800 #ifdef CONFIG_SLIP_SMART
801 /* initialize timer_list struct */
802 init_timer(&sl
->keepalive_timer
);
803 sl
->keepalive_timer
.data
= (unsigned long)sl
;
804 sl
->keepalive_timer
.function
= sl_keepalive
;
805 init_timer(&sl
->outfill_timer
);
806 sl
->outfill_timer
.data
= (unsigned long)sl
;
807 sl
->outfill_timer
.function
= sl_outfill
;
814 * Open the high-level part of the SLIP channel.
815 * This function is called by the TTY module when the
816 * SLIP line discipline is called for. Because we are
817 * sure the tty line exists, we only have to link it to
818 * a free SLIP channel...
820 * Called in process context serialized from other ldisc calls.
823 static int slip_open(struct tty_struct
*tty
)
828 if (!capable(CAP_NET_ADMIN
))
831 if (tty
->ops
->write
== NULL
)
834 /* RTnetlink lock is misused here to serialize concurrent
835 opens of slip channels. There are better ways, but it is
840 /* Collect hanged up channels. */
846 /* First make sure we're not already connected. */
847 if (sl
&& sl
->magic
== SLIP_MAGIC
)
850 /* OK. Find a free SLIP channel to use. */
852 sl
= sl_alloc(tty_devnum(tty
));
858 sl
->line
= tty_devnum(tty
);
859 sl
->pid
= current
->pid
;
861 if (!test_bit(SLF_INUSE
, &sl
->flags
)) {
862 /* Perform the low-level SLIP initialization. */
863 err
= sl_alloc_bufs(sl
, SL_MTU
);
867 set_bit(SLF_INUSE
, &sl
->flags
);
869 err
= register_netdevice(sl
->dev
);
874 #ifdef CONFIG_SLIP_SMART
876 sl
->keepalive_timer
.expires
= jiffies
+ sl
->keepalive
* HZ
;
877 add_timer(&sl
->keepalive_timer
);
880 sl
->outfill_timer
.expires
= jiffies
+ sl
->outfill
* HZ
;
881 add_timer(&sl
->outfill_timer
);
885 /* Done. We have linked the TTY line to a channel. */
887 tty
->receive_room
= 65536; /* We don't flow control */
888 return sl
->dev
->base_addr
;
895 tty
->disc_data
= NULL
;
896 clear_bit(SLF_INUSE
, &sl
->flags
);
901 /* Count references from TTY module */
907 FIXME: 1,2 are fixed 3 was never true anyway.
909 Let me to blame a bit.
910 1. TTY module calls this funstion on soft interrupt.
911 2. TTY module calls this function WITH MASKED INTERRUPTS!
912 3. TTY module does not notify us about line discipline
915 Seems, now it is clean. The solution is to consider netdevice and
916 line discipline sides as two independent threads.
918 By-product (not desired): sl? does not feel hangups and remains open.
919 It is supposed, that user level program (dip, diald, slattach...)
920 will catch SIGHUP and make the rest of work.
922 I see no way to make more with current tty code. --ANK
926 * Close down a SLIP channel.
927 * This means flushing out any pending queues, and then returning. This
928 * call is serialized against other ldisc functions.
930 static void slip_close(struct tty_struct
*tty
)
932 struct slip
*sl
= tty
->disc_data
;
934 /* First make sure we're connected. */
935 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| sl
->tty
!= tty
)
938 tty
->disc_data
= NULL
;
943 /* VSV = very important to remove timers */
944 #ifdef CONFIG_SLIP_SMART
945 del_timer_sync(&sl
->keepalive_timer
);
946 del_timer_sync(&sl
->outfill_timer
);
949 /* Count references from TTY module */
952 /************************************************************************
953 * STANDARD SLIP ENCAPSULATION *
954 ************************************************************************/
956 static int slip_esc(unsigned char *s
, unsigned char *d
, int len
)
958 unsigned char *ptr
= d
;
962 * Send an initial END character to flush out any
963 * data that may have accumulated in the receiver
970 * For each byte in the packet, send the appropriate
971 * character sequence, according to the SLIP protocol.
993 static void slip_unesc(struct slip
*sl
, unsigned char s
)
998 #ifdef CONFIG_SLIP_SMART
999 /* drop keeptest bit = VSV */
1000 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1001 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1004 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
)
1005 && (sl
->rcount
> 2))
1007 clear_bit(SLF_ESCAPE
, &sl
->flags
);
1012 set_bit(SLF_ESCAPE
, &sl
->flags
);
1015 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
1019 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
1023 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1024 if (sl
->rcount
< sl
->buffsize
) {
1025 sl
->rbuff
[sl
->rcount
++] = s
;
1028 sl
->rx_over_errors
++;
1029 set_bit(SLF_ERROR
, &sl
->flags
);
1034 #ifdef CONFIG_SLIP_MODE_SLIP6
1035 /************************************************************************
1036 * 6 BIT SLIP ENCAPSULATION *
1037 ************************************************************************/
1039 static int slip_esc6(unsigned char *s
, unsigned char *d
, int len
)
1041 unsigned char *ptr
= d
;
1044 unsigned short v
= 0;
1048 * Send an initial END character to flush out any
1049 * data that may have accumulated in the receiver
1050 * due to line noise.
1056 * Encode the packet into printable ascii characters
1059 for (i
= 0; i
< len
; ++i
) {
1060 v
= (v
<< 8) | s
[i
];
1064 c
= 0x30 + ((v
>> bits
) & 0x3F);
1069 c
= 0x30 + ((v
<< (6 - bits
)) & 0x3F);
1076 static void slip_unesc6(struct slip
*sl
, unsigned char s
)
1081 #ifdef CONFIG_SLIP_SMART
1082 /* drop keeptest bit = VSV */
1083 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1084 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1087 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
)
1088 && (sl
->rcount
> 2))
1093 } else if (s
>= 0x30 && s
< 0x70) {
1094 sl
->xdata
= (sl
->xdata
<< 6) | ((s
- 0x30) & 0x3F);
1096 if (sl
->xbits
>= 8) {
1098 c
= (unsigned char)(sl
->xdata
>> sl
->xbits
);
1099 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1100 if (sl
->rcount
< sl
->buffsize
) {
1101 sl
->rbuff
[sl
->rcount
++] = c
;
1104 sl
->rx_over_errors
++;
1105 set_bit(SLF_ERROR
, &sl
->flags
);
1110 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1112 /* Perform I/O control on an active SLIP channel. */
1113 static int slip_ioctl(struct tty_struct
*tty
, struct file
*file
,
1114 unsigned int cmd
, unsigned long arg
)
1116 struct slip
*sl
= tty
->disc_data
;
1118 int __user
*p
= (int __user
*)arg
;
1120 /* First make sure we're connected. */
1121 if (!sl
|| sl
->magic
!= SLIP_MAGIC
)
1126 tmp
= strlen(sl
->dev
->name
) + 1;
1127 if (copy_to_user((void __user
*)arg
, sl
->dev
->name
, tmp
))
1132 if (put_user(sl
->mode
, p
))
1137 if (get_user(tmp
, p
))
1139 #ifndef SL_INCLUDE_CSLIP
1140 if (tmp
& (SL_MODE_CSLIP
|SL_MODE_ADAPTIVE
))
1143 if ((tmp
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) ==
1144 (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
))
1145 /* return -EINVAL; */
1146 tmp
&= ~SL_MODE_ADAPTIVE
;
1148 #ifndef CONFIG_SLIP_MODE_SLIP6
1149 if (tmp
& SL_MODE_SLIP6
)
1153 sl
->dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
1159 #ifdef CONFIG_SLIP_SMART
1160 /* VSV changes start here */
1161 case SIOCSKEEPALIVE
:
1162 if (get_user(tmp
, p
))
1164 if (tmp
> 255) /* max for unchar */
1167 spin_lock_bh(&sl
->lock
);
1169 spin_unlock_bh(&sl
->lock
);
1172 sl
->keepalive
= (u8
)tmp
;
1173 if (sl
->keepalive
!= 0) {
1174 mod_timer(&sl
->keepalive_timer
,
1175 jiffies
+ sl
->keepalive
* HZ
);
1176 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1178 del_timer(&sl
->keepalive_timer
);
1179 spin_unlock_bh(&sl
->lock
);
1182 case SIOCGKEEPALIVE
:
1183 if (put_user(sl
->keepalive
, p
))
1188 if (get_user(tmp
, p
))
1190 if (tmp
> 255) /* max for unchar */
1192 spin_lock_bh(&sl
->lock
);
1194 spin_unlock_bh(&sl
->lock
);
1197 sl
->outfill
= (u8
)tmp
;
1198 if (sl
->outfill
!= 0) {
1199 mod_timer(&sl
->outfill_timer
,
1200 jiffies
+ sl
->outfill
* HZ
);
1201 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1203 del_timer(&sl
->outfill_timer
);
1204 spin_unlock_bh(&sl
->lock
);
1208 if (put_user(sl
->outfill
, p
))
1211 /* VSV changes end */
1214 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1218 /* VSV changes start here */
1219 #ifdef CONFIG_SLIP_SMART
1220 /* function do_ioctl called from net/core/dev.c
1221 to allow get/set outfill/keepalive parameter
1224 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1226 struct slip
*sl
= netdev_priv(dev
);
1227 unsigned long *p
= (unsigned long *)&rq
->ifr_ifru
;
1229 if (sl
== NULL
) /* Allocation failed ?? */
1232 spin_lock_bh(&sl
->lock
);
1235 spin_unlock_bh(&sl
->lock
);
1240 case SIOCSKEEPALIVE
:
1241 /* max for unchar */
1242 if ((unsigned)*p
> 255) {
1243 spin_unlock_bh(&sl
->lock
);
1246 sl
->keepalive
= (u8
)*p
;
1247 if (sl
->keepalive
!= 0) {
1248 sl
->keepalive_timer
.expires
=
1249 jiffies
+ sl
->keepalive
* HZ
;
1250 mod_timer(&sl
->keepalive_timer
,
1251 jiffies
+ sl
->keepalive
* HZ
);
1252 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1254 del_timer(&sl
->keepalive_timer
);
1257 case SIOCGKEEPALIVE
:
1262 if ((unsigned)*p
> 255) { /* max for unchar */
1263 spin_unlock_bh(&sl
->lock
);
1266 sl
->outfill
= (u8
)*p
;
1267 if (sl
->outfill
!= 0) {
1268 mod_timer(&sl
->outfill_timer
,
1269 jiffies
+ sl
->outfill
* HZ
);
1270 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1272 del_timer(&sl
->outfill_timer
);
1280 /* Resolve race condition, when ioctl'ing hanged up
1281 and opened by another process device.
1283 if (sl
->tty
!= current
->signal
->tty
&&
1284 sl
->pid
!= current
->pid
) {
1285 spin_unlock_bh(&sl
->lock
);
1296 spin_unlock_bh(&sl
->lock
);
1300 /* VSV changes end */
1302 static struct tty_ldisc_ops sl_ldisc
= {
1303 .owner
= THIS_MODULE
,
1304 .magic
= TTY_LDISC_MAGIC
,
1307 .close
= slip_close
,
1308 .ioctl
= slip_ioctl
,
1309 .receive_buf
= slip_receive_buf
,
1310 .write_wakeup
= slip_write_wakeup
,
1313 static int __init
slip_init(void)
1317 if (slip_maxdev
< 4)
1318 slip_maxdev
= 4; /* Sanity */
1320 printk(KERN_INFO
"SLIP: version %s (dynamic channels, max=%d)"
1321 #ifdef CONFIG_SLIP_MODE_SLIP6
1322 " (6 bit encapsulation enabled)"
1325 SLIP_VERSION
, slip_maxdev
);
1326 #if defined(SL_INCLUDE_CSLIP)
1327 printk(KERN_INFO
"CSLIP: code copyright 1989 Regents of the University of California.\n");
1329 #ifdef CONFIG_SLIP_SMART
1330 printk(KERN_INFO
"SLIP linefill/keepalive option.\n");
1333 slip_devs
= kzalloc(sizeof(struct net_device
*)*slip_maxdev
,
1336 printk(KERN_ERR
"SLIP: Can't allocate slip devices array.\n");
1340 /* Fill in our line protocol discipline, and register it */
1341 status
= tty_register_ldisc(N_SLIP
, &sl_ldisc
);
1343 printk(KERN_ERR
"SLIP: can't register line discipline (err = %d)\n", status
);
1349 static void __exit
slip_exit(void)
1352 struct net_device
*dev
;
1354 unsigned long timeout
= jiffies
+ HZ
;
1357 if (slip_devs
== NULL
)
1360 /* First of all: check for active disciplines and hangup them.
1364 msleep_interruptible(100);
1367 for (i
= 0; i
< slip_maxdev
; i
++) {
1371 sl
= netdev_priv(dev
);
1372 spin_lock_bh(&sl
->lock
);
1375 tty_hangup(sl
->tty
);
1377 spin_unlock_bh(&sl
->lock
);
1379 } while (busy
&& time_before(jiffies
, timeout
));
1382 for (i
= 0; i
< slip_maxdev
; i
++) {
1386 slip_devs
[i
] = NULL
;
1388 sl
= netdev_priv(dev
);
1390 printk(KERN_ERR
"%s: tty discipline still running\n",
1392 /* Intentionally leak the control block. */
1393 dev
->destructor
= NULL
;
1396 unregister_netdev(dev
);
1402 i
= tty_unregister_ldisc(N_SLIP
);
1404 printk(KERN_ERR
"SLIP: can't unregister line discipline (err = %d)\n", i
);
1407 module_init(slip_init
);
1408 module_exit(slip_exit
);
1410 #ifdef CONFIG_SLIP_SMART
1412 * This is start of the code for multislip style line checking
1413 * added by Stanislav Voronyi. All changes before marked VSV
1416 static void sl_outfill(unsigned long sls
)
1418 struct slip
*sl
= (struct slip
*)sls
;
1420 spin_lock(&sl
->lock
);
1422 if (sl
->tty
== NULL
)
1426 if (test_bit(SLF_OUTWAIT
, &sl
->flags
)) {
1427 /* no packets were transmitted, do outfill */
1428 #ifdef CONFIG_SLIP_MODE_SLIP6
1429 unsigned char s
= (sl
->mode
& SL_MODE_SLIP6
)?0x70:END
;
1431 unsigned char s
= END
;
1433 /* put END into tty queue. Is it right ??? */
1434 if (!netif_queue_stopped(sl
->dev
)) {
1435 /* if device busy no outfill */
1436 sl
->tty
->ops
->write(sl
->tty
, &s
, 1);
1439 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1441 mod_timer(&sl
->outfill_timer
, jiffies
+sl
->outfill
*HZ
);
1444 spin_unlock(&sl
->lock
);
1447 static void sl_keepalive(unsigned long sls
)
1449 struct slip
*sl
= (struct slip
*)sls
;
1451 spin_lock(&sl
->lock
);
1453 if (sl
->tty
== NULL
)
1456 if (sl
->keepalive
) {
1457 if (test_bit(SLF_KEEPTEST
, &sl
->flags
)) {
1458 /* keepalive still high :(, we must hangup */
1460 /* outfill timer must be deleted too */
1461 (void)del_timer(&sl
->outfill_timer
);
1462 printk(KERN_DEBUG
"%s: no packets received during keepalive timeout, hangup.\n", sl
->dev
->name
);
1463 /* this must hangup tty & close slip */
1464 tty_hangup(sl
->tty
);
1465 /* I think we need not something else */
1468 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1470 mod_timer(&sl
->keepalive_timer
, jiffies
+sl
->keepalive
*HZ
);
1473 spin_unlock(&sl
->lock
);
1477 MODULE_LICENSE("GPL");
1478 MODULE_ALIAS_LDISC(N_SLIP
);
This page took 0.059614 seconds and 5 git commands to generate.