2019-05-19 06:08:20 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
|
* slip.c This module implements the SLIP protocol for kernel-based
|
|
|
|
|
* devices like TTY. It interfaces between a raw TTY, and the
|
|
|
|
|
* kernel's INET protocol layers.
|
|
|
|
|
*
|
|
|
|
|
* Version: @(#)slip.c 0.8.3 12/24/94
|
|
|
|
|
*
|
|
|
|
|
* Authors: Laurence Culhane, <loz@holmes.demon.co.uk>
|
|
|
|
|
* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
|
|
|
|
|
*
|
|
|
|
|
* Fixes:
|
|
|
|
|
* Alan Cox : Sanity checks and avoid tx overruns.
|
|
|
|
|
* Has a new sl->mtu field.
|
2007-11-19 08:03:38 -07:00
|
|
|
* Alan Cox : Found cause of overrun. ifconfig sl0
|
|
|
|
|
* mtu upwards. Driver now spots this
|
|
|
|
|
* and grows/shrinks its buffers(hack!).
|
|
|
|
|
* Memory leak if you run out of memory
|
|
|
|
|
* setting up a slip driver fixed.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Matt Dillon : Printable slip (borrowed from NET2E)
|
|
|
|
|
* Pauline Middelink : Slip driver fixes.
|
|
|
|
|
* Alan Cox : Honours the old SL_COMPRESSED flag
|
|
|
|
|
* Alan Cox : KISS AX.25 and AXUI IP support
|
|
|
|
|
* Michael Riepe : Automatic CSLIP recognition added
|
|
|
|
|
* Charles Hedrick : CSLIP header length problem fix.
|
|
|
|
|
* Alan Cox : Corrected non-IP cases of the above.
|
|
|
|
|
* Alan Cox : Now uses hardware type as per FvK.
|
|
|
|
|
* Alan Cox : Default to 192.168.0.0 (RFC 1597)
|
|
|
|
|
* A.N.Kuznetsov : dev_tint() recursion fix.
|
|
|
|
|
* Dmitry Gorodchanin : SLIP memory leaks
|
|
|
|
|
* Dmitry Gorodchanin : Code cleanup. Reduce tty driver
|
|
|
|
|
* buffering from 4096 to 256 bytes.
|
|
|
|
|
* Improving SLIP response time.
|
|
|
|
|
* CONFIG_SLIP_MODE_SLIP6.
|
2007-11-19 08:03:38 -07:00
|
|
|
* ifconfig sl? up & down now works
|
|
|
|
|
* correctly.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Modularization.
|
|
|
|
|
* Alan Cox : Oops - fix AX.25 buffer lengths
|
|
|
|
|
* Dmitry Gorodchanin : Even more cleanups. Preserve CSLIP
|
|
|
|
|
* statistics. Include CSLIP code only
|
|
|
|
|
* if it really needed.
|
|
|
|
|
* Alan Cox : Free slhc buffers in the right place.
|
|
|
|
|
* Alan Cox : Allow for digipeated IP over AX.25
|
|
|
|
|
* Matti Aarnio : Dynamic SLIP devices, with ideas taken
|
|
|
|
|
* from Jim Freeman's <jfree@caldera.com>
|
|
|
|
|
* dynamic PPP devices. We do NOT kfree()
|
|
|
|
|
* device entries, just reg./unreg. them
|
|
|
|
|
* as they are needed. We kfree() them
|
|
|
|
|
* at module cleanup.
|
2007-11-19 08:03:38 -07:00
|
|
|
* With MODULE-loading ``insmod'', user
|
|
|
|
|
* can issue parameter: slip_maxdev=1024
|
|
|
|
|
* (Or how much he/she wants.. Default
|
|
|
|
|
* is 256)
|
|
|
|
|
* Stanislav Voronyi : Slip line checking, with ideas taken
|
|
|
|
|
* from multislip BSDI driver which was
|
|
|
|
|
* written by Igor Chechik, RELCOM Corp.
|
|
|
|
|
* Only algorithms have been ported to
|
|
|
|
|
* Linux SLIP driver.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Vitaly E. Lavrov : Sane behaviour on tty hangup.
|
2007-11-19 08:03:38 -07:00
|
|
|
* Alexey Kuznetsov : Cleanup interfaces to tty & netdevice
|
|
|
|
|
* modules.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define SL_CHECK_TRANSMIT
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
|
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/bitops.h>
|
2017-02-08 10:51:30 -07:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/in.h>
|
|
|
|
|
#include <linux/tty.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
|
#include <linux/if_slip.h>
|
2005-06-28 17:27:32 -06:00
|
|
|
#include <linux/delay.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/init.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2014-06-15 20:23:16 -06:00
|
|
|
#include <linux/workqueue.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "slip.h"
|
|
|
|
|
#ifdef CONFIG_INET
|
|
|
|
|
#include <linux/ip.h>
|
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
|
#include <net/slhc_vj.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define SLIP_VERSION "0.8.4-NET3.019-NEWTTY"
|
|
|
|
|
|
|
|
|
|
static struct net_device **slip_devs;
|
|
|
|
|
|
|
|
|
|
static int slip_maxdev = SL_NRUNIT;
|
|
|
|
|
module_param(slip_maxdev, int, 0);
|
|
|
|
|
MODULE_PARM_DESC(slip_maxdev, "Maximum number of slip devices");
|
|
|
|
|
|
|
|
|
|
static int slip_esc(unsigned char *p, unsigned char *d, int len);
|
|
|
|
|
static void slip_unesc(struct slip *sl, unsigned char c);
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
static int slip_esc6(unsigned char *p, unsigned char *d, int len);
|
|
|
|
|
static void slip_unesc6(struct slip *sl, unsigned char c);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
static void sl_keepalive(struct timer_list *t);
|
|
|
|
|
static void sl_outfill(struct timer_list *t);
|
2007-11-19 08:03:38 -07:00
|
|
|
static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/********************************
|
|
|
|
|
* Buffer administration routines:
|
|
|
|
|
* sl_alloc_bufs()
|
|
|
|
|
* sl_free_bufs()
|
|
|
|
|
* sl_realloc_bufs()
|
|
|
|
|
*
|
|
|
|
|
* NOTE: sl_realloc_bufs != sl_free_bufs + sl_alloc_bufs, because
|
|
|
|
|
* sl_realloc_bufs provides strong atomicity and reallocation
|
|
|
|
|
* on actively running device.
|
|
|
|
|
*********************************/
|
|
|
|
|
|
2006-09-13 11:24:59 -06:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
Allocate channel buffers.
|
|
|
|
|
*/
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static int sl_alloc_bufs(struct slip *sl, int mtu)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
int err = -ENOBUFS;
|
|
|
|
|
unsigned long len;
|
2007-11-19 08:03:38 -07:00
|
|
|
char *rbuff = NULL;
|
|
|
|
|
char *xbuff = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2007-11-19 08:03:38 -07:00
|
|
|
char *cbuff = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct slcompress *slcomp = NULL;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate the SLIP frame buffers:
|
|
|
|
|
*
|
|
|
|
|
* rbuff Receive buffer.
|
|
|
|
|
* xbuff Transmit buffer.
|
|
|
|
|
* cbuff Temporary compression buffer.
|
|
|
|
|
*/
|
|
|
|
|
len = mtu * 2;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* allow for arrival of larger UDP packets, even if we say not to
|
|
|
|
|
* also fixes a bug in which SunOS sends 512-byte packets even with
|
|
|
|
|
* an MSS of 128
|
|
|
|
|
*/
|
|
|
|
|
if (len < 576 * 2)
|
|
|
|
|
len = 576 * 2;
|
|
|
|
|
rbuff = kmalloc(len + 4, GFP_KERNEL);
|
|
|
|
|
if (rbuff == NULL)
|
|
|
|
|
goto err_exit;
|
|
|
|
|
xbuff = kmalloc(len + 4, GFP_KERNEL);
|
|
|
|
|
if (xbuff == NULL)
|
|
|
|
|
goto err_exit;
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
cbuff = kmalloc(len + 4, GFP_KERNEL);
|
|
|
|
|
if (cbuff == NULL)
|
|
|
|
|
goto err_exit;
|
|
|
|
|
slcomp = slhc_init(16, 16);
|
2015-11-01 09:22:53 -07:00
|
|
|
if (IS_ERR(slcomp))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto err_exit;
|
|
|
|
|
#endif
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
if (sl->tty == NULL) {
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
err = -ENODEV;
|
|
|
|
|
goto err_exit;
|
|
|
|
|
}
|
|
|
|
|
sl->mtu = mtu;
|
|
|
|
|
sl->buffsize = len;
|
|
|
|
|
sl->rcount = 0;
|
|
|
|
|
sl->xleft = 0;
|
|
|
|
|
rbuff = xchg(&sl->rbuff, rbuff);
|
|
|
|
|
xbuff = xchg(&sl->xbuff, xbuff);
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
cbuff = xchg(&sl->cbuff, cbuff);
|
|
|
|
|
slcomp = xchg(&sl->slcomp, slcomp);
|
2011-07-10 02:49:26 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
sl->xdata = 0;
|
|
|
|
|
sl->xbits = 0;
|
|
|
|
|
#endif
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
|
|
/* Cleanup */
|
|
|
|
|
err_exit:
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2005-04-24 19:59:30 -06:00
|
|
|
kfree(cbuff);
|
2011-07-12 15:45:37 -06:00
|
|
|
slhc_free(slcomp);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2005-04-24 19:59:30 -06:00
|
|
|
kfree(xbuff);
|
|
|
|
|
kfree(rbuff);
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free a SLIP channel buffers. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static void sl_free_bufs(struct slip *sl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
/* Free all SLIP frame buffers. */
|
2005-06-23 22:06:56 -06:00
|
|
|
kfree(xchg(&sl->rbuff, NULL));
|
|
|
|
|
kfree(xchg(&sl->xbuff, NULL));
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2005-06-23 22:06:56 -06:00
|
|
|
kfree(xchg(&sl->cbuff, NULL));
|
|
|
|
|
slhc_free(xchg(&sl->slcomp, NULL));
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2006-09-13 11:24:59 -06:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
Reallocate slip channel buffers.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int sl_realloc_bufs(struct slip *sl, int mtu)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
struct net_device *dev = sl->dev;
|
|
|
|
|
unsigned char *xbuff, *rbuff;
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
unsigned char *cbuff;
|
|
|
|
|
#endif
|
|
|
|
|
int len = mtu * 2;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* allow for arrival of larger UDP packets, even if we say not to
|
|
|
|
|
* also fixes a bug in which SunOS sends 512-byte packets even with
|
|
|
|
|
* an MSS of 128
|
|
|
|
|
*/
|
|
|
|
|
if (len < 576 * 2)
|
|
|
|
|
len = 576 * 2;
|
|
|
|
|
|
2006-12-13 01:35:56 -07:00
|
|
|
xbuff = kmalloc(len + 4, GFP_ATOMIC);
|
|
|
|
|
rbuff = kmalloc(len + 4, GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2006-12-13 01:35:56 -07:00
|
|
|
cbuff = kmalloc(len + 4, GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
if (xbuff == NULL || rbuff == NULL || cbuff == NULL) {
|
|
|
|
|
#else
|
|
|
|
|
if (xbuff == NULL || rbuff == NULL) {
|
|
|
|
|
#endif
|
2011-07-12 15:46:17 -06:00
|
|
|
if (mtu > sl->mtu) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_WARNING "%s: unable to grow slip buffers, MTU change cancelled.\n",
|
|
|
|
|
dev->name);
|
|
|
|
|
err = -ENOBUFS;
|
|
|
|
|
}
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
|
|
|
|
|
err = -ENODEV;
|
|
|
|
|
if (sl->tty == NULL)
|
|
|
|
|
goto done_on_bh;
|
|
|
|
|
|
|
|
|
|
xbuff = xchg(&sl->xbuff, xbuff);
|
|
|
|
|
rbuff = xchg(&sl->rbuff, rbuff);
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
cbuff = xchg(&sl->cbuff, cbuff);
|
|
|
|
|
#endif
|
|
|
|
|
if (sl->xleft) {
|
|
|
|
|
if (sl->xleft <= len) {
|
|
|
|
|
memcpy(sl->xbuff, sl->xhead, sl->xleft);
|
|
|
|
|
} else {
|
|
|
|
|
sl->xleft = 0;
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.tx_dropped++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
sl->xhead = sl->xbuff;
|
|
|
|
|
|
|
|
|
|
if (sl->rcount) {
|
|
|
|
|
if (sl->rcount <= len) {
|
|
|
|
|
memcpy(sl->rbuff, rbuff, sl->rcount);
|
|
|
|
|
} else {
|
|
|
|
|
sl->rcount = 0;
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.rx_over_errors++;
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_ERROR, &sl->flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
sl->mtu = mtu;
|
|
|
|
|
dev->mtu = mtu;
|
|
|
|
|
sl->buffsize = len;
|
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
|
|
done_on_bh:
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
|
|
|
|
|
done:
|
2005-04-24 19:59:30 -06:00
|
|
|
kfree(xbuff);
|
|
|
|
|
kfree(rbuff);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2005-04-24 19:59:30 -06:00
|
|
|
kfree(cbuff);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Set the "sending" flag. This must be atomic hence the set_bit. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static inline void sl_lock(struct slip *sl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
netif_stop_queue(sl->dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Clear the "sending" flag. This must be atomic, hence the ASM. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static inline void sl_unlock(struct slip *sl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
netif_wake_queue(sl->dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Send one completely decapsulated IP datagram to the IP layer. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static void sl_bump(struct slip *sl)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-08-26 16:12:08 -06:00
|
|
|
struct net_device *dev = sl->dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
int count;
|
|
|
|
|
|
|
|
|
|
count = sl->rcount;
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
if (sl->mode & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) {
|
2007-11-19 08:03:38 -07:00
|
|
|
unsigned char c = sl->rbuff[0];
|
|
|
|
|
if (c & SL_TYPE_COMPRESSED_TCP) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* ignore compressed packets when CSLIP is off */
|
|
|
|
|
if (!(sl->mode & SL_MODE_CSLIP)) {
|
2010-08-26 16:12:08 -06:00
|
|
|
printk(KERN_WARNING "%s: compressed packet ignored\n", dev->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
/* make sure we've reserved enough space for uncompress
|
|
|
|
|
to use */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (count + 80 > sl->buffsize) {
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.rx_over_errors++;
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
count = slhc_uncompress(sl->slcomp, sl->rbuff, count);
|
2007-11-19 08:03:38 -07:00
|
|
|
if (count <= 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
} else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
|
|
|
|
|
if (!(sl->mode & SL_MODE_CSLIP)) {
|
|
|
|
|
/* turn on header compression */
|
|
|
|
|
sl->mode |= SL_MODE_CSLIP;
|
|
|
|
|
sl->mode &= ~SL_MODE_ADAPTIVE;
|
2010-08-26 16:12:08 -06:00
|
|
|
printk(KERN_INFO "%s: header compression turned on\n", dev->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
sl->rbuff[0] &= 0x4f;
|
2007-11-19 08:03:38 -07:00
|
|
|
if (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /* SL_INCLUDE_CSLIP */
|
|
|
|
|
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.rx_bytes += count;
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
skb = dev_alloc_skb(count);
|
2007-11-19 08:03:38 -07:00
|
|
|
if (skb == NULL) {
|
2010-08-26 16:12:08 -06:00
|
|
|
printk(KERN_WARNING "%s: memory squeeze, dropping packet.\n", dev->name);
|
|
|
|
|
dev->stats.rx_dropped++;
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
}
|
2010-08-26 16:12:08 -06:00
|
|
|
skb->dev = dev;
|
networking: introduce and use skb_put_data()
A common pattern with skb_put() is to just want to memcpy()
some data into the new space, introduce skb_put_data() for
this.
An spatch similar to the one for skb_put_zero() converts many
of the places using it:
@@
identifier p, p2;
expression len, skb, data;
type t, t2;
@@
(
-p = skb_put(skb, len);
+p = skb_put_data(skb, data, len);
|
-p = (t)skb_put(skb, len);
+p = skb_put_data(skb, data, len);
)
(
p2 = (t2)p;
-memcpy(p2, data, len);
|
-memcpy(p, data, len);
)
@@
type t, t2;
identifier p, p2;
expression skb, data;
@@
t *p;
...
(
-p = skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
|
-p = (t *)skb_put(skb, sizeof(t));
+p = skb_put_data(skb, data, sizeof(t));
)
(
p2 = (t2)p;
-memcpy(p2, data, sizeof(*p));
|
-memcpy(p, data, sizeof(*p));
)
@@
expression skb, len, data;
@@
-memcpy(skb_put(skb, len), data, len);
+skb_put_data(skb, data, len);
(again, manually post-processed to retain some comments)
Reviewed-by: Stephen Hemminger <stephen@networkplumber.org>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 06:29:20 -06:00
|
|
|
skb_put_data(skb, sl->rbuff, count);
|
2007-03-19 16:33:04 -06:00
|
|
|
skb_reset_mac_header(skb);
|
2007-11-19 08:03:38 -07:00
|
|
|
skb->protocol = htons(ETH_P_IP);
|
2011-08-05 03:23:51 -06:00
|
|
|
netif_rx_ni(skb);
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.rx_packets++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Encapsulate one IP datagram and stuff into a TTY queue. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static void sl_encaps(struct slip *sl, unsigned char *icp, int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
unsigned char *p;
|
|
|
|
|
int actual, count;
|
|
|
|
|
|
|
|
|
|
if (len > sl->mtu) { /* Sigh, shouldn't occur BUT ... */
|
|
|
|
|
printk(KERN_WARNING "%s: truncating oversized transmit packet!\n", sl->dev->name);
|
2010-08-26 16:12:08 -06:00
|
|
|
sl->dev->stats.tx_dropped++;
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_unlock(sl);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = icp;
|
|
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->mode & SL_MODE_CSLIP)
|
2005-04-16 16:20:36 -06:00
|
|
|
len = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->mode & SL_MODE_SLIP6)
|
2012-06-04 06:44:18 -06:00
|
|
|
count = slip_esc6(p, sl->xbuff, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
|
#endif
|
2012-06-04 06:44:18 -06:00
|
|
|
count = slip_esc(p, sl->xbuff, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
/* Order of next two lines is *very* important.
|
|
|
|
|
* When we are sending a little amount of data,
|
2008-04-30 01:54:13 -06:00
|
|
|
* the transfer may be completed inside the ops->write()
|
2005-04-16 16:20:36 -06:00
|
|
|
* routine, because it's running with interrupts enabled.
|
|
|
|
|
* In this case we *never* got WRITE_WAKEUP event,
|
|
|
|
|
* if we did not request it before write operation.
|
|
|
|
|
* 14 Oct 1994 Dmitry Gorodchanin.
|
|
|
|
|
*/
|
2008-12-05 23:31:52 -07:00
|
|
|
set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
|
2008-04-30 01:54:13 -06:00
|
|
|
actual = sl->tty->ops->write(sl->tty, sl->xbuff, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_CHECK_TRANSMIT
|
2016-05-03 08:33:13 -06:00
|
|
|
netif_trans_update(sl->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
sl->xleft = count - actual;
|
|
|
|
|
sl->xhead = sl->xbuff + actual;
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/* VSV */
|
|
|
|
|
clear_bit(SLF_OUTWAIT, &sl->flags); /* reset outfill flag */
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-15 20:23:16 -06:00
|
|
|
/* Write out any remaining transmit buffer. Scheduled when tty is writable */
|
|
|
|
|
static void slip_transmit(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-06-15 20:23:16 -06:00
|
|
|
struct slip *sl = container_of(work, struct slip, tx_work);
|
2005-04-16 16:20:36 -06:00
|
|
|
int actual;
|
|
|
|
|
|
2014-06-15 20:23:16 -06:00
|
|
|
spin_lock_bh(&sl->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* First make sure we're connected. */
|
2014-06-15 20:23:16 -06:00
|
|
|
if (!sl->tty || sl->magic != SLIP_MAGIC || !netif_running(sl->dev)) {
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2014-06-15 20:23:16 -06:00
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sl->xleft <= 0) {
|
|
|
|
|
/* Now serial buffer is almost free & we can start
|
|
|
|
|
* transmission of another packet */
|
2010-08-26 16:12:08 -06:00
|
|
|
sl->dev->stats.tx_packets++;
|
2014-06-15 20:23:16 -06:00
|
|
|
clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
|
2014-04-26 13:18:32 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_unlock(sl);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-15 20:23:16 -06:00
|
|
|
actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft);
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->xleft -= actual;
|
|
|
|
|
sl->xhead += actual;
|
2014-04-26 13:18:32 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
2014-06-15 20:23:16 -06:00
|
|
|
/*
|
|
|
|
|
* Called by the driver when there's room for more data.
|
|
|
|
|
* Schedule the transmit.
|
|
|
|
|
*/
|
|
|
|
|
static void slip_write_wakeup(struct tty_struct *tty)
|
|
|
|
|
{
|
2020-01-21 06:42:58 -07:00
|
|
|
struct slip *sl;
|
|
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
sl = rcu_dereference(tty->disc_data);
|
|
|
|
|
if (!sl)
|
|
|
|
|
goto out;
|
2014-06-15 20:23:16 -06:00
|
|
|
|
|
|
|
|
schedule_work(&sl->tx_work);
|
2020-01-21 06:42:58 -07:00
|
|
|
out:
|
|
|
|
|
rcu_read_unlock();
|
2014-06-15 20:23:16 -06:00
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void sl_tx_timeout(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
spin_lock(&sl->lock);
|
|
|
|
|
|
|
|
|
|
if (netif_queue_stopped(dev)) {
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/* May be we must check transmitter timeout here ?
|
|
|
|
|
* 14 Oct 1994 Dmitry Gorodchanin.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef SL_CHECK_TRANSMIT
|
2010-05-10 06:01:31 -06:00
|
|
|
if (time_before(jiffies, dev_trans_start(dev) + 20 * HZ)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* 20 sec timeout not reached */
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
printk(KERN_WARNING "%s: transmit timed out, %s?\n",
|
|
|
|
|
dev->name,
|
2008-04-30 01:54:13 -06:00
|
|
|
(tty_chars_in_buffer(sl->tty) || sl->xleft) ?
|
2007-11-19 08:03:38 -07:00
|
|
|
"bad line quality" : "driver error");
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->xleft = 0;
|
2008-12-05 23:31:52 -07:00
|
|
|
clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_unlock(sl);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Encapsulate an IP datagram and kick it into a TTY queue. */
|
2009-08-31 13:50:51 -06:00
|
|
|
static netdev_tx_t
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
spin_lock(&sl->lock);
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!netif_running(dev)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
printk(KERN_WARNING "%s: xmit call when iface is down\n", dev->name);
|
|
|
|
|
dev_kfree_skb(skb);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
if (sl->tty == NULL) {
|
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
dev_kfree_skb(skb);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sl_lock(sl);
|
2010-08-26 16:12:08 -06:00
|
|
|
dev->stats.tx_bytes += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_encaps(sl, skb->data, skb->len);
|
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
|
|
|
|
|
dev_kfree_skb(skb);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************
|
|
|
|
|
* Routines looking at netdevice side.
|
|
|
|
|
******************************************/
|
|
|
|
|
|
|
|
|
|
/* Netdevice UP -> DOWN routine */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
sl_close(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
2008-12-05 23:31:52 -07:00
|
|
|
if (sl->tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
/* TTY discipline is running. */
|
2008-12-05 23:31:52 -07:00
|
|
|
clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
sl->rcount = 0;
|
|
|
|
|
sl->xleft = 0;
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Netdevice DOWN -> UP routine */
|
|
|
|
|
|
|
|
|
|
static int sl_open(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->tty == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
sl->flags &= (1 << SLF_INUSE);
|
|
|
|
|
netif_start_queue(dev);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Netdevice change MTU request */
|
|
|
|
|
|
|
|
|
|
static int sl_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
net: use core MTU range checking in misc drivers
firewire-net:
- set min/max_mtu
- remove fwnet_change_mtu
nes:
- set max_mtu
- clean up nes_netdev_change_mtu
xpnet:
- set min/max_mtu
- remove xpnet_dev_change_mtu
hippi:
- set min/max_mtu
- remove hippi_change_mtu
batman-adv:
- set max_mtu
- remove batadv_interface_change_mtu
- initialization is a little async, not 100% certain that max_mtu is set
in the optimal place, don't have hardware to test with
rionet:
- set min/max_mtu
- remove rionet_change_mtu
slip:
- set min/max_mtu
- streamline sl_change_mtu
um/net_kern:
- remove pointless ndo_change_mtu
hsi/clients/ssi_protocol:
- use core MTU range checking
- remove now redundant ssip_pn_set_mtu
ipoib:
- set a default max MTU value
- Note: ipoib's actual max MTU can vary, depending on if the device is in
connected mode or not, so we'll just set the max_mtu value to the max
possible, and let the ndo_change_mtu function continue to validate any new
MTU change requests with checks for CM or not. Note that ipoib has no
min_mtu set, and thus, the network core's mtu > 0 check is the only lower
bounds here.
mptlan:
- use net core MTU range checking
- remove now redundant mpt_lan_change_mtu
fddi:
- min_mtu = 21, max_mtu = 4470
- remove now redundant fddi_change_mtu (including export)
fjes:
- min_mtu = 8192, max_mtu = 65536
- The max_mtu value is actually one over IP_MAX_MTU here, but the idea is to
get past the core net MTU range checks so fjes_change_mtu can validate a
new MTU against what it supports (see fjes_support_mtu in fjes_hw.c)
hsr:
- min_mtu = 0 (calls ether_setup, max_mtu is 1500)
f_phonet:
- min_mtu = 6, max_mtu = 65541
u_ether:
- min_mtu = 14, max_mtu = 15412
phonet/pep-gprs:
- min_mtu = 576, max_mtu = 65530
- remove redundant gprs_set_mtu
CC: netdev@vger.kernel.org
CC: linux-rdma@vger.kernel.org
CC: Stefan Richter <stefanr@s5r6.in-berlin.de>
CC: Faisal Latif <faisal.latif@intel.com>
CC: linux-rdma@vger.kernel.org
CC: Cliff Whickman <cpw@sgi.com>
CC: Robin Holt <robinmholt@gmail.com>
CC: Jes Sorensen <jes@trained-monkey.org>
CC: Marek Lindner <mareklindner@neomailbox.ch>
CC: Simon Wunderlich <sw@simonwunderlich.de>
CC: Antonio Quartulli <a@unstable.cc>
CC: Sathya Prakash <sathya.prakash@broadcom.com>
CC: Chaitra P B <chaitra.basappa@broadcom.com>
CC: Suganath Prabu Subramani <suganath-prabu.subramani@broadcom.com>
CC: MPT-FusionLinux.pdl@broadcom.com
CC: Sebastian Reichel <sre@kernel.org>
CC: Felipe Balbi <balbi@kernel.org>
CC: Arvid Brodin <arvid.brodin@alten.se>
CC: Remi Denis-Courmont <courmisch@gmail.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 11:55:22 -06:00
|
|
|
return sl_realloc_bufs(sl, new_mtu);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Netdevice get statistics request */
|
|
|
|
|
|
2017-01-06 20:12:52 -07:00
|
|
|
static void
|
2010-08-26 16:12:08 -06:00
|
|
|
sl_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-08-26 16:12:08 -06:00
|
|
|
struct net_device_stats *devstats = &dev->stats;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
2010-08-26 16:12:08 -06:00
|
|
|
struct slip *sl = netdev_priv(dev);
|
2010-08-17 21:13:08 -06:00
|
|
|
struct slcompress *comp = sl->slcomp;
|
|
|
|
|
#endif
|
2010-08-26 16:12:08 -06:00
|
|
|
stats->rx_packets = devstats->rx_packets;
|
|
|
|
|
stats->tx_packets = devstats->tx_packets;
|
|
|
|
|
stats->rx_bytes = devstats->rx_bytes;
|
|
|
|
|
stats->tx_bytes = devstats->tx_bytes;
|
2011-08-03 20:12:15 -06:00
|
|
|
stats->rx_dropped = devstats->rx_dropped;
|
2010-08-26 16:12:08 -06:00
|
|
|
stats->tx_dropped = devstats->tx_dropped;
|
|
|
|
|
stats->tx_errors = devstats->tx_errors;
|
|
|
|
|
stats->rx_errors = devstats->rx_errors;
|
|
|
|
|
stats->rx_over_errors = devstats->rx_over_errors;
|
2010-08-17 21:13:08 -06:00
|
|
|
|
2011-08-03 20:12:15 -06:00
|
|
|
#ifdef SL_INCLUDE_CSLIP
|
|
|
|
|
if (comp) {
|
|
|
|
|
/* Generic compressed statistics */
|
|
|
|
|
stats->rx_compressed = comp->sls_i_compressed;
|
|
|
|
|
stats->tx_compressed = comp->sls_o_compressed;
|
|
|
|
|
|
|
|
|
|
/* Are we really still needs this? */
|
|
|
|
|
stats->rx_fifo_errors += comp->sls_i_compressed;
|
|
|
|
|
stats->rx_dropped += comp->sls_i_tossed;
|
|
|
|
|
stats->tx_fifo_errors += comp->sls_o_compressed;
|
|
|
|
|
stats->collisions += comp->sls_o_misses;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Netdevice register callback */
|
|
|
|
|
|
|
|
|
|
static int sl_init(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
/*
|
2006-09-13 11:24:59 -06:00
|
|
|
* Finish setting up the DEVICE info.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
dev->mtu = sl->mtu;
|
|
|
|
|
dev->type = ARPHRD_SLIP + sl->mode;
|
|
|
|
|
#ifdef SL_CHECK_TRANSMIT
|
|
|
|
|
dev->watchdog_timeo = 20*HZ;
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void sl_uninit(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
sl_free_bufs(sl);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-19 14:13:17 -06:00
|
|
|
/* Hook the destructor so we can free slip devices at the right point in time */
|
|
|
|
|
static void sl_free_netdev(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
int i = dev->base_addr;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 10:52:56 -06:00
|
|
|
|
2009-09-19 14:13:17 -06:00
|
|
|
slip_devs[i] = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-07 19:09:36 -07:00
|
|
|
static const struct net_device_ops sl_netdev_ops = {
|
|
|
|
|
.ndo_init = sl_init,
|
|
|
|
|
.ndo_uninit = sl_uninit,
|
|
|
|
|
.ndo_open = sl_open,
|
|
|
|
|
.ndo_stop = sl_close,
|
|
|
|
|
.ndo_start_xmit = sl_xmit,
|
2010-08-26 16:12:08 -06:00
|
|
|
.ndo_get_stats64 = sl_get_stats64,
|
2009-01-07 19:09:36 -07:00
|
|
|
.ndo_change_mtu = sl_change_mtu,
|
|
|
|
|
.ndo_tx_timeout = sl_tx_timeout,
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
.ndo_do_ioctl = sl_ioctl,
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void sl_setup(struct net_device *dev)
|
|
|
|
|
{
|
2009-01-07 19:09:36 -07:00
|
|
|
dev->netdev_ops = &sl_netdev_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 10:52:56 -06:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
|
dev->priv_destructor = sl_free_netdev;
|
2009-01-07 19:09:36 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->hard_header_len = 0;
|
|
|
|
|
dev->addr_len = 0;
|
|
|
|
|
dev->tx_queue_len = 10;
|
|
|
|
|
|
net: use core MTU range checking in misc drivers
firewire-net:
- set min/max_mtu
- remove fwnet_change_mtu
nes:
- set max_mtu
- clean up nes_netdev_change_mtu
xpnet:
- set min/max_mtu
- remove xpnet_dev_change_mtu
hippi:
- set min/max_mtu
- remove hippi_change_mtu
batman-adv:
- set max_mtu
- remove batadv_interface_change_mtu
- initialization is a little async, not 100% certain that max_mtu is set
in the optimal place, don't have hardware to test with
rionet:
- set min/max_mtu
- remove rionet_change_mtu
slip:
- set min/max_mtu
- streamline sl_change_mtu
um/net_kern:
- remove pointless ndo_change_mtu
hsi/clients/ssi_protocol:
- use core MTU range checking
- remove now redundant ssip_pn_set_mtu
ipoib:
- set a default max MTU value
- Note: ipoib's actual max MTU can vary, depending on if the device is in
connected mode or not, so we'll just set the max_mtu value to the max
possible, and let the ndo_change_mtu function continue to validate any new
MTU change requests with checks for CM or not. Note that ipoib has no
min_mtu set, and thus, the network core's mtu > 0 check is the only lower
bounds here.
mptlan:
- use net core MTU range checking
- remove now redundant mpt_lan_change_mtu
fddi:
- min_mtu = 21, max_mtu = 4470
- remove now redundant fddi_change_mtu (including export)
fjes:
- min_mtu = 8192, max_mtu = 65536
- The max_mtu value is actually one over IP_MAX_MTU here, but the idea is to
get past the core net MTU range checks so fjes_change_mtu can validate a
new MTU against what it supports (see fjes_support_mtu in fjes_hw.c)
hsr:
- min_mtu = 0 (calls ether_setup, max_mtu is 1500)
f_phonet:
- min_mtu = 6, max_mtu = 65541
u_ether:
- min_mtu = 14, max_mtu = 15412
phonet/pep-gprs:
- min_mtu = 576, max_mtu = 65530
- remove redundant gprs_set_mtu
CC: netdev@vger.kernel.org
CC: linux-rdma@vger.kernel.org
CC: Stefan Richter <stefanr@s5r6.in-berlin.de>
CC: Faisal Latif <faisal.latif@intel.com>
CC: linux-rdma@vger.kernel.org
CC: Cliff Whickman <cpw@sgi.com>
CC: Robin Holt <robinmholt@gmail.com>
CC: Jes Sorensen <jes@trained-monkey.org>
CC: Marek Lindner <mareklindner@neomailbox.ch>
CC: Simon Wunderlich <sw@simonwunderlich.de>
CC: Antonio Quartulli <a@unstable.cc>
CC: Sathya Prakash <sathya.prakash@broadcom.com>
CC: Chaitra P B <chaitra.basappa@broadcom.com>
CC: Suganath Prabu Subramani <suganath-prabu.subramani@broadcom.com>
CC: MPT-FusionLinux.pdl@broadcom.com
CC: Sebastian Reichel <sre@kernel.org>
CC: Felipe Balbi <balbi@kernel.org>
CC: Arvid Brodin <arvid.brodin@alten.se>
CC: Remi Denis-Courmont <courmisch@gmail.com>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-20 11:55:22 -06:00
|
|
|
/* MTU range: 68 - 65534 */
|
|
|
|
|
dev->min_mtu = 68;
|
|
|
|
|
dev->max_mtu = 65534;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* New-style flags. */
|
|
|
|
|
dev->flags = IFF_NOARP|IFF_POINTOPOINT|IFF_MULTICAST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/******************************************
|
|
|
|
|
Routines looking at TTY side.
|
|
|
|
|
******************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Handle the 'receiver data ready' interrupt.
|
|
|
|
|
* This function is called by the 'tty_io' module in the kernel when
|
|
|
|
|
* a block of SLIP data has been received, which can now be decapsulated
|
|
|
|
|
* and sent on to some IP layer for further processing. This will not
|
|
|
|
|
* be re-entered while running but other ldisc functions may be called
|
|
|
|
|
* in parallel
|
|
|
|
|
*/
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2011-06-03 15:33:24 -06:00
|
|
|
static void slip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
|
|
|
|
char *fp, int count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-19 08:03:38 -07:00
|
|
|
struct slip *sl = tty->disc_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!sl || sl->magic != SLIP_MAGIC || !netif_running(sl->dev))
|
2011-06-03 15:33:24 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
/* Read the characters out of the buffer */
|
2011-06-03 15:33:24 -06:00
|
|
|
while (count--) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (fp && *fp++) {
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!test_and_set_bit(SLF_ERROR, &sl->flags))
|
2010-08-26 16:12:08 -06:00
|
|
|
sl->dev->stats.rx_errors++;
|
2005-04-16 16:20:36 -06:00
|
|
|
cp++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
if (sl->mode & SL_MODE_SLIP6)
|
|
|
|
|
slip_unesc6(sl, *cp++);
|
|
|
|
|
else
|
|
|
|
|
#endif
|
|
|
|
|
slip_unesc(sl, *cp++);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/************************************
|
|
|
|
|
* slip_open helper routines.
|
|
|
|
|
************************************/
|
|
|
|
|
|
|
|
|
|
/* Collect hanged up channels */
|
|
|
|
|
static void sl_sync(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct net_device *dev;
|
|
|
|
|
struct slip *sl;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < slip_maxdev; i++) {
|
2007-11-19 08:03:38 -07:00
|
|
|
dev = slip_devs[i];
|
|
|
|
|
if (dev == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
sl = netdev_priv(dev);
|
|
|
|
|
if (sl->tty || sl->leased)
|
|
|
|
|
continue;
|
2007-11-19 08:03:38 -07:00
|
|
|
if (dev->flags & IFF_UP)
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_close(dev);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Find a free SLIP channel, and link in this `tty' line. */
|
2017-12-08 04:18:59 -07:00
|
|
|
static struct slip *sl_alloc(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
int i;
|
2011-07-12 15:47:38 -06:00
|
|
|
char name[IFNAMSIZ];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev = NULL;
|
|
|
|
|
struct slip *sl;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < slip_maxdev; i++) {
|
|
|
|
|
dev = slip_devs[i];
|
|
|
|
|
if (dev == NULL)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* Sorry, too many, all slots in use */
|
|
|
|
|
if (i >= slip_maxdev)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2011-07-12 15:47:38 -06:00
|
|
|
sprintf(name, "sl%d", i);
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 08:37:24 -06:00
|
|
|
dev = alloc_netdev(sizeof(*sl), name, NET_NAME_UNKNOWN, sl_setup);
|
2011-07-12 15:47:38 -06:00
|
|
|
if (!dev)
|
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-12 15:47:38 -06:00
|
|
|
dev->base_addr = i;
|
2005-04-16 16:20:36 -06:00
|
|
|
sl = netdev_priv(dev);
|
|
|
|
|
|
|
|
|
|
/* Initialize channel control data */
|
|
|
|
|
sl->magic = SLIP_MAGIC;
|
|
|
|
|
sl->dev = dev;
|
|
|
|
|
spin_lock_init(&sl->lock);
|
2014-06-15 20:23:16 -06:00
|
|
|
INIT_WORK(&sl->tx_work, slip_transmit);
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->mode = SL_MODE_DEFAULT;
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
2007-11-19 08:03:38 -07:00
|
|
|
/* initialize timer_list struct */
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
timer_setup(&sl->keepalive_timer, sl_keepalive, 0);
|
|
|
|
|
timer_setup(&sl->outfill_timer, sl_outfill, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
slip_devs[i] = dev;
|
|
|
|
|
return sl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Open the high-level part of the SLIP channel.
|
|
|
|
|
* This function is called by the TTY module when the
|
|
|
|
|
* SLIP line discipline is called for. Because we are
|
|
|
|
|
* sure the tty line exists, we only have to link it to
|
|
|
|
|
* a free SLIP channel...
|
|
|
|
|
*
|
|
|
|
|
* Called in process context serialized from other ldisc calls.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int slip_open(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
struct slip *sl;
|
|
|
|
|
int err;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EPERM;
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->write == NULL)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* RTnetlink lock is misused here to serialize concurrent
|
|
|
|
|
opens of slip channels. There are better ways, but it is
|
|
|
|
|
the simplest one.
|
|
|
|
|
*/
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
|
|
/* Collect hanged up channels. */
|
|
|
|
|
sl_sync();
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
sl = tty->disc_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
err = -EEXIST;
|
|
|
|
|
/* First make sure we're not already connected. */
|
|
|
|
|
if (sl && sl->magic == SLIP_MAGIC)
|
|
|
|
|
goto err_exit;
|
|
|
|
|
|
|
|
|
|
/* OK. Find a free SLIP channel to use. */
|
|
|
|
|
err = -ENFILE;
|
2017-12-08 04:18:59 -07:00
|
|
|
sl = sl_alloc();
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto err_exit;
|
|
|
|
|
|
|
|
|
|
sl->tty = tty;
|
|
|
|
|
tty->disc_data = sl;
|
|
|
|
|
sl->pid = current->pid;
|
2006-09-13 11:24:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!test_bit(SLF_INUSE, &sl->flags)) {
|
|
|
|
|
/* Perform the low-level SLIP initialization. */
|
2007-11-19 08:03:38 -07:00
|
|
|
err = sl_alloc_bufs(sl, SL_MTU);
|
|
|
|
|
if (err)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto err_free_chan;
|
|
|
|
|
|
|
|
|
|
set_bit(SLF_INUSE, &sl->flags);
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
err = register_netdevice(sl->dev);
|
|
|
|
|
if (err)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto err_free_bufs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
if (sl->keepalive) {
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->keepalive_timer.expires = jiffies + sl->keepalive * HZ;
|
|
|
|
|
add_timer(&sl->keepalive_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
if (sl->outfill) {
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->outfill_timer.expires = jiffies + sl->outfill * HZ;
|
|
|
|
|
add_timer(&sl->outfill_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Done. We have linked the TTY line to a channel. */
|
|
|
|
|
rtnl_unlock();
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
tty->receive_room = 65536; /* We don't flow control */
|
2011-05-06 00:23:09 -06:00
|
|
|
|
|
|
|
|
/* TTY layer expects 0 on success */
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
err_free_bufs:
|
|
|
|
|
sl_free_bufs(sl);
|
|
|
|
|
|
|
|
|
|
err_free_chan:
|
|
|
|
|
sl->tty = NULL;
|
|
|
|
|
tty->disc_data = NULL;
|
|
|
|
|
clear_bit(SLF_INUSE, &sl->flags);
|
2019-11-25 05:23:43 -07:00
|
|
|
sl_free_netdev(sl->dev);
|
2020-02-25 20:54:35 -07:00
|
|
|
/* do not call free_netdev before rtnl_unlock */
|
|
|
|
|
rtnl_unlock();
|
2019-11-13 04:45:02 -07:00
|
|
|
free_netdev(sl->dev);
|
2020-02-25 20:54:35 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
err_exit:
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
|
|
/* Count references from TTY module */
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Close down a SLIP channel.
|
|
|
|
|
* This means flushing out any pending queues, and then returning. This
|
|
|
|
|
* call is serialized against other ldisc functions.
|
2009-09-19 14:13:17 -06:00
|
|
|
*
|
|
|
|
|
* We also use this method fo a hangup event
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2009-09-19 14:13:17 -06:00
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static void slip_close(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-19 08:03:38 -07:00
|
|
|
struct slip *sl = tty->disc_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
/* First make sure we're connected. */
|
|
|
|
|
if (!sl || sl->magic != SLIP_MAGIC || sl->tty != tty)
|
|
|
|
|
return;
|
|
|
|
|
|
2014-06-15 20:23:16 -06:00
|
|
|
spin_lock_bh(&sl->lock);
|
2020-01-21 06:42:58 -07:00
|
|
|
rcu_assign_pointer(tty->disc_data, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->tty = NULL;
|
2014-06-15 20:23:16 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
|
2020-01-21 06:42:58 -07:00
|
|
|
synchronize_rcu();
|
2014-06-15 20:23:16 -06:00
|
|
|
flush_work(&sl->tx_work);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
/* VSV = very important to remove timers */
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
del_timer_sync(&sl->keepalive_timer);
|
|
|
|
|
del_timer_sync(&sl->outfill_timer);
|
|
|
|
|
#endif
|
2009-09-19 14:13:17 -06:00
|
|
|
/* Flush network side */
|
|
|
|
|
unregister_netdev(sl->dev);
|
|
|
|
|
/* This will complete via sl_free_netdev */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
2009-09-19 14:13:17 -06:00
|
|
|
static int slip_hangup(struct tty_struct *tty)
|
|
|
|
|
{
|
|
|
|
|
slip_close(tty);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
/************************************************************************
|
|
|
|
|
* STANDARD SLIP ENCAPSULATION *
|
|
|
|
|
************************************************************************/
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static int slip_esc(unsigned char *s, unsigned char *d, int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
unsigned char *ptr = d;
|
|
|
|
|
unsigned char c;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Send an initial END character to flush out any
|
|
|
|
|
* data that may have accumulated in the receiver
|
|
|
|
|
* due to line noise.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
*ptr++ = END;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For each byte in the packet, send the appropriate
|
|
|
|
|
* character sequence, according to the SLIP protocol.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
while (len-- > 0) {
|
2007-11-19 08:03:38 -07:00
|
|
|
switch (c = *s++) {
|
|
|
|
|
case END:
|
2005-04-16 16:20:36 -06:00
|
|
|
*ptr++ = ESC;
|
|
|
|
|
*ptr++ = ESC_END;
|
|
|
|
|
break;
|
2007-11-19 08:03:38 -07:00
|
|
|
case ESC:
|
2005-04-16 16:20:36 -06:00
|
|
|
*ptr++ = ESC;
|
|
|
|
|
*ptr++ = ESC_ESC;
|
|
|
|
|
break;
|
2007-11-19 08:03:38 -07:00
|
|
|
default:
|
2005-04-16 16:20:36 -06:00
|
|
|
*ptr++ = c;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*ptr++ = END;
|
2010-09-22 23:40:09 -06:00
|
|
|
return ptr - d;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void slip_unesc(struct slip *sl, unsigned char s)
|
|
|
|
|
{
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
switch (s) {
|
|
|
|
|
case END:
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/* drop keeptest bit = VSV */
|
|
|
|
|
if (test_bit(SLF_KEEPTEST, &sl->flags))
|
|
|
|
|
clear_bit(SLF_KEEPTEST, &sl->flags);
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-12-03 00:58:21 -07:00
|
|
|
if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
|
|
|
|
|
(sl->rcount > 2))
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_bump(sl);
|
|
|
|
|
clear_bit(SLF_ESCAPE, &sl->flags);
|
|
|
|
|
sl->rcount = 0;
|
|
|
|
|
return;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case ESC:
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_ESCAPE, &sl->flags);
|
|
|
|
|
return;
|
2007-11-19 08:03:38 -07:00
|
|
|
case ESC_ESC:
|
|
|
|
|
if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
s = ESC;
|
|
|
|
|
break;
|
2007-11-19 08:03:38 -07:00
|
|
|
case ESC_END:
|
|
|
|
|
if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
|
2005-04-16 16:20:36 -06:00
|
|
|
s = END;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!test_bit(SLF_ERROR, &sl->flags)) {
|
|
|
|
|
if (sl->rcount < sl->buffsize) {
|
|
|
|
|
sl->rbuff[sl->rcount++] = s;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-08-26 16:12:08 -06:00
|
|
|
sl->dev->stats.rx_over_errors++;
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_ERROR, &sl->flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
/************************************************************************
|
|
|
|
|
* 6 BIT SLIP ENCAPSULATION *
|
|
|
|
|
************************************************************************/
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static int slip_esc6(unsigned char *s, unsigned char *d, int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
unsigned char *ptr = d;
|
|
|
|
|
unsigned char c;
|
|
|
|
|
int i;
|
|
|
|
|
unsigned short v = 0;
|
|
|
|
|
short bits = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Send an initial END character to flush out any
|
|
|
|
|
* data that may have accumulated in the receiver
|
|
|
|
|
* due to line noise.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
*ptr++ = 0x70;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Encode the packet into printable ascii characters
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; ++i) {
|
|
|
|
|
v = (v << 8) | s[i];
|
|
|
|
|
bits += 8;
|
|
|
|
|
while (bits >= 6) {
|
|
|
|
|
bits -= 6;
|
|
|
|
|
c = 0x30 + ((v >> bits) & 0x3F);
|
|
|
|
|
*ptr++ = c;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (bits) {
|
|
|
|
|
c = 0x30 + ((v << (6 - bits)) & 0x3F);
|
|
|
|
|
*ptr++ = c;
|
|
|
|
|
}
|
|
|
|
|
*ptr++ = 0x70;
|
|
|
|
|
return ptr - d;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static void slip_unesc6(struct slip *sl, unsigned char s)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
unsigned char c;
|
|
|
|
|
|
|
|
|
|
if (s == 0x70) {
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/* drop keeptest bit = VSV */
|
|
|
|
|
if (test_bit(SLF_KEEPTEST, &sl->flags))
|
|
|
|
|
clear_bit(SLF_KEEPTEST, &sl->flags);
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-12-03 00:58:21 -07:00
|
|
|
if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
|
|
|
|
|
(sl->rcount > 2))
|
2005-04-16 16:20:36 -06:00
|
|
|
sl_bump(sl);
|
|
|
|
|
sl->rcount = 0;
|
|
|
|
|
sl->xbits = 0;
|
|
|
|
|
sl->xdata = 0;
|
2007-11-19 08:03:38 -07:00
|
|
|
} else if (s >= 0x30 && s < 0x70) {
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->xdata = (sl->xdata << 6) | ((s - 0x30) & 0x3F);
|
|
|
|
|
sl->xbits += 6;
|
|
|
|
|
if (sl->xbits >= 8) {
|
|
|
|
|
sl->xbits -= 8;
|
|
|
|
|
c = (unsigned char)(sl->xdata >> sl->xbits);
|
|
|
|
|
if (!test_bit(SLF_ERROR, &sl->flags)) {
|
|
|
|
|
if (sl->rcount < sl->buffsize) {
|
|
|
|
|
sl->rbuff[sl->rcount++] = c;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2010-08-26 16:12:08 -06:00
|
|
|
sl->dev->stats.rx_over_errors++;
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_ERROR, &sl->flags);
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_SLIP_MODE_SLIP6 */
|
|
|
|
|
|
|
|
|
|
/* Perform I/O control on an active SLIP channel. */
|
2007-11-19 08:03:38 -07:00
|
|
|
static int slip_ioctl(struct tty_struct *tty, struct file *file,
|
|
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-19 08:03:38 -07:00
|
|
|
struct slip *sl = tty->disc_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int tmp;
|
|
|
|
|
int __user *p = (int __user *)arg;
|
|
|
|
|
|
|
|
|
|
/* First make sure we're connected. */
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!sl || sl->magic != SLIP_MAGIC)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
switch (cmd) {
|
|
|
|
|
case SIOCGIFNAME:
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp = strlen(sl->dev->name) + 1;
|
|
|
|
|
if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
case SIOCGIFENCAP:
|
|
|
|
|
if (put_user(sl->mode, p))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
case SIOCSIFENCAP:
|
|
|
|
|
if (get_user(tmp, p))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
#ifndef SL_INCLUDE_CSLIP
|
2007-11-19 08:03:38 -07:00
|
|
|
if (tmp & (SL_MODE_CSLIP|SL_MODE_ADAPTIVE))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
#else
|
|
|
|
|
if ((tmp & (SL_MODE_ADAPTIVE | SL_MODE_CSLIP)) ==
|
2007-11-19 08:03:38 -07:00
|
|
|
(SL_MODE_ADAPTIVE | SL_MODE_CSLIP))
|
2005-04-16 16:20:36 -06:00
|
|
|
/* return -EINVAL; */
|
|
|
|
|
tmp &= ~SL_MODE_ADAPTIVE;
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef CONFIG_SLIP_MODE_SLIP6
|
2007-11-19 08:03:38 -07:00
|
|
|
if (tmp & SL_MODE_SLIP6)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
#endif
|
|
|
|
|
sl->mode = tmp;
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->dev->type = ARPHRD_SLIP + sl->mode;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCSIFHWADDR:
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/* VSV changes start here */
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCSKEEPALIVE:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (get_user(tmp, p))
|
|
|
|
|
return -EFAULT;
|
2007-11-19 08:03:38 -07:00
|
|
|
if (tmp > 255) /* max for unchar */
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
if (!sl->tty) {
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->keepalive = (u8)tmp;
|
|
|
|
|
if (sl->keepalive != 0) {
|
|
|
|
|
mod_timer(&sl->keepalive_timer,
|
|
|
|
|
jiffies + sl->keepalive * HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_KEEPTEST, &sl->flags);
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
|
|
|
|
del_timer(&sl->keepalive_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return 0;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCGKEEPALIVE:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (put_user(sl->keepalive, p))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCSOUTFILL:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (get_user(tmp, p))
|
|
|
|
|
return -EFAULT;
|
2007-11-19 08:03:38 -07:00
|
|
|
if (tmp > 255) /* max for unchar */
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
if (!sl->tty) {
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->outfill = (u8)tmp;
|
|
|
|
|
if (sl->outfill != 0) {
|
|
|
|
|
mod_timer(&sl->outfill_timer,
|
|
|
|
|
jiffies + sl->outfill * HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_OUTWAIT, &sl->flags);
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
|
|
|
|
del_timer(&sl->outfill_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
2007-11-19 08:03:38 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCGOUTFILL:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (put_user(sl->outfill, p))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
return 0;
|
|
|
|
|
/* VSV changes end */
|
|
|
|
|
#endif
|
|
|
|
|
default:
|
2007-11-07 02:27:34 -07:00
|
|
|
return tty_mode_ioctl(tty, file, cmd, arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* VSV changes start here */
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/* function do_ioctl called from net/core/dev.c
|
|
|
|
|
to allow get/set outfill/keepalive parameter
|
|
|
|
|
by ifconfig */
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
static int sl_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
struct slip *sl = netdev_priv(dev);
|
|
|
|
|
unsigned long *p = (unsigned long *)&rq->ifr_ifru;
|
|
|
|
|
|
|
|
|
|
if (sl == NULL) /* Allocation failed ?? */
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
|
|
|
|
|
if (!sl->tty) {
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
switch (cmd) {
|
|
|
|
|
case SIOCSKEEPALIVE:
|
2005-04-16 16:20:36 -06:00
|
|
|
/* max for unchar */
|
2007-11-19 08:03:38 -07:00
|
|
|
if ((unsigned)*p > 255) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->keepalive = (u8)*p;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sl->keepalive != 0) {
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->keepalive_timer.expires =
|
|
|
|
|
jiffies + sl->keepalive * HZ;
|
|
|
|
|
mod_timer(&sl->keepalive_timer,
|
|
|
|
|
jiffies + sl->keepalive * HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_KEEPTEST, &sl->flags);
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
|
|
|
|
del_timer(&sl->keepalive_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCGKEEPALIVE:
|
2005-04-16 16:20:36 -06:00
|
|
|
*p = sl->keepalive;
|
|
|
|
|
break;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCSOUTFILL:
|
|
|
|
|
if ((unsigned)*p > 255) { /* max for unchar */
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
sl->outfill = (u8)*p;
|
|
|
|
|
if (sl->outfill != 0) {
|
|
|
|
|
mod_timer(&sl->outfill_timer,
|
|
|
|
|
jiffies + sl->outfill * HZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_OUTWAIT, &sl->flags);
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
|
|
|
|
del_timer(&sl->outfill_timer);
|
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCGOUTFILL:
|
2005-04-16 16:20:36 -06:00
|
|
|
*p = sl->outfill;
|
|
|
|
|
break;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCSLEASE:
|
2006-09-13 11:24:59 -06:00
|
|
|
/* Resolve race condition, when ioctl'ing hanged up
|
2005-04-16 16:20:36 -06:00
|
|
|
and opened by another process device.
|
|
|
|
|
*/
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->tty != current->signal->tty &&
|
|
|
|
|
sl->pid != current->pid) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
sl->leased = 0;
|
2007-11-19 08:03:38 -07:00
|
|
|
if (*p)
|
2005-04-16 16:20:36 -06:00
|
|
|
sl->leased = 1;
|
2007-11-19 08:03:38 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
case SIOCGLEASE:
|
2005-04-16 16:20:36 -06:00
|
|
|
*p = sl->leased;
|
2010-05-17 23:47:34 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
/* VSV changes end */
|
|
|
|
|
|
2008-07-16 14:53:12 -06:00
|
|
|
static struct tty_ldisc_ops sl_ldisc = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.magic = TTY_LDISC_MAGIC,
|
|
|
|
|
.name = "slip",
|
|
|
|
|
.open = slip_open,
|
|
|
|
|
.close = slip_close,
|
2009-09-19 14:13:17 -06:00
|
|
|
.hangup = slip_hangup,
|
2005-04-16 16:20:36 -06:00
|
|
|
.ioctl = slip_ioctl,
|
|
|
|
|
.receive_buf = slip_receive_buf,
|
|
|
|
|
.write_wakeup = slip_write_wakeup,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init slip_init(void)
|
|
|
|
|
{
|
|
|
|
|
int status;
|
|
|
|
|
|
|
|
|
|
if (slip_maxdev < 4)
|
|
|
|
|
slip_maxdev = 4; /* Sanity */
|
|
|
|
|
|
|
|
|
|
printk(KERN_INFO "SLIP: version %s (dynamic channels, max=%d)"
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
" (6 bit encapsulation enabled)"
|
|
|
|
|
#endif
|
|
|
|
|
".\n",
|
2007-11-19 08:03:38 -07:00
|
|
|
SLIP_VERSION, slip_maxdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(SL_INCLUDE_CSLIP)
|
|
|
|
|
printk(KERN_INFO "CSLIP: code copyright 1989 Regents of the University of California.\n");
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
printk(KERN_INFO "SLIP linefill/keepalive option.\n");
|
|
|
|
|
#endif
|
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 15:03:40 -06:00
|
|
|
slip_devs = kcalloc(slip_maxdev, sizeof(struct net_device *),
|
2007-11-19 08:03:38 -07:00
|
|
|
GFP_KERNEL);
|
2012-01-29 05:56:23 -07:00
|
|
|
if (!slip_devs)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
/* Fill in our line protocol discipline, and register it */
|
2007-11-19 08:03:38 -07:00
|
|
|
status = tty_register_ldisc(N_SLIP, &sl_ldisc);
|
|
|
|
|
if (status != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "SLIP: can't register line discipline (err = %d)\n", status);
|
|
|
|
|
kfree(slip_devs);
|
|
|
|
|
}
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit slip_exit(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct net_device *dev;
|
|
|
|
|
struct slip *sl;
|
|
|
|
|
unsigned long timeout = jiffies + HZ;
|
|
|
|
|
int busy = 0;
|
|
|
|
|
|
2006-09-13 11:24:59 -06:00
|
|
|
if (slip_devs == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* First of all: check for active disciplines and hangup them.
|
|
|
|
|
*/
|
|
|
|
|
do {
|
2005-05-02 00:34:57 -06:00
|
|
|
if (busy)
|
|
|
|
|
msleep_interruptible(100);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
busy = 0;
|
|
|
|
|
for (i = 0; i < slip_maxdev; i++) {
|
|
|
|
|
dev = slip_devs[i];
|
|
|
|
|
if (!dev)
|
|
|
|
|
continue;
|
|
|
|
|
sl = netdev_priv(dev);
|
|
|
|
|
spin_lock_bh(&sl->lock);
|
|
|
|
|
if (sl->tty) {
|
|
|
|
|
busy++;
|
|
|
|
|
tty_hangup(sl->tty);
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_bh(&sl->lock);
|
|
|
|
|
}
|
|
|
|
|
} while (busy && time_before(jiffies, timeout));
|
|
|
|
|
|
2009-09-19 14:13:17 -06:00
|
|
|
/* FIXME: hangup is async so we should wait when doing this second
|
|
|
|
|
phase */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
for (i = 0; i < slip_maxdev; i++) {
|
|
|
|
|
dev = slip_devs[i];
|
|
|
|
|
if (!dev)
|
|
|
|
|
continue;
|
|
|
|
|
slip_devs[i] = NULL;
|
|
|
|
|
|
|
|
|
|
sl = netdev_priv(dev);
|
|
|
|
|
if (sl->tty) {
|
|
|
|
|
printk(KERN_ERR "%s: tty discipline still running\n",
|
|
|
|
|
dev->name);
|
2006-09-13 11:24:59 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
unregister_netdev(dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kfree(slip_devs);
|
|
|
|
|
slip_devs = NULL;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
i = tty_unregister_ldisc(N_SLIP);
|
|
|
|
|
if (i != 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(slip_init);
|
|
|
|
|
module_exit(slip_exit);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SLIP_SMART
|
|
|
|
|
/*
|
|
|
|
|
* This is start of the code for multislip style line checking
|
|
|
|
|
* added by Stanislav Voronyi. All changes before marked VSV
|
|
|
|
|
*/
|
|
|
|
|
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
static void sl_outfill(struct timer_list *t)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
struct slip *sl = from_timer(sl, t, outfill_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
spin_lock(&sl->lock);
|
|
|
|
|
|
|
|
|
|
if (sl->tty == NULL)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->outfill) {
|
|
|
|
|
if (test_bit(SLF_OUTWAIT, &sl->flags)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* no packets were transmitted, do outfill */
|
|
|
|
|
#ifdef CONFIG_SLIP_MODE_SLIP6
|
|
|
|
|
unsigned char s = (sl->mode & SL_MODE_SLIP6)?0x70:END;
|
|
|
|
|
#else
|
|
|
|
|
unsigned char s = END;
|
|
|
|
|
#endif
|
|
|
|
|
/* put END into tty queue. Is it right ??? */
|
2007-11-19 08:03:38 -07:00
|
|
|
if (!netif_queue_stopped(sl->dev)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* if device busy no outfill */
|
2008-04-30 01:54:13 -06:00
|
|
|
sl->tty->ops->write(sl->tty, &s, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_OUTWAIT, &sl->flags);
|
|
|
|
|
|
|
|
|
|
mod_timer(&sl->outfill_timer, jiffies+sl->outfill*HZ);
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
}
|
|
|
|
|
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
static void sl_keepalive(struct timer_list *t)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 15:43:17 -06:00
|
|
|
struct slip *sl = from_timer(sl, t, keepalive_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
spin_lock(&sl->lock);
|
|
|
|
|
|
|
|
|
|
if (sl->tty == NULL)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->keepalive) {
|
|
|
|
|
if (test_bit(SLF_KEEPTEST, &sl->flags)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* keepalive still high :(, we must hangup */
|
2007-11-19 08:03:38 -07:00
|
|
|
if (sl->outfill)
|
|
|
|
|
/* outfill timer must be deleted too */
|
2005-04-16 16:20:36 -06:00
|
|
|
(void)del_timer(&sl->outfill_timer);
|
|
|
|
|
printk(KERN_DEBUG "%s: no packets received during keepalive timeout, hangup.\n", sl->dev->name);
|
2007-11-19 08:03:38 -07:00
|
|
|
/* this must hangup tty & close slip */
|
|
|
|
|
tty_hangup(sl->tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* I think we need not something else */
|
|
|
|
|
goto out;
|
2007-11-19 08:03:38 -07:00
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(SLF_KEEPTEST, &sl->flags);
|
|
|
|
|
|
|
|
|
|
mod_timer(&sl->keepalive_timer, jiffies+sl->keepalive*HZ);
|
|
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
spin_unlock(&sl->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_ALIAS_LDISC(N_SLIP);
|