summaryrefslogtreecommitdiffhomepage
path: root/pkg/tcpip/transport
diff options
context:
space:
mode:
authorgVisor bot <gvisor-bot@google.com>2020-10-08 01:32:17 +0000
committergVisor bot <gvisor-bot@google.com>2020-10-08 01:32:17 +0000
commit8f70c8003e9d132fc766ed7d92ce805c093d518b (patch)
tree6d77a3246e3f04605790d410e7630cb910704ced /pkg/tcpip/transport
parent8f9d99c812b7599c52ed98f80c1a33717758a5c6 (diff)
parenta55bd73d4802112a7055de8663e947b9c0f42a2e (diff)
Merge release-20200928.0-66-ga55bd73d4 (automated)
Diffstat (limited to 'pkg/tcpip/transport')
-rw-r--r--pkg/tcpip/transport/icmp/icmp_state_autogen.go154
-rw-r--r--pkg/tcpip/transport/packet/packet_state_autogen.go164
-rw-r--r--pkg/tcpip/transport/raw/raw_state_autogen.go158
-rw-r--r--pkg/tcpip/transport/tcp/tcp_state_autogen.go1050
-rw-r--r--pkg/tcpip/transport/udp/udp_state_autogen.go266
5 files changed, 896 insertions, 896 deletions
diff --git a/pkg/tcpip/transport/icmp/icmp_state_autogen.go b/pkg/tcpip/transport/icmp/icmp_state_autogen.go
index 776ef0850..d88c817e4 100644
--- a/pkg/tcpip/transport/icmp/icmp_state_autogen.go
+++ b/pkg/tcpip/transport/icmp/icmp_state_autogen.go
@@ -7,11 +7,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip/buffer"
)
-func (x *icmpPacket) StateTypeName() string {
+func (i *icmpPacket) StateTypeName() string {
return "pkg/tcpip/transport/icmp.icmpPacket"
}
-func (x *icmpPacket) StateFields() []string {
+func (i *icmpPacket) StateFields() []string {
return []string{
"icmpPacketEntry",
"senderAddress",
@@ -20,31 +20,31 @@ func (x *icmpPacket) StateFields() []string {
}
}
-func (x *icmpPacket) beforeSave() {}
+func (i *icmpPacket) beforeSave() {}
-func (x *icmpPacket) StateSave(m state.Sink) {
- x.beforeSave()
- var data buffer.VectorisedView = x.saveData()
- m.SaveValue(2, data)
- m.Save(0, &x.icmpPacketEntry)
- m.Save(1, &x.senderAddress)
- m.Save(3, &x.timestamp)
+func (i *icmpPacket) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ var dataValue buffer.VectorisedView = i.saveData()
+ stateSinkObject.SaveValue(2, dataValue)
+ stateSinkObject.Save(0, &i.icmpPacketEntry)
+ stateSinkObject.Save(1, &i.senderAddress)
+ stateSinkObject.Save(3, &i.timestamp)
}
-func (x *icmpPacket) afterLoad() {}
+func (i *icmpPacket) afterLoad() {}
-func (x *icmpPacket) StateLoad(m state.Source) {
- m.Load(0, &x.icmpPacketEntry)
- m.Load(1, &x.senderAddress)
- m.Load(3, &x.timestamp)
- m.LoadValue(2, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+func (i *icmpPacket) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.icmpPacketEntry)
+ stateSourceObject.Load(1, &i.senderAddress)
+ stateSourceObject.Load(3, &i.timestamp)
+ stateSourceObject.LoadValue(2, new(buffer.VectorisedView), func(y interface{}) { i.loadData(y.(buffer.VectorisedView)) })
}
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
return "pkg/tcpip/transport/icmp.endpoint"
}
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
return []string{
"TransportEndpointInfo",
"waiterQueue",
@@ -63,93 +63,93 @@ func (x *endpoint) StateFields() []string {
}
}
-func (x *endpoint) StateSave(m state.Sink) {
- x.beforeSave()
- var rcvBufSizeMax int = x.saveRcvBufSizeMax()
- m.SaveValue(5, rcvBufSizeMax)
- m.Save(0, &x.TransportEndpointInfo)
- m.Save(1, &x.waiterQueue)
- m.Save(2, &x.uniqueID)
- m.Save(3, &x.rcvReady)
- m.Save(4, &x.rcvList)
- m.Save(6, &x.rcvBufSize)
- m.Save(7, &x.rcvClosed)
- m.Save(8, &x.sndBufSize)
- m.Save(9, &x.shutdownFlags)
- m.Save(10, &x.state)
- m.Save(11, &x.ttl)
- m.Save(12, &x.linger)
- m.Save(13, &x.owner)
-}
-
-func (x *endpoint) StateLoad(m state.Source) {
- m.Load(0, &x.TransportEndpointInfo)
- m.Load(1, &x.waiterQueue)
- m.Load(2, &x.uniqueID)
- m.Load(3, &x.rcvReady)
- m.Load(4, &x.rcvList)
- m.Load(6, &x.rcvBufSize)
- m.Load(7, &x.rcvClosed)
- m.Load(8, &x.sndBufSize)
- m.Load(9, &x.shutdownFlags)
- m.Load(10, &x.state)
- m.Load(11, &x.ttl)
- m.Load(12, &x.linger)
- m.Load(13, &x.owner)
- m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *icmpPacketList) StateTypeName() string {
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var rcvBufSizeMaxValue int = e.saveRcvBufSizeMax()
+ stateSinkObject.SaveValue(5, rcvBufSizeMaxValue)
+ stateSinkObject.Save(0, &e.TransportEndpointInfo)
+ stateSinkObject.Save(1, &e.waiterQueue)
+ stateSinkObject.Save(2, &e.uniqueID)
+ stateSinkObject.Save(3, &e.rcvReady)
+ stateSinkObject.Save(4, &e.rcvList)
+ stateSinkObject.Save(6, &e.rcvBufSize)
+ stateSinkObject.Save(7, &e.rcvClosed)
+ stateSinkObject.Save(8, &e.sndBufSize)
+ stateSinkObject.Save(9, &e.shutdownFlags)
+ stateSinkObject.Save(10, &e.state)
+ stateSinkObject.Save(11, &e.ttl)
+ stateSinkObject.Save(12, &e.linger)
+ stateSinkObject.Save(13, &e.owner)
+}
+
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.TransportEndpointInfo)
+ stateSourceObject.Load(1, &e.waiterQueue)
+ stateSourceObject.Load(2, &e.uniqueID)
+ stateSourceObject.Load(3, &e.rcvReady)
+ stateSourceObject.Load(4, &e.rcvList)
+ stateSourceObject.Load(6, &e.rcvBufSize)
+ stateSourceObject.Load(7, &e.rcvClosed)
+ stateSourceObject.Load(8, &e.sndBufSize)
+ stateSourceObject.Load(9, &e.shutdownFlags)
+ stateSourceObject.Load(10, &e.state)
+ stateSourceObject.Load(11, &e.ttl)
+ stateSourceObject.Load(12, &e.linger)
+ stateSourceObject.Load(13, &e.owner)
+ stateSourceObject.LoadValue(5, new(int), func(y interface{}) { e.loadRcvBufSizeMax(y.(int)) })
+ stateSourceObject.AfterLoad(e.afterLoad)
+}
+
+func (i *icmpPacketList) StateTypeName() string {
return "pkg/tcpip/transport/icmp.icmpPacketList"
}
-func (x *icmpPacketList) StateFields() []string {
+func (i *icmpPacketList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *icmpPacketList) beforeSave() {}
+func (i *icmpPacketList) beforeSave() {}
-func (x *icmpPacketList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (i *icmpPacketList) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.head)
+ stateSinkObject.Save(1, &i.tail)
}
-func (x *icmpPacketList) afterLoad() {}
+func (i *icmpPacketList) afterLoad() {}
-func (x *icmpPacketList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (i *icmpPacketList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.head)
+ stateSourceObject.Load(1, &i.tail)
}
-func (x *icmpPacketEntry) StateTypeName() string {
+func (i *icmpPacketEntry) StateTypeName() string {
return "pkg/tcpip/transport/icmp.icmpPacketEntry"
}
-func (x *icmpPacketEntry) StateFields() []string {
+func (i *icmpPacketEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *icmpPacketEntry) beforeSave() {}
+func (i *icmpPacketEntry) beforeSave() {}
-func (x *icmpPacketEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (i *icmpPacketEntry) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.next)
+ stateSinkObject.Save(1, &i.prev)
}
-func (x *icmpPacketEntry) afterLoad() {}
+func (i *icmpPacketEntry) afterLoad() {}
-func (x *icmpPacketEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (i *icmpPacketEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.next)
+ stateSourceObject.Load(1, &i.prev)
}
func init() {
diff --git a/pkg/tcpip/transport/packet/packet_state_autogen.go b/pkg/tcpip/transport/packet/packet_state_autogen.go
index 5edd9db89..261bf1448 100644
--- a/pkg/tcpip/transport/packet/packet_state_autogen.go
+++ b/pkg/tcpip/transport/packet/packet_state_autogen.go
@@ -7,11 +7,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip/buffer"
)
-func (x *packet) StateTypeName() string {
+func (p *packet) StateTypeName() string {
return "pkg/tcpip/transport/packet.packet"
}
-func (x *packet) StateFields() []string {
+func (p *packet) StateFields() []string {
return []string{
"packetEntry",
"data",
@@ -21,33 +21,33 @@ func (x *packet) StateFields() []string {
}
}
-func (x *packet) beforeSave() {}
+func (p *packet) beforeSave() {}
-func (x *packet) StateSave(m state.Sink) {
- x.beforeSave()
- var data buffer.VectorisedView = x.saveData()
- m.SaveValue(1, data)
- m.Save(0, &x.packetEntry)
- m.Save(2, &x.timestampNS)
- m.Save(3, &x.senderAddr)
- m.Save(4, &x.packetInfo)
+func (p *packet) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ var dataValue buffer.VectorisedView = p.saveData()
+ stateSinkObject.SaveValue(1, dataValue)
+ stateSinkObject.Save(0, &p.packetEntry)
+ stateSinkObject.Save(2, &p.timestampNS)
+ stateSinkObject.Save(3, &p.senderAddr)
+ stateSinkObject.Save(4, &p.packetInfo)
}
-func (x *packet) afterLoad() {}
+func (p *packet) afterLoad() {}
-func (x *packet) StateLoad(m state.Source) {
- m.Load(0, &x.packetEntry)
- m.Load(2, &x.timestampNS)
- m.Load(3, &x.senderAddr)
- m.Load(4, &x.packetInfo)
- m.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+func (p *packet) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.packetEntry)
+ stateSourceObject.Load(2, &p.timestampNS)
+ stateSourceObject.Load(3, &p.senderAddr)
+ stateSourceObject.Load(4, &p.packetInfo)
+ stateSourceObject.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { p.loadData(y.(buffer.VectorisedView)) })
}
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
return "pkg/tcpip/transport/packet.endpoint"
}
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
return []string{
"TransportEndpointInfo",
"netProto",
@@ -67,96 +67,96 @@ func (x *endpoint) StateFields() []string {
}
}
-func (x *endpoint) StateSave(m state.Sink) {
- x.beforeSave()
- var rcvBufSizeMax int = x.saveRcvBufSizeMax()
- m.SaveValue(5, rcvBufSizeMax)
- var lastError string = x.saveLastError()
- m.SaveValue(14, lastError)
- m.Save(0, &x.TransportEndpointInfo)
- m.Save(1, &x.netProto)
- m.Save(2, &x.waiterQueue)
- m.Save(3, &x.cooked)
- m.Save(4, &x.rcvList)
- m.Save(6, &x.rcvBufSize)
- m.Save(7, &x.rcvClosed)
- m.Save(8, &x.sndBufSize)
- m.Save(9, &x.sndBufSizeMax)
- m.Save(10, &x.closed)
- m.Save(11, &x.bound)
- m.Save(12, &x.boundNIC)
- m.Save(13, &x.linger)
-}
-
-func (x *endpoint) StateLoad(m state.Source) {
- m.Load(0, &x.TransportEndpointInfo)
- m.Load(1, &x.netProto)
- m.Load(2, &x.waiterQueue)
- m.Load(3, &x.cooked)
- m.Load(4, &x.rcvList)
- m.Load(6, &x.rcvBufSize)
- m.Load(7, &x.rcvClosed)
- m.Load(8, &x.sndBufSize)
- m.Load(9, &x.sndBufSizeMax)
- m.Load(10, &x.closed)
- m.Load(11, &x.bound)
- m.Load(12, &x.boundNIC)
- m.Load(13, &x.linger)
- m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
- m.LoadValue(14, new(string), func(y interface{}) { x.loadLastError(y.(string)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *packetList) StateTypeName() string {
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var rcvBufSizeMaxValue int = e.saveRcvBufSizeMax()
+ stateSinkObject.SaveValue(5, rcvBufSizeMaxValue)
+ var lastErrorValue string = e.saveLastError()
+ stateSinkObject.SaveValue(14, lastErrorValue)
+ stateSinkObject.Save(0, &e.TransportEndpointInfo)
+ stateSinkObject.Save(1, &e.netProto)
+ stateSinkObject.Save(2, &e.waiterQueue)
+ stateSinkObject.Save(3, &e.cooked)
+ stateSinkObject.Save(4, &e.rcvList)
+ stateSinkObject.Save(6, &e.rcvBufSize)
+ stateSinkObject.Save(7, &e.rcvClosed)
+ stateSinkObject.Save(8, &e.sndBufSize)
+ stateSinkObject.Save(9, &e.sndBufSizeMax)
+ stateSinkObject.Save(10, &e.closed)
+ stateSinkObject.Save(11, &e.bound)
+ stateSinkObject.Save(12, &e.boundNIC)
+ stateSinkObject.Save(13, &e.linger)
+}
+
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.TransportEndpointInfo)
+ stateSourceObject.Load(1, &e.netProto)
+ stateSourceObject.Load(2, &e.waiterQueue)
+ stateSourceObject.Load(3, &e.cooked)
+ stateSourceObject.Load(4, &e.rcvList)
+ stateSourceObject.Load(6, &e.rcvBufSize)
+ stateSourceObject.Load(7, &e.rcvClosed)
+ stateSourceObject.Load(8, &e.sndBufSize)
+ stateSourceObject.Load(9, &e.sndBufSizeMax)
+ stateSourceObject.Load(10, &e.closed)
+ stateSourceObject.Load(11, &e.bound)
+ stateSourceObject.Load(12, &e.boundNIC)
+ stateSourceObject.Load(13, &e.linger)
+ stateSourceObject.LoadValue(5, new(int), func(y interface{}) { e.loadRcvBufSizeMax(y.(int)) })
+ stateSourceObject.LoadValue(14, new(string), func(y interface{}) { e.loadLastError(y.(string)) })
+ stateSourceObject.AfterLoad(e.afterLoad)
+}
+
+func (p *packetList) StateTypeName() string {
return "pkg/tcpip/transport/packet.packetList"
}
-func (x *packetList) StateFields() []string {
+func (p *packetList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *packetList) beforeSave() {}
+func (p *packetList) beforeSave() {}
-func (x *packetList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (p *packetList) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.head)
+ stateSinkObject.Save(1, &p.tail)
}
-func (x *packetList) afterLoad() {}
+func (p *packetList) afterLoad() {}
-func (x *packetList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (p *packetList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.head)
+ stateSourceObject.Load(1, &p.tail)
}
-func (x *packetEntry) StateTypeName() string {
+func (p *packetEntry) StateTypeName() string {
return "pkg/tcpip/transport/packet.packetEntry"
}
-func (x *packetEntry) StateFields() []string {
+func (p *packetEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *packetEntry) beforeSave() {}
+func (p *packetEntry) beforeSave() {}
-func (x *packetEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (p *packetEntry) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.next)
+ stateSinkObject.Save(1, &p.prev)
}
-func (x *packetEntry) afterLoad() {}
+func (p *packetEntry) afterLoad() {}
-func (x *packetEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (p *packetEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.next)
+ stateSourceObject.Load(1, &p.prev)
}
func init() {
diff --git a/pkg/tcpip/transport/raw/raw_state_autogen.go b/pkg/tcpip/transport/raw/raw_state_autogen.go
index 4930b46f4..6efb1f07e 100644
--- a/pkg/tcpip/transport/raw/raw_state_autogen.go
+++ b/pkg/tcpip/transport/raw/raw_state_autogen.go
@@ -7,11 +7,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip/buffer"
)
-func (x *rawPacket) StateTypeName() string {
+func (r *rawPacket) StateTypeName() string {
return "pkg/tcpip/transport/raw.rawPacket"
}
-func (x *rawPacket) StateFields() []string {
+func (r *rawPacket) StateFields() []string {
return []string{
"rawPacketEntry",
"data",
@@ -20,31 +20,31 @@ func (x *rawPacket) StateFields() []string {
}
}
-func (x *rawPacket) beforeSave() {}
+func (r *rawPacket) beforeSave() {}
-func (x *rawPacket) StateSave(m state.Sink) {
- x.beforeSave()
- var data buffer.VectorisedView = x.saveData()
- m.SaveValue(1, data)
- m.Save(0, &x.rawPacketEntry)
- m.Save(2, &x.timestampNS)
- m.Save(3, &x.senderAddr)
+func (r *rawPacket) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ var dataValue buffer.VectorisedView = r.saveData()
+ stateSinkObject.SaveValue(1, dataValue)
+ stateSinkObject.Save(0, &r.rawPacketEntry)
+ stateSinkObject.Save(2, &r.timestampNS)
+ stateSinkObject.Save(3, &r.senderAddr)
}
-func (x *rawPacket) afterLoad() {}
+func (r *rawPacket) afterLoad() {}
-func (x *rawPacket) StateLoad(m state.Source) {
- m.Load(0, &x.rawPacketEntry)
- m.Load(2, &x.timestampNS)
- m.Load(3, &x.senderAddr)
- m.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+func (r *rawPacket) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.rawPacketEntry)
+ stateSourceObject.Load(2, &r.timestampNS)
+ stateSourceObject.Load(3, &r.senderAddr)
+ stateSourceObject.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { r.loadData(y.(buffer.VectorisedView)) })
}
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
return "pkg/tcpip/transport/raw.endpoint"
}
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
return []string{
"TransportEndpointInfo",
"waiterQueue",
@@ -64,95 +64,95 @@ func (x *endpoint) StateFields() []string {
}
}
-func (x *endpoint) StateSave(m state.Sink) {
- x.beforeSave()
- var rcvBufSizeMax int = x.saveRcvBufSizeMax()
- m.SaveValue(6, rcvBufSizeMax)
- m.Save(0, &x.TransportEndpointInfo)
- m.Save(1, &x.waiterQueue)
- m.Save(2, &x.associated)
- m.Save(3, &x.hdrIncluded)
- m.Save(4, &x.rcvList)
- m.Save(5, &x.rcvBufSize)
- m.Save(7, &x.rcvClosed)
- m.Save(8, &x.sndBufSize)
- m.Save(9, &x.sndBufSizeMax)
- m.Save(10, &x.closed)
- m.Save(11, &x.connected)
- m.Save(12, &x.bound)
- m.Save(13, &x.linger)
- m.Save(14, &x.owner)
-}
-
-func (x *endpoint) StateLoad(m state.Source) {
- m.Load(0, &x.TransportEndpointInfo)
- m.Load(1, &x.waiterQueue)
- m.Load(2, &x.associated)
- m.Load(3, &x.hdrIncluded)
- m.Load(4, &x.rcvList)
- m.Load(5, &x.rcvBufSize)
- m.Load(7, &x.rcvClosed)
- m.Load(8, &x.sndBufSize)
- m.Load(9, &x.sndBufSizeMax)
- m.Load(10, &x.closed)
- m.Load(11, &x.connected)
- m.Load(12, &x.bound)
- m.Load(13, &x.linger)
- m.Load(14, &x.owner)
- m.LoadValue(6, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *rawPacketList) StateTypeName() string {
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var rcvBufSizeMaxValue int = e.saveRcvBufSizeMax()
+ stateSinkObject.SaveValue(6, rcvBufSizeMaxValue)
+ stateSinkObject.Save(0, &e.TransportEndpointInfo)
+ stateSinkObject.Save(1, &e.waiterQueue)
+ stateSinkObject.Save(2, &e.associated)
+ stateSinkObject.Save(3, &e.hdrIncluded)
+ stateSinkObject.Save(4, &e.rcvList)
+ stateSinkObject.Save(5, &e.rcvBufSize)
+ stateSinkObject.Save(7, &e.rcvClosed)
+ stateSinkObject.Save(8, &e.sndBufSize)
+ stateSinkObject.Save(9, &e.sndBufSizeMax)
+ stateSinkObject.Save(10, &e.closed)
+ stateSinkObject.Save(11, &e.connected)
+ stateSinkObject.Save(12, &e.bound)
+ stateSinkObject.Save(13, &e.linger)
+ stateSinkObject.Save(14, &e.owner)
+}
+
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.TransportEndpointInfo)
+ stateSourceObject.Load(1, &e.waiterQueue)
+ stateSourceObject.Load(2, &e.associated)
+ stateSourceObject.Load(3, &e.hdrIncluded)
+ stateSourceObject.Load(4, &e.rcvList)
+ stateSourceObject.Load(5, &e.rcvBufSize)
+ stateSourceObject.Load(7, &e.rcvClosed)
+ stateSourceObject.Load(8, &e.sndBufSize)
+ stateSourceObject.Load(9, &e.sndBufSizeMax)
+ stateSourceObject.Load(10, &e.closed)
+ stateSourceObject.Load(11, &e.connected)
+ stateSourceObject.Load(12, &e.bound)
+ stateSourceObject.Load(13, &e.linger)
+ stateSourceObject.Load(14, &e.owner)
+ stateSourceObject.LoadValue(6, new(int), func(y interface{}) { e.loadRcvBufSizeMax(y.(int)) })
+ stateSourceObject.AfterLoad(e.afterLoad)
+}
+
+func (r *rawPacketList) StateTypeName() string {
return "pkg/tcpip/transport/raw.rawPacketList"
}
-func (x *rawPacketList) StateFields() []string {
+func (r *rawPacketList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *rawPacketList) beforeSave() {}
+func (r *rawPacketList) beforeSave() {}
-func (x *rawPacketList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (r *rawPacketList) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.head)
+ stateSinkObject.Save(1, &r.tail)
}
-func (x *rawPacketList) afterLoad() {}
+func (r *rawPacketList) afterLoad() {}
-func (x *rawPacketList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (r *rawPacketList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.head)
+ stateSourceObject.Load(1, &r.tail)
}
-func (x *rawPacketEntry) StateTypeName() string {
+func (r *rawPacketEntry) StateTypeName() string {
return "pkg/tcpip/transport/raw.rawPacketEntry"
}
-func (x *rawPacketEntry) StateFields() []string {
+func (r *rawPacketEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *rawPacketEntry) beforeSave() {}
+func (r *rawPacketEntry) beforeSave() {}
-func (x *rawPacketEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (r *rawPacketEntry) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.next)
+ stateSinkObject.Save(1, &r.prev)
}
-func (x *rawPacketEntry) afterLoad() {}
+func (r *rawPacketEntry) afterLoad() {}
-func (x *rawPacketEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (r *rawPacketEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.next)
+ stateSourceObject.Load(1, &r.prev)
}
func init() {
diff --git a/pkg/tcpip/transport/tcp/tcp_state_autogen.go b/pkg/tcpip/transport/tcp/tcp_state_autogen.go
index 08f185795..9893252ef 100644
--- a/pkg/tcpip/transport/tcp/tcp_state_autogen.go
+++ b/pkg/tcpip/transport/tcp/tcp_state_autogen.go
@@ -7,11 +7,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip/buffer"
)
-func (x *cubicState) StateTypeName() string {
+func (c *cubicState) StateTypeName() string {
return "pkg/tcpip/transport/tcp.cubicState"
}
-func (x *cubicState) StateFields() []string {
+func (c *cubicState) StateFields() []string {
return []string{
"wLastMax",
"wMax",
@@ -26,69 +26,69 @@ func (x *cubicState) StateFields() []string {
}
}
-func (x *cubicState) beforeSave() {}
+func (c *cubicState) beforeSave() {}
-func (x *cubicState) StateSave(m state.Sink) {
- x.beforeSave()
- var t unixTime = x.saveT()
- m.SaveValue(2, t)
- m.Save(0, &x.wLastMax)
- m.Save(1, &x.wMax)
- m.Save(3, &x.numCongestionEvents)
- m.Save(4, &x.c)
- m.Save(5, &x.k)
- m.Save(6, &x.beta)
- m.Save(7, &x.wC)
- m.Save(8, &x.wEst)
- m.Save(9, &x.s)
+func (c *cubicState) StateSave(stateSinkObject state.Sink) {
+ c.beforeSave()
+ var tValue unixTime = c.saveT()
+ stateSinkObject.SaveValue(2, tValue)
+ stateSinkObject.Save(0, &c.wLastMax)
+ stateSinkObject.Save(1, &c.wMax)
+ stateSinkObject.Save(3, &c.numCongestionEvents)
+ stateSinkObject.Save(4, &c.c)
+ stateSinkObject.Save(5, &c.k)
+ stateSinkObject.Save(6, &c.beta)
+ stateSinkObject.Save(7, &c.wC)
+ stateSinkObject.Save(8, &c.wEst)
+ stateSinkObject.Save(9, &c.s)
}
-func (x *cubicState) afterLoad() {}
+func (c *cubicState) afterLoad() {}
-func (x *cubicState) StateLoad(m state.Source) {
- m.Load(0, &x.wLastMax)
- m.Load(1, &x.wMax)
- m.Load(3, &x.numCongestionEvents)
- m.Load(4, &x.c)
- m.Load(5, &x.k)
- m.Load(6, &x.beta)
- m.Load(7, &x.wC)
- m.Load(8, &x.wEst)
- m.Load(9, &x.s)
- m.LoadValue(2, new(unixTime), func(y interface{}) { x.loadT(y.(unixTime)) })
+func (c *cubicState) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &c.wLastMax)
+ stateSourceObject.Load(1, &c.wMax)
+ stateSourceObject.Load(3, &c.numCongestionEvents)
+ stateSourceObject.Load(4, &c.c)
+ stateSourceObject.Load(5, &c.k)
+ stateSourceObject.Load(6, &c.beta)
+ stateSourceObject.Load(7, &c.wC)
+ stateSourceObject.Load(8, &c.wEst)
+ stateSourceObject.Load(9, &c.s)
+ stateSourceObject.LoadValue(2, new(unixTime), func(y interface{}) { c.loadT(y.(unixTime)) })
}
-func (x *SACKInfo) StateTypeName() string {
+func (s *SACKInfo) StateTypeName() string {
return "pkg/tcpip/transport/tcp.SACKInfo"
}
-func (x *SACKInfo) StateFields() []string {
+func (s *SACKInfo) StateFields() []string {
return []string{
"Blocks",
"NumBlocks",
}
}
-func (x *SACKInfo) beforeSave() {}
+func (s *SACKInfo) beforeSave() {}
-func (x *SACKInfo) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Blocks)
- m.Save(1, &x.NumBlocks)
+func (s *SACKInfo) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.Blocks)
+ stateSinkObject.Save(1, &s.NumBlocks)
}
-func (x *SACKInfo) afterLoad() {}
+func (s *SACKInfo) afterLoad() {}
-func (x *SACKInfo) StateLoad(m state.Source) {
- m.Load(0, &x.Blocks)
- m.Load(1, &x.NumBlocks)
+func (s *SACKInfo) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.Blocks)
+ stateSourceObject.Load(1, &s.NumBlocks)
}
-func (x *rcvBufAutoTuneParams) StateTypeName() string {
+func (r *rcvBufAutoTuneParams) StateTypeName() string {
return "pkg/tcpip/transport/tcp.rcvBufAutoTuneParams"
}
-func (x *rcvBufAutoTuneParams) StateFields() []string {
+func (r *rcvBufAutoTuneParams) StateFields() []string {
return []string{
"measureTime",
"copied",
@@ -100,65 +100,65 @@ func (x *rcvBufAutoTuneParams) StateFields() []string {
}
}
-func (x *rcvBufAutoTuneParams) beforeSave() {}
+func (r *rcvBufAutoTuneParams) beforeSave() {}
-func (x *rcvBufAutoTuneParams) StateSave(m state.Sink) {
- x.beforeSave()
- var measureTime unixTime = x.saveMeasureTime()
- m.SaveValue(0, measureTime)
- var rttMeasureTime unixTime = x.saveRttMeasureTime()
- m.SaveValue(5, rttMeasureTime)
- m.Save(1, &x.copied)
- m.Save(2, &x.prevCopied)
- m.Save(3, &x.rtt)
- m.Save(4, &x.rttMeasureSeqNumber)
- m.Save(6, &x.disabled)
+func (r *rcvBufAutoTuneParams) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ var measureTimeValue unixTime = r.saveMeasureTime()
+ stateSinkObject.SaveValue(0, measureTimeValue)
+ var rttMeasureTimeValue unixTime = r.saveRttMeasureTime()
+ stateSinkObject.SaveValue(5, rttMeasureTimeValue)
+ stateSinkObject.Save(1, &r.copied)
+ stateSinkObject.Save(2, &r.prevCopied)
+ stateSinkObject.Save(3, &r.rtt)
+ stateSinkObject.Save(4, &r.rttMeasureSeqNumber)
+ stateSinkObject.Save(6, &r.disabled)
}
-func (x *rcvBufAutoTuneParams) afterLoad() {}
+func (r *rcvBufAutoTuneParams) afterLoad() {}
-func (x *rcvBufAutoTuneParams) StateLoad(m state.Source) {
- m.Load(1, &x.copied)
- m.Load(2, &x.prevCopied)
- m.Load(3, &x.rtt)
- m.Load(4, &x.rttMeasureSeqNumber)
- m.Load(6, &x.disabled)
- m.LoadValue(0, new(unixTime), func(y interface{}) { x.loadMeasureTime(y.(unixTime)) })
- m.LoadValue(5, new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
+func (r *rcvBufAutoTuneParams) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(1, &r.copied)
+ stateSourceObject.Load(2, &r.prevCopied)
+ stateSourceObject.Load(3, &r.rtt)
+ stateSourceObject.Load(4, &r.rttMeasureSeqNumber)
+ stateSourceObject.Load(6, &r.disabled)
+ stateSourceObject.LoadValue(0, new(unixTime), func(y interface{}) { r.loadMeasureTime(y.(unixTime)) })
+ stateSourceObject.LoadValue(5, new(unixTime), func(y interface{}) { r.loadRttMeasureTime(y.(unixTime)) })
}
-func (x *EndpointInfo) StateTypeName() string {
+func (e *EndpointInfo) StateTypeName() string {
return "pkg/tcpip/transport/tcp.EndpointInfo"
}
-func (x *EndpointInfo) StateFields() []string {
+func (e *EndpointInfo) StateFields() []string {
return []string{
"TransportEndpointInfo",
"HardError",
}
}
-func (x *EndpointInfo) beforeSave() {}
+func (e *EndpointInfo) beforeSave() {}
-func (x *EndpointInfo) StateSave(m state.Sink) {
- x.beforeSave()
- var HardError string = x.saveHardError()
- m.SaveValue(1, HardError)
- m.Save(0, &x.TransportEndpointInfo)
+func (e *EndpointInfo) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var HardErrorValue string = e.saveHardError()
+ stateSinkObject.SaveValue(1, HardErrorValue)
+ stateSinkObject.Save(0, &e.TransportEndpointInfo)
}
-func (x *EndpointInfo) afterLoad() {}
+func (e *EndpointInfo) afterLoad() {}
-func (x *EndpointInfo) StateLoad(m state.Source) {
- m.Load(0, &x.TransportEndpointInfo)
- m.LoadValue(1, new(string), func(y interface{}) { x.loadHardError(y.(string)) })
+func (e *EndpointInfo) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.TransportEndpointInfo)
+ stateSourceObject.LoadValue(1, new(string), func(y interface{}) { e.loadHardError(y.(string)) })
}
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
return "pkg/tcpip/transport/tcp.endpoint"
}
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
return []string{
"EndpointInfo",
"waiterQueue",
@@ -227,151 +227,151 @@ func (x *endpoint) StateFields() []string {
}
}
-func (x *endpoint) StateSave(m state.Sink) {
- x.beforeSave()
- var lastError string = x.saveLastError()
- m.SaveValue(3, lastError)
- var state EndpointState = x.saveState()
- m.SaveValue(11, state)
- var recentTSTime unixTime = x.saveRecentTSTime()
- m.SaveValue(26, recentTSTime)
- var acceptedChan []*endpoint = x.saveAcceptedChan()
- m.SaveValue(52, acceptedChan)
- m.Save(0, &x.EndpointInfo)
- m.Save(1, &x.waiterQueue)
- m.Save(2, &x.uniqueID)
- m.Save(4, &x.rcvList)
- m.Save(5, &x.rcvClosed)
- m.Save(6, &x.rcvBufSize)
- m.Save(7, &x.rcvBufUsed)
- m.Save(8, &x.rcvAutoParams)
- m.Save(9, &x.rcvMemUsed)
- m.Save(10, &x.ownedByUser)
- m.Save(12, &x.boundNICID)
- m.Save(13, &x.ttl)
- m.Save(14, &x.v6only)
- m.Save(15, &x.isConnectNotified)
- m.Save(16, &x.broadcast)
- m.Save(17, &x.portFlags)
- m.Save(18, &x.boundBindToDevice)
- m.Save(19, &x.boundPortFlags)
- m.Save(20, &x.boundDest)
- m.Save(21, &x.effectiveNetProtos)
- m.Save(22, &x.workerRunning)
- m.Save(23, &x.workerCleanup)
- m.Save(24, &x.sendTSOk)
- m.Save(25, &x.recentTS)
- m.Save(27, &x.tsOffset)
- m.Save(28, &x.shutdownFlags)
- m.Save(29, &x.sackPermitted)
- m.Save(30, &x.sack)
- m.Save(31, &x.bindToDevice)
- m.Save(32, &x.delay)
- m.Save(33, &x.cork)
- m.Save(34, &x.scoreboard)
- m.Save(35, &x.slowAck)
- m.Save(36, &x.segmentQueue)
- m.Save(37, &x.synRcvdCount)
- m.Save(38, &x.userMSS)
- m.Save(39, &x.maxSynRetries)
- m.Save(40, &x.windowClamp)
- m.Save(41, &x.sndBufSize)
- m.Save(42, &x.sndBufUsed)
- m.Save(43, &x.sndClosed)
- m.Save(44, &x.sndBufInQueue)
- m.Save(45, &x.sndQueue)
- m.Save(46, &x.cc)
- m.Save(47, &x.packetTooBigCount)
- m.Save(48, &x.sndMTU)
- m.Save(49, &x.keepalive)
- m.Save(50, &x.userTimeout)
- m.Save(51, &x.deferAccept)
- m.Save(53, &x.rcv)
- m.Save(54, &x.snd)
- m.Save(55, &x.connectingAddress)
- m.Save(56, &x.amss)
- m.Save(57, &x.sendTOS)
- m.Save(58, &x.gso)
- m.Save(59, &x.tcpLingerTimeout)
- m.Save(60, &x.closed)
- m.Save(61, &x.txHash)
- m.Save(62, &x.owner)
- m.Save(63, &x.linger)
-}
-
-func (x *endpoint) StateLoad(m state.Source) {
- m.Load(0, &x.EndpointInfo)
- m.LoadWait(1, &x.waiterQueue)
- m.Load(2, &x.uniqueID)
- m.LoadWait(4, &x.rcvList)
- m.Load(5, &x.rcvClosed)
- m.Load(6, &x.rcvBufSize)
- m.Load(7, &x.rcvBufUsed)
- m.Load(8, &x.rcvAutoParams)
- m.Load(9, &x.rcvMemUsed)
- m.Load(10, &x.ownedByUser)
- m.Load(12, &x.boundNICID)
- m.Load(13, &x.ttl)
- m.Load(14, &x.v6only)
- m.Load(15, &x.isConnectNotified)
- m.Load(16, &x.broadcast)
- m.Load(17, &x.portFlags)
- m.Load(18, &x.boundBindToDevice)
- m.Load(19, &x.boundPortFlags)
- m.Load(20, &x.boundDest)
- m.Load(21, &x.effectiveNetProtos)
- m.Load(22, &x.workerRunning)
- m.Load(23, &x.workerCleanup)
- m.Load(24, &x.sendTSOk)
- m.Load(25, &x.recentTS)
- m.Load(27, &x.tsOffset)
- m.Load(28, &x.shutdownFlags)
- m.Load(29, &x.sackPermitted)
- m.Load(30, &x.sack)
- m.Load(31, &x.bindToDevice)
- m.Load(32, &x.delay)
- m.Load(33, &x.cork)
- m.Load(34, &x.scoreboard)
- m.Load(35, &x.slowAck)
- m.LoadWait(36, &x.segmentQueue)
- m.Load(37, &x.synRcvdCount)
- m.Load(38, &x.userMSS)
- m.Load(39, &x.maxSynRetries)
- m.Load(40, &x.windowClamp)
- m.Load(41, &x.sndBufSize)
- m.Load(42, &x.sndBufUsed)
- m.Load(43, &x.sndClosed)
- m.Load(44, &x.sndBufInQueue)
- m.LoadWait(45, &x.sndQueue)
- m.Load(46, &x.cc)
- m.Load(47, &x.packetTooBigCount)
- m.Load(48, &x.sndMTU)
- m.Load(49, &x.keepalive)
- m.Load(50, &x.userTimeout)
- m.Load(51, &x.deferAccept)
- m.LoadWait(53, &x.rcv)
- m.LoadWait(54, &x.snd)
- m.Load(55, &x.connectingAddress)
- m.Load(56, &x.amss)
- m.Load(57, &x.sendTOS)
- m.Load(58, &x.gso)
- m.Load(59, &x.tcpLingerTimeout)
- m.Load(60, &x.closed)
- m.Load(61, &x.txHash)
- m.Load(62, &x.owner)
- m.Load(63, &x.linger)
- m.LoadValue(3, new(string), func(y interface{}) { x.loadLastError(y.(string)) })
- m.LoadValue(11, new(EndpointState), func(y interface{}) { x.loadState(y.(EndpointState)) })
- m.LoadValue(26, new(unixTime), func(y interface{}) { x.loadRecentTSTime(y.(unixTime)) })
- m.LoadValue(52, new([]*endpoint), func(y interface{}) { x.loadAcceptedChan(y.([]*endpoint)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *keepalive) StateTypeName() string {
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var lastErrorValue string = e.saveLastError()
+ stateSinkObject.SaveValue(3, lastErrorValue)
+ var stateValue EndpointState = e.saveState()
+ stateSinkObject.SaveValue(11, stateValue)
+ var recentTSTimeValue unixTime = e.saveRecentTSTime()
+ stateSinkObject.SaveValue(26, recentTSTimeValue)
+ var acceptedChanValue []*endpoint = e.saveAcceptedChan()
+ stateSinkObject.SaveValue(52, acceptedChanValue)
+ stateSinkObject.Save(0, &e.EndpointInfo)
+ stateSinkObject.Save(1, &e.waiterQueue)
+ stateSinkObject.Save(2, &e.uniqueID)
+ stateSinkObject.Save(4, &e.rcvList)
+ stateSinkObject.Save(5, &e.rcvClosed)
+ stateSinkObject.Save(6, &e.rcvBufSize)
+ stateSinkObject.Save(7, &e.rcvBufUsed)
+ stateSinkObject.Save(8, &e.rcvAutoParams)
+ stateSinkObject.Save(9, &e.rcvMemUsed)
+ stateSinkObject.Save(10, &e.ownedByUser)
+ stateSinkObject.Save(12, &e.boundNICID)
+ stateSinkObject.Save(13, &e.ttl)
+ stateSinkObject.Save(14, &e.v6only)
+ stateSinkObject.Save(15, &e.isConnectNotified)
+ stateSinkObject.Save(16, &e.broadcast)
+ stateSinkObject.Save(17, &e.portFlags)
+ stateSinkObject.Save(18, &e.boundBindToDevice)
+ stateSinkObject.Save(19, &e.boundPortFlags)
+ stateSinkObject.Save(20, &e.boundDest)
+ stateSinkObject.Save(21, &e.effectiveNetProtos)
+ stateSinkObject.Save(22, &e.workerRunning)
+ stateSinkObject.Save(23, &e.workerCleanup)
+ stateSinkObject.Save(24, &e.sendTSOk)
+ stateSinkObject.Save(25, &e.recentTS)
+ stateSinkObject.Save(27, &e.tsOffset)
+ stateSinkObject.Save(28, &e.shutdownFlags)
+ stateSinkObject.Save(29, &e.sackPermitted)
+ stateSinkObject.Save(30, &e.sack)
+ stateSinkObject.Save(31, &e.bindToDevice)
+ stateSinkObject.Save(32, &e.delay)
+ stateSinkObject.Save(33, &e.cork)
+ stateSinkObject.Save(34, &e.scoreboard)
+ stateSinkObject.Save(35, &e.slowAck)
+ stateSinkObject.Save(36, &e.segmentQueue)
+ stateSinkObject.Save(37, &e.synRcvdCount)
+ stateSinkObject.Save(38, &e.userMSS)
+ stateSinkObject.Save(39, &e.maxSynRetries)
+ stateSinkObject.Save(40, &e.windowClamp)
+ stateSinkObject.Save(41, &e.sndBufSize)
+ stateSinkObject.Save(42, &e.sndBufUsed)
+ stateSinkObject.Save(43, &e.sndClosed)
+ stateSinkObject.Save(44, &e.sndBufInQueue)
+ stateSinkObject.Save(45, &e.sndQueue)
+ stateSinkObject.Save(46, &e.cc)
+ stateSinkObject.Save(47, &e.packetTooBigCount)
+ stateSinkObject.Save(48, &e.sndMTU)
+ stateSinkObject.Save(49, &e.keepalive)
+ stateSinkObject.Save(50, &e.userTimeout)
+ stateSinkObject.Save(51, &e.deferAccept)
+ stateSinkObject.Save(53, &e.rcv)
+ stateSinkObject.Save(54, &e.snd)
+ stateSinkObject.Save(55, &e.connectingAddress)
+ stateSinkObject.Save(56, &e.amss)
+ stateSinkObject.Save(57, &e.sendTOS)
+ stateSinkObject.Save(58, &e.gso)
+ stateSinkObject.Save(59, &e.tcpLingerTimeout)
+ stateSinkObject.Save(60, &e.closed)
+ stateSinkObject.Save(61, &e.txHash)
+ stateSinkObject.Save(62, &e.owner)
+ stateSinkObject.Save(63, &e.linger)
+}
+
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.EndpointInfo)
+ stateSourceObject.LoadWait(1, &e.waiterQueue)
+ stateSourceObject.Load(2, &e.uniqueID)
+ stateSourceObject.LoadWait(4, &e.rcvList)
+ stateSourceObject.Load(5, &e.rcvClosed)
+ stateSourceObject.Load(6, &e.rcvBufSize)
+ stateSourceObject.Load(7, &e.rcvBufUsed)
+ stateSourceObject.Load(8, &e.rcvAutoParams)
+ stateSourceObject.Load(9, &e.rcvMemUsed)
+ stateSourceObject.Load(10, &e.ownedByUser)
+ stateSourceObject.Load(12, &e.boundNICID)
+ stateSourceObject.Load(13, &e.ttl)
+ stateSourceObject.Load(14, &e.v6only)
+ stateSourceObject.Load(15, &e.isConnectNotified)
+ stateSourceObject.Load(16, &e.broadcast)
+ stateSourceObject.Load(17, &e.portFlags)
+ stateSourceObject.Load(18, &e.boundBindToDevice)
+ stateSourceObject.Load(19, &e.boundPortFlags)
+ stateSourceObject.Load(20, &e.boundDest)
+ stateSourceObject.Load(21, &e.effectiveNetProtos)
+ stateSourceObject.Load(22, &e.workerRunning)
+ stateSourceObject.Load(23, &e.workerCleanup)
+ stateSourceObject.Load(24, &e.sendTSOk)
+ stateSourceObject.Load(25, &e.recentTS)
+ stateSourceObject.Load(27, &e.tsOffset)
+ stateSourceObject.Load(28, &e.shutdownFlags)
+ stateSourceObject.Load(29, &e.sackPermitted)
+ stateSourceObject.Load(30, &e.sack)
+ stateSourceObject.Load(31, &e.bindToDevice)
+ stateSourceObject.Load(32, &e.delay)
+ stateSourceObject.Load(33, &e.cork)
+ stateSourceObject.Load(34, &e.scoreboard)
+ stateSourceObject.Load(35, &e.slowAck)
+ stateSourceObject.LoadWait(36, &e.segmentQueue)
+ stateSourceObject.Load(37, &e.synRcvdCount)
+ stateSourceObject.Load(38, &e.userMSS)
+ stateSourceObject.Load(39, &e.maxSynRetries)
+ stateSourceObject.Load(40, &e.windowClamp)
+ stateSourceObject.Load(41, &e.sndBufSize)
+ stateSourceObject.Load(42, &e.sndBufUsed)
+ stateSourceObject.Load(43, &e.sndClosed)
+ stateSourceObject.Load(44, &e.sndBufInQueue)
+ stateSourceObject.LoadWait(45, &e.sndQueue)
+ stateSourceObject.Load(46, &e.cc)
+ stateSourceObject.Load(47, &e.packetTooBigCount)
+ stateSourceObject.Load(48, &e.sndMTU)
+ stateSourceObject.Load(49, &e.keepalive)
+ stateSourceObject.Load(50, &e.userTimeout)
+ stateSourceObject.Load(51, &e.deferAccept)
+ stateSourceObject.LoadWait(53, &e.rcv)
+ stateSourceObject.LoadWait(54, &e.snd)
+ stateSourceObject.Load(55, &e.connectingAddress)
+ stateSourceObject.Load(56, &e.amss)
+ stateSourceObject.Load(57, &e.sendTOS)
+ stateSourceObject.Load(58, &e.gso)
+ stateSourceObject.Load(59, &e.tcpLingerTimeout)
+ stateSourceObject.Load(60, &e.closed)
+ stateSourceObject.Load(61, &e.txHash)
+ stateSourceObject.Load(62, &e.owner)
+ stateSourceObject.Load(63, &e.linger)
+ stateSourceObject.LoadValue(3, new(string), func(y interface{}) { e.loadLastError(y.(string)) })
+ stateSourceObject.LoadValue(11, new(EndpointState), func(y interface{}) { e.loadState(y.(EndpointState)) })
+ stateSourceObject.LoadValue(26, new(unixTime), func(y interface{}) { e.loadRecentTSTime(y.(unixTime)) })
+ stateSourceObject.LoadValue(52, new([]*endpoint), func(y interface{}) { e.loadAcceptedChan(y.([]*endpoint)) })
+ stateSourceObject.AfterLoad(e.afterLoad)
+}
+
+func (k *keepalive) StateTypeName() string {
return "pkg/tcpip/transport/tcp.keepalive"
}
-func (x *keepalive) StateFields() []string {
+func (k *keepalive) StateFields() []string {
return []string{
"enabled",
"idle",
@@ -381,32 +381,32 @@ func (x *keepalive) StateFields() []string {
}
}
-func (x *keepalive) beforeSave() {}
+func (k *keepalive) beforeSave() {}
-func (x *keepalive) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.enabled)
- m.Save(1, &x.idle)
- m.Save(2, &x.interval)
- m.Save(3, &x.count)
- m.Save(4, &x.unacked)
+func (k *keepalive) StateSave(stateSinkObject state.Sink) {
+ k.beforeSave()
+ stateSinkObject.Save(0, &k.enabled)
+ stateSinkObject.Save(1, &k.idle)
+ stateSinkObject.Save(2, &k.interval)
+ stateSinkObject.Save(3, &k.count)
+ stateSinkObject.Save(4, &k.unacked)
}
-func (x *keepalive) afterLoad() {}
+func (k *keepalive) afterLoad() {}
-func (x *keepalive) StateLoad(m state.Source) {
- m.Load(0, &x.enabled)
- m.Load(1, &x.idle)
- m.Load(2, &x.interval)
- m.Load(3, &x.count)
- m.Load(4, &x.unacked)
+func (k *keepalive) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &k.enabled)
+ stateSourceObject.Load(1, &k.idle)
+ stateSourceObject.Load(2, &k.interval)
+ stateSourceObject.Load(3, &k.count)
+ stateSourceObject.Load(4, &k.unacked)
}
-func (x *rackControl) StateTypeName() string {
+func (r *rackControl) StateTypeName() string {
return "pkg/tcpip/transport/tcp.rackControl"
}
-func (x *rackControl) StateFields() []string {
+func (r *rackControl) StateFields() []string {
return []string{
"xmitTime",
"endSequence",
@@ -416,33 +416,33 @@ func (x *rackControl) StateFields() []string {
}
}
-func (x *rackControl) beforeSave() {}
+func (r *rackControl) beforeSave() {}
-func (x *rackControl) StateSave(m state.Sink) {
- x.beforeSave()
- var xmitTime unixTime = x.saveXmitTime()
- m.SaveValue(0, xmitTime)
- m.Save(1, &x.endSequence)
- m.Save(2, &x.fack)
- m.Save(3, &x.minRTT)
- m.Save(4, &x.rtt)
+func (r *rackControl) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ var xmitTimeValue unixTime = r.saveXmitTime()
+ stateSinkObject.SaveValue(0, xmitTimeValue)
+ stateSinkObject.Save(1, &r.endSequence)
+ stateSinkObject.Save(2, &r.fack)
+ stateSinkObject.Save(3, &r.minRTT)
+ stateSinkObject.Save(4, &r.rtt)
}
-func (x *rackControl) afterLoad() {}
+func (r *rackControl) afterLoad() {}
-func (x *rackControl) StateLoad(m state.Source) {
- m.Load(1, &x.endSequence)
- m.Load(2, &x.fack)
- m.Load(3, &x.minRTT)
- m.Load(4, &x.rtt)
- m.LoadValue(0, new(unixTime), func(y interface{}) { x.loadXmitTime(y.(unixTime)) })
+func (r *rackControl) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(1, &r.endSequence)
+ stateSourceObject.Load(2, &r.fack)
+ stateSourceObject.Load(3, &r.minRTT)
+ stateSourceObject.Load(4, &r.rtt)
+ stateSourceObject.LoadValue(0, new(unixTime), func(y interface{}) { r.loadXmitTime(y.(unixTime)) })
}
-func (x *receiver) StateTypeName() string {
+func (r *receiver) StateTypeName() string {
return "pkg/tcpip/transport/tcp.receiver"
}
-func (x *receiver) StateFields() []string {
+func (r *receiver) StateFields() []string {
return []string{
"ep",
"rcvNxt",
@@ -456,90 +456,90 @@ func (x *receiver) StateFields() []string {
}
}
-func (x *receiver) beforeSave() {}
+func (r *receiver) beforeSave() {}
-func (x *receiver) StateSave(m state.Sink) {
- x.beforeSave()
- var lastRcvdAckTime unixTime = x.saveLastRcvdAckTime()
- m.SaveValue(8, lastRcvdAckTime)
- m.Save(0, &x.ep)
- m.Save(1, &x.rcvNxt)
- m.Save(2, &x.rcvAcc)
- m.Save(3, &x.rcvWnd)
- m.Save(4, &x.rcvWndScale)
- m.Save(5, &x.closed)
- m.Save(6, &x.pendingRcvdSegments)
- m.Save(7, &x.pendingBufUsed)
+func (r *receiver) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ var lastRcvdAckTimeValue unixTime = r.saveLastRcvdAckTime()
+ stateSinkObject.SaveValue(8, lastRcvdAckTimeValue)
+ stateSinkObject.Save(0, &r.ep)
+ stateSinkObject.Save(1, &r.rcvNxt)
+ stateSinkObject.Save(2, &r.rcvAcc)
+ stateSinkObject.Save(3, &r.rcvWnd)
+ stateSinkObject.Save(4, &r.rcvWndScale)
+ stateSinkObject.Save(5, &r.closed)
+ stateSinkObject.Save(6, &r.pendingRcvdSegments)
+ stateSinkObject.Save(7, &r.pendingBufUsed)
}
-func (x *receiver) afterLoad() {}
+func (r *receiver) afterLoad() {}
-func (x *receiver) StateLoad(m state.Source) {
- m.Load(0, &x.ep)
- m.Load(1, &x.rcvNxt)
- m.Load(2, &x.rcvAcc)
- m.Load(3, &x.rcvWnd)
- m.Load(4, &x.rcvWndScale)
- m.Load(5, &x.closed)
- m.Load(6, &x.pendingRcvdSegments)
- m.Load(7, &x.pendingBufUsed)
- m.LoadValue(8, new(unixTime), func(y interface{}) { x.loadLastRcvdAckTime(y.(unixTime)) })
+func (r *receiver) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.ep)
+ stateSourceObject.Load(1, &r.rcvNxt)
+ stateSourceObject.Load(2, &r.rcvAcc)
+ stateSourceObject.Load(3, &r.rcvWnd)
+ stateSourceObject.Load(4, &r.rcvWndScale)
+ stateSourceObject.Load(5, &r.closed)
+ stateSourceObject.Load(6, &r.pendingRcvdSegments)
+ stateSourceObject.Load(7, &r.pendingBufUsed)
+ stateSourceObject.LoadValue(8, new(unixTime), func(y interface{}) { r.loadLastRcvdAckTime(y.(unixTime)) })
}
-func (x *renoState) StateTypeName() string {
+func (r *renoState) StateTypeName() string {
return "pkg/tcpip/transport/tcp.renoState"
}
-func (x *renoState) StateFields() []string {
+func (r *renoState) StateFields() []string {
return []string{
"s",
}
}
-func (x *renoState) beforeSave() {}
+func (r *renoState) beforeSave() {}
-func (x *renoState) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.s)
+func (r *renoState) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.s)
}
-func (x *renoState) afterLoad() {}
+func (r *renoState) afterLoad() {}
-func (x *renoState) StateLoad(m state.Source) {
- m.Load(0, &x.s)
+func (r *renoState) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.s)
}
-func (x *SACKScoreboard) StateTypeName() string {
+func (s *SACKScoreboard) StateTypeName() string {
return "pkg/tcpip/transport/tcp.SACKScoreboard"
}
-func (x *SACKScoreboard) StateFields() []string {
+func (s *SACKScoreboard) StateFields() []string {
return []string{
"smss",
"maxSACKED",
}
}
-func (x *SACKScoreboard) beforeSave() {}
+func (s *SACKScoreboard) beforeSave() {}
-func (x *SACKScoreboard) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.smss)
- m.Save(1, &x.maxSACKED)
+func (s *SACKScoreboard) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.smss)
+ stateSinkObject.Save(1, &s.maxSACKED)
}
-func (x *SACKScoreboard) afterLoad() {}
+func (s *SACKScoreboard) afterLoad() {}
-func (x *SACKScoreboard) StateLoad(m state.Source) {
- m.Load(0, &x.smss)
- m.Load(1, &x.maxSACKED)
+func (s *SACKScoreboard) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.smss)
+ stateSourceObject.Load(1, &s.maxSACKED)
}
-func (x *segment) StateTypeName() string {
+func (s *segment) StateTypeName() string {
return "pkg/tcpip/transport/tcp.segment"
}
-func (x *segment) StateFields() []string {
+func (s *segment) StateFields() []string {
return []string{
"segmentEntry",
"refCnt",
@@ -563,64 +563,64 @@ func (x *segment) StateFields() []string {
}
}
-func (x *segment) beforeSave() {}
-
-func (x *segment) StateSave(m state.Sink) {
- x.beforeSave()
- var data buffer.VectorisedView = x.saveData()
- m.SaveValue(4, data)
- var options []byte = x.saveOptions()
- m.SaveValue(14, options)
- var rcvdTime unixTime = x.saveRcvdTime()
- m.SaveValue(16, rcvdTime)
- var xmitTime unixTime = x.saveXmitTime()
- m.SaveValue(17, xmitTime)
- m.Save(0, &x.segmentEntry)
- m.Save(1, &x.refCnt)
- m.Save(2, &x.ep)
- m.Save(3, &x.qFlags)
- m.Save(5, &x.hdr)
- m.Save(6, &x.viewToDeliver)
- m.Save(7, &x.sequenceNumber)
- m.Save(8, &x.ackNumber)
- m.Save(9, &x.flags)
- m.Save(10, &x.window)
- m.Save(11, &x.csum)
- m.Save(12, &x.csumValid)
- m.Save(13, &x.parsedOptions)
- m.Save(15, &x.hasNewSACKInfo)
- m.Save(18, &x.xmitCount)
-}
-
-func (x *segment) afterLoad() {}
-
-func (x *segment) StateLoad(m state.Source) {
- m.Load(0, &x.segmentEntry)
- m.Load(1, &x.refCnt)
- m.Load(2, &x.ep)
- m.Load(3, &x.qFlags)
- m.Load(5, &x.hdr)
- m.Load(6, &x.viewToDeliver)
- m.Load(7, &x.sequenceNumber)
- m.Load(8, &x.ackNumber)
- m.Load(9, &x.flags)
- m.Load(10, &x.window)
- m.Load(11, &x.csum)
- m.Load(12, &x.csumValid)
- m.Load(13, &x.parsedOptions)
- m.Load(15, &x.hasNewSACKInfo)
- m.Load(18, &x.xmitCount)
- m.LoadValue(4, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
- m.LoadValue(14, new([]byte), func(y interface{}) { x.loadOptions(y.([]byte)) })
- m.LoadValue(16, new(unixTime), func(y interface{}) { x.loadRcvdTime(y.(unixTime)) })
- m.LoadValue(17, new(unixTime), func(y interface{}) { x.loadXmitTime(y.(unixTime)) })
-}
-
-func (x *segmentQueue) StateTypeName() string {
+func (s *segment) beforeSave() {}
+
+func (s *segment) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ var dataValue buffer.VectorisedView = s.saveData()
+ stateSinkObject.SaveValue(4, dataValue)
+ var optionsValue []byte = s.saveOptions()
+ stateSinkObject.SaveValue(14, optionsValue)
+ var rcvdTimeValue unixTime = s.saveRcvdTime()
+ stateSinkObject.SaveValue(16, rcvdTimeValue)
+ var xmitTimeValue unixTime = s.saveXmitTime()
+ stateSinkObject.SaveValue(17, xmitTimeValue)
+ stateSinkObject.Save(0, &s.segmentEntry)
+ stateSinkObject.Save(1, &s.refCnt)
+ stateSinkObject.Save(2, &s.ep)
+ stateSinkObject.Save(3, &s.qFlags)
+ stateSinkObject.Save(5, &s.hdr)
+ stateSinkObject.Save(6, &s.viewToDeliver)
+ stateSinkObject.Save(7, &s.sequenceNumber)
+ stateSinkObject.Save(8, &s.ackNumber)
+ stateSinkObject.Save(9, &s.flags)
+ stateSinkObject.Save(10, &s.window)
+ stateSinkObject.Save(11, &s.csum)
+ stateSinkObject.Save(12, &s.csumValid)
+ stateSinkObject.Save(13, &s.parsedOptions)
+ stateSinkObject.Save(15, &s.hasNewSACKInfo)
+ stateSinkObject.Save(18, &s.xmitCount)
+}
+
+func (s *segment) afterLoad() {}
+
+func (s *segment) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.segmentEntry)
+ stateSourceObject.Load(1, &s.refCnt)
+ stateSourceObject.Load(2, &s.ep)
+ stateSourceObject.Load(3, &s.qFlags)
+ stateSourceObject.Load(5, &s.hdr)
+ stateSourceObject.Load(6, &s.viewToDeliver)
+ stateSourceObject.Load(7, &s.sequenceNumber)
+ stateSourceObject.Load(8, &s.ackNumber)
+ stateSourceObject.Load(9, &s.flags)
+ stateSourceObject.Load(10, &s.window)
+ stateSourceObject.Load(11, &s.csum)
+ stateSourceObject.Load(12, &s.csumValid)
+ stateSourceObject.Load(13, &s.parsedOptions)
+ stateSourceObject.Load(15, &s.hasNewSACKInfo)
+ stateSourceObject.Load(18, &s.xmitCount)
+ stateSourceObject.LoadValue(4, new(buffer.VectorisedView), func(y interface{}) { s.loadData(y.(buffer.VectorisedView)) })
+ stateSourceObject.LoadValue(14, new([]byte), func(y interface{}) { s.loadOptions(y.([]byte)) })
+ stateSourceObject.LoadValue(16, new(unixTime), func(y interface{}) { s.loadRcvdTime(y.(unixTime)) })
+ stateSourceObject.LoadValue(17, new(unixTime), func(y interface{}) { s.loadXmitTime(y.(unixTime)) })
+}
+
+func (s *segmentQueue) StateTypeName() string {
return "pkg/tcpip/transport/tcp.segmentQueue"
}
-func (x *segmentQueue) StateFields() []string {
+func (s *segmentQueue) StateFields() []string {
return []string{
"list",
"ep",
@@ -628,28 +628,28 @@ func (x *segmentQueue) StateFields() []string {
}
}
-func (x *segmentQueue) beforeSave() {}
+func (s *segmentQueue) beforeSave() {}
-func (x *segmentQueue) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.list)
- m.Save(1, &x.ep)
- m.Save(2, &x.frozen)
+func (s *segmentQueue) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.list)
+ stateSinkObject.Save(1, &s.ep)
+ stateSinkObject.Save(2, &s.frozen)
}
-func (x *segmentQueue) afterLoad() {}
+func (s *segmentQueue) afterLoad() {}
-func (x *segmentQueue) StateLoad(m state.Source) {
- m.LoadWait(0, &x.list)
- m.Load(1, &x.ep)
- m.Load(2, &x.frozen)
+func (s *segmentQueue) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadWait(0, &s.list)
+ stateSourceObject.Load(1, &s.ep)
+ stateSourceObject.Load(2, &s.frozen)
}
-func (x *sender) StateTypeName() string {
+func (s *sender) StateTypeName() string {
return "pkg/tcpip/transport/tcp.sender"
}
-func (x *sender) StateFields() []string {
+func (s *sender) StateFields() []string {
return []string{
"ep",
"lastSendTime",
@@ -683,82 +683,82 @@ func (x *sender) StateFields() []string {
}
}
-func (x *sender) beforeSave() {}
-
-func (x *sender) StateSave(m state.Sink) {
- x.beforeSave()
- var lastSendTime unixTime = x.saveLastSendTime()
- m.SaveValue(1, lastSendTime)
- var rttMeasureTime unixTime = x.saveRttMeasureTime()
- m.SaveValue(12, rttMeasureTime)
- var firstRetransmittedSegXmitTime unixTime = x.saveFirstRetransmittedSegXmitTime()
- m.SaveValue(13, firstRetransmittedSegXmitTime)
- m.Save(0, &x.ep)
- m.Save(2, &x.dupAckCount)
- m.Save(3, &x.fr)
- m.Save(4, &x.sndCwnd)
- m.Save(5, &x.sndSsthresh)
- m.Save(6, &x.sndCAAckCount)
- m.Save(7, &x.outstanding)
- m.Save(8, &x.sndWnd)
- m.Save(9, &x.sndUna)
- m.Save(10, &x.sndNxt)
- m.Save(11, &x.rttMeasureSeqNum)
- m.Save(14, &x.closed)
- m.Save(15, &x.writeNext)
- m.Save(16, &x.writeList)
- m.Save(17, &x.rtt)
- m.Save(18, &x.rto)
- m.Save(19, &x.minRTO)
- m.Save(20, &x.maxRTO)
- m.Save(21, &x.maxRetries)
- m.Save(22, &x.maxPayloadSize)
- m.Save(23, &x.gso)
- m.Save(24, &x.sndWndScale)
- m.Save(25, &x.maxSentAck)
- m.Save(26, &x.state)
- m.Save(27, &x.cc)
- m.Save(28, &x.rc)
-}
-
-func (x *sender) StateLoad(m state.Source) {
- m.Load(0, &x.ep)
- m.Load(2, &x.dupAckCount)
- m.Load(3, &x.fr)
- m.Load(4, &x.sndCwnd)
- m.Load(5, &x.sndSsthresh)
- m.Load(6, &x.sndCAAckCount)
- m.Load(7, &x.outstanding)
- m.Load(8, &x.sndWnd)
- m.Load(9, &x.sndUna)
- m.Load(10, &x.sndNxt)
- m.Load(11, &x.rttMeasureSeqNum)
- m.Load(14, &x.closed)
- m.Load(15, &x.writeNext)
- m.Load(16, &x.writeList)
- m.Load(17, &x.rtt)
- m.Load(18, &x.rto)
- m.Load(19, &x.minRTO)
- m.Load(20, &x.maxRTO)
- m.Load(21, &x.maxRetries)
- m.Load(22, &x.maxPayloadSize)
- m.Load(23, &x.gso)
- m.Load(24, &x.sndWndScale)
- m.Load(25, &x.maxSentAck)
- m.Load(26, &x.state)
- m.Load(27, &x.cc)
- m.Load(28, &x.rc)
- m.LoadValue(1, new(unixTime), func(y interface{}) { x.loadLastSendTime(y.(unixTime)) })
- m.LoadValue(12, new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
- m.LoadValue(13, new(unixTime), func(y interface{}) { x.loadFirstRetransmittedSegXmitTime(y.(unixTime)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *rtt) StateTypeName() string {
+func (s *sender) beforeSave() {}
+
+func (s *sender) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ var lastSendTimeValue unixTime = s.saveLastSendTime()
+ stateSinkObject.SaveValue(1, lastSendTimeValue)
+ var rttMeasureTimeValue unixTime = s.saveRttMeasureTime()
+ stateSinkObject.SaveValue(12, rttMeasureTimeValue)
+ var firstRetransmittedSegXmitTimeValue unixTime = s.saveFirstRetransmittedSegXmitTime()
+ stateSinkObject.SaveValue(13, firstRetransmittedSegXmitTimeValue)
+ stateSinkObject.Save(0, &s.ep)
+ stateSinkObject.Save(2, &s.dupAckCount)
+ stateSinkObject.Save(3, &s.fr)
+ stateSinkObject.Save(4, &s.sndCwnd)
+ stateSinkObject.Save(5, &s.sndSsthresh)
+ stateSinkObject.Save(6, &s.sndCAAckCount)
+ stateSinkObject.Save(7, &s.outstanding)
+ stateSinkObject.Save(8, &s.sndWnd)
+ stateSinkObject.Save(9, &s.sndUna)
+ stateSinkObject.Save(10, &s.sndNxt)
+ stateSinkObject.Save(11, &s.rttMeasureSeqNum)
+ stateSinkObject.Save(14, &s.closed)
+ stateSinkObject.Save(15, &s.writeNext)
+ stateSinkObject.Save(16, &s.writeList)
+ stateSinkObject.Save(17, &s.rtt)
+ stateSinkObject.Save(18, &s.rto)
+ stateSinkObject.Save(19, &s.minRTO)
+ stateSinkObject.Save(20, &s.maxRTO)
+ stateSinkObject.Save(21, &s.maxRetries)
+ stateSinkObject.Save(22, &s.maxPayloadSize)
+ stateSinkObject.Save(23, &s.gso)
+ stateSinkObject.Save(24, &s.sndWndScale)
+ stateSinkObject.Save(25, &s.maxSentAck)
+ stateSinkObject.Save(26, &s.state)
+ stateSinkObject.Save(27, &s.cc)
+ stateSinkObject.Save(28, &s.rc)
+}
+
+func (s *sender) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.ep)
+ stateSourceObject.Load(2, &s.dupAckCount)
+ stateSourceObject.Load(3, &s.fr)
+ stateSourceObject.Load(4, &s.sndCwnd)
+ stateSourceObject.Load(5, &s.sndSsthresh)
+ stateSourceObject.Load(6, &s.sndCAAckCount)
+ stateSourceObject.Load(7, &s.outstanding)
+ stateSourceObject.Load(8, &s.sndWnd)
+ stateSourceObject.Load(9, &s.sndUna)
+ stateSourceObject.Load(10, &s.sndNxt)
+ stateSourceObject.Load(11, &s.rttMeasureSeqNum)
+ stateSourceObject.Load(14, &s.closed)
+ stateSourceObject.Load(15, &s.writeNext)
+ stateSourceObject.Load(16, &s.writeList)
+ stateSourceObject.Load(17, &s.rtt)
+ stateSourceObject.Load(18, &s.rto)
+ stateSourceObject.Load(19, &s.minRTO)
+ stateSourceObject.Load(20, &s.maxRTO)
+ stateSourceObject.Load(21, &s.maxRetries)
+ stateSourceObject.Load(22, &s.maxPayloadSize)
+ stateSourceObject.Load(23, &s.gso)
+ stateSourceObject.Load(24, &s.sndWndScale)
+ stateSourceObject.Load(25, &s.maxSentAck)
+ stateSourceObject.Load(26, &s.state)
+ stateSourceObject.Load(27, &s.cc)
+ stateSourceObject.Load(28, &s.rc)
+ stateSourceObject.LoadValue(1, new(unixTime), func(y interface{}) { s.loadLastSendTime(y.(unixTime)) })
+ stateSourceObject.LoadValue(12, new(unixTime), func(y interface{}) { s.loadRttMeasureTime(y.(unixTime)) })
+ stateSourceObject.LoadValue(13, new(unixTime), func(y interface{}) { s.loadFirstRetransmittedSegXmitTime(y.(unixTime)) })
+ stateSourceObject.AfterLoad(s.afterLoad)
+}
+
+func (r *rtt) StateTypeName() string {
return "pkg/tcpip/transport/tcp.rtt"
}
-func (x *rtt) StateFields() []string {
+func (r *rtt) StateFields() []string {
return []string{
"srtt",
"rttvar",
@@ -766,28 +766,28 @@ func (x *rtt) StateFields() []string {
}
}
-func (x *rtt) beforeSave() {}
+func (r *rtt) beforeSave() {}
-func (x *rtt) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.srtt)
- m.Save(1, &x.rttvar)
- m.Save(2, &x.srttInited)
+func (r *rtt) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.srtt)
+ stateSinkObject.Save(1, &r.rttvar)
+ stateSinkObject.Save(2, &r.srttInited)
}
-func (x *rtt) afterLoad() {}
+func (r *rtt) afterLoad() {}
-func (x *rtt) StateLoad(m state.Source) {
- m.Load(0, &x.srtt)
- m.Load(1, &x.rttvar)
- m.Load(2, &x.srttInited)
+func (r *rtt) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.srtt)
+ stateSourceObject.Load(1, &r.rttvar)
+ stateSourceObject.Load(2, &r.srttInited)
}
-func (x *fastRecovery) StateTypeName() string {
+func (f *fastRecovery) StateTypeName() string {
return "pkg/tcpip/transport/tcp.fastRecovery"
}
-func (x *fastRecovery) StateFields() []string {
+func (f *fastRecovery) StateFields() []string {
return []string{
"active",
"first",
@@ -798,157 +798,157 @@ func (x *fastRecovery) StateFields() []string {
}
}
-func (x *fastRecovery) beforeSave() {}
+func (f *fastRecovery) beforeSave() {}
-func (x *fastRecovery) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.active)
- m.Save(1, &x.first)
- m.Save(2, &x.last)
- m.Save(3, &x.maxCwnd)
- m.Save(4, &x.highRxt)
- m.Save(5, &x.rescueRxt)
+func (f *fastRecovery) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.active)
+ stateSinkObject.Save(1, &f.first)
+ stateSinkObject.Save(2, &f.last)
+ stateSinkObject.Save(3, &f.maxCwnd)
+ stateSinkObject.Save(4, &f.highRxt)
+ stateSinkObject.Save(5, &f.rescueRxt)
}
-func (x *fastRecovery) afterLoad() {}
+func (f *fastRecovery) afterLoad() {}
-func (x *fastRecovery) StateLoad(m state.Source) {
- m.Load(0, &x.active)
- m.Load(1, &x.first)
- m.Load(2, &x.last)
- m.Load(3, &x.maxCwnd)
- m.Load(4, &x.highRxt)
- m.Load(5, &x.rescueRxt)
+func (f *fastRecovery) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.active)
+ stateSourceObject.Load(1, &f.first)
+ stateSourceObject.Load(2, &f.last)
+ stateSourceObject.Load(3, &f.maxCwnd)
+ stateSourceObject.Load(4, &f.highRxt)
+ stateSourceObject.Load(5, &f.rescueRxt)
}
-func (x *unixTime) StateTypeName() string {
+func (u *unixTime) StateTypeName() string {
return "pkg/tcpip/transport/tcp.unixTime"
}
-func (x *unixTime) StateFields() []string {
+func (u *unixTime) StateFields() []string {
return []string{
"second",
"nano",
}
}
-func (x *unixTime) beforeSave() {}
+func (u *unixTime) beforeSave() {}
-func (x *unixTime) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.second)
- m.Save(1, &x.nano)
+func (u *unixTime) StateSave(stateSinkObject state.Sink) {
+ u.beforeSave()
+ stateSinkObject.Save(0, &u.second)
+ stateSinkObject.Save(1, &u.nano)
}
-func (x *unixTime) afterLoad() {}
+func (u *unixTime) afterLoad() {}
-func (x *unixTime) StateLoad(m state.Source) {
- m.Load(0, &x.second)
- m.Load(1, &x.nano)
+func (u *unixTime) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &u.second)
+ stateSourceObject.Load(1, &u.nano)
}
-func (x *endpointList) StateTypeName() string {
+func (e *endpointList) StateTypeName() string {
return "pkg/tcpip/transport/tcp.endpointList"
}
-func (x *endpointList) StateFields() []string {
+func (e *endpointList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *endpointList) beforeSave() {}
+func (e *endpointList) beforeSave() {}
-func (x *endpointList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (e *endpointList) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ stateSinkObject.Save(0, &e.head)
+ stateSinkObject.Save(1, &e.tail)
}
-func (x *endpointList) afterLoad() {}
+func (e *endpointList) afterLoad() {}
-func (x *endpointList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (e *endpointList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.head)
+ stateSourceObject.Load(1, &e.tail)
}
-func (x *endpointEntry) StateTypeName() string {
+func (e *endpointEntry) StateTypeName() string {
return "pkg/tcpip/transport/tcp.endpointEntry"
}
-func (x *endpointEntry) StateFields() []string {
+func (e *endpointEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *endpointEntry) beforeSave() {}
+func (e *endpointEntry) beforeSave() {}
-func (x *endpointEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (e *endpointEntry) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ stateSinkObject.Save(0, &e.next)
+ stateSinkObject.Save(1, &e.prev)
}
-func (x *endpointEntry) afterLoad() {}
+func (e *endpointEntry) afterLoad() {}
-func (x *endpointEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (e *endpointEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.next)
+ stateSourceObject.Load(1, &e.prev)
}
-func (x *segmentList) StateTypeName() string {
+func (s *segmentList) StateTypeName() string {
return "pkg/tcpip/transport/tcp.segmentList"
}
-func (x *segmentList) StateFields() []string {
+func (s *segmentList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *segmentList) beforeSave() {}
+func (s *segmentList) beforeSave() {}
-func (x *segmentList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (s *segmentList) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.head)
+ stateSinkObject.Save(1, &s.tail)
}
-func (x *segmentList) afterLoad() {}
+func (s *segmentList) afterLoad() {}
-func (x *segmentList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (s *segmentList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.head)
+ stateSourceObject.Load(1, &s.tail)
}
-func (x *segmentEntry) StateTypeName() string {
+func (s *segmentEntry) StateTypeName() string {
return "pkg/tcpip/transport/tcp.segmentEntry"
}
-func (x *segmentEntry) StateFields() []string {
+func (s *segmentEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *segmentEntry) beforeSave() {}
+func (s *segmentEntry) beforeSave() {}
-func (x *segmentEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (s *segmentEntry) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.next)
+ stateSinkObject.Save(1, &s.prev)
}
-func (x *segmentEntry) afterLoad() {}
+func (s *segmentEntry) afterLoad() {}
-func (x *segmentEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (s *segmentEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.next)
+ stateSourceObject.Load(1, &s.prev)
}
func init() {
diff --git a/pkg/tcpip/transport/udp/udp_state_autogen.go b/pkg/tcpip/transport/udp/udp_state_autogen.go
index ce3b1df48..74cec739f 100644
--- a/pkg/tcpip/transport/udp/udp_state_autogen.go
+++ b/pkg/tcpip/transport/udp/udp_state_autogen.go
@@ -7,11 +7,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip/buffer"
)
-func (x *udpPacket) StateTypeName() string {
+func (u *udpPacket) StateTypeName() string {
return "pkg/tcpip/transport/udp.udpPacket"
}
-func (x *udpPacket) StateFields() []string {
+func (u *udpPacket) StateFields() []string {
return []string{
"udpPacketEntry",
"senderAddress",
@@ -22,35 +22,35 @@ func (x *udpPacket) StateFields() []string {
}
}
-func (x *udpPacket) beforeSave() {}
+func (u *udpPacket) beforeSave() {}
-func (x *udpPacket) StateSave(m state.Sink) {
- x.beforeSave()
- var data buffer.VectorisedView = x.saveData()
- m.SaveValue(3, data)
- m.Save(0, &x.udpPacketEntry)
- m.Save(1, &x.senderAddress)
- m.Save(2, &x.packetInfo)
- m.Save(4, &x.timestamp)
- m.Save(5, &x.tos)
+func (u *udpPacket) StateSave(stateSinkObject state.Sink) {
+ u.beforeSave()
+ var dataValue buffer.VectorisedView = u.saveData()
+ stateSinkObject.SaveValue(3, dataValue)
+ stateSinkObject.Save(0, &u.udpPacketEntry)
+ stateSinkObject.Save(1, &u.senderAddress)
+ stateSinkObject.Save(2, &u.packetInfo)
+ stateSinkObject.Save(4, &u.timestamp)
+ stateSinkObject.Save(5, &u.tos)
}
-func (x *udpPacket) afterLoad() {}
+func (u *udpPacket) afterLoad() {}
-func (x *udpPacket) StateLoad(m state.Source) {
- m.Load(0, &x.udpPacketEntry)
- m.Load(1, &x.senderAddress)
- m.Load(2, &x.packetInfo)
- m.Load(4, &x.timestamp)
- m.Load(5, &x.tos)
- m.LoadValue(3, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+func (u *udpPacket) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &u.udpPacketEntry)
+ stateSourceObject.Load(1, &u.senderAddress)
+ stateSourceObject.Load(2, &u.packetInfo)
+ stateSourceObject.Load(4, &u.timestamp)
+ stateSourceObject.Load(5, &u.tos)
+ stateSourceObject.LoadValue(3, new(buffer.VectorisedView), func(y interface{}) { u.loadData(y.(buffer.VectorisedView)) })
}
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
return "pkg/tcpip/transport/udp.endpoint"
}
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
return []string{
"TransportEndpointInfo",
"waiterQueue",
@@ -89,160 +89,160 @@ func (x *endpoint) StateFields() []string {
}
}
-func (x *endpoint) StateSave(m state.Sink) {
- x.beforeSave()
- var rcvBufSizeMax int = x.saveRcvBufSizeMax()
- m.SaveValue(5, rcvBufSizeMax)
- var lastError string = x.saveLastError()
- m.SaveValue(22, lastError)
- m.Save(0, &x.TransportEndpointInfo)
- m.Save(1, &x.waiterQueue)
- m.Save(2, &x.uniqueID)
- m.Save(3, &x.rcvReady)
- m.Save(4, &x.rcvList)
- m.Save(6, &x.rcvBufSize)
- m.Save(7, &x.rcvClosed)
- m.Save(8, &x.sndBufSize)
- m.Save(9, &x.sndBufSizeMax)
- m.Save(10, &x.state)
- m.Save(11, &x.dstPort)
- m.Save(12, &x.v6only)
- m.Save(13, &x.ttl)
- m.Save(14, &x.multicastTTL)
- m.Save(15, &x.multicastAddr)
- m.Save(16, &x.multicastNICID)
- m.Save(17, &x.multicastLoop)
- m.Save(18, &x.portFlags)
- m.Save(19, &x.bindToDevice)
- m.Save(20, &x.broadcast)
- m.Save(21, &x.noChecksum)
- m.Save(23, &x.boundBindToDevice)
- m.Save(24, &x.boundPortFlags)
- m.Save(25, &x.sendTOS)
- m.Save(26, &x.receiveTOS)
- m.Save(27, &x.receiveTClass)
- m.Save(28, &x.receiveIPPacketInfo)
- m.Save(29, &x.shutdownFlags)
- m.Save(30, &x.multicastMemberships)
- m.Save(31, &x.effectiveNetProtos)
- m.Save(32, &x.owner)
- m.Save(33, &x.linger)
-}
-
-func (x *endpoint) StateLoad(m state.Source) {
- m.Load(0, &x.TransportEndpointInfo)
- m.Load(1, &x.waiterQueue)
- m.Load(2, &x.uniqueID)
- m.Load(3, &x.rcvReady)
- m.Load(4, &x.rcvList)
- m.Load(6, &x.rcvBufSize)
- m.Load(7, &x.rcvClosed)
- m.Load(8, &x.sndBufSize)
- m.Load(9, &x.sndBufSizeMax)
- m.Load(10, &x.state)
- m.Load(11, &x.dstPort)
- m.Load(12, &x.v6only)
- m.Load(13, &x.ttl)
- m.Load(14, &x.multicastTTL)
- m.Load(15, &x.multicastAddr)
- m.Load(16, &x.multicastNICID)
- m.Load(17, &x.multicastLoop)
- m.Load(18, &x.portFlags)
- m.Load(19, &x.bindToDevice)
- m.Load(20, &x.broadcast)
- m.Load(21, &x.noChecksum)
- m.Load(23, &x.boundBindToDevice)
- m.Load(24, &x.boundPortFlags)
- m.Load(25, &x.sendTOS)
- m.Load(26, &x.receiveTOS)
- m.Load(27, &x.receiveTClass)
- m.Load(28, &x.receiveIPPacketInfo)
- m.Load(29, &x.shutdownFlags)
- m.Load(30, &x.multicastMemberships)
- m.Load(31, &x.effectiveNetProtos)
- m.Load(32, &x.owner)
- m.Load(33, &x.linger)
- m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
- m.LoadValue(22, new(string), func(y interface{}) { x.loadLastError(y.(string)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *multicastMembership) StateTypeName() string {
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ var rcvBufSizeMaxValue int = e.saveRcvBufSizeMax()
+ stateSinkObject.SaveValue(5, rcvBufSizeMaxValue)
+ var lastErrorValue string = e.saveLastError()
+ stateSinkObject.SaveValue(22, lastErrorValue)
+ stateSinkObject.Save(0, &e.TransportEndpointInfo)
+ stateSinkObject.Save(1, &e.waiterQueue)
+ stateSinkObject.Save(2, &e.uniqueID)
+ stateSinkObject.Save(3, &e.rcvReady)
+ stateSinkObject.Save(4, &e.rcvList)
+ stateSinkObject.Save(6, &e.rcvBufSize)
+ stateSinkObject.Save(7, &e.rcvClosed)
+ stateSinkObject.Save(8, &e.sndBufSize)
+ stateSinkObject.Save(9, &e.sndBufSizeMax)
+ stateSinkObject.Save(10, &e.state)
+ stateSinkObject.Save(11, &e.dstPort)
+ stateSinkObject.Save(12, &e.v6only)
+ stateSinkObject.Save(13, &e.ttl)
+ stateSinkObject.Save(14, &e.multicastTTL)
+ stateSinkObject.Save(15, &e.multicastAddr)
+ stateSinkObject.Save(16, &e.multicastNICID)
+ stateSinkObject.Save(17, &e.multicastLoop)
+ stateSinkObject.Save(18, &e.portFlags)
+ stateSinkObject.Save(19, &e.bindToDevice)
+ stateSinkObject.Save(20, &e.broadcast)
+ stateSinkObject.Save(21, &e.noChecksum)
+ stateSinkObject.Save(23, &e.boundBindToDevice)
+ stateSinkObject.Save(24, &e.boundPortFlags)
+ stateSinkObject.Save(25, &e.sendTOS)
+ stateSinkObject.Save(26, &e.receiveTOS)
+ stateSinkObject.Save(27, &e.receiveTClass)
+ stateSinkObject.Save(28, &e.receiveIPPacketInfo)
+ stateSinkObject.Save(29, &e.shutdownFlags)
+ stateSinkObject.Save(30, &e.multicastMemberships)
+ stateSinkObject.Save(31, &e.effectiveNetProtos)
+ stateSinkObject.Save(32, &e.owner)
+ stateSinkObject.Save(33, &e.linger)
+}
+
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.TransportEndpointInfo)
+ stateSourceObject.Load(1, &e.waiterQueue)
+ stateSourceObject.Load(2, &e.uniqueID)
+ stateSourceObject.Load(3, &e.rcvReady)
+ stateSourceObject.Load(4, &e.rcvList)
+ stateSourceObject.Load(6, &e.rcvBufSize)
+ stateSourceObject.Load(7, &e.rcvClosed)
+ stateSourceObject.Load(8, &e.sndBufSize)
+ stateSourceObject.Load(9, &e.sndBufSizeMax)
+ stateSourceObject.Load(10, &e.state)
+ stateSourceObject.Load(11, &e.dstPort)
+ stateSourceObject.Load(12, &e.v6only)
+ stateSourceObject.Load(13, &e.ttl)
+ stateSourceObject.Load(14, &e.multicastTTL)
+ stateSourceObject.Load(15, &e.multicastAddr)
+ stateSourceObject.Load(16, &e.multicastNICID)
+ stateSourceObject.Load(17, &e.multicastLoop)
+ stateSourceObject.Load(18, &e.portFlags)
+ stateSourceObject.Load(19, &e.bindToDevice)
+ stateSourceObject.Load(20, &e.broadcast)
+ stateSourceObject.Load(21, &e.noChecksum)
+ stateSourceObject.Load(23, &e.boundBindToDevice)
+ stateSourceObject.Load(24, &e.boundPortFlags)
+ stateSourceObject.Load(25, &e.sendTOS)
+ stateSourceObject.Load(26, &e.receiveTOS)
+ stateSourceObject.Load(27, &e.receiveTClass)
+ stateSourceObject.Load(28, &e.receiveIPPacketInfo)
+ stateSourceObject.Load(29, &e.shutdownFlags)
+ stateSourceObject.Load(30, &e.multicastMemberships)
+ stateSourceObject.Load(31, &e.effectiveNetProtos)
+ stateSourceObject.Load(32, &e.owner)
+ stateSourceObject.Load(33, &e.linger)
+ stateSourceObject.LoadValue(5, new(int), func(y interface{}) { e.loadRcvBufSizeMax(y.(int)) })
+ stateSourceObject.LoadValue(22, new(string), func(y interface{}) { e.loadLastError(y.(string)) })
+ stateSourceObject.AfterLoad(e.afterLoad)
+}
+
+func (m *multicastMembership) StateTypeName() string {
return "pkg/tcpip/transport/udp.multicastMembership"
}
-func (x *multicastMembership) StateFields() []string {
+func (m *multicastMembership) StateFields() []string {
return []string{
"nicID",
"multicastAddr",
}
}
-func (x *multicastMembership) beforeSave() {}
+func (m *multicastMembership) beforeSave() {}
-func (x *multicastMembership) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.nicID)
- m.Save(1, &x.multicastAddr)
+func (m *multicastMembership) StateSave(stateSinkObject state.Sink) {
+ m.beforeSave()
+ stateSinkObject.Save(0, &m.nicID)
+ stateSinkObject.Save(1, &m.multicastAddr)
}
-func (x *multicastMembership) afterLoad() {}
+func (m *multicastMembership) afterLoad() {}
-func (x *multicastMembership) StateLoad(m state.Source) {
- m.Load(0, &x.nicID)
- m.Load(1, &x.multicastAddr)
+func (m *multicastMembership) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &m.nicID)
+ stateSourceObject.Load(1, &m.multicastAddr)
}
-func (x *udpPacketList) StateTypeName() string {
+func (u *udpPacketList) StateTypeName() string {
return "pkg/tcpip/transport/udp.udpPacketList"
}
-func (x *udpPacketList) StateFields() []string {
+func (u *udpPacketList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *udpPacketList) beforeSave() {}
+func (u *udpPacketList) beforeSave() {}
-func (x *udpPacketList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (u *udpPacketList) StateSave(stateSinkObject state.Sink) {
+ u.beforeSave()
+ stateSinkObject.Save(0, &u.head)
+ stateSinkObject.Save(1, &u.tail)
}
-func (x *udpPacketList) afterLoad() {}
+func (u *udpPacketList) afterLoad() {}
-func (x *udpPacketList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (u *udpPacketList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &u.head)
+ stateSourceObject.Load(1, &u.tail)
}
-func (x *udpPacketEntry) StateTypeName() string {
+func (u *udpPacketEntry) StateTypeName() string {
return "pkg/tcpip/transport/udp.udpPacketEntry"
}
-func (x *udpPacketEntry) StateFields() []string {
+func (u *udpPacketEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *udpPacketEntry) beforeSave() {}
+func (u *udpPacketEntry) beforeSave() {}
-func (x *udpPacketEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (u *udpPacketEntry) StateSave(stateSinkObject state.Sink) {
+ u.beforeSave()
+ stateSinkObject.Save(0, &u.next)
+ stateSinkObject.Save(1, &u.prev)
}
-func (x *udpPacketEntry) afterLoad() {}
+func (u *udpPacketEntry) afterLoad() {}
-func (x *udpPacketEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (u *udpPacketEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &u.next)
+ stateSourceObject.Load(1, &u.prev)
}
func init() {