static void clip_neigh_destroy(struct neighbour *neigh)
{
DPRINTK("clip_neigh_destroy (neigh %p)\n",neigh);
if (NEIGH2ENTRY(neigh)->vccs)
printk(KERN_CRIT "clip_neigh_destroy: vccs != NULL !!!\n");
NEIGH2ENTRY(neigh)->vccs = (void *) 0xdeadbeef;
}
static void clip_neigh_destroy(struct neighbour *neigh)
{
struct clip_vcc *clip_vcc, *next;
struct atmarp_entry *entry = NEIGH2ENTRY(neigh);
DPRINTK("clip_neigh_destroy (neigh %p) ent %p vccs %p\n", neigh, entry,
entry->vccs);
for (clip_vcc = entry->vccs; clip_vcc; clip_vcc = next)
{
next = clip_vcc->next;
clip_vcc->entry = NULL;
clip_vcc->next = NULL;
}
NEIGH2ENTRY(neigh)->vccs = (void *) 0xdeadbeef;
}
static int clip_constructor(struct neighbour *neigh)
{
struct atmarp_entry *entry = NEIGH2ENTRY(neigh);
struct net_device *dev = neigh->dev;
struct in_device *in_dev;
struct neigh_parms *parms;
DPRINTK("clip_constructor (neigh %p, entry %p)\n",neigh,entry);
neigh->type = inet_addr_type(entry->ip);
if (neigh->type != RTN_UNICAST) return -EINVAL;
rcu_read_lock();
in_dev = rcu_dereference(__in_dev_get(dev));
if (!in_dev) {
rcu_read_unlock();
return -EINVAL;
}
parms = in_dev->arp_parms;
__neigh_parms_put(neigh->parms);
neigh->parms = neigh_parms_clone(parms);
rcu_read_unlock();
neigh->ops = &clip_neigh_ops;
neigh->output = neigh->nud_state & NUD_VALID ?
neigh->ops->connected_output : neigh->ops->output;
entry->neigh = neigh;
entry->vccs = NULL;
entry->expires = jiffies-1;
return 0;
}
/* The neighbour entry n->lock is held. */
static int neigh_check_cb(struct neighbour *n)
{
struct atmarp_entry *entry = NEIGH2ENTRY(n);
struct clip_vcc *cv;
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)) {
DPRINTK("releasing vcc %p->%p of entry %p\n",
cv, cv->vcc, entry);
vcc_release_async(cv->vcc, -ETIMEDOUT);
}
}
if (entry->vccs || time_before(jiffies, entry->expires))
return 0;
if (atomic_read(&n->refcnt) > 1) {
struct sk_buff *skb;
DPRINTK("destruction postponed with ref %d\n",
atomic_read(&n->refcnt));
while ((skb = skb_dequeue(&n->arp_queue)) != NULL)
dev_kfree_skb(skb);
return 0;
}
DPRINTK("expired neigh %p\n",n);
return 1;
}
static int clip_setentry(struct atm_vcc *vcc,u32 ip)
{
struct neighbour *neigh;
struct atmarp_entry *entry;
int error;
struct clip_vcc *clip_vcc;
#ifndef __TCS__
struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip, .tos = 1 } } };
struct rtable *rt;
#else
struct rtable *rt;
struct flowi fl;
memset(&fl,0,sizeof(fl));
fl.nl_u.ip4_u.daddr=ip;
fl.nl_u.ip4_u.tos=1;
#endif
if (vcc->push != clip_push) {
printk(KERN_WARNING "clip_setentry: non-CLIP VCC\n");
return -EBADF;
}
clip_vcc = CLIP_VCC(vcc);
if (!ip) {
if (!clip_vcc->entry) {
printk(KERN_ERR "hiding hidden ATMARP entry\n");
return 0;
}
DPRINTK("setentry: remove\n");
unlink_clip_vcc(clip_vcc);
return 0;
}
error = ip_route_output_key(&rt,&fl);
if (error) return error;
neigh = __neigh_lookup(&clip_tbl,&ip,rt->u.dst.dev,1);
ip_rt_put(rt);
if (!neigh)
return -ENOMEM;
entry = NEIGH2ENTRY(neigh);
if (entry != clip_vcc->entry) {
if (!clip_vcc->entry) DPRINTK("setentry: add\n");
else {
DPRINTK("setentry: update\n");
unlink_clip_vcc(clip_vcc);
}
link_vcc(clip_vcc,entry);
}
error = neigh_update(neigh, llc_oui, NUD_PERMANENT,
NEIGH_UPDATE_F_OVERRIDE|NEIGH_UPDATE_F_ADMIN);
neigh_release(neigh);
return error;
}
static void idle_timer_check(unsigned long dummy)
{
int i;
/*DPRINTK("idle_timer_check\n");*/
write_lock(&clip_tbl.lock);
for (i = 0; i <= NEIGH_HASHMASK; i++) {
struct neighbour **np;
for (np = &clip_tbl.hash_buckets[i]; *np;) {
struct neighbour *n = *np;
struct atmarp_entry *entry = NEIGH2ENTRY(n);
struct clip_vcc *clip_vcc;
for (clip_vcc = entry->vccs; clip_vcc;
clip_vcc = clip_vcc->next)
if (clip_vcc->idle_timeout &&
time_after(jiffies, clip_vcc->last_use+
clip_vcc->idle_timeout)) {
DPRINTK("releasing vcc %p->%p of "
"entry %p\n",clip_vcc,clip_vcc->vcc,
entry);
atm_async_release_vcc(clip_vcc->vcc,
-ETIMEDOUT);
}
if (entry->vccs ||
time_before(jiffies, entry->expires)) {
np = &n->next;
continue;
}
if (atomic_read(&n->refcnt) > 1) {
struct sk_buff *skb;
DPRINTK("destruction postponed with ref %d\n",
atomic_read(&n->refcnt));
while ((skb = skb_dequeue(&n->arp_queue)) !=
NULL)
dev_kfree_skb(skb);
np = &n->next;
continue;
}
*np = n->next;
DPRINTK("expired neigh %p\n",n);
n->dead = 1;
neigh_release(n);
}
}
mod_timer(&idle_timer, jiffies+CLIP_CHECK_INTERVAL*HZ);
write_unlock(&clip_tbl.lock);
}
static int clip_constructor(struct neighbour *neigh)
{
struct atmarp_entry *entry = NEIGH2ENTRY(neigh);
struct net_device *dev = neigh->dev;
struct in_device *in_dev = dev->ip_ptr;
DPRINTK("clip_constructor (neigh %p, entry %p)\n",neigh,entry);
if (!in_dev) return -EINVAL;
neigh->type = inet_addr_type(entry->ip);
if (neigh->type != RTN_UNICAST) return -EINVAL;
if (in_dev->arp_parms) neigh->parms = in_dev->arp_parms;
neigh->ops = &clip_neigh_ops;
neigh->output = neigh->nud_state & NUD_VALID ?
neigh->ops->connected_output : neigh->ops->output;
entry->neigh = neigh;
entry->vccs = NULL;
entry->expires = jiffies-1;
return 0;
}
int clip_setentry(struct atm_vcc *vcc,u32 ip)
{
struct neighbour *neigh;
struct atmarp_entry *entry;
int error;
struct clip_vcc *clip_vcc;
struct rtable *rt;
if (vcc->push != clip_push) {
printk(KERN_WARNING "clip_setentry: non-CLIP VCC\n");
return -EBADF;
}
clip_vcc = CLIP_VCC(vcc);
if (!ip) {
if (!clip_vcc->entry) {
printk(KERN_ERR "hiding hidden ATMARP entry\n");
return 0;
}
DPRINTK("setentry: remove\n");
unlink_clip_vcc(clip_vcc);
return 0;
}
error = ip_route_output(&rt,ip,0,1,0);
if (error) return error;
neigh = __neigh_lookup(&clip_tbl,&ip,rt->u.dst.dev,1);
ip_rt_put(rt);
if (!neigh)
return -ENOMEM;
entry = NEIGH2ENTRY(neigh);
if (entry != clip_vcc->entry) {
if (!clip_vcc->entry) DPRINTK("setentry: add\n");
else {
DPRINTK("setentry: update\n");
unlink_clip_vcc(clip_vcc);
}
link_vcc(clip_vcc,entry);
}
error = neigh_update(neigh,llc_oui,NUD_PERMANENT,1,0);
neigh_release(neigh);
return error;
}
static int clip_learn(struct clip_vcc *clip_vcc, u32 ip)
{
struct neighbour *neigh;
struct atmarp_entry *entry;
int error;
if (!ip)
{
if (!clip_vcc->entry)
{
printk(KERN_ERR "hiding hidden ATMARP entry\n");
return 0;
}
DPRINTK("setentry: remove\n");
unlink_clip_vcc(clip_vcc);
return 0;
}
neigh = __neigh_lookup(&clip_tbl, &ip, clip_vcc->dev, 1);
if (!neigh)
return -ENOMEM;
del_timer(&clip_vcc->resolve_timer);
clip_vcc->resolve_timeout = 0; /* Mark resolved */
entry = NEIGH2ENTRY(neigh);
if (entry != clip_vcc->entry)
{
if (!clip_vcc->entry)
DPRINTK("setentry: add\n");
else
{
DPRINTK("setentry: update %p\n", clip_vcc->entry);
unlink_clip_vcc(clip_vcc);
}
link_vcc(clip_vcc, entry);
}
error = neigh_update(neigh, llc_oui, NUD_PERMANENT, 1, 0);
entry->expires = jiffies + CLIP_ENTRY_EXPIRE;
neigh_release(neigh);
return error;
}
static int clip_start_xmit(struct sk_buff *skb,struct net_device *dev)
{
struct clip_priv *clip_priv = PRIV(dev);
struct atmarp_entry *entry;
struct atm_vcc *vcc;
int old;
unsigned long flags;
DPRINTK("clip_start_xmit (skb %p)\n",skb);
if (!skb->dst) {
printk(KERN_ERR "clip_start_xmit: skb->dst == NULL\n");
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
return 0;
}
if (!skb->dst->neighbour) {
#if 0
skb->dst->neighbour = clip_find_neighbour(skb->dst,1);
if (!skb->dst->neighbour) {
dev_kfree_skb(skb); /* lost that one */
clip_priv->stats.tx_dropped++;
return 0;
}
#endif
printk(KERN_ERR "clip_start_xmit: NO NEIGHBOUR !\n");
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
return 0;
}
entry = NEIGH2ENTRY(skb->dst->neighbour);
if (!entry->vccs) {
if (time_after(jiffies, entry->expires)) {
/* should be resolved */
entry->expires = jiffies+ATMARP_RETRY_DELAY*HZ;
to_atmarpd(act_need,PRIV(dev)->number,entry->ip);
}
if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
skb_queue_tail(&entry->neigh->arp_queue,skb);
else {
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
}
return 0;
}
DPRINTK("neigh %p, vccs %p\n",entry,entry->vccs);
ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
DPRINTK("using neighbour %p, vcc %p\n",skb->dst->neighbour,vcc);
if (entry->vccs->encap) {
void *here;
here = skb_push(skb,RFC1483LLC_LEN);
memcpy(here,llc_oui,sizeof(llc_oui));
((u16 *) here)[3] = skb->protocol;
}
atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
ATM_SKB(skb)->atm_options = vcc->atm_options;
entry->vccs->last_use = jiffies;
DPRINTK("atm_skb(%p)->vcc(%p)->dev(%p)\n",skb,vcc,vcc->dev);
old = xchg(&entry->vccs->xoff,1); /* assume XOFF ... */
if (old) {
printk(KERN_WARNING "clip_start_xmit: XOFF->XOFF transition\n");
return 0;
}
clip_priv->stats.tx_packets++;
clip_priv->stats.tx_bytes += skb->len;
(void) vcc->send(vcc,skb);
if (atm_may_send(vcc,0)) {
entry->vccs->xoff = 0;
return 0;
}
spin_lock_irqsave(&clip_priv->xoff_lock,flags);
netif_stop_queue(dev); /* XOFF -> throttle immediately */
barrier();
if (!entry->vccs->xoff)
netif_start_queue(dev);
/* 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);
return 0;
}
static void clip_neigh_solicit(struct neighbour *neigh,struct sk_buff *skb)
{
DPRINTK("clip_neigh_solicit (neigh %p, skb %p)\n",neigh,skb);
to_atmarpd(act_need,PRIV(neigh->dev)->number,NEIGH2ENTRY(neigh)->ip);
}
static int clip_start_xmit(struct sk_buff *skb, knet_netdev_t *dev)
{
struct clip_priv *clip_priv = PRIV(dev);
struct atmarp_entry *entry;
struct atm_vcc *vcc;
int old;
unsigned long flags;
DPRINTK("clip_start_xmit (skb %p)\n", skb);
if (!skb->dst)
{
printk(KERN_ERR "clip_start_xmit: skb->dst == NULL\n");
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
return 0;
}
if (!skb->dst->neighbour)
{
printk(KERN_ERR "clip_start_xmit: NO NEIGHBOUR!\n");
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
return 0;
}
entry = NEIGH2ENTRY(skb->dst->neighbour);
if (!entry->vccs)
{
if (time_after(jiffies, entry->expires))
{
/* should be resolved */
entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ;
}
if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
skb_queue_tail(&entry->neigh->arp_queue, skb);
else
{
dev_kfree_skb(skb);
clip_priv->stats.tx_dropped++;
}
/* If a vcc was not resolved for a long time, it sends an InARP
* packet every 5 minutes. But if the other side connected now
* we do not want to wait.
*/
all_clip_vccs_start_resolving();
return 0;
}
DPRINTK("neigh %p, vccs %p\n", entry, entry->vccs);
ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
DPRINTK("using neighbour %p, vcc %p\n", skb->dst->neighbour, vcc);
if (entry->vccs->encap)
{
void *here;
here = skb_push(skb, RFC1483LLC_LEN);
memcpy(here, llc_oui, sizeof(llc_oui));
((u16 *) here)[3] = skb->protocol;
}
atomic_add(skb->truesize, &vcc->tx_inuse);
ATM_SKB(skb)->iovcnt = 0;
ATM_SKB(skb)->atm_options = vcc->atm_options;
entry->vccs->last_use = jiffies;
DPRINTK("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, vcc,vcc->dev);
old = xchg(&entry->vccs->xoff, 1); /* assume XOFF ... */
if (old)
{
printk(KERN_WARNING "clip_start_xmit: XOFF->XOFF transition\n");
return 0;
}
clip_priv->stats.tx_packets++;
clip_priv->stats.tx_bytes += skb->len;
vcc->dev->ops->send(vcc, skb);
if (atm_may_send(vcc, 0))
{
entry->vccs->xoff = 0;
return 0;
}
spin_lock_irqsave(&clip_priv->xoff_lock, flags);
knet_netdev_stop_queue(dev); /* XOFF -> throttle immediately */
barrier();
if (!entry->vccs->xoff)
knet_netdev_start_queue(dev);
/* 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);
return 0;
}
static void neigh_expire_timer_check(unsigned long dummy)
{
int i;
unsigned long flags;
save_flags(flags);
cli();
write_lock(&clip_tbl.lock);
for (i = 0; i <= NEIGH_HASHMASK; i++)
{
struct neighbour **np;
for (np = &clip_tbl.hash_buckets[i]; *np;)
{
struct neighbour *n = *np;
struct atmarp_entry *entry = NEIGH2ENTRY(n);
struct clip_vcc *clip_vcc;
int need_resolving = 1;
if (time_before(jiffies + CLIP_ENTRY_EXPIRE / 4, entry->expires))
need_resolving = 0;
for (clip_vcc = entry->vccs; clip_vcc; clip_vcc = clip_vcc->next)
{
if (clip_vcc->idle_timeout && time_after(jiffies,
clip_vcc->last_use + clip_vcc->idle_timeout))
{
DPRINTK("releasing vcc %p->%p of entry %p\n",
clip_vcc, clip_vcc->vcc, entry);
atm_async_release_vcc(clip_vcc->vcc, -ETIMEDOUT);
}
else if (need_resolving && !clip_vcc->resolve_timeout)
clip_start_resolving(clip_vcc);
}
if (!need_resolving || time_before(jiffies, entry->expires))
{
np = &n->next;
continue;
}
if (atomic_read(&n->refcnt) > 1)
{
struct sk_buff *skb;
DPRINTK("destruction postponed with ref %d\n",
atomic_read(&n->refcnt));
while ((skb = skb_dequeue(&n->arp_queue)))
dev_kfree_skb(skb);
np = &n->next;
continue;
}
*np = n->next;
DPRINTK("expired neigh %p\n",n);
n->dead = 1;
neigh_release(n);
}
}
mod_timer(&neigh_expire_timer, jiffies + CLIP_CHECK_INTERVAL * HZ);
write_unlock(&clip_tbl.lock);
restore_flags(flags);
}
