2020-07-30 20:28:21 +00:00
|
|
|
// Copyright 2020 The gVisor Authors.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package stack
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"gvisor.dev/gvisor/pkg/sync"
|
|
|
|
"gvisor.dev/gvisor/pkg/tcpip"
|
|
|
|
)
|
|
|
|
|
|
|
|
const neighborCacheSize = 512 // max entries per interface
|
|
|
|
|
2020-11-24 22:20:15 +00:00
|
|
|
// NeighborStats holds metrics for the neighbor table.
|
|
|
|
type NeighborStats struct {
|
|
|
|
// FailedEntryLookups counts the number of lookups performed on an entry in
|
|
|
|
// Failed state.
|
|
|
|
FailedEntryLookups *tcpip.StatCounter
|
|
|
|
}
|
|
|
|
|
2020-07-30 20:28:21 +00:00
|
|
|
// neighborCache maps IP addresses to link addresses. It uses the Least
|
|
|
|
// Recently Used (LRU) eviction strategy to implement a bounded cache for
|
2020-11-24 22:20:15 +00:00
|
|
|
// dynamically acquired entries. It contains the state machine and configuration
|
2020-07-30 20:28:21 +00:00
|
|
|
// for running Neighbor Unreachability Detection (NUD).
|
|
|
|
//
|
|
|
|
// There are two types of entries in the neighbor cache:
|
|
|
|
// 1. Dynamic entries are discovered automatically by neighbor discovery
|
|
|
|
// protocols (e.g. ARP, NDP). These protocols will attempt to reconfirm
|
|
|
|
// reachability with the device once the entry's state becomes Stale.
|
|
|
|
// 2. Static entries are explicitly added by a user and have no expiration.
|
|
|
|
// Their state is always Static. The amount of static entries stored in the
|
|
|
|
// cache is unbounded.
|
|
|
|
type neighborCache struct {
|
|
|
|
nic *NIC
|
|
|
|
state *NUDState
|
|
|
|
|
|
|
|
// mu protects the fields below.
|
|
|
|
mu sync.RWMutex
|
|
|
|
|
|
|
|
cache map[tcpip.Address]*neighborEntry
|
|
|
|
dynamic struct {
|
|
|
|
lru neighborEntryList
|
|
|
|
|
|
|
|
// count tracks the amount of dynamic entries in the cache. This is
|
|
|
|
// needed since static entries do not count towards the LRU cache
|
|
|
|
// eviction strategy.
|
|
|
|
count uint16
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// getOrCreateEntry retrieves a cache entry associated with addr. The
|
|
|
|
// returned entry is always refreshed in the cache (it is reachable via the
|
|
|
|
// map, and its place is bumped in LRU).
|
|
|
|
//
|
|
|
|
// If a matching entry exists in the cache, it is returned. If no matching
|
|
|
|
// entry exists and the cache is full, an existing entry is evicted via LRU,
|
|
|
|
// reset to state incomplete, and returned. If no matching entry exists and the
|
|
|
|
// cache is not full, a new entry with state incomplete is allocated and
|
|
|
|
// returned.
|
2020-10-23 17:29:46 +00:00
|
|
|
func (n *neighborCache) getOrCreateEntry(remoteAddr tcpip.Address, linkRes LinkAddressResolver) *neighborEntry {
|
2020-07-30 20:28:21 +00:00
|
|
|
n.mu.Lock()
|
|
|
|
defer n.mu.Unlock()
|
|
|
|
|
|
|
|
if entry, ok := n.cache[remoteAddr]; ok {
|
|
|
|
entry.mu.RLock()
|
|
|
|
if entry.neigh.State != Static {
|
|
|
|
n.dynamic.lru.Remove(entry)
|
|
|
|
n.dynamic.lru.PushFront(entry)
|
|
|
|
}
|
|
|
|
entry.mu.RUnlock()
|
|
|
|
return entry
|
|
|
|
}
|
|
|
|
|
|
|
|
// The entry that needs to be created must be dynamic since all static
|
|
|
|
// entries are directly added to the cache via addStaticEntry.
|
2020-10-23 17:29:46 +00:00
|
|
|
entry := newNeighborEntry(n.nic, remoteAddr, n.state, linkRes)
|
2020-07-30 20:28:21 +00:00
|
|
|
if n.dynamic.count == neighborCacheSize {
|
|
|
|
e := n.dynamic.lru.Back()
|
|
|
|
e.mu.Lock()
|
|
|
|
|
|
|
|
delete(n.cache, e.neigh.Addr)
|
|
|
|
n.dynamic.lru.Remove(e)
|
|
|
|
n.dynamic.count--
|
|
|
|
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
e.removeLocked()
|
2020-07-30 20:28:21 +00:00
|
|
|
e.mu.Unlock()
|
|
|
|
}
|
|
|
|
n.cache[remoteAddr] = entry
|
|
|
|
n.dynamic.lru.PushFront(entry)
|
|
|
|
n.dynamic.count++
|
|
|
|
return entry
|
|
|
|
}
|
|
|
|
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
// entry looks up neighbor information matching the remote address, and returns
|
|
|
|
// it if readily available.
|
|
|
|
//
|
|
|
|
// Returns ErrWouldBlock if the link address is not readily available, along
|
|
|
|
// with a notification channel for the caller to block on. Triggers address
|
|
|
|
// resolution asynchronously.
|
|
|
|
//
|
|
|
|
// If onResolve is provided, it will be called either immediately, if resolution
|
|
|
|
// is not required, or when address resolution is complete, with the resolved
|
|
|
|
// link address and whether resolution succeeded. After any callbacks have been
|
|
|
|
// called, the returned notification channel is closed.
|
|
|
|
//
|
|
|
|
// NB: if a callback is provided, it should not call into the neighbor cache.
|
2020-07-30 20:28:21 +00:00
|
|
|
//
|
2020-10-23 17:29:46 +00:00
|
|
|
// If specified, the local address must be an address local to the interface the
|
|
|
|
// neighbor cache belongs to. The local address is the source address of a
|
|
|
|
// packet prompting NUD/link address resolution.
|
|
|
|
//
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
// TODO(gvisor.dev/issue/5151): Don't return the neighbor entry.
|
2021-01-29 01:57:42 +00:00
|
|
|
func (n *neighborCache) entry(remoteAddr, localAddr tcpip.Address, linkRes LinkAddressResolver, onResolve func(LinkResolutionResult)) (NeighborEntry, <-chan struct{}, tcpip.Error) {
|
2020-10-23 17:29:46 +00:00
|
|
|
entry := n.getOrCreateEntry(remoteAddr, linkRes)
|
2020-07-30 20:28:21 +00:00
|
|
|
entry.mu.Lock()
|
|
|
|
defer entry.mu.Unlock()
|
|
|
|
|
|
|
|
switch s := entry.neigh.State; s {
|
2020-10-09 00:32:41 +00:00
|
|
|
case Stale:
|
2020-10-23 17:29:46 +00:00
|
|
|
entry.handlePacketQueuedLocked(localAddr)
|
2020-10-09 00:32:41 +00:00
|
|
|
fallthrough
|
|
|
|
case Reachable, Static, Delay, Probe:
|
|
|
|
// As per RFC 4861 section 7.3.3:
|
|
|
|
// "Neighbor Unreachability Detection operates in parallel with the sending
|
|
|
|
// of packets to a neighbor. While reasserting a neighbor's reachability,
|
|
|
|
// a node continues sending packets to that neighbor using the cached
|
|
|
|
// link-layer address."
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
if onResolve != nil {
|
2021-01-22 03:53:31 +00:00
|
|
|
onResolve(LinkResolutionResult{LinkAddress: entry.neigh.LinkAddr, Success: true})
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
}
|
2020-07-30 20:28:21 +00:00
|
|
|
return entry.neigh, nil, nil
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
case Unknown, Incomplete, Failed:
|
|
|
|
if onResolve != nil {
|
|
|
|
entry.onResolve = append(entry.onResolve, onResolve)
|
|
|
|
}
|
2020-07-30 20:28:21 +00:00
|
|
|
if entry.done == nil {
|
|
|
|
// Address resolution needs to be initiated.
|
|
|
|
entry.done = make(chan struct{})
|
|
|
|
}
|
2020-10-23 17:29:46 +00:00
|
|
|
entry.handlePacketQueuedLocked(localAddr)
|
2021-01-29 01:57:42 +00:00
|
|
|
return entry.neigh, entry.done, &tcpip.ErrWouldBlock{}
|
2020-07-30 20:28:21 +00:00
|
|
|
default:
|
|
|
|
panic(fmt.Sprintf("Invalid cache entry state: %s", s))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// entries returns all entries in the neighbor cache.
|
|
|
|
func (n *neighborCache) entries() []NeighborEntry {
|
|
|
|
n.mu.RLock()
|
2020-12-02 05:32:36 +00:00
|
|
|
defer n.mu.RUnlock()
|
|
|
|
|
|
|
|
entries := make([]NeighborEntry, 0, len(n.cache))
|
2020-07-30 20:28:21 +00:00
|
|
|
for _, entry := range n.cache {
|
|
|
|
entry.mu.RLock()
|
|
|
|
entries = append(entries, entry.neigh)
|
|
|
|
entry.mu.RUnlock()
|
|
|
|
}
|
|
|
|
return entries
|
|
|
|
}
|
|
|
|
|
|
|
|
// addStaticEntry adds a static entry to the neighbor cache, mapping an IP
|
|
|
|
// address to a link address. If a dynamic entry exists in the neighbor cache
|
|
|
|
// with the same address, it will be replaced with this static entry. If a
|
|
|
|
// static entry exists with the same address but different link address, it
|
|
|
|
// will be updated with the new link address. If a static entry exists with the
|
|
|
|
// same address and link address, nothing will happen.
|
|
|
|
func (n *neighborCache) addStaticEntry(addr tcpip.Address, linkAddr tcpip.LinkAddress) {
|
|
|
|
n.mu.Lock()
|
|
|
|
defer n.mu.Unlock()
|
|
|
|
|
|
|
|
if entry, ok := n.cache[addr]; ok {
|
|
|
|
entry.mu.Lock()
|
|
|
|
if entry.neigh.State != Static {
|
|
|
|
// Dynamic entry found with the same address.
|
|
|
|
n.dynamic.lru.Remove(entry)
|
|
|
|
n.dynamic.count--
|
|
|
|
} else if entry.neigh.LinkAddr == linkAddr {
|
|
|
|
// Static entry found with the same address and link address.
|
|
|
|
entry.mu.Unlock()
|
|
|
|
return
|
|
|
|
} else {
|
|
|
|
// Static entry found with the same address but different link address.
|
|
|
|
entry.neigh.LinkAddr = linkAddr
|
2020-10-27 22:43:08 +00:00
|
|
|
entry.dispatchChangeEventLocked()
|
2020-07-30 20:28:21 +00:00
|
|
|
entry.mu.Unlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
entry.removeLocked()
|
2020-07-30 20:28:21 +00:00
|
|
|
entry.mu.Unlock()
|
|
|
|
}
|
|
|
|
|
2020-10-27 22:43:08 +00:00
|
|
|
n.cache[addr] = newStaticNeighborEntry(n.nic, addr, linkAddr, n.state)
|
2020-07-30 20:28:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// removeEntry removes a dynamic or static entry by address from the neighbor
|
|
|
|
// cache. Returns true if the entry was found and deleted.
|
|
|
|
func (n *neighborCache) removeEntry(addr tcpip.Address) bool {
|
|
|
|
n.mu.Lock()
|
|
|
|
defer n.mu.Unlock()
|
|
|
|
|
|
|
|
entry, ok := n.cache[addr]
|
|
|
|
if !ok {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
entry.mu.Lock()
|
|
|
|
defer entry.mu.Unlock()
|
|
|
|
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
if entry.neigh.State != Static {
|
|
|
|
n.dynamic.lru.Remove(entry)
|
|
|
|
n.dynamic.count--
|
|
|
|
}
|
|
|
|
|
|
|
|
entry.removeLocked()
|
|
|
|
delete(n.cache, entry.neigh.Addr)
|
2020-07-30 20:28:21 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// clear removes all dynamic and static entries from the neighbor cache.
|
|
|
|
func (n *neighborCache) clear() {
|
|
|
|
n.mu.Lock()
|
|
|
|
defer n.mu.Unlock()
|
|
|
|
|
|
|
|
for _, entry := range n.cache {
|
|
|
|
entry.mu.Lock()
|
Invoke address resolution upon subsequent traffic to Failed neighbor
Removes the period of time in which subseqeuent traffic to a Failed neighbor
immediately fails with ErrNoLinkAddress. A Failed neighbor is one in which
address resolution fails; or in other words, the neighbor's IP address cannot
be translated to a MAC address.
This means removing the Failed state for linkAddrCache and allowing transitiong
out of Failed into Incomplete for neighborCache. Previously, both caches would
transition entries to Failed after address resolution fails. In this state, any
subsequent traffic requested within an unreachable time would immediately fail
with ErrNoLinkAddress. This does not follow RFC 4861 section 7.3.3:
If address resolution fails, the entry SHOULD be deleted, so that subsequent
traffic to that neighbor invokes the next-hop determination procedure again.
Invoking next-hop determination at this point ensures that alternate default
routers are tried.
The API for getting a link address for a given address, whether through the link
address cache or the neighbor table, is updated to optionally take a callback
which will be called when address resolution completes. This allows `Route` to
handle completing link resolution internally, so callers of (*Route).Resolve
(e.g. endpoints) don’t have to keep track of when it completes and update the
Route accordingly.
This change also removes the wakers from LinkAddressCache, NeighborCache, and
Route in favor of the callbacks, and callers that previously used a waker can
now just pass a callback to (*Route).Resolve that will notify the waker on
resolution completion.
Fixes #4796
Startblock:
has LGTM from sbalana
and then
add reviewer ghanan
PiperOrigin-RevId: 348597478
2020-12-22 09:34:41 +00:00
|
|
|
entry.removeLocked()
|
2020-07-30 20:28:21 +00:00
|
|
|
entry.mu.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
n.dynamic.lru = neighborEntryList{}
|
|
|
|
n.cache = make(map[tcpip.Address]*neighborEntry)
|
|
|
|
n.dynamic.count = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// config returns the NUD configuration.
|
|
|
|
func (n *neighborCache) config() NUDConfigurations {
|
|
|
|
return n.state.Config()
|
|
|
|
}
|
|
|
|
|
|
|
|
// setConfig changes the NUD configuration.
|
|
|
|
//
|
|
|
|
// If config contains invalid NUD configuration values, it will be fixed to
|
|
|
|
// use default values for the erroneous values.
|
|
|
|
func (n *neighborCache) setConfig(config NUDConfigurations) {
|
|
|
|
config.resetInvalidFields()
|
|
|
|
n.state.SetConfig(config)
|
|
|
|
}
|
|
|
|
|
2021-01-31 18:01:30 +00:00
|
|
|
var _ neighborTable = (*neighborCache)(nil)
|
|
|
|
|
|
|
|
func (n *neighborCache) neighbors() ([]NeighborEntry, tcpip.Error) {
|
|
|
|
return n.entries(), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *neighborCache) get(addr tcpip.Address, linkRes LinkAddressResolver, localAddr tcpip.Address, onResolve func(LinkResolutionResult)) (tcpip.LinkAddress, <-chan struct{}, tcpip.Error) {
|
|
|
|
entry, ch, err := n.entry(addr, localAddr, linkRes, onResolve)
|
|
|
|
return entry.LinkAddr, ch, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *neighborCache) remove(addr tcpip.Address) tcpip.Error {
|
|
|
|
if !n.removeEntry(addr) {
|
|
|
|
return &tcpip.ErrBadAddress{}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *neighborCache) removeAll() tcpip.Error {
|
|
|
|
n.clear()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// handleProbe handles a neighbor probe as defined by RFC 4861 section 7.2.3.
|
|
|
|
//
|
|
|
|
// Validation of the probe is expected to be handled by the caller.
|
|
|
|
func (n *neighborCache) handleProbe(remoteAddr tcpip.Address, remoteLinkAddr tcpip.LinkAddress, linkRes LinkAddressResolver) {
|
2020-10-23 17:29:46 +00:00
|
|
|
entry := n.getOrCreateEntry(remoteAddr, linkRes)
|
2020-07-30 20:28:21 +00:00
|
|
|
entry.mu.Lock()
|
|
|
|
entry.handleProbeLocked(remoteLinkAddr)
|
|
|
|
entry.mu.Unlock()
|
|
|
|
}
|
|
|
|
|
2021-01-31 18:01:30 +00:00
|
|
|
// handleConfirmation handles a neighbor confirmation as defined by
|
|
|
|
// RFC 4861 section 7.2.5.
|
2020-07-30 20:28:21 +00:00
|
|
|
//
|
2021-01-31 18:01:30 +00:00
|
|
|
// Validation of the confirmation is expected to be handled by the caller.
|
|
|
|
func (n *neighborCache) handleConfirmation(addr tcpip.Address, linkAddr tcpip.LinkAddress, flags ReachabilityConfirmationFlags) {
|
2020-07-30 20:28:21 +00:00
|
|
|
n.mu.RLock()
|
|
|
|
entry, ok := n.cache[addr]
|
|
|
|
n.mu.RUnlock()
|
|
|
|
if ok {
|
|
|
|
entry.mu.Lock()
|
|
|
|
entry.handleConfirmationLocked(linkAddr, flags)
|
|
|
|
entry.mu.Unlock()
|
|
|
|
}
|
|
|
|
// The confirmation SHOULD be silently discarded if the recipient did not
|
|
|
|
// initiate any communication with the target. This is indicated if there is
|
|
|
|
// no matching entry for the remote address.
|
|
|
|
}
|
|
|
|
|
2021-01-28 03:06:47 +00:00
|
|
|
// handleUpperLevelConfirmation processes a confirmation of reachablity from
|
|
|
|
// some protocol that operates at a layer above the IP/link layer.
|
|
|
|
func (n *neighborCache) handleUpperLevelConfirmation(addr tcpip.Address) {
|
2020-07-30 20:28:21 +00:00
|
|
|
n.mu.RLock()
|
|
|
|
entry, ok := n.cache[addr]
|
|
|
|
n.mu.RUnlock()
|
|
|
|
if ok {
|
|
|
|
entry.mu.Lock()
|
|
|
|
entry.handleUpperLevelConfirmationLocked()
|
|
|
|
entry.mu.Unlock()
|
|
|
|
}
|
|
|
|
}
|
2021-01-31 18:01:30 +00:00
|
|
|
|
|
|
|
func (n *neighborCache) nudConfig() (NUDConfigurations, tcpip.Error) {
|
|
|
|
return n.config(), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *neighborCache) setNUDConfig(c NUDConfigurations) tcpip.Error {
|
|
|
|
n.setConfig(c)
|
|
|
|
return nil
|
|
|
|
}
|