2019-05-19 06:08:20 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 16:20:36 -06:00
|
|
|
/* net/atm/clip.c - RFC1577 Classical IP over ATM */
|
|
|
|
|
|
|
|
/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h> /* for UINT_MAX */
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/if_arp.h> /* for some manifest constants */
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/atm.h>
|
|
|
|
#include <linux/atmdev.h>
|
|
|
|
#include <linux/atmclip.h>
|
|
|
|
#include <linux/atmarp.h>
|
2006-01-11 13:17:47 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/ip.h> /* for net/route.h */
|
|
|
|
#include <linux/in.h> /* for struct sockaddr_in */
|
|
|
|
#include <linux/if.h> /* for IFF_UP */
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-07-03 20:47:27 -06:00
|
|
|
#include <linux/poison.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
#include <linux/jhash.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>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/route.h> /* for struct rtable and routing */
|
|
|
|
#include <net/icmp.h> /* icmp_send */
|
2011-07-24 18:01:41 -06:00
|
|
|
#include <net/arp.h>
|
2010-01-26 04:40:05 -07:00
|
|
|
#include <linux/param.h> /* for HZ */
|
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/byteorder.h> /* for htons etc. */
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include "common.h"
|
|
|
|
#include "resources.h"
|
|
|
|
#include <net/atmclip.h>
|
|
|
|
|
|
|
|
static struct net_device *clip_devs;
|
|
|
|
static struct atm_vcc *atmarpd;
|
|
|
|
static struct timer_list idle_timer;
|
2012-02-21 03:46:49 -07:00
|
|
|
static const struct neigh_ops clip_neigh_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 22:11:29 -07:00
|
|
|
static int to_atmarpd(enum atmarp_ctrl_type type, int itf, __be32 ip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
struct atmarp_ctrl *ctrl;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("(%d)\n", type);
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!atmarpd)
|
|
|
|
return -EUNATCH;
|
2010-01-26 04:40:05 -07:00
|
|
|
skb = alloc_skb(sizeof(struct atmarp_ctrl), GFP_ATOMIC);
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
networking: make skb_put & friends return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions (skb_put, __skb_put and pskb_put) return void *
and remove all the casts across the tree, adding a (u8 *) cast only
where the unsigned char pointer was used directly, all done with the
following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = { skb_put, __skb_put };
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = { skb_put, __skb_put };
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
which actually doesn't cover pskb_put since there are only three
users overall.
A handful of stragglers were converted manually, notably a macro in
drivers/isdn/i4l/isdn_bsdcomp.c and, oddly enough, one of the many
instances in net/bluetooth/hci_sock.c. In the former file, I also
had to fix one whitespace problem spatch introduced.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 06:29:21 -06:00
|
|
|
ctrl = skb_put(skb, sizeof(struct atmarp_ctrl));
|
2005-04-16 16:20:36 -06:00
|
|
|
ctrl->type = type;
|
|
|
|
ctrl->itf_num = itf;
|
|
|
|
ctrl->ip = ip;
|
2006-04-14 16:59:37 -06:00
|
|
|
atm_force_charge(atmarpd, skb->truesize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sk = sk_atm(atmarpd);
|
|
|
|
skb_queue_tail(&sk->sk_receive_queue, skb);
|
2014-04-11 14:15:36 -06:00
|
|
|
sk->sk_data_ready(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void link_vcc(struct clip_vcc *clip_vcc, struct atmarp_entry *entry)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("%p to entry %p (neigh %p)\n", clip_vcc, entry, entry->neigh);
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_vcc->entry = entry;
|
2006-04-14 16:59:37 -06:00
|
|
|
clip_vcc->xoff = 0; /* @@@ may overrun buffer by one packet */
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_vcc->next = entry->vccs;
|
|
|
|
entry->vccs = clip_vcc;
|
|
|
|
entry->neigh->used = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unlink_clip_vcc(struct clip_vcc *clip_vcc)
|
|
|
|
{
|
|
|
|
struct atmarp_entry *entry = clip_vcc->entry;
|
|
|
|
struct clip_vcc **walk;
|
|
|
|
|
|
|
|
if (!entry) {
|
2019-11-17 13:28:36 -07:00
|
|
|
pr_err("!clip_vcc->entry (clip_vcc %p)\n", clip_vcc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
2006-06-09 13:20:56 -06:00
|
|
|
netif_tx_lock_bh(entry->neigh->dev); /* block clip_start_xmit() */
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->neigh->used = jiffies;
|
|
|
|
for (walk = &entry->vccs; *walk; walk = &(*walk)->next)
|
|
|
|
if (*walk == clip_vcc) {
|
|
|
|
int error;
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
*walk = clip_vcc->next; /* atomic */
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_vcc->entry = NULL;
|
|
|
|
if (clip_vcc->xoff)
|
|
|
|
netif_wake_queue(entry->neigh->dev);
|
|
|
|
if (entry->vccs)
|
|
|
|
goto out;
|
2006-04-14 16:59:37 -06:00
|
|
|
entry->expires = jiffies - 1;
|
|
|
|
/* force resolution or expiration */
|
2005-04-16 16:20:36 -06:00
|
|
|
error = neigh_update(entry->neigh, NULL, NUD_NONE,
|
2017-03-19 23:01:28 -06:00
|
|
|
NEIGH_UPDATE_F_ADMIN, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
2019-11-17 13:28:36 -07:00
|
|
|
pr_err("neigh_update failed with %d\n", error);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2019-11-17 13:28:36 -07:00
|
|
|
pr_err("ATMARP: failed (entry %p, vcc 0x%p)\n", entry, clip_vcc);
|
2010-01-26 04:40:05 -07:00
|
|
|
out:
|
2006-06-09 13:20:56 -06:00
|
|
|
netif_tx_unlock_bh(entry->neigh->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The neighbour entry n->lock is held. */
|
|
|
|
static int neigh_check_cb(struct neighbour *n)
|
|
|
|
{
|
2011-07-24 18:01:33 -06:00
|
|
|
struct atmarp_entry *entry = neighbour_priv(n);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct clip_vcc *cv;
|
|
|
|
|
2012-02-21 03:46:49 -07:00
|
|
|
if (n->ops != &clip_neigh_ops)
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (cv = entry->vccs; cv; cv = cv->next) {
|
|
|
|
unsigned long exp = cv->last_use + cv->idle_timeout;
|
|
|
|
|
|
|
|
if (cv->idle_timeout && time_after(jiffies, exp)) {
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("releasing vcc %p->%p of entry %p\n",
|
2010-01-26 04:40:00 -07:00
|
|
|
cv, cv->vcc, entry);
|
2005-04-16 16:20:36 -06:00
|
|
|
vcc_release_async(cv->vcc, -ETIMEDOUT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (entry->vccs || time_before(jiffies, entry->expires))
|
|
|
|
return 0;
|
|
|
|
|
2017-06-30 04:07:55 -06:00
|
|
|
if (refcount_read(&n->refcnt) > 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("destruction postponed with ref %d\n",
|
2017-06-30 04:07:55 -06:00
|
|
|
refcount_read(&n->refcnt));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
while ((skb = skb_dequeue(&n->arp_queue)) != NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("expired neigh %p\n", n);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-10-16 18:29:37 -06:00
|
|
|
static void idle_timer_check(struct timer_list *unused)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-02-21 03:46:49 -07:00
|
|
|
write_lock(&arp_tbl.lock);
|
|
|
|
__neigh_for_each_release(&arp_tbl, neigh_check_cb);
|
2006-04-14 16:59:37 -06:00
|
|
|
mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
|
2012-02-21 03:46:49 -07:00
|
|
|
write_unlock(&arp_tbl.lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int clip_arp_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct atm_vcc *vcc;
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
vcc = ATM_SKB(skb)->vcc;
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!vcc || !atm_charge(vcc, skb->truesize)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("pushing to %p\n", vcc);
|
|
|
|
pr_debug("using %p\n", CLIP_VCC(vcc)->old_push);
|
2006-04-14 16:59:37 -06:00
|
|
|
CLIP_VCC(vcc)->old_push(vcc, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const unsigned char llc_oui[] = {
|
|
|
|
0xaa, /* DSAP: non-ISO */
|
|
|
|
0xaa, /* SSAP: non-ISO */
|
|
|
|
0x03, /* Ctrl: Unnumbered Information Command PDU */
|
|
|
|
0x00, /* OUI: EtherType */
|
|
|
|
0x00,
|
2006-04-14 16:59:37 -06:00
|
|
|
0x00
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void clip_push(struct atm_vcc *vcc, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("\n");
|
2011-11-21 03:25:56 -07:00
|
|
|
|
|
|
|
if (!clip_devs) {
|
|
|
|
atm_return(vcc, skb->truesize);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!skb) {
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("removing VCC %p\n", clip_vcc);
|
2006-04-14 16:59:37 -06:00
|
|
|
if (clip_vcc->entry)
|
|
|
|
unlink_clip_vcc(clip_vcc);
|
|
|
|
clip_vcc->old_push(vcc, NULL); /* pass on the bad news */
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(clip_vcc);
|
|
|
|
return;
|
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
atm_return(vcc, skb->truesize);
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : clip_devs;
|
2006-04-14 16:59:37 -06:00
|
|
|
/* clip_vcc->entry == NULL if we don't have an IP address yet */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!skb->dev) {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ATM_SKB(skb)->vcc = vcc;
|
2007-03-19 16:30:44 -06:00
|
|
|
skb_reset_mac_header(skb);
|
2010-01-26 04:40:05 -07:00
|
|
|
if (!clip_vcc->encap ||
|
|
|
|
skb->len < RFC1483LLC_LEN ||
|
|
|
|
memcmp(skb->data, llc_oui, sizeof(llc_oui)))
|
2006-04-14 16:59:37 -06:00
|
|
|
skb->protocol = htons(ETH_P_IP);
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2010-01-26 04:40:05 -07:00
|
|
|
skb->protocol = ((__be16 *)skb->data)[3];
|
2006-04-14 16:59:37 -06:00
|
|
|
skb_pull(skb, RFC1483LLC_LEN);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb->protocol == htons(ETH_P_ARP)) {
|
2009-01-09 06:01:00 -07:00
|
|
|
skb->dev->stats.rx_packets++;
|
|
|
|
skb->dev->stats.rx_bytes += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_arp_rcv(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
clip_vcc->last_use = jiffies;
|
2009-01-09 06:01:00 -07:00
|
|
|
skb->dev->stats.rx_packets++;
|
|
|
|
skb->dev->stats.rx_bytes += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
|
|
|
|
netif_rx(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
|
|
|
|
* clip_pop is atomic with respect to the critical section in clip_start_xmit.
|
|
|
|
*/
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void clip_pop(struct atm_vcc *vcc, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct clip_vcc *clip_vcc = CLIP_VCC(vcc);
|
|
|
|
struct net_device *dev = skb->dev;
|
|
|
|
int old;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("(vcc %p)\n", vcc);
|
2006-04-14 16:59:37 -06:00
|
|
|
clip_vcc->old_pop(vcc, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* skb->dev == NULL in outbound ARP packets */
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!dev)
|
|
|
|
return;
|
|
|
|
spin_lock_irqsave(&PRIV(dev)->xoff_lock, flags);
|
|
|
|
if (atm_may_send(vcc, 0)) {
|
|
|
|
old = xchg(&clip_vcc->xoff, 0);
|
|
|
|
if (old)
|
|
|
|
netif_wake_queue(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
spin_unlock_irqrestore(&PRIV(dev)->xoff_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void clip_neigh_solicit(struct neighbour *neigh, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-07-24 18:01:33 -06:00
|
|
|
__be32 *ip = (__be32 *) neigh->primary_key;
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("(neigh %p, skb %p)\n", neigh, skb);
|
2011-07-24 18:01:33 -06:00
|
|
|
to_atmarpd(act_need, PRIV(neigh->dev)->number, *ip);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void clip_neigh_error(struct neighbour *neigh, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
#ifndef CONFIG_ATM_CLIP_NO_ICMP
|
2006-04-14 16:59:37 -06:00
|
|
|
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2009-09-01 05:13:19 -06:00
|
|
|
static const struct neigh_ops clip_neigh_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.family = AF_INET,
|
|
|
|
.solicit = clip_neigh_solicit,
|
|
|
|
.error_report = clip_neigh_error,
|
2011-07-17 14:34:11 -06:00
|
|
|
.output = neigh_direct_output,
|
|
|
|
.connected_output = neigh_direct_output,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2016-07-05 03:27:37 -06:00
|
|
|
static int clip_constructor(struct net_device *dev, struct neighbour *neigh)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-07-24 18:01:33 -06:00
|
|
|
struct atmarp_entry *entry = neighbour_priv(neigh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-24 18:01:41 -06:00
|
|
|
if (neigh->tbl->family != AF_INET)
|
2006-04-14 16:59:37 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-24 18:01:41 -06:00
|
|
|
if (neigh->type != RTN_UNICAST)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-24 18:01:41 -06:00
|
|
|
neigh->nud_state = NUD_NONE;
|
2005-04-16 16:20:36 -06:00
|
|
|
neigh->ops = &clip_neigh_ops;
|
2011-07-24 18:01:41 -06:00
|
|
|
neigh->output = neigh->ops->output;
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->neigh = neigh;
|
|
|
|
entry->vccs = NULL;
|
2006-04-14 16:59:37 -06:00
|
|
|
entry->expires = jiffies - 1;
|
2011-07-24 18:01:41 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
|
|
|
|
* to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
|
|
|
|
* don't increment the usage count. This is used to create entries in
|
|
|
|
* clip_setentry.
|
|
|
|
*/
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static int clip_encap(struct atm_vcc *vcc, int mode)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
atm: deal with setting entry before mkip was called
If we didn't call ATMARP_MKIP before ATMARP_ENCAP the VCC descriptor is
non-existant and we'll end up dereferencing a NULL ptr:
[1033173.491930] kasan: GPF could be caused by NULL-ptr deref or user memory accessirq event stamp: 123386
[1033173.493678] general protection fault: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC KASAN
[1033173.493689] Modules linked in:
[1033173.493697] CPU: 9 PID: 23815 Comm: trinity-c64 Not tainted 4.2.0-next-20150911-sasha-00043-g353d875-dirty #2545
[1033173.493706] task: ffff8800630c4000 ti: ffff880063110000 task.ti: ffff880063110000
[1033173.493823] RIP: clip_ioctl (net/atm/clip.c:320 net/atm/clip.c:689)
[1033173.493826] RSP: 0018:ffff880063117a88 EFLAGS: 00010203
[1033173.493828] RAX: dffffc0000000000 RBX: 0000000000000000 RCX: 000000000000000c
[1033173.493830] RDX: 0000000000000002 RSI: ffffffffb3f10720 RDI: 0000000000000014
[1033173.493832] RBP: ffff880063117b80 R08: ffff88047574d9a4 R09: 0000000000000000
[1033173.493834] R10: 0000000000000000 R11: 0000000000000000 R12: 1ffff1000c622f53
[1033173.493836] R13: ffff8800cb905500 R14: ffff8808d6da2000 R15: 00000000fffffdfd
[1033173.493840] FS: 00007fa56b92d700(0000) GS:ffff880478000000(0000) knlGS:0000000000000000
[1033173.493843] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
[1033173.493845] CR2: 0000000000000000 CR3: 00000000630e8000 CR4: 00000000000006a0
[1033173.493855] Stack:
[1033173.493862] ffffffffb0b60444 000000000000eaea 0000000041b58ab3 ffffffffb3c3ce32
[1033173.493867] ffffffffb0b6f3e0 ffffffffb0b60444 ffffffffb5ea2e50 1ffff1000c622f5e
[1033173.493873] ffff8800630c4cd8 00000000000ee09a ffffffffb3ec4888 ffffffffb5ea2de8
[1033173.493874] Call Trace:
[1033173.494108] do_vcc_ioctl (net/atm/ioctl.c:170)
[1033173.494113] vcc_ioctl (net/atm/ioctl.c:189)
[1033173.494116] svc_ioctl (net/atm/svc.c:605)
[1033173.494200] sock_do_ioctl (net/socket.c:874)
[1033173.494204] sock_ioctl (net/socket.c:958)
[1033173.494244] do_vfs_ioctl (fs/ioctl.c:43 fs/ioctl.c:607)
[1033173.494290] SyS_ioctl (fs/ioctl.c:622 fs/ioctl.c:613)
[1033173.494295] entry_SYSCALL_64_fastpath (arch/x86/entry/entry_64.S:186)
[1033173.494362] Code: fa 48 c1 ea 03 80 3c 02 00 0f 85 50 09 00 00 49 8b 9e 60 06 00 00 48 b8 00 00 00 00 00 fc ff df 48 8d 7b 14 48 89 fa 48 c1 ea 03 <0f> b6 04 02 48 89 fa 83 e2 07 38 d0 7f 08 84 c0 0f 85 14 09 00
All code
========
0: fa cli
1: 48 c1 ea 03 shr $0x3,%rdx
5: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
9: 0f 85 50 09 00 00 jne 0x95f
f: 49 8b 9e 60 06 00 00 mov 0x660(%r14),%rbx
16: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
1d: fc ff df
20: 48 8d 7b 14 lea 0x14(%rbx),%rdi
24: 48 89 fa mov %rdi,%rdx
27: 48 c1 ea 03 shr $0x3,%rdx
2b:* 0f b6 04 02 movzbl (%rdx,%rax,1),%eax <-- trapping instruction
2f: 48 89 fa mov %rdi,%rdx
32: 83 e2 07 and $0x7,%edx
35: 38 d0 cmp %dl,%al
37: 7f 08 jg 0x41
39: 84 c0 test %al,%al
3b: 0f 85 14 09 00 00 jne 0x955
Code starting with the faulting instruction
===========================================
0: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
4: 48 89 fa mov %rdi,%rdx
7: 83 e2 07 and $0x7,%edx
a: 38 d0 cmp %dl,%al
c: 7f 08 jg 0x16
e: 84 c0 test %al,%al
10: 0f 85 14 09 00 00 jne 0x92a
[1033173.494366] RIP clip_ioctl (net/atm/clip.c:320 net/atm/clip.c:689)
[1033173.494368] RSP <ffff880063117a88>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-09-16 13:30:21 -06:00
|
|
|
if (!CLIP_VCC(vcc))
|
|
|
|
return -EBADFD;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
CLIP_VCC(vcc)->encap = mode;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-31 13:50:42 -06:00
|
|
|
static netdev_tx_t clip_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct clip_priv *clip_priv = PRIV(dev);
|
2011-07-18 00:09:49 -06:00
|
|
|
struct dst_entry *dst = skb_dst(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct atmarp_entry *entry;
|
2011-07-18 00:09:49 -06:00
|
|
|
struct neighbour *n;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct atm_vcc *vcc;
|
2012-02-01 15:23:11 -07:00
|
|
|
struct rtable *rt;
|
|
|
|
__be32 *daddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
int old;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("(skb %p)\n", skb);
|
2011-07-18 00:09:49 -06:00
|
|
|
if (!dst) {
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_err("skb_dst(skb) == NULL\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_kfree_skb(skb);
|
2009-01-09 06:01:00 -07:00
|
|
|
dev->stats.tx_dropped++;
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-02-01 15:23:11 -07:00
|
|
|
rt = (struct rtable *) dst;
|
2019-04-05 17:30:27 -06:00
|
|
|
if (rt->rt_gw_family == AF_INET)
|
|
|
|
daddr = &rt->rt_gw4;
|
2012-02-01 15:23:11 -07:00
|
|
|
else
|
|
|
|
daddr = &ip_hdr(skb)->daddr;
|
|
|
|
n = dst_neigh_lookup(dst, daddr);
|
2011-07-18 00:09:49 -06:00
|
|
|
if (!n) {
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_err("NO NEIGHBOUR !\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_kfree_skb(skb);
|
2009-01-09 06:01:00 -07:00
|
|
|
dev->stats.tx_dropped++;
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-07-24 18:01:33 -06:00
|
|
|
entry = neighbour_priv(n);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!entry->vccs) {
|
|
|
|
if (time_after(jiffies, entry->expires)) {
|
|
|
|
/* should be resolved */
|
2006-04-14 16:59:37 -06:00
|
|
|
entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ;
|
2011-07-24 18:01:33 -06:00
|
|
|
to_atmarpd(act_need, PRIV(dev)->number, *((__be32 *)n->primary_key));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
|
2006-04-14 16:59:37 -06:00
|
|
|
skb_queue_tail(&entry->neigh->arp_queue, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
|
|
|
dev_kfree_skb(skb);
|
2009-01-09 06:01:00 -07:00
|
|
|
dev->stats.tx_dropped++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-02-01 15:23:11 -07:00
|
|
|
goto out_release_neigh;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("neigh %p, vccs %p\n", entry, entry->vccs);
|
2005-04-16 16:20:36 -06:00
|
|
|
ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
|
2011-07-18 00:09:49 -06:00
|
|
|
pr_debug("using neighbour %p, vcc %p\n", n, vcc);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry->vccs->encap) {
|
|
|
|
void *here;
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
here = skb_push(skb, RFC1483LLC_LEN);
|
|
|
|
memcpy(here, llc_oui, sizeof(llc_oui));
|
2006-11-14 22:11:29 -07:00
|
|
|
((__be16 *) here)[3] = skb->protocol;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
atm: Preserve value of skb->truesize when accounting to vcc
ATM accounts for in-flight TX packets in sk_wmem_alloc of the VCC on
which they are to be sent. But it doesn't take ownership of those
packets from the sock (if any) which originally owned them. They should
remain owned by their actual sender until they've left the box.
There's a hack in pskb_expand_head() to avoid adjusting skb->truesize
for certain skbs, precisely to avoid messing up sk_wmem_alloc
accounting. Ideally that hack would cover the ATM use case too, but it
doesn't — skbs which aren't owned by any sock, for example PPP control
frames, still get their truesize adjusted when the low-level ATM driver
adds headroom.
This has always been an issue, it seems. The truesize of a packet
increases, and sk_wmem_alloc on the VCC goes negative. But this wasn't
for normal traffic, only for control frames. So I think we just got away
with it, and we probably needed to send 2GiB of LCP echo frames before
the misaccounting would ever have caused a problem and caused
atm_may_send() to start refusing packets.
Commit 14afee4b609 ("net: convert sock.sk_wmem_alloc from atomic_t to
refcount_t") did exactly what it was intended to do, and turned this
mostly-theoretical problem into a real one, causing PPPoATM to fail
immediately as sk_wmem_alloc underflows and atm_may_send() *immediately*
starts refusing to allow new packets.
The least intrusive solution to this problem is to stash the value of
skb->truesize that was accounted to the VCC, in a new member of the
ATM_SKB(skb) structure. Then in atm_pop_raw() subtract precisely that
value instead of the then-current value of skb->truesize.
Fixes: 158f323b9868 ("net: adjust skb->truesize in pskb_expand_head()")
Signed-off-by: David Woodhouse <dwmw2@infradead.org>
Tested-by: Kevin Darbyshire-Bryant <ldir@darbyshire-bryant.me.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-06-16 04:55:44 -06:00
|
|
|
atm_account_tx(vcc, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->vccs->last_use = jiffies;
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, vcc, vcc->dev);
|
2006-04-14 16:59:37 -06:00
|
|
|
old = xchg(&entry->vccs->xoff, 1); /* assume XOFF ... */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (old) {
|
2014-09-09 22:17:28 -06:00
|
|
|
pr_warn("XOFF->XOFF transition\n");
|
2012-02-01 15:23:11 -07:00
|
|
|
goto out_release_neigh;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-01-09 06:01:00 -07:00
|
|
|
dev->stats.tx_packets++;
|
|
|
|
dev->stats.tx_bytes += skb->len;
|
2006-04-14 17:00:59 -06:00
|
|
|
vcc->send(vcc, skb);
|
2006-04-14 16:59:37 -06:00
|
|
|
if (atm_may_send(vcc, 0)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->vccs->xoff = 0;
|
2012-02-01 15:23:11 -07:00
|
|
|
goto out_release_neigh;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
spin_lock_irqsave(&clip_priv->xoff_lock, flags);
|
|
|
|
netif_stop_queue(dev); /* XOFF -> throttle immediately */
|
2005-04-16 16:20:36 -06:00
|
|
|
barrier();
|
|
|
|
if (!entry->vccs->xoff)
|
|
|
|
netif_start_queue(dev);
|
2006-04-14 16:59:37 -06:00
|
|
|
/* Oh, we just raced with clip_pop. netif_start_queue should be
|
|
|
|
good enough, because nothing should really be asleep because
|
|
|
|
of the brief netif_stop_queue. If this isn't true or if it
|
|
|
|
changes, use netif_wake_queue instead. */
|
|
|
|
spin_unlock_irqrestore(&clip_priv->xoff_lock, flags);
|
2012-02-01 15:23:11 -07:00
|
|
|
out_release_neigh:
|
|
|
|
neigh_release(n);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static int clip_mkip(struct atm_vcc *vcc, int timeout)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct clip_vcc *clip_vcc;
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!vcc->push)
|
|
|
|
return -EBADFD;
|
|
|
|
clip_vcc = kmalloc(sizeof(struct clip_vcc), GFP_KERNEL);
|
|
|
|
if (!clip_vcc)
|
|
|
|
return -ENOMEM;
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("%p vcc %p\n", clip_vcc, vcc);
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_vcc->vcc = vcc;
|
|
|
|
vcc->user_back = clip_vcc;
|
|
|
|
set_bit(ATM_VF_IS_CLIP, &vcc->flags);
|
|
|
|
clip_vcc->entry = NULL;
|
|
|
|
clip_vcc->xoff = 0;
|
|
|
|
clip_vcc->encap = 1;
|
|
|
|
clip_vcc->last_use = jiffies;
|
2006-04-14 16:59:37 -06:00
|
|
|
clip_vcc->idle_timeout = timeout * HZ;
|
2005-04-16 16:20:36 -06:00
|
|
|
clip_vcc->old_push = vcc->push;
|
|
|
|
clip_vcc->old_pop = vcc->pop;
|
|
|
|
vcc->push = clip_push;
|
|
|
|
vcc->pop = clip_pop;
|
2006-11-30 22:05:23 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* re-process everything received between connection setup and MKIP */
|
2011-11-21 03:25:57 -07:00
|
|
|
vcc_process_recv_queue(vcc);
|
2011-11-21 03:25:56 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-14 22:11:29 -07:00
|
|
|
static int clip_setentry(struct atm_vcc *vcc, __be32 ip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct neighbour *neigh;
|
|
|
|
struct atmarp_entry *entry;
|
|
|
|
int error;
|
|
|
|
struct clip_vcc *clip_vcc;
|
|
|
|
struct rtable *rt;
|
|
|
|
|
|
|
|
if (vcc->push != clip_push) {
|
2014-09-09 22:17:28 -06:00
|
|
|
pr_warn("non-CLIP VCC\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBADF;
|
|
|
|
}
|
|
|
|
clip_vcc = CLIP_VCC(vcc);
|
|
|
|
if (!ip) {
|
|
|
|
if (!clip_vcc->entry) {
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_err("hiding hidden ATMARP entry\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("remove\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
unlink_clip_vcc(clip_vcc);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-03-11 22:00:52 -07:00
|
|
|
rt = ip_route_output(&init_net, ip, 0, 1, 0);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt))
|
|
|
|
return PTR_ERR(rt);
|
2011-07-24 18:01:41 -06:00
|
|
|
neigh = __neigh_lookup(&arp_tbl, &ip, rt->dst.dev, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_rt_put(rt);
|
|
|
|
if (!neigh)
|
|
|
|
return -ENOMEM;
|
2011-07-24 18:01:33 -06:00
|
|
|
entry = neighbour_priv(neigh);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (entry != clip_vcc->entry) {
|
2006-04-14 16:59:37 -06:00
|
|
|
if (!clip_vcc->entry)
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("add\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("update\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
unlink_clip_vcc(clip_vcc);
|
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
link_vcc(clip_vcc, entry);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
error = neigh_update(neigh, llc_oui, NUD_PERMANENT,
|
2017-03-19 23:01:28 -06:00
|
|
|
NEIGH_UPDATE_F_OVERRIDE | NEIGH_UPDATE_F_ADMIN, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
neigh_release(neigh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-03-20 13:35:29 -06:00
|
|
|
static const struct net_device_ops clip_netdev_ops = {
|
2011-07-24 18:01:41 -06:00
|
|
|
.ndo_start_xmit = clip_start_xmit,
|
|
|
|
.ndo_neigh_construct = clip_constructor,
|
2009-03-20 13:35:29 -06:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void clip_setup(struct net_device *dev)
|
|
|
|
{
|
2009-03-20 13:35:29 -06:00
|
|
|
dev->netdev_ops = &clip_netdev_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->type = ARPHRD_ATM;
|
2011-07-24 18:01:25 -06:00
|
|
|
dev->neigh_priv_len = sizeof(struct atmarp_entry);
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->hard_header_len = RFC1483LLC_LEN;
|
|
|
|
dev->mtu = RFC1626_MTU;
|
2006-04-14 16:59:37 -06:00
|
|
|
dev->tx_queue_len = 100; /* "normal" queue (packets) */
|
|
|
|
/* When using a "real" qdisc, the qdisc determines the queue */
|
|
|
|
/* length. tx_queue_len is only used for the default case, */
|
|
|
|
/* without any more elaborate queuing. 100 is a reasonable */
|
|
|
|
/* compromise between decent burst-tolerance and protection */
|
|
|
|
/* against memory hogs. */
|
2014-10-05 19:38:35 -06:00
|
|
|
netif_keep_dst(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int clip_create(int number)
|
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct clip_priv *clip_priv;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (number != -1) {
|
|
|
|
for (dev = clip_devs; dev; dev = PRIV(dev)->next)
|
2006-04-14 16:59:37 -06:00
|
|
|
if (PRIV(dev)->number == number)
|
|
|
|
return -EEXIST;
|
|
|
|
} else {
|
2005-04-16 16:20:36 -06:00
|
|
|
number = 0;
|
|
|
|
for (dev = clip_devs; dev; dev = PRIV(dev)->next)
|
|
|
|
if (PRIV(dev)->number >= number)
|
2006-04-14 16:59:37 -06:00
|
|
|
number = PRIV(dev)->number + 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
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(struct clip_priv), "", NET_NAME_UNKNOWN,
|
|
|
|
clip_setup);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
clip_priv = PRIV(dev);
|
2006-04-14 16:59:37 -06:00
|
|
|
sprintf(dev->name, "atm%d", number);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_init(&clip_priv->xoff_lock);
|
|
|
|
clip_priv->number = number;
|
|
|
|
error = register_netdev(dev);
|
|
|
|
if (error) {
|
|
|
|
free_netdev(dev);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
clip_priv->next = clip_devs;
|
|
|
|
clip_devs = dev;
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("registered (net:%s)\n", dev->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
return number;
|
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static int clip_device_event(struct notifier_block *this, unsigned long event,
|
2013-05-27 19:30:21 -06:00
|
|
|
void *ptr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-05-27 19:30:21 -06:00
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
2006-04-14 16:07:27 -06:00
|
|
|
|
2008-07-19 23:34:43 -06:00
|
|
|
if (!net_eq(dev_net(dev), &init_net))
|
2007-09-12 05:02:17 -06:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2011-07-24 18:01:41 -06:00
|
|
|
if (event == NETDEV_UNREGISTER)
|
2006-04-14 16:07:27 -06:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* ignore non-CLIP devices */
|
2009-03-20 13:35:29 -06:00
|
|
|
if (dev->type != ARPHRD_ATM || dev->netdev_ops != &clip_netdev_ops)
|
2005-04-16 16:20:36 -06:00
|
|
|
return NOTIFY_DONE;
|
2006-04-14 16:07:27 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (event) {
|
2006-04-14 16:59:37 -06:00
|
|
|
case NETDEV_UP:
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("NETDEV_UP\n");
|
2006-04-14 17:00:59 -06:00
|
|
|
to_atmarpd(act_up, PRIV(dev)->number, 0);
|
2006-04-14 16:59:37 -06:00
|
|
|
break;
|
|
|
|
case NETDEV_GOING_DOWN:
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("NETDEV_DOWN\n");
|
2006-04-14 17:00:59 -06:00
|
|
|
to_atmarpd(act_down, PRIV(dev)->number, 0);
|
2006-04-14 16:59:37 -06:00
|
|
|
break;
|
|
|
|
case NETDEV_CHANGE:
|
|
|
|
case NETDEV_CHANGEMTU:
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("NETDEV_CHANGE*\n");
|
2006-04-14 17:00:59 -06:00
|
|
|
to_atmarpd(act_change, PRIV(dev)->number, 0);
|
2006-04-14 16:59:37 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static int clip_inet_event(struct notifier_block *this, unsigned long event,
|
|
|
|
void *ifa)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct in_device *in_dev;
|
2013-05-28 21:30:50 -06:00
|
|
|
struct netdev_notifier_info info;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
in_dev = ((struct in_ifaddr *)ifa)->ifa_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Transitions are of the down-change-up type, so it's sufficient to
|
|
|
|
* handle the change on up.
|
|
|
|
*/
|
2006-04-14 16:59:37 -06:00
|
|
|
if (event != NETDEV_UP)
|
|
|
|
return NOTIFY_DONE;
|
2013-05-28 21:30:50 -06:00
|
|
|
netdev_notifier_info_init(&info, in_dev->dev);
|
|
|
|
return clip_device_event(this, NETDEV_CHANGE, &info);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block clip_dev_notifier = {
|
2006-04-14 17:00:59 -06:00
|
|
|
.notifier_call = clip_device_event,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct notifier_block clip_inet_notifier = {
|
2006-04-14 17:00:59 -06:00
|
|
|
.notifier_call = clip_inet_event,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void atmarpd_close(struct atm_vcc *vcc)
|
|
|
|
{
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_debug("\n");
|
2006-04-14 16:07:27 -06:00
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
atmarpd = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
skb_queue_purge(&sk_atm(vcc)->sk_receive_queue);
|
2006-04-14 16:07:27 -06:00
|
|
|
rtnl_unlock();
|
|
|
|
|
2007-08-28 16:22:09 -06:00
|
|
|
pr_debug("(done)\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
|
|
|
|
2017-08-09 03:32:08 -06:00
|
|
|
static const struct atmdev_ops atmarpd_dev_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.close = atmarpd_close
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static struct atm_dev atmarpd_dev = {
|
|
|
|
.ops = &atmarpd_dev_ops,
|
|
|
|
.type = "arpd",
|
|
|
|
.number = 999,
|
2007-04-26 02:37:44 -06:00
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(atmarpd_dev.lock)
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static int atm_init_atmarp(struct atm_vcc *vcc)
|
|
|
|
{
|
2006-04-14 16:07:27 -06:00
|
|
|
rtnl_lock();
|
|
|
|
if (atmarpd) {
|
|
|
|
rtnl_unlock();
|
|
|
|
return -EADDRINUSE;
|
|
|
|
}
|
|
|
|
|
2010-01-26 04:40:05 -07:00
|
|
|
mod_timer(&idle_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
|
2006-04-14 16:56:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
atmarpd = vcc;
|
2010-01-26 04:40:05 -07:00
|
|
|
set_bit(ATM_VF_META, &vcc->flags);
|
|
|
|
set_bit(ATM_VF_READY, &vcc->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* allow replies and avoid getting closed if signaling dies */
|
|
|
|
vcc->dev = &atmarpd_dev;
|
|
|
|
vcc_insert_socket(sk_atm(vcc));
|
|
|
|
vcc->push = NULL;
|
|
|
|
vcc->pop = NULL; /* crash */
|
|
|
|
vcc->push_oam = NULL; /* crash */
|
2006-04-14 16:07:27 -06:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int clip_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct atm_vcc *vcc = ATM_SD(sock);
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
switch (cmd) {
|
2006-04-14 16:59:37 -06:00
|
|
|
case SIOCMKCLIP:
|
|
|
|
case ATMARPD_CTRL:
|
|
|
|
case ATMARP_MKIP:
|
|
|
|
case ATMARP_SETENTRY:
|
|
|
|
case ATMARP_ENCAP:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (cmd) {
|
2006-04-14 16:59:37 -06:00
|
|
|
case SIOCMKCLIP:
|
|
|
|
err = clip_create(arg);
|
|
|
|
break;
|
|
|
|
case ATMARPD_CTRL:
|
|
|
|
err = atm_init_atmarp(vcc);
|
|
|
|
if (!err) {
|
|
|
|
sock->state = SS_CONNECTED;
|
|
|
|
__module_get(THIS_MODULE);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ATMARP_MKIP:
|
|
|
|
err = clip_mkip(vcc, arg);
|
|
|
|
break;
|
|
|
|
case ATMARP_SETENTRY:
|
2006-11-14 22:11:29 -07:00
|
|
|
err = clip_setentry(vcc, (__force __be32)arg);
|
2006-04-14 16:59:37 -06:00
|
|
|
break;
|
|
|
|
case ATMARP_ENCAP:
|
|
|
|
err = clip_encap(vcc, arg);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct atm_ioctl clip_ioctl_ops = {
|
2006-04-14 16:59:37 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.ioctl = clip_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
|
|
|
static void svc_addr(struct seq_file *seq, struct sockaddr_atmsvc *addr)
|
|
|
|
{
|
2006-04-14 16:59:37 -06:00
|
|
|
static int code[] = { 1, 2, 10, 6, 1, 0 };
|
|
|
|
static int e164[] = { 1, 8, 4, 6, 1, 0 };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (*addr->sas_addr.pub) {
|
|
|
|
seq_printf(seq, "%s", addr->sas_addr.pub);
|
|
|
|
if (*addr->sas_addr.prv)
|
|
|
|
seq_putc(seq, '+');
|
|
|
|
} else if (!*addr->sas_addr.prv) {
|
|
|
|
seq_printf(seq, "%s", "(none)");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (*addr->sas_addr.prv) {
|
|
|
|
unsigned char *prv = addr->sas_addr.prv;
|
|
|
|
int *fields;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
fields = *prv == ATM_AFI_E164 ? e164 : code;
|
|
|
|
for (i = 0; fields[i]; i++) {
|
|
|
|
for (j = fields[i]; j; j--)
|
|
|
|
seq_printf(seq, "%02X", *prv++);
|
2006-04-14 16:59:37 -06:00
|
|
|
if (fields[i + 1])
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_putc(seq, '.');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This means the neighbour entry has no attached VCC objects. */
|
|
|
|
#define SEQ_NO_VCC_TOKEN ((void *) 2)
|
|
|
|
|
2011-07-24 18:01:33 -06:00
|
|
|
static void atmarp_info(struct seq_file *seq, struct neighbour *n,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct atmarp_entry *entry, struct clip_vcc *clip_vcc)
|
|
|
|
{
|
2011-07-24 18:01:33 -06:00
|
|
|
struct net_device *dev = n->dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long exp;
|
|
|
|
char buf[17];
|
|
|
|
int svc, llc, off;
|
|
|
|
|
|
|
|
svc = ((clip_vcc == SEQ_NO_VCC_TOKEN) ||
|
|
|
|
(sk_atm(clip_vcc->vcc)->sk_family == AF_ATMSVC));
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
llc = ((clip_vcc == SEQ_NO_VCC_TOKEN) || clip_vcc->encap);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (clip_vcc == SEQ_NO_VCC_TOKEN)
|
|
|
|
exp = entry->neigh->used;
|
|
|
|
else
|
|
|
|
exp = clip_vcc->last_use;
|
|
|
|
|
|
|
|
exp = (jiffies - exp) / HZ;
|
|
|
|
|
|
|
|
seq_printf(seq, "%-6s%-4s%-4s%5ld ",
|
2006-04-14 16:59:37 -06:00
|
|
|
dev->name, svc ? "SVC" : "PVC", llc ? "LLC" : "NULL", exp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-24 18:01:33 -06:00
|
|
|
off = scnprintf(buf, sizeof(buf) - 1, "%pI4", n->primary_key);
|
2005-04-16 16:20:36 -06:00
|
|
|
while (off < 16)
|
|
|
|
buf[off++] = ' ';
|
|
|
|
buf[off] = '\0';
|
|
|
|
seq_printf(seq, "%s", buf);
|
|
|
|
|
|
|
|
if (clip_vcc == SEQ_NO_VCC_TOKEN) {
|
|
|
|
if (time_before(jiffies, entry->expires))
|
|
|
|
seq_printf(seq, "(resolving)\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "(expired, ref %d)\n",
|
2017-06-30 04:07:55 -06:00
|
|
|
refcount_read(&entry->neigh->refcnt));
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (!svc) {
|
|
|
|
seq_printf(seq, "%d.%d.%d\n",
|
|
|
|
clip_vcc->vcc->dev->number,
|
2006-04-14 16:59:37 -06:00
|
|
|
clip_vcc->vcc->vpi, clip_vcc->vcc->vci);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
svc_addr(seq, &clip_vcc->vcc->remote);
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct clip_seq_state {
|
|
|
|
/* This member must be first. */
|
|
|
|
struct neigh_seq_state ns;
|
|
|
|
|
|
|
|
/* Local to clip specific iteration. */
|
|
|
|
struct clip_vcc *vcc;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct clip_vcc *clip_seq_next_vcc(struct atmarp_entry *e,
|
|
|
|
struct clip_vcc *curr)
|
|
|
|
{
|
|
|
|
if (!curr) {
|
|
|
|
curr = e->vccs;
|
|
|
|
if (!curr)
|
|
|
|
return SEQ_NO_VCC_TOKEN;
|
|
|
|
return curr;
|
|
|
|
}
|
|
|
|
if (curr == SEQ_NO_VCC_TOKEN)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
curr = curr->next;
|
|
|
|
|
|
|
|
return curr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *clip_seq_vcc_walk(struct clip_seq_state *state,
|
2006-04-14 16:59:37 -06:00
|
|
|
struct atmarp_entry *e, loff_t * pos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct clip_vcc *vcc = state->vcc;
|
|
|
|
|
|
|
|
vcc = clip_seq_next_vcc(e, vcc);
|
|
|
|
if (vcc && pos != NULL) {
|
|
|
|
while (*pos) {
|
|
|
|
vcc = clip_seq_next_vcc(e, vcc);
|
|
|
|
if (!vcc)
|
|
|
|
break;
|
|
|
|
--(*pos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
state->vcc = vcc;
|
|
|
|
|
|
|
|
return vcc;
|
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void *clip_seq_sub_iter(struct neigh_seq_state *_state,
|
2006-04-14 16:59:37 -06:00
|
|
|
struct neighbour *n, loff_t * pos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-04-14 16:59:37 -06:00
|
|
|
struct clip_seq_state *state = (struct clip_seq_state *)_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-24 18:01:41 -06:00
|
|
|
if (n->dev->type != ARPHRD_ATM)
|
|
|
|
return NULL;
|
|
|
|
|
2011-07-24 18:01:33 -06:00
|
|
|
return clip_seq_vcc_walk(state, neighbour_priv(n), pos);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-04-14 16:59:37 -06:00
|
|
|
static void *clip_seq_start(struct seq_file *seq, loff_t * pos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-01-10 04:52:35 -07:00
|
|
|
struct clip_seq_state *state = seq->private;
|
|
|
|
state->ns.neigh_sub_iter = clip_seq_sub_iter;
|
2011-07-24 18:01:41 -06:00
|
|
|
return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_NEIGH_ONLY);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int clip_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2006-04-14 16:59:37 -06:00
|
|
|
static char atm_arp_banner[] =
|
|
|
|
"IPitf TypeEncp Idle IP address ATM address\n";
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
seq_puts(seq, atm_arp_banner);
|
|
|
|
} else {
|
|
|
|
struct clip_seq_state *state = seq->private;
|
|
|
|
struct clip_vcc *vcc = state->vcc;
|
2011-07-24 18:01:33 -06:00
|
|
|
struct neighbour *n = v;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-24 18:01:33 -06:00
|
|
|
atmarp_info(seq, n, neighbour_priv(n), vcc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-04-14 16:59:37 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-11 00:07:31 -06:00
|
|
|
static const struct seq_operations arp_seq_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = clip_seq_start,
|
|
|
|
.next = neigh_seq_next,
|
|
|
|
.stop = neigh_seq_stop,
|
|
|
|
.show = clip_seq_show,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2008-03-23 22:45:36 -06:00
|
|
|
static void atm_clip_exit_noproc(void);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init atm_clip_init(void)
|
|
|
|
{
|
|
|
|
register_atm_ioctl(&clip_ioctl_ops);
|
2006-04-14 16:07:27 -06:00
|
|
|
register_netdevice_notifier(&clip_dev_notifier);
|
|
|
|
register_inetaddr_notifier(&clip_inet_notifier);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-10-16 18:29:37 -06:00
|
|
|
timer_setup(&idle_timer, idle_timer_check, 0);
|
2006-04-14 16:56:02 -06:00
|
|
|
|
2006-07-09 13:13:18 -06:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *p;
|
|
|
|
|
2018-04-10 11:42:55 -06:00
|
|
|
p = proc_create_net("arp", 0444, atm_proc_root, &arp_seq_ops,
|
|
|
|
sizeof(struct clip_seq_state));
|
2008-03-23 22:45:36 -06:00
|
|
|
if (!p) {
|
2010-01-26 04:40:00 -07:00
|
|
|
pr_err("Unable to initialize /proc/net/atm/arp\n");
|
2008-03-23 22:45:36 -06:00
|
|
|
atm_clip_exit_noproc();
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2006-07-09 13:13:18 -06:00
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-23 22:45:36 -06:00
|
|
|
static void atm_clip_exit_noproc(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev, *next;
|
|
|
|
|
2006-04-14 16:07:27 -06:00
|
|
|
unregister_inetaddr_notifier(&clip_inet_notifier);
|
|
|
|
unregister_netdevice_notifier(&clip_dev_notifier);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
deregister_atm_ioctl(&clip_ioctl_ops);
|
|
|
|
|
|
|
|
/* First, stop the idle timer, so it stops banging
|
|
|
|
* on the table.
|
|
|
|
*/
|
2006-04-14 16:56:02 -06:00
|
|
|
del_timer_sync(&idle_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dev = clip_devs;
|
|
|
|
while (dev) {
|
|
|
|
next = PRIV(dev)->next;
|
|
|
|
unregister_netdev(dev);
|
|
|
|
free_netdev(dev);
|
|
|
|
dev = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-23 22:45:36 -06:00
|
|
|
static void __exit atm_clip_exit(void)
|
|
|
|
{
|
|
|
|
remove_proc_entry("arp", atm_proc_root);
|
|
|
|
|
|
|
|
atm_clip_exit_noproc();
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
module_init(atm_clip_init);
|
|
|
|
module_exit(atm_clip_exit);
|
2006-04-14 17:01:26 -06:00
|
|
|
MODULE_AUTHOR("Werner Almesberger");
|
|
|
|
MODULE_DESCRIPTION("Classical/IP over ATM interface");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|