Remove unnecessary defer
PiperOrigin-RevId: 214073949
diff --git a/tcpip/network/fragmentation/reassembler_list.go b/tcpip/network/fragmentation/reassembler_list.go
index 1222949..3189cae 100644
--- a/tcpip/network/fragmentation/reassembler_list.go
+++ b/tcpip/network/fragmentation/reassembler_list.go
@@ -1,5 +1,20 @@
package fragmentation
+// ElementMapper provides an identity mapping by default.
+//
+// This can be replaced to provide a struct that maps elements to linker
+// objects, if they are not the same. An ElementMapper is not typically
+// required if: Linker is left as is, Element is left as is, or Linker and
+// Element are the same type.
+type reassemblerElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (reassemblerElementMapper) linkerFor(elem *reassembler) *reassembler { return elem }
+
// List is an intrusive list. Entries can be added to or removed from the list
// in O(1) time and with no additional memory allocations.
//
@@ -9,6 +24,8 @@
// for e := l.Front(); e != nil; e = e.Next() {
// // do something with e.
// }
+//
+// +stateify savable
type reassemblerList struct {
head *reassembler
tail *reassembler
@@ -37,11 +54,11 @@
// PushFront inserts the element e at the front of list l.
func (l *reassemblerList) PushFront(e *reassembler) {
- e.SetNext(l.head)
- e.SetPrev(nil)
+ reassemblerElementMapper{}.linkerFor(e).SetNext(l.head)
+ reassemblerElementMapper{}.linkerFor(e).SetPrev(nil)
if l.head != nil {
- l.head.SetPrev(e)
+ reassemblerElementMapper{}.linkerFor(l.head).SetPrev(e)
} else {
l.tail = e
}
@@ -51,11 +68,11 @@
// PushBack inserts the element e at the back of list l.
func (l *reassemblerList) PushBack(e *reassembler) {
- e.SetNext(nil)
- e.SetPrev(l.tail)
+ reassemblerElementMapper{}.linkerFor(e).SetNext(nil)
+ reassemblerElementMapper{}.linkerFor(e).SetPrev(l.tail)
if l.tail != nil {
- l.tail.SetNext(e)
+ reassemblerElementMapper{}.linkerFor(l.tail).SetNext(e)
} else {
l.head = e
}
@@ -69,8 +86,8 @@
l.head = m.head
l.tail = m.tail
} else if m.head != nil {
- l.tail.SetNext(m.head)
- m.head.SetPrev(l.tail)
+ reassemblerElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+ reassemblerElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
l.tail = m.tail
}
@@ -81,13 +98,13 @@
// InsertAfter inserts e after b.
func (l *reassemblerList) InsertAfter(b, e *reassembler) {
- a := b.Next()
- e.SetNext(a)
- e.SetPrev(b)
- b.SetNext(e)
+ a := reassemblerElementMapper{}.linkerFor(b).Next()
+ reassemblerElementMapper{}.linkerFor(e).SetNext(a)
+ reassemblerElementMapper{}.linkerFor(e).SetPrev(b)
+ reassemblerElementMapper{}.linkerFor(b).SetNext(e)
if a != nil {
- a.SetPrev(e)
+ reassemblerElementMapper{}.linkerFor(a).SetPrev(e)
} else {
l.tail = e
}
@@ -95,13 +112,13 @@
// InsertBefore inserts e before a.
func (l *reassemblerList) InsertBefore(a, e *reassembler) {
- b := a.Prev()
- e.SetNext(a)
- e.SetPrev(b)
- a.SetPrev(e)
+ b := reassemblerElementMapper{}.linkerFor(a).Prev()
+ reassemblerElementMapper{}.linkerFor(e).SetNext(a)
+ reassemblerElementMapper{}.linkerFor(e).SetPrev(b)
+ reassemblerElementMapper{}.linkerFor(a).SetPrev(e)
if b != nil {
- b.SetNext(e)
+ reassemblerElementMapper{}.linkerFor(b).SetNext(e)
} else {
l.head = e
}
@@ -109,17 +126,17 @@
// Remove removes e from l.
func (l *reassemblerList) Remove(e *reassembler) {
- prev := e.Prev()
- next := e.Next()
+ prev := reassemblerElementMapper{}.linkerFor(e).Prev()
+ next := reassemblerElementMapper{}.linkerFor(e).Next()
if prev != nil {
- prev.SetNext(next)
+ reassemblerElementMapper{}.linkerFor(prev).SetNext(next)
} else {
l.head = next
}
if next != nil {
- next.SetPrev(prev)
+ reassemblerElementMapper{}.linkerFor(next).SetPrev(prev)
} else {
l.tail = prev
}
@@ -128,6 +145,8 @@
// Entry is a default implementation of Linker. Users can add anonymous fields
// of this type to their structs to make them automatically implement the
// methods needed by List.
+//
+// +stateify savable
type reassemblerEntry struct {
next *reassembler
prev *reassembler
@@ -144,11 +163,11 @@
}
// SetNext assigns 'entry' as the entry that follows e in the list.
-func (e *reassemblerEntry) SetNext(entry *reassembler) {
- e.next = entry
+func (e *reassemblerEntry) SetNext(elem *reassembler) {
+ e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
-func (e *reassemblerEntry) SetPrev(entry *reassembler) {
- e.prev = entry
+func (e *reassemblerEntry) SetPrev(elem *reassembler) {
+ e.prev = elem
}
diff --git a/tcpip/transport/ping/ping_packet_list.go b/tcpip/transport/ping/ping_packet_list.go
index e3db86f..bf82747 100644
--- a/tcpip/transport/ping/ping_packet_list.go
+++ b/tcpip/transport/ping/ping_packet_list.go
@@ -1,5 +1,20 @@
package ping
+// ElementMapper provides an identity mapping by default.
+//
+// This can be replaced to provide a struct that maps elements to linker
+// objects, if they are not the same. An ElementMapper is not typically
+// required if: Linker is left as is, Element is left as is, or Linker and
+// Element are the same type.
+type pingPacketElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (pingPacketElementMapper) linkerFor(elem *pingPacket) *pingPacket { return elem }
+
// List is an intrusive list. Entries can be added to or removed from the list
// in O(1) time and with no additional memory allocations.
//
@@ -9,6 +24,8 @@
// for e := l.Front(); e != nil; e = e.Next() {
// // do something with e.
// }
+//
+// +stateify savable
type pingPacketList struct {
head *pingPacket
tail *pingPacket
@@ -37,11 +54,11 @@
// PushFront inserts the element e at the front of list l.
func (l *pingPacketList) PushFront(e *pingPacket) {
- e.SetNext(l.head)
- e.SetPrev(nil)
+ pingPacketElementMapper{}.linkerFor(e).SetNext(l.head)
+ pingPacketElementMapper{}.linkerFor(e).SetPrev(nil)
if l.head != nil {
- l.head.SetPrev(e)
+ pingPacketElementMapper{}.linkerFor(l.head).SetPrev(e)
} else {
l.tail = e
}
@@ -51,11 +68,11 @@
// PushBack inserts the element e at the back of list l.
func (l *pingPacketList) PushBack(e *pingPacket) {
- e.SetNext(nil)
- e.SetPrev(l.tail)
+ pingPacketElementMapper{}.linkerFor(e).SetNext(nil)
+ pingPacketElementMapper{}.linkerFor(e).SetPrev(l.tail)
if l.tail != nil {
- l.tail.SetNext(e)
+ pingPacketElementMapper{}.linkerFor(l.tail).SetNext(e)
} else {
l.head = e
}
@@ -69,8 +86,8 @@
l.head = m.head
l.tail = m.tail
} else if m.head != nil {
- l.tail.SetNext(m.head)
- m.head.SetPrev(l.tail)
+ pingPacketElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+ pingPacketElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
l.tail = m.tail
}
@@ -81,13 +98,13 @@
// InsertAfter inserts e after b.
func (l *pingPacketList) InsertAfter(b, e *pingPacket) {
- a := b.Next()
- e.SetNext(a)
- e.SetPrev(b)
- b.SetNext(e)
+ a := pingPacketElementMapper{}.linkerFor(b).Next()
+ pingPacketElementMapper{}.linkerFor(e).SetNext(a)
+ pingPacketElementMapper{}.linkerFor(e).SetPrev(b)
+ pingPacketElementMapper{}.linkerFor(b).SetNext(e)
if a != nil {
- a.SetPrev(e)
+ pingPacketElementMapper{}.linkerFor(a).SetPrev(e)
} else {
l.tail = e
}
@@ -95,13 +112,13 @@
// InsertBefore inserts e before a.
func (l *pingPacketList) InsertBefore(a, e *pingPacket) {
- b := a.Prev()
- e.SetNext(a)
- e.SetPrev(b)
- a.SetPrev(e)
+ b := pingPacketElementMapper{}.linkerFor(a).Prev()
+ pingPacketElementMapper{}.linkerFor(e).SetNext(a)
+ pingPacketElementMapper{}.linkerFor(e).SetPrev(b)
+ pingPacketElementMapper{}.linkerFor(a).SetPrev(e)
if b != nil {
- b.SetNext(e)
+ pingPacketElementMapper{}.linkerFor(b).SetNext(e)
} else {
l.head = e
}
@@ -109,17 +126,17 @@
// Remove removes e from l.
func (l *pingPacketList) Remove(e *pingPacket) {
- prev := e.Prev()
- next := e.Next()
+ prev := pingPacketElementMapper{}.linkerFor(e).Prev()
+ next := pingPacketElementMapper{}.linkerFor(e).Next()
if prev != nil {
- prev.SetNext(next)
+ pingPacketElementMapper{}.linkerFor(prev).SetNext(next)
} else {
l.head = next
}
if next != nil {
- next.SetPrev(prev)
+ pingPacketElementMapper{}.linkerFor(next).SetPrev(prev)
} else {
l.tail = prev
}
@@ -128,6 +145,8 @@
// Entry is a default implementation of Linker. Users can add anonymous fields
// of this type to their structs to make them automatically implement the
// methods needed by List.
+//
+// +stateify savable
type pingPacketEntry struct {
next *pingPacket
prev *pingPacket
@@ -144,11 +163,11 @@
}
// SetNext assigns 'entry' as the entry that follows e in the list.
-func (e *pingPacketEntry) SetNext(entry *pingPacket) {
- e.next = entry
+func (e *pingPacketEntry) SetNext(elem *pingPacket) {
+ e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
-func (e *pingPacketEntry) SetPrev(entry *pingPacket) {
- e.prev = entry
+func (e *pingPacketEntry) SetPrev(elem *pingPacket) {
+ e.prev = elem
}
diff --git a/tcpip/transport/tcp/tcp_segment_list.go b/tcpip/transport/tcp/tcp_segment_list.go
index 22491b0..029f98a 100644
--- a/tcpip/transport/tcp/tcp_segment_list.go
+++ b/tcpip/transport/tcp/tcp_segment_list.go
@@ -1,5 +1,20 @@
package tcp
+// ElementMapper provides an identity mapping by default.
+//
+// This can be replaced to provide a struct that maps elements to linker
+// objects, if they are not the same. An ElementMapper is not typically
+// required if: Linker is left as is, Element is left as is, or Linker and
+// Element are the same type.
+type segmentElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (segmentElementMapper) linkerFor(elem *segment) *segment { return elem }
+
// List is an intrusive list. Entries can be added to or removed from the list
// in O(1) time and with no additional memory allocations.
//
@@ -9,6 +24,8 @@
// for e := l.Front(); e != nil; e = e.Next() {
// // do something with e.
// }
+//
+// +stateify savable
type segmentList struct {
head *segment
tail *segment
@@ -37,11 +54,11 @@
// PushFront inserts the element e at the front of list l.
func (l *segmentList) PushFront(e *segment) {
- e.SetNext(l.head)
- e.SetPrev(nil)
+ segmentElementMapper{}.linkerFor(e).SetNext(l.head)
+ segmentElementMapper{}.linkerFor(e).SetPrev(nil)
if l.head != nil {
- l.head.SetPrev(e)
+ segmentElementMapper{}.linkerFor(l.head).SetPrev(e)
} else {
l.tail = e
}
@@ -51,11 +68,11 @@
// PushBack inserts the element e at the back of list l.
func (l *segmentList) PushBack(e *segment) {
- e.SetNext(nil)
- e.SetPrev(l.tail)
+ segmentElementMapper{}.linkerFor(e).SetNext(nil)
+ segmentElementMapper{}.linkerFor(e).SetPrev(l.tail)
if l.tail != nil {
- l.tail.SetNext(e)
+ segmentElementMapper{}.linkerFor(l.tail).SetNext(e)
} else {
l.head = e
}
@@ -69,8 +86,8 @@
l.head = m.head
l.tail = m.tail
} else if m.head != nil {
- l.tail.SetNext(m.head)
- m.head.SetPrev(l.tail)
+ segmentElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+ segmentElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
l.tail = m.tail
}
@@ -81,13 +98,13 @@
// InsertAfter inserts e after b.
func (l *segmentList) InsertAfter(b, e *segment) {
- a := b.Next()
- e.SetNext(a)
- e.SetPrev(b)
- b.SetNext(e)
+ a := segmentElementMapper{}.linkerFor(b).Next()
+ segmentElementMapper{}.linkerFor(e).SetNext(a)
+ segmentElementMapper{}.linkerFor(e).SetPrev(b)
+ segmentElementMapper{}.linkerFor(b).SetNext(e)
if a != nil {
- a.SetPrev(e)
+ segmentElementMapper{}.linkerFor(a).SetPrev(e)
} else {
l.tail = e
}
@@ -95,13 +112,13 @@
// InsertBefore inserts e before a.
func (l *segmentList) InsertBefore(a, e *segment) {
- b := a.Prev()
- e.SetNext(a)
- e.SetPrev(b)
- a.SetPrev(e)
+ b := segmentElementMapper{}.linkerFor(a).Prev()
+ segmentElementMapper{}.linkerFor(e).SetNext(a)
+ segmentElementMapper{}.linkerFor(e).SetPrev(b)
+ segmentElementMapper{}.linkerFor(a).SetPrev(e)
if b != nil {
- b.SetNext(e)
+ segmentElementMapper{}.linkerFor(b).SetNext(e)
} else {
l.head = e
}
@@ -109,17 +126,17 @@
// Remove removes e from l.
func (l *segmentList) Remove(e *segment) {
- prev := e.Prev()
- next := e.Next()
+ prev := segmentElementMapper{}.linkerFor(e).Prev()
+ next := segmentElementMapper{}.linkerFor(e).Next()
if prev != nil {
- prev.SetNext(next)
+ segmentElementMapper{}.linkerFor(prev).SetNext(next)
} else {
l.head = next
}
if next != nil {
- next.SetPrev(prev)
+ segmentElementMapper{}.linkerFor(next).SetPrev(prev)
} else {
l.tail = prev
}
@@ -128,6 +145,8 @@
// Entry is a default implementation of Linker. Users can add anonymous fields
// of this type to their structs to make them automatically implement the
// methods needed by List.
+//
+// +stateify savable
type segmentEntry struct {
next *segment
prev *segment
@@ -144,11 +163,11 @@
}
// SetNext assigns 'entry' as the entry that follows e in the list.
-func (e *segmentEntry) SetNext(entry *segment) {
- e.next = entry
+func (e *segmentEntry) SetNext(elem *segment) {
+ e.next = elem
}
// SetPrev assigns 'entry' as the entry that precedes e in the list.
-func (e *segmentEntry) SetPrev(entry *segment) {
- e.prev = entry
+func (e *segmentEntry) SetPrev(elem *segment) {
+ e.prev = elem
}
diff --git a/tcpip/transport/udp/endpoint.go b/tcpip/transport/udp/endpoint.go
index a45f780..7feb546 100644
--- a/tcpip/transport/udp/endpoint.go
+++ b/tcpip/transport/udp/endpoint.go
@@ -400,8 +400,8 @@
case tcpip.MulticastTTLOption:
e.mu.Lock()
- defer e.mu.Unlock()
e.multicastTTL = uint8(v)
+ e.mu.Unlock()
case tcpip.AddMembershipOption:
nicID := v.NIC
diff --git a/tcpip/transport/udp/udp_packet_list.go b/tcpip/transport/udp/udp_packet_list.go
index e69de29..673a937 100644
--- a/tcpip/transport/udp/udp_packet_list.go
+++ b/tcpip/transport/udp/udp_packet_list.go
@@ -0,0 +1,173 @@
+package udp
+
+// ElementMapper provides an identity mapping by default.
+//
+// This can be replaced to provide a struct that maps elements to linker
+// objects, if they are not the same. An ElementMapper is not typically
+// required if: Linker is left as is, Element is left as is, or Linker and
+// Element are the same type.
+type udpPacketElementMapper struct{}
+
+// linkerFor maps an Element to a Linker.
+//
+// This default implementation should be inlined.
+//
+//go:nosplit
+func (udpPacketElementMapper) linkerFor(elem *udpPacket) *udpPacket { return elem }
+
+// List is an intrusive list. Entries can be added to or removed from the list
+// in O(1) time and with no additional memory allocations.
+//
+// The zero value for List is an empty list ready to use.
+//
+// To iterate over a list (where l is a List):
+// for e := l.Front(); e != nil; e = e.Next() {
+// // do something with e.
+// }
+//
+// +stateify savable
+type udpPacketList struct {
+ head *udpPacket
+ tail *udpPacket
+}
+
+// Reset resets list l to the empty state.
+func (l *udpPacketList) Reset() {
+ l.head = nil
+ l.tail = nil
+}
+
+// Empty returns true iff the list is empty.
+func (l *udpPacketList) Empty() bool {
+ return l.head == nil
+}
+
+// Front returns the first element of list l or nil.
+func (l *udpPacketList) Front() *udpPacket {
+ return l.head
+}
+
+// Back returns the last element of list l or nil.
+func (l *udpPacketList) Back() *udpPacket {
+ return l.tail
+}
+
+// PushFront inserts the element e at the front of list l.
+func (l *udpPacketList) PushFront(e *udpPacket) {
+ udpPacketElementMapper{}.linkerFor(e).SetNext(l.head)
+ udpPacketElementMapper{}.linkerFor(e).SetPrev(nil)
+
+ if l.head != nil {
+ udpPacketElementMapper{}.linkerFor(l.head).SetPrev(e)
+ } else {
+ l.tail = e
+ }
+
+ l.head = e
+}
+
+// PushBack inserts the element e at the back of list l.
+func (l *udpPacketList) PushBack(e *udpPacket) {
+ udpPacketElementMapper{}.linkerFor(e).SetNext(nil)
+ udpPacketElementMapper{}.linkerFor(e).SetPrev(l.tail)
+
+ if l.tail != nil {
+ udpPacketElementMapper{}.linkerFor(l.tail).SetNext(e)
+ } else {
+ l.head = e
+ }
+
+ l.tail = e
+}
+
+// PushBackList inserts list m at the end of list l, emptying m.
+func (l *udpPacketList) PushBackList(m *udpPacketList) {
+ if l.head == nil {
+ l.head = m.head
+ l.tail = m.tail
+ } else if m.head != nil {
+ udpPacketElementMapper{}.linkerFor(l.tail).SetNext(m.head)
+ udpPacketElementMapper{}.linkerFor(m.head).SetPrev(l.tail)
+
+ l.tail = m.tail
+ }
+
+ m.head = nil
+ m.tail = nil
+}
+
+// InsertAfter inserts e after b.
+func (l *udpPacketList) InsertAfter(b, e *udpPacket) {
+ a := udpPacketElementMapper{}.linkerFor(b).Next()
+ udpPacketElementMapper{}.linkerFor(e).SetNext(a)
+ udpPacketElementMapper{}.linkerFor(e).SetPrev(b)
+ udpPacketElementMapper{}.linkerFor(b).SetNext(e)
+
+ if a != nil {
+ udpPacketElementMapper{}.linkerFor(a).SetPrev(e)
+ } else {
+ l.tail = e
+ }
+}
+
+// InsertBefore inserts e before a.
+func (l *udpPacketList) InsertBefore(a, e *udpPacket) {
+ b := udpPacketElementMapper{}.linkerFor(a).Prev()
+ udpPacketElementMapper{}.linkerFor(e).SetNext(a)
+ udpPacketElementMapper{}.linkerFor(e).SetPrev(b)
+ udpPacketElementMapper{}.linkerFor(a).SetPrev(e)
+
+ if b != nil {
+ udpPacketElementMapper{}.linkerFor(b).SetNext(e)
+ } else {
+ l.head = e
+ }
+}
+
+// Remove removes e from l.
+func (l *udpPacketList) Remove(e *udpPacket) {
+ prev := udpPacketElementMapper{}.linkerFor(e).Prev()
+ next := udpPacketElementMapper{}.linkerFor(e).Next()
+
+ if prev != nil {
+ udpPacketElementMapper{}.linkerFor(prev).SetNext(next)
+ } else {
+ l.head = next
+ }
+
+ if next != nil {
+ udpPacketElementMapper{}.linkerFor(next).SetPrev(prev)
+ } else {
+ l.tail = prev
+ }
+}
+
+// Entry is a default implementation of Linker. Users can add anonymous fields
+// of this type to their structs to make them automatically implement the
+// methods needed by List.
+//
+// +stateify savable
+type udpPacketEntry struct {
+ next *udpPacket
+ prev *udpPacket
+}
+
+// Next returns the entry that follows e in the list.
+func (e *udpPacketEntry) Next() *udpPacket {
+ return e.next
+}
+
+// Prev returns the entry that precedes e in the list.
+func (e *udpPacketEntry) Prev() *udpPacket {
+ return e.prev
+}
+
+// SetNext assigns 'entry' as the entry that follows e in the list.
+func (e *udpPacketEntry) SetNext(elem *udpPacket) {
+ e.next = elem
+}
+
+// SetPrev assigns 'entry' as the entry that precedes e in the list.
+func (e *udpPacketEntry) SetPrev(elem *udpPacket) {
+ e.prev = elem
+}
