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 <linux/uaccess.h>
68 #include <linux/bitops.h>
69 #include <linux/sched/signal.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/compat.h>
83 #include <linux/delay.h>
84 #include <linux/init.h>
85 #include <linux/slab.h>
86 #include <linux/workqueue.h>
90 #include <linux/tcp.h>
91 #include <net/slhc_vj.h>
94 #define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
96 static struct net_device
**slip_devs
;
98 static int slip_maxdev
= SL_NRUNIT
;
99 module_param(slip_maxdev
, int, 0);
100 MODULE_PARM_DESC(slip_maxdev
, "Maximum number of slip devices");
102 static int slip_esc(unsigned char *p
, unsigned char *d
, int len
);
103 static void slip_unesc(struct slip
*sl
, unsigned char c
);
104 #ifdef CONFIG_SLIP_MODE_SLIP6
105 static int slip_esc6(unsigned char *p
, unsigned char *d
, int len
);
106 static void slip_unesc6(struct slip
*sl
, unsigned char c
);
108 #ifdef CONFIG_SLIP_SMART
109 static void sl_keepalive(unsigned long sls
);
110 static void sl_outfill(unsigned long sls
);
111 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
114 /********************************
115 * Buffer administration routines:
120 * NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
121 * sl_realloc_bufs provides strong atomicity and reallocation
122 * on actively running device.
123 *********************************/
126 Allocate channel buffers.
129 static int sl_alloc_bufs(struct slip
*sl
, int mtu
)
135 #ifdef SL_INCLUDE_CSLIP
137 struct slcompress
*slcomp
= NULL
;
141 * Allocate the SLIP frame buffers:
143 * rbuff Receive buffer.
144 * xbuff Transmit buffer.
145 * cbuff Temporary compression buffer.
150 * allow for arrival of larger UDP packets, even if we say not to
151 * also fixes a bug in which SunOS sends 512-byte packets even with
156 rbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
159 xbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
162 #ifdef SL_INCLUDE_CSLIP
163 cbuff
= kmalloc(len
+ 4, GFP_KERNEL
);
166 slcomp
= slhc_init(16, 16);
170 spin_lock_bh(&sl
->lock
);
171 if (sl
->tty
== NULL
) {
172 spin_unlock_bh(&sl
->lock
);
180 rbuff
= xchg(&sl
->rbuff
, rbuff
);
181 xbuff
= xchg(&sl
->xbuff
, xbuff
);
182 #ifdef SL_INCLUDE_CSLIP
183 cbuff
= xchg(&sl
->cbuff
, cbuff
);
184 slcomp
= xchg(&sl
->slcomp
, slcomp
);
186 #ifdef CONFIG_SLIP_MODE_SLIP6
190 spin_unlock_bh(&sl
->lock
);
195 #ifdef SL_INCLUDE_CSLIP
204 /* Free a SLIP channel buffers. */
205 static void sl_free_bufs(struct slip
*sl
)
207 /* Free all SLIP frame buffers. */
208 kfree(xchg(&sl
->rbuff
, NULL
));
209 kfree(xchg(&sl
->xbuff
, NULL
));
210 #ifdef SL_INCLUDE_CSLIP
211 kfree(xchg(&sl
->cbuff
, NULL
));
212 slhc_free(xchg(&sl
->slcomp
, NULL
));
217 Reallocate slip channel buffers.
220 static int sl_realloc_bufs(struct slip
*sl
, int mtu
)
223 struct net_device
*dev
= sl
->dev
;
224 unsigned char *xbuff
, *rbuff
;
225 #ifdef SL_INCLUDE_CSLIP
226 unsigned char *cbuff
;
231 * allow for arrival of larger UDP packets, even if we say not to
232 * also fixes a bug in which SunOS sends 512-byte packets even with
238 xbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
239 rbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
240 #ifdef SL_INCLUDE_CSLIP
241 cbuff
= kmalloc(len
+ 4, GFP_ATOMIC
);
245 #ifdef SL_INCLUDE_CSLIP
246 if (xbuff
== NULL
|| rbuff
== NULL
|| cbuff
== NULL
) {
248 if (xbuff
== NULL
|| rbuff
== NULL
) {
251 printk(KERN_WARNING
"%s: unable to grow slip buffers, MTU change cancelled.\n",
257 spin_lock_bh(&sl
->lock
);
263 xbuff
= xchg(&sl
->xbuff
, xbuff
);
264 rbuff
= xchg(&sl
->rbuff
, rbuff
);
265 #ifdef SL_INCLUDE_CSLIP
266 cbuff
= xchg(&sl
->cbuff
, cbuff
);
269 if (sl
->xleft
<= len
) {
270 memcpy(sl
->xbuff
, sl
->xhead
, sl
->xleft
);
273 dev
->stats
.tx_dropped
++;
276 sl
->xhead
= sl
->xbuff
;
279 if (sl
->rcount
<= len
) {
280 memcpy(sl
->rbuff
, rbuff
, sl
->rcount
);
283 dev
->stats
.rx_over_errors
++;
284 set_bit(SLF_ERROR
, &sl
->flags
);
293 spin_unlock_bh(&sl
->lock
);
298 #ifdef SL_INCLUDE_CSLIP
305 /* Set the "sending" flag. This must be atomic hence the set_bit. */
306 static inline void sl_lock(struct slip
*sl
)
308 netif_stop_queue(sl
->dev
);
312 /* Clear the "sending" flag. This must be atomic, hence the ASM. */
313 static inline void sl_unlock(struct slip
*sl
)
315 netif_wake_queue(sl
->dev
);
318 /* Send one completely decapsulated IP datagram to the IP layer. */
319 static void sl_bump(struct slip
*sl
)
321 struct net_device
*dev
= sl
->dev
;
326 #ifdef SL_INCLUDE_CSLIP
327 if (sl
->mode
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) {
328 unsigned char c
= sl
->rbuff
[0];
329 if (c
& SL_TYPE_COMPRESSED_TCP
) {
330 /* ignore compressed packets when CSLIP is off */
331 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
332 printk(KERN_WARNING
"%s: compressed packet ignored\n", dev
->name
);
335 /* make sure we've reserved enough space for uncompress
337 if (count
+ 80 > sl
->buffsize
) {
338 dev
->stats
.rx_over_errors
++;
341 count
= slhc_uncompress(sl
->slcomp
, sl
->rbuff
, count
);
344 } else if (c
>= SL_TYPE_UNCOMPRESSED_TCP
) {
345 if (!(sl
->mode
& SL_MODE_CSLIP
)) {
346 /* turn on header compression */
347 sl
->mode
|= SL_MODE_CSLIP
;
348 sl
->mode
&= ~SL_MODE_ADAPTIVE
;
349 printk(KERN_INFO
"%s: header compression turned on\n", dev
->name
);
351 sl
->rbuff
[0] &= 0x4f;
352 if (slhc_remember(sl
->slcomp
, sl
->rbuff
, count
) <= 0)
356 #endif /* SL_INCLUDE_CSLIP */
358 dev
->stats
.rx_bytes
+= count
;
360 skb
= dev_alloc_skb(count
);
362 printk(KERN_WARNING
"%s: memory squeeze, dropping packet.\n", dev
->name
);
363 dev
->stats
.rx_dropped
++;
367 memcpy(skb_put(skb
, count
), sl
->rbuff
, count
);
368 skb_reset_mac_header(skb
);
369 skb
->protocol
= htons(ETH_P_IP
);
371 dev
->stats
.rx_packets
++;
374 /* Encapsulate one IP datagram and stuff into a TTY queue. */
375 static void sl_encaps(struct slip
*sl
, unsigned char *icp
, int len
)
380 if (len
> sl
->mtu
) { /* Sigh, shouldn't occur BUT ... */
381 printk(KERN_WARNING
"%s: truncating oversized transmit packet!\n", sl
->dev
->name
);
382 sl
->dev
->stats
.tx_dropped
++;
388 #ifdef SL_INCLUDE_CSLIP
389 if (sl
->mode
& SL_MODE_CSLIP
)
390 len
= slhc_compress(sl
->slcomp
, p
, len
, sl
->cbuff
, &p
, 1);
392 #ifdef CONFIG_SLIP_MODE_SLIP6
393 if (sl
->mode
& SL_MODE_SLIP6
)
394 count
= slip_esc6(p
, sl
->xbuff
, len
);
397 count
= slip_esc(p
, sl
->xbuff
, len
);
399 /* Order of next two lines is *very* important.
400 * When we are sending a little amount of data,
401 * the transfer may be completed inside the ops->write()
402 * routine, because it's running with interrupts enabled.
403 * In this case we *never* got WRITE_WAKEUP event,
404 * if we did not request it before write operation.
405 * 14 Oct 1994 Dmitry Gorodchanin.
407 set_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
408 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xbuff
, count
);
409 #ifdef SL_CHECK_TRANSMIT
410 netif_trans_update(sl
->dev
);
412 sl
->xleft
= count
- actual
;
413 sl
->xhead
= sl
->xbuff
+ actual
;
414 #ifdef CONFIG_SLIP_SMART
416 clear_bit(SLF_OUTWAIT
, &sl
->flags
); /* reset outfill flag */
420 /* Write out any remaining transmit buffer. Scheduled when tty is writable */
421 static void slip_transmit(struct work_struct
*work
)
423 struct slip
*sl
= container_of(work
, struct slip
, tx_work
);
426 spin_lock_bh(&sl
->lock
);
427 /* First make sure we're connected. */
428 if (!sl
->tty
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
)) {
429 spin_unlock_bh(&sl
->lock
);
433 if (sl
->xleft
<= 0) {
434 /* Now serial buffer is almost free & we can start
435 * transmission of another packet */
436 sl
->dev
->stats
.tx_packets
++;
437 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
438 spin_unlock_bh(&sl
->lock
);
443 actual
= sl
->tty
->ops
->write(sl
->tty
, sl
->xhead
, sl
->xleft
);
446 spin_unlock_bh(&sl
->lock
);
450 * Called by the driver when there's room for more data.
451 * Schedule the transmit.
453 static void slip_write_wakeup(struct tty_struct
*tty
)
455 struct slip
*sl
= tty
->disc_data
;
457 schedule_work(&sl
->tx_work
);
460 static void sl_tx_timeout(struct net_device
*dev
)
462 struct slip
*sl
= netdev_priv(dev
);
464 spin_lock(&sl
->lock
);
466 if (netif_queue_stopped(dev
)) {
467 if (!netif_running(dev
))
470 /* May be we must check transmitter timeout here ?
471 * 14 Oct 1994 Dmitry Gorodchanin.
473 #ifdef SL_CHECK_TRANSMIT
474 if (time_before(jiffies
, dev_trans_start(dev
) + 20 * HZ
)) {
475 /* 20 sec timeout not reached */
478 printk(KERN_WARNING
"%s: transmit timed out, %s?\n",
480 (tty_chars_in_buffer(sl
->tty
) || sl
->xleft
) ?
481 "bad line quality" : "driver error");
483 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
488 spin_unlock(&sl
->lock
);
492 /* Encapsulate an IP datagram and kick it into a TTY queue. */
494 sl_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
496 struct slip
*sl
= netdev_priv(dev
);
498 spin_lock(&sl
->lock
);
499 if (!netif_running(dev
)) {
500 spin_unlock(&sl
->lock
);
501 printk(KERN_WARNING
"%s: xmit call when iface is down\n", dev
->name
);
505 if (sl
->tty
== NULL
) {
506 spin_unlock(&sl
->lock
);
512 dev
->stats
.tx_bytes
+= skb
->len
;
513 sl_encaps(sl
, skb
->data
, skb
->len
);
514 spin_unlock(&sl
->lock
);
521 /******************************************
522 * Routines looking at netdevice side.
523 ******************************************/
525 /* Netdevice UP -> DOWN routine */
528 sl_close(struct net_device
*dev
)
530 struct slip
*sl
= netdev_priv(dev
);
532 spin_lock_bh(&sl
->lock
);
534 /* TTY discipline is running. */
535 clear_bit(TTY_DO_WRITE_WAKEUP
, &sl
->tty
->flags
);
536 netif_stop_queue(dev
);
539 spin_unlock_bh(&sl
->lock
);
544 /* Netdevice DOWN -> UP routine */
546 static int sl_open(struct net_device
*dev
)
548 struct slip
*sl
= netdev_priv(dev
);
553 sl
->flags
&= (1 << SLF_INUSE
);
554 netif_start_queue(dev
);
558 /* Netdevice change MTU request */
560 static int sl_change_mtu(struct net_device
*dev
, int new_mtu
)
562 struct slip
*sl
= netdev_priv(dev
);
564 return sl_realloc_bufs(sl
, new_mtu
);
567 /* Netdevice get statistics request */
570 sl_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
572 struct net_device_stats
*devstats
= &dev
->stats
;
573 #ifdef SL_INCLUDE_CSLIP
574 struct slip
*sl
= netdev_priv(dev
);
575 struct slcompress
*comp
= sl
->slcomp
;
577 stats
->rx_packets
= devstats
->rx_packets
;
578 stats
->tx_packets
= devstats
->tx_packets
;
579 stats
->rx_bytes
= devstats
->rx_bytes
;
580 stats
->tx_bytes
= devstats
->tx_bytes
;
581 stats
->rx_dropped
= devstats
->rx_dropped
;
582 stats
->tx_dropped
= devstats
->tx_dropped
;
583 stats
->tx_errors
= devstats
->tx_errors
;
584 stats
->rx_errors
= devstats
->rx_errors
;
585 stats
->rx_over_errors
= devstats
->rx_over_errors
;
587 #ifdef SL_INCLUDE_CSLIP
589 /* Generic compressed statistics */
590 stats
->rx_compressed
= comp
->sls_i_compressed
;
591 stats
->tx_compressed
= comp
->sls_o_compressed
;
593 /* Are we really still needs this? */
594 stats
->rx_fifo_errors
+= comp
->sls_i_compressed
;
595 stats
->rx_dropped
+= comp
->sls_i_tossed
;
596 stats
->tx_fifo_errors
+= comp
->sls_o_compressed
;
597 stats
->collisions
+= comp
->sls_o_misses
;
602 /* Netdevice register callback */
604 static int sl_init(struct net_device
*dev
)
606 struct slip
*sl
= netdev_priv(dev
);
609 * Finish setting up the DEVICE info.
613 dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
614 #ifdef SL_CHECK_TRANSMIT
615 dev
->watchdog_timeo
= 20*HZ
;
621 static void sl_uninit(struct net_device
*dev
)
623 struct slip
*sl
= netdev_priv(dev
);
628 /* Hook the destructor so we can free slip devices at the right point in time */
629 static void sl_free_netdev(struct net_device
*dev
)
631 int i
= dev
->base_addr
;
636 static const struct net_device_ops sl_netdev_ops
= {
638 .ndo_uninit
= sl_uninit
,
640 .ndo_stop
= sl_close
,
641 .ndo_start_xmit
= sl_xmit
,
642 .ndo_get_stats64
= sl_get_stats64
,
643 .ndo_change_mtu
= sl_change_mtu
,
644 .ndo_tx_timeout
= sl_tx_timeout
,
645 #ifdef CONFIG_SLIP_SMART
646 .ndo_do_ioctl
= sl_ioctl
,
651 static void sl_setup(struct net_device
*dev
)
653 dev
->netdev_ops
= &sl_netdev_ops
;
654 dev
->destructor
= sl_free_netdev
;
656 dev
->hard_header_len
= 0;
658 dev
->tx_queue_len
= 10;
660 /* MTU range: 68 - 65534 */
662 dev
->max_mtu
= 65534;
664 /* New-style flags. */
665 dev
->flags
= IFF_NOARP
|IFF_POINTOPOINT
|IFF_MULTICAST
;
668 /******************************************
669 Routines looking at TTY side.
670 ******************************************/
674 * Handle the 'receiver data ready' interrupt.
675 * This function is called by the 'tty_io' module in the kernel when
676 * a block of SLIP data has been received, which can now be decapsulated
677 * and sent on to some IP layer for further processing. This will not
678 * be re-entered while running but other ldisc functions may be called
682 static void slip_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
685 struct slip
*sl
= tty
->disc_data
;
687 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| !netif_running(sl
->dev
))
690 /* Read the characters out of the buffer */
693 if (!test_and_set_bit(SLF_ERROR
, &sl
->flags
))
694 sl
->dev
->stats
.rx_errors
++;
698 #ifdef CONFIG_SLIP_MODE_SLIP6
699 if (sl
->mode
& SL_MODE_SLIP6
)
700 slip_unesc6(sl
, *cp
++);
703 slip_unesc(sl
, *cp
++);
707 /************************************
708 * slip_open helper routines.
709 ************************************/
711 /* Collect hanged up channels */
712 static void sl_sync(void)
715 struct net_device
*dev
;
718 for (i
= 0; i
< slip_maxdev
; i
++) {
723 sl
= netdev_priv(dev
);
724 if (sl
->tty
|| sl
->leased
)
726 if (dev
->flags
& IFF_UP
)
732 /* Find a free SLIP channel, and link in this `tty' line. */
733 static struct slip
*sl_alloc(dev_t line
)
737 struct net_device
*dev
= NULL
;
740 for (i
= 0; i
< slip_maxdev
; i
++) {
745 /* Sorry, too many, all slots in use */
746 if (i
>= slip_maxdev
)
749 sprintf(name
, "sl%d", i
);
750 dev
= alloc_netdev(sizeof(*sl
), name
, NET_NAME_UNKNOWN
, sl_setup
);
755 sl
= netdev_priv(dev
);
757 /* Initialize channel control data */
758 sl
->magic
= SLIP_MAGIC
;
760 spin_lock_init(&sl
->lock
);
761 INIT_WORK(&sl
->tx_work
, slip_transmit
);
762 sl
->mode
= SL_MODE_DEFAULT
;
763 #ifdef CONFIG_SLIP_SMART
764 /* initialize timer_list struct */
765 init_timer(&sl
->keepalive_timer
);
766 sl
->keepalive_timer
.data
= (unsigned long)sl
;
767 sl
->keepalive_timer
.function
= sl_keepalive
;
768 init_timer(&sl
->outfill_timer
);
769 sl
->outfill_timer
.data
= (unsigned long)sl
;
770 sl
->outfill_timer
.function
= sl_outfill
;
777 * Open the high-level part of the SLIP channel.
778 * This function is called by the TTY module when the
779 * SLIP line discipline is called for. Because we are
780 * sure the tty line exists, we only have to link it to
781 * a free SLIP channel...
783 * Called in process context serialized from other ldisc calls.
786 static int slip_open(struct tty_struct
*tty
)
791 if (!capable(CAP_NET_ADMIN
))
794 if (tty
->ops
->write
== NULL
)
797 /* RTnetlink lock is misused here to serialize concurrent
798 opens of slip channels. There are better ways, but it is
803 /* Collect hanged up channels. */
809 /* First make sure we're not already connected. */
810 if (sl
&& sl
->magic
== SLIP_MAGIC
)
813 /* OK. Find a free SLIP channel to use. */
815 sl
= sl_alloc(tty_devnum(tty
));
821 sl
->pid
= current
->pid
;
823 if (!test_bit(SLF_INUSE
, &sl
->flags
)) {
824 /* Perform the low-level SLIP initialization. */
825 err
= sl_alloc_bufs(sl
, SL_MTU
);
829 set_bit(SLF_INUSE
, &sl
->flags
);
831 err
= register_netdevice(sl
->dev
);
836 #ifdef CONFIG_SLIP_SMART
838 sl
->keepalive_timer
.expires
= jiffies
+ sl
->keepalive
* HZ
;
839 add_timer(&sl
->keepalive_timer
);
842 sl
->outfill_timer
.expires
= jiffies
+ sl
->outfill
* HZ
;
843 add_timer(&sl
->outfill_timer
);
847 /* Done. We have linked the TTY line to a channel. */
849 tty
->receive_room
= 65536; /* We don't flow control */
851 /* TTY layer expects 0 on success */
859 tty
->disc_data
= NULL
;
860 clear_bit(SLF_INUSE
, &sl
->flags
);
865 /* Count references from TTY module */
870 * Close down a SLIP channel.
871 * This means flushing out any pending queues, and then returning. This
872 * call is serialized against other ldisc functions.
874 * We also use this method fo a hangup event
877 static void slip_close(struct tty_struct
*tty
)
879 struct slip
*sl
= tty
->disc_data
;
881 /* First make sure we're connected. */
882 if (!sl
|| sl
->magic
!= SLIP_MAGIC
|| sl
->tty
!= tty
)
885 spin_lock_bh(&sl
->lock
);
886 tty
->disc_data
= NULL
;
888 spin_unlock_bh(&sl
->lock
);
890 flush_work(&sl
->tx_work
);
892 /* VSV = very important to remove timers */
893 #ifdef CONFIG_SLIP_SMART
894 del_timer_sync(&sl
->keepalive_timer
);
895 del_timer_sync(&sl
->outfill_timer
);
897 /* Flush network side */
898 unregister_netdev(sl
->dev
);
899 /* This will complete via sl_free_netdev */
902 static int slip_hangup(struct tty_struct
*tty
)
907 /************************************************************************
908 * STANDARD SLIP ENCAPSULATION *
909 ************************************************************************/
911 static int slip_esc(unsigned char *s
, unsigned char *d
, int len
)
913 unsigned char *ptr
= d
;
917 * Send an initial END character to flush out any
918 * data that may have accumulated in the receiver
925 * For each byte in the packet, send the appropriate
926 * character sequence, according to the SLIP protocol.
948 static void slip_unesc(struct slip
*sl
, unsigned char s
)
953 #ifdef CONFIG_SLIP_SMART
954 /* drop keeptest bit = VSV */
955 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
956 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
959 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
962 clear_bit(SLF_ESCAPE
, &sl
->flags
);
967 set_bit(SLF_ESCAPE
, &sl
->flags
);
970 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
974 if (test_and_clear_bit(SLF_ESCAPE
, &sl
->flags
))
978 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
979 if (sl
->rcount
< sl
->buffsize
) {
980 sl
->rbuff
[sl
->rcount
++] = s
;
983 sl
->dev
->stats
.rx_over_errors
++;
984 set_bit(SLF_ERROR
, &sl
->flags
);
989 #ifdef CONFIG_SLIP_MODE_SLIP6
990 /************************************************************************
991 * 6 BIT SLIP ENCAPSULATION *
992 ************************************************************************/
994 static int slip_esc6(unsigned char *s
, unsigned char *d
, int len
)
996 unsigned char *ptr
= d
;
999 unsigned short v
= 0;
1003 * Send an initial END character to flush out any
1004 * data that may have accumulated in the receiver
1005 * due to line noise.
1011 * Encode the packet into printable ascii characters
1014 for (i
= 0; i
< len
; ++i
) {
1015 v
= (v
<< 8) | s
[i
];
1019 c
= 0x30 + ((v
>> bits
) & 0x3F);
1024 c
= 0x30 + ((v
<< (6 - bits
)) & 0x3F);
1031 static void slip_unesc6(struct slip
*sl
, unsigned char s
)
1036 #ifdef CONFIG_SLIP_SMART
1037 /* drop keeptest bit = VSV */
1038 if (test_bit(SLF_KEEPTEST
, &sl
->flags
))
1039 clear_bit(SLF_KEEPTEST
, &sl
->flags
);
1042 if (!test_and_clear_bit(SLF_ERROR
, &sl
->flags
) &&
1048 } else if (s
>= 0x30 && s
< 0x70) {
1049 sl
->xdata
= (sl
->xdata
<< 6) | ((s
- 0x30) & 0x3F);
1051 if (sl
->xbits
>= 8) {
1053 c
= (unsigned char)(sl
->xdata
>> sl
->xbits
);
1054 if (!test_bit(SLF_ERROR
, &sl
->flags
)) {
1055 if (sl
->rcount
< sl
->buffsize
) {
1056 sl
->rbuff
[sl
->rcount
++] = c
;
1059 sl
->dev
->stats
.rx_over_errors
++;
1060 set_bit(SLF_ERROR
, &sl
->flags
);
1065 #endif /* CONFIG_SLIP_MODE_SLIP6 */
1067 /* Perform I/O control on an active SLIP channel. */
1068 static int slip_ioctl(struct tty_struct
*tty
, struct file
*file
,
1069 unsigned int cmd
, unsigned long arg
)
1071 struct slip
*sl
= tty
->disc_data
;
1073 int __user
*p
= (int __user
*)arg
;
1075 /* First make sure we're connected. */
1076 if (!sl
|| sl
->magic
!= SLIP_MAGIC
)
1081 tmp
= strlen(sl
->dev
->name
) + 1;
1082 if (copy_to_user((void __user
*)arg
, sl
->dev
->name
, tmp
))
1087 if (put_user(sl
->mode
, p
))
1092 if (get_user(tmp
, p
))
1094 #ifndef SL_INCLUDE_CSLIP
1095 if (tmp
& (SL_MODE_CSLIP
|SL_MODE_ADAPTIVE
))
1098 if ((tmp
& (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
)) ==
1099 (SL_MODE_ADAPTIVE
| SL_MODE_CSLIP
))
1100 /* return -EINVAL; */
1101 tmp
&= ~SL_MODE_ADAPTIVE
;
1103 #ifndef CONFIG_SLIP_MODE_SLIP6
1104 if (tmp
& SL_MODE_SLIP6
)
1108 sl
->dev
->type
= ARPHRD_SLIP
+ sl
->mode
;
1114 #ifdef CONFIG_SLIP_SMART
1115 /* VSV changes start here */
1116 case SIOCSKEEPALIVE
:
1117 if (get_user(tmp
, p
))
1119 if (tmp
> 255) /* max for unchar */
1122 spin_lock_bh(&sl
->lock
);
1124 spin_unlock_bh(&sl
->lock
);
1127 sl
->keepalive
= (u8
)tmp
;
1128 if (sl
->keepalive
!= 0) {
1129 mod_timer(&sl
->keepalive_timer
,
1130 jiffies
+ sl
->keepalive
* HZ
);
1131 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1133 del_timer(&sl
->keepalive_timer
);
1134 spin_unlock_bh(&sl
->lock
);
1137 case SIOCGKEEPALIVE
:
1138 if (put_user(sl
->keepalive
, p
))
1143 if (get_user(tmp
, p
))
1145 if (tmp
> 255) /* max for unchar */
1147 spin_lock_bh(&sl
->lock
);
1149 spin_unlock_bh(&sl
->lock
);
1152 sl
->outfill
= (u8
)tmp
;
1153 if (sl
->outfill
!= 0) {
1154 mod_timer(&sl
->outfill_timer
,
1155 jiffies
+ sl
->outfill
* HZ
);
1156 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1158 del_timer(&sl
->outfill_timer
);
1159 spin_unlock_bh(&sl
->lock
);
1163 if (put_user(sl
->outfill
, p
))
1166 /* VSV changes end */
1169 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1173 #ifdef CONFIG_COMPAT
1174 static long slip_compat_ioctl(struct tty_struct
*tty
, struct file
*file
,
1175 unsigned int cmd
, unsigned long arg
)
1182 case SIOCSKEEPALIVE
:
1183 case SIOCGKEEPALIVE
:
1186 return slip_ioctl(tty
, file
, cmd
,
1187 (unsigned long)compat_ptr(arg
));
1190 return -ENOIOCTLCMD
;
1194 /* VSV changes start here */
1195 #ifdef CONFIG_SLIP_SMART
1196 /* function do_ioctl called from net/core/dev.c
1197 to allow get/set outfill/keepalive parameter
1200 static int sl_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1202 struct slip
*sl
= netdev_priv(dev
);
1203 unsigned long *p
= (unsigned long *)&rq
->ifr_ifru
;
1205 if (sl
== NULL
) /* Allocation failed ?? */
1208 spin_lock_bh(&sl
->lock
);
1211 spin_unlock_bh(&sl
->lock
);
1216 case SIOCSKEEPALIVE
:
1217 /* max for unchar */
1218 if ((unsigned)*p
> 255) {
1219 spin_unlock_bh(&sl
->lock
);
1222 sl
->keepalive
= (u8
)*p
;
1223 if (sl
->keepalive
!= 0) {
1224 sl
->keepalive_timer
.expires
=
1225 jiffies
+ sl
->keepalive
* HZ
;
1226 mod_timer(&sl
->keepalive_timer
,
1227 jiffies
+ sl
->keepalive
* HZ
);
1228 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1230 del_timer(&sl
->keepalive_timer
);
1233 case SIOCGKEEPALIVE
:
1238 if ((unsigned)*p
> 255) { /* max for unchar */
1239 spin_unlock_bh(&sl
->lock
);
1242 sl
->outfill
= (u8
)*p
;
1243 if (sl
->outfill
!= 0) {
1244 mod_timer(&sl
->outfill_timer
,
1245 jiffies
+ sl
->outfill
* HZ
);
1246 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1248 del_timer(&sl
->outfill_timer
);
1256 /* Resolve race condition, when ioctl'ing hanged up
1257 and opened by another process device.
1259 if (sl
->tty
!= current
->signal
->tty
&&
1260 sl
->pid
!= current
->pid
) {
1261 spin_unlock_bh(&sl
->lock
);
1272 spin_unlock_bh(&sl
->lock
);
1276 /* VSV changes end */
1278 static struct tty_ldisc_ops sl_ldisc
= {
1279 .owner
= THIS_MODULE
,
1280 .magic
= TTY_LDISC_MAGIC
,
1283 .close
= slip_close
,
1284 .hangup
= slip_hangup
,
1285 .ioctl
= slip_ioctl
,
1286 #ifdef CONFIG_COMPAT
1287 .compat_ioctl
= slip_compat_ioctl
,
1289 .receive_buf
= slip_receive_buf
,
1290 .write_wakeup
= slip_write_wakeup
,
1293 static int __init
slip_init(void)
1297 if (slip_maxdev
< 4)
1298 slip_maxdev
= 4; /* Sanity */
1300 printk(KERN_INFO
"SLIP: version %s (dynamic channels, max=%d)"
1301 #ifdef CONFIG_SLIP_MODE_SLIP6
1302 " (6 bit encapsulation enabled)"
1305 SLIP_VERSION
, slip_maxdev
);
1306 #if defined(SL_INCLUDE_CSLIP)
1307 printk(KERN_INFO
"CSLIP: code copyright 1989 Regents of the University of California.\n");
1309 #ifdef CONFIG_SLIP_SMART
1310 printk(KERN_INFO
"SLIP linefill/keepalive option.\n");
1313 slip_devs
= kzalloc(sizeof(struct net_device
*)*slip_maxdev
,
1318 /* Fill in our line protocol discipline, and register it */
1319 status
= tty_register_ldisc(N_SLIP
, &sl_ldisc
);
1321 printk(KERN_ERR
"SLIP: can't register line discipline (err = %d)\n", status
);
1327 static void __exit
slip_exit(void)
1330 struct net_device
*dev
;
1332 unsigned long timeout
= jiffies
+ HZ
;
1335 if (slip_devs
== NULL
)
1338 /* First of all: check for active disciplines and hangup them.
1342 msleep_interruptible(100);
1345 for (i
= 0; i
< slip_maxdev
; i
++) {
1349 sl
= netdev_priv(dev
);
1350 spin_lock_bh(&sl
->lock
);
1353 tty_hangup(sl
->tty
);
1355 spin_unlock_bh(&sl
->lock
);
1357 } while (busy
&& time_before(jiffies
, timeout
));
1359 /* FIXME: hangup is async so we should wait when doing this second
1362 for (i
= 0; i
< slip_maxdev
; i
++) {
1366 slip_devs
[i
] = NULL
;
1368 sl
= netdev_priv(dev
);
1370 printk(KERN_ERR
"%s: tty discipline still running\n",
1372 /* Intentionally leak the control block. */
1373 dev
->destructor
= NULL
;
1376 unregister_netdev(dev
);
1382 i
= tty_unregister_ldisc(N_SLIP
);
1384 printk(KERN_ERR
"SLIP: can't unregister line discipline (err = %d)\n", i
);
1387 module_init(slip_init
);
1388 module_exit(slip_exit
);
1390 #ifdef CONFIG_SLIP_SMART
1392 * This is start of the code for multislip style line checking
1393 * added by Stanislav Voronyi. All changes before marked VSV
1396 static void sl_outfill(unsigned long sls
)
1398 struct slip
*sl
= (struct slip
*)sls
;
1400 spin_lock(&sl
->lock
);
1402 if (sl
->tty
== NULL
)
1406 if (test_bit(SLF_OUTWAIT
, &sl
->flags
)) {
1407 /* no packets were transmitted, do outfill */
1408 #ifdef CONFIG_SLIP_MODE_SLIP6
1409 unsigned char s
= (sl
->mode
& SL_MODE_SLIP6
)?0x70:END
;
1411 unsigned char s
= END
;
1413 /* put END into tty queue. Is it right ??? */
1414 if (!netif_queue_stopped(sl
->dev
)) {
1415 /* if device busy no outfill */
1416 sl
->tty
->ops
->write(sl
->tty
, &s
, 1);
1419 set_bit(SLF_OUTWAIT
, &sl
->flags
);
1421 mod_timer(&sl
->outfill_timer
, jiffies
+sl
->outfill
*HZ
);
1424 spin_unlock(&sl
->lock
);
1427 static void sl_keepalive(unsigned long sls
)
1429 struct slip
*sl
= (struct slip
*)sls
;
1431 spin_lock(&sl
->lock
);
1433 if (sl
->tty
== NULL
)
1436 if (sl
->keepalive
) {
1437 if (test_bit(SLF_KEEPTEST
, &sl
->flags
)) {
1438 /* keepalive still high :(, we must hangup */
1440 /* outfill timer must be deleted too */
1441 (void)del_timer(&sl
->outfill_timer
);
1442 printk(KERN_DEBUG
"%s: no packets received during keepalive timeout, hangup.\n", sl
->dev
->name
);
1443 /* this must hangup tty & close slip */
1444 tty_hangup(sl
->tty
);
1445 /* I think we need not something else */
1448 set_bit(SLF_KEEPTEST
, &sl
->flags
);
1450 mod_timer(&sl
->keepalive_timer
, jiffies
+sl
->keepalive
*HZ
);
1453 spin_unlock(&sl
->lock
);
1457 MODULE_LICENSE("GPL");
1458 MODULE_ALIAS_LDISC(N_SLIP
);