1 files changed, 22 insertions, 7 deletions
diff --git a/pkg/tcpip/stack/linkaddrcache.go b/pkg/tcpip/stack/linkaddrcache.go
index 3c4fa341e..ba6d56a7d 100644
--- a/pkg/tcpip/stack/linkaddrcache.go
+++ b/pkg/tcpip/stack/linkaddrcache.go
@@ -32,6 +32,8 @@ var _ LinkAddressCache = (*linkAddrCache)(nil)
 //
 // This struct is safe for concurrent use.
 type linkAddrCache struct {
+	nic *NIC
+
 	// ageLimit is how long a cache entry is valid for.
 	ageLimit time.Duration
 
@@ -79,6 +81,8 @@ type linkAddrEntry struct {
 	// linkAddrEntryEntry access is synchronized by the linkAddrCache lock.
 	linkAddrEntryEntry
 
+	cache *linkAddrCache
+
 	// TODO(gvisor.dev/issue/5150): move these fields under mu.
 	// mu protects the fields below.
 	mu sync.RWMutex
@@ -93,17 +97,26 @@ type linkAddrEntry struct {
 	done chan struct{}
 
 	// onResolve is called with the result of address resolution.
-	onResolve []func(tcpip.LinkAddress, bool)
+	onResolve []func(LinkResolutionResult)
 }
 
 func (e *linkAddrEntry) notifyCompletionLocked(linkAddr tcpip.LinkAddress) {
+	res := LinkResolutionResult{LinkAddress: linkAddr, Success: len(linkAddr) != 0}
 	for _, callback := range e.onResolve {
-		callback(linkAddr, len(linkAddr) != 0)
+		callback(res)
 	}
 	e.onResolve = nil
 	if ch := e.done; ch != nil {
 		close(ch)
 		e.done = nil
+		// Dequeue the pending packets in a new goroutine to not hold up the current
+		// goroutine as writing packets may be a costly operation.
+		//
+		// At the time of writing, when writing packets, a neighbor's link address
+		// is resolved (which ends up obtaining the entry's lock) while holding the
+		// link resolution queue's lock. Dequeuing packets in a new goroutine avoids
+		// a lock ordering violation.
+		go e.cache.nic.linkResQueue.dequeue(ch, linkAddr, len(linkAddr) != 0)
 	}
 }
 
@@ -174,8 +187,9 @@ func (c *linkAddrCache) getOrCreateEntryLocked(k tcpip.Address) *linkAddrEntry {
 	}
 
 	*entry = linkAddrEntry{
-		addr: k,
-		s:    incomplete,
+		cache: c,
+		addr:  k,
+		s:     incomplete,
 	}
 	c.cache.table[k] = entry
 	c.cache.lru.PushFront(entry)
@@ -183,7 +197,7 @@ func (c *linkAddrCache) getOrCreateEntryLocked(k tcpip.Address) *linkAddrEntry {
 }
 
 // get reports any known link address for k.
-func (c *linkAddrCache) get(k tcpip.Address, linkRes LinkAddressResolver, localAddr tcpip.Address, nic NetworkInterface, onResolve func(tcpip.LinkAddress, bool)) (tcpip.LinkAddress, <-chan struct{}, *tcpip.Error) {
+func (c *linkAddrCache) get(k tcpip.Address, linkRes LinkAddressResolver, localAddr tcpip.Address, nic NetworkInterface, onResolve func(LinkResolutionResult)) (tcpip.LinkAddress, <-chan struct{}, *tcpip.Error) {
 	c.cache.Lock()
 	defer c.cache.Unlock()
 	entry := c.getOrCreateEntryLocked(k)
@@ -195,7 +209,7 @@ func (c *linkAddrCache) get(k tcpip.Address, linkRes LinkAddressResolver, localA
 		if !time.Now().After(entry.expiration) {
 			// Not expired.
 			if onResolve != nil {
-				onResolve(entry.linkAddr, true)
+				onResolve(LinkResolutionResult{LinkAddress: entry.linkAddr, Success: true})
 			}
 			return entry.linkAddr, nil, nil
 		}
@@ -264,8 +278,9 @@ func (c *linkAddrCache) checkLinkRequest(now time.Time, k tcpip.Address, attempt
 	return true
 }
 
-func newLinkAddrCache(ageLimit, resolutionTimeout time.Duration, resolutionAttempts int) *linkAddrCache {
+func newLinkAddrCache(nic *NIC, ageLimit, resolutionTimeout time.Duration, resolutionAttempts int) *linkAddrCache {
 	c := &linkAddrCache{
+		nic:                nic,
 		ageLimit:           ageLimit,
 		resolutionTimeout:  resolutionTimeout,
 		resolutionAttempts: resolutionAttempts,