diff options
author | gVisor bot <gvisor-bot@google.com> | 2020-10-08 01:32:17 +0000 |
---|---|---|
committer | gVisor bot <gvisor-bot@google.com> | 2020-10-08 01:32:17 +0000 |
commit | 8f70c8003e9d132fc766ed7d92ce805c093d518b (patch) | |
tree | 6d77a3246e3f04605790d410e7630cb910704ced /pkg/tcpip/transport | |
parent | 8f9d99c812b7599c52ed98f80c1a33717758a5c6 (diff) | |
parent | a55bd73d4802112a7055de8663e947b9c0f42a2e (diff) |
Merge release-20200928.0-66-ga55bd73d4 (automated)
Diffstat (limited to 'pkg/tcpip/transport')
-rw-r--r-- | pkg/tcpip/transport/icmp/icmp_state_autogen.go | 154 | ||||
-rw-r--r-- | pkg/tcpip/transport/packet/packet_state_autogen.go | 164 | ||||
-rw-r--r-- | pkg/tcpip/transport/raw/raw_state_autogen.go | 158 | ||||
-rw-r--r-- | pkg/tcpip/transport/tcp/tcp_state_autogen.go | 1050 | ||||
-rw-r--r-- | pkg/tcpip/transport/udp/udp_state_autogen.go | 266 |
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() { |