| // automatically generated by stateify. |
| |
| package tcp |
| |
| import ( |
| "gvisor.dev/gvisor/pkg/state" |
| "gvisor.dev/gvisor/pkg/tcpip/buffer" |
| ) |
| |
| func (c *cubicState) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.cubicState" |
| } |
| |
| func (c *cubicState) StateFields() []string { |
| return []string{ |
| "wLastMax", |
| "wMax", |
| "t", |
| "numCongestionEvents", |
| "c", |
| "k", |
| "beta", |
| "wC", |
| "wEst", |
| "s", |
| } |
| } |
| |
| func (c *cubicState) beforeSave() {} |
| |
| // +checklocksignore |
| 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 (c *cubicState) afterLoad() {} |
| |
| // +checklocksignore |
| 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 (s *SACKInfo) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.SACKInfo" |
| } |
| |
| func (s *SACKInfo) StateFields() []string { |
| return []string{ |
| "Blocks", |
| "NumBlocks", |
| } |
| } |
| |
| func (s *SACKInfo) beforeSave() {} |
| |
| // +checklocksignore |
| func (s *SACKInfo) StateSave(stateSinkObject state.Sink) { |
| s.beforeSave() |
| stateSinkObject.Save(0, &s.Blocks) |
| stateSinkObject.Save(1, &s.NumBlocks) |
| } |
| |
| func (s *SACKInfo) afterLoad() {} |
| |
| // +checklocksignore |
| func (s *SACKInfo) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &s.Blocks) |
| stateSourceObject.Load(1, &s.NumBlocks) |
| } |
| |
| func (r *rcvBufAutoTuneParams) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.rcvBufAutoTuneParams" |
| } |
| |
| func (r *rcvBufAutoTuneParams) StateFields() []string { |
| return []string{ |
| "measureTime", |
| "copied", |
| "prevCopied", |
| "rtt", |
| "rttMeasureSeqNumber", |
| "rttMeasureTime", |
| "disabled", |
| } |
| } |
| |
| func (r *rcvBufAutoTuneParams) beforeSave() {} |
| |
| // +checklocksignore |
| 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 (r *rcvBufAutoTuneParams) afterLoad() {} |
| |
| // +checklocksignore |
| 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 (e *EndpointInfo) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.EndpointInfo" |
| } |
| |
| func (e *EndpointInfo) StateFields() []string { |
| return []string{ |
| "TransportEndpointInfo", |
| } |
| } |
| |
| func (e *EndpointInfo) beforeSave() {} |
| |
| // +checklocksignore |
| func (e *EndpointInfo) StateSave(stateSinkObject state.Sink) { |
| e.beforeSave() |
| stateSinkObject.Save(0, &e.TransportEndpointInfo) |
| } |
| |
| func (e *EndpointInfo) afterLoad() {} |
| |
| // +checklocksignore |
| func (e *EndpointInfo) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &e.TransportEndpointInfo) |
| } |
| |
| func (e *endpoint) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.endpoint" |
| } |
| |
| func (e *endpoint) StateFields() []string { |
| return []string{ |
| "EndpointInfo", |
| "DefaultSocketOptionsHandler", |
| "waiterQueue", |
| "uniqueID", |
| "hardError", |
| "lastError", |
| "rcvList", |
| "rcvClosed", |
| "rcvBufSize", |
| "rcvBufUsed", |
| "rcvAutoParams", |
| "rcvMemUsed", |
| "ownedByUser", |
| "state", |
| "boundNICID", |
| "ttl", |
| "isConnectNotified", |
| "portFlags", |
| "boundBindToDevice", |
| "boundPortFlags", |
| "boundDest", |
| "effectiveNetProtos", |
| "workerRunning", |
| "workerCleanup", |
| "sendTSOk", |
| "recentTS", |
| "recentTSTime", |
| "tsOffset", |
| "shutdownFlags", |
| "tcpRecovery", |
| "sackPermitted", |
| "sack", |
| "delay", |
| "scoreboard", |
| "segmentQueue", |
| "synRcvdCount", |
| "userMSS", |
| "maxSynRetries", |
| "windowClamp", |
| "sndBufUsed", |
| "sndClosed", |
| "sndBufInQueue", |
| "sndQueue", |
| "cc", |
| "packetTooBigCount", |
| "sndMTU", |
| "keepalive", |
| "userTimeout", |
| "deferAccept", |
| "acceptedChan", |
| "rcv", |
| "snd", |
| "connectingAddress", |
| "amss", |
| "sendTOS", |
| "gso", |
| "tcpLingerTimeout", |
| "closed", |
| "txHash", |
| "owner", |
| "ops", |
| "lastOutOfWindowAckTime", |
| } |
| } |
| |
| // +checklocksignore |
| func (e *endpoint) StateSave(stateSinkObject state.Sink) { |
| e.beforeSave() |
| var stateValue EndpointState = e.saveState() |
| stateSinkObject.SaveValue(13, stateValue) |
| var recentTSTimeValue unixTime = e.saveRecentTSTime() |
| stateSinkObject.SaveValue(26, recentTSTimeValue) |
| var acceptedChanValue []*endpoint = e.saveAcceptedChan() |
| stateSinkObject.SaveValue(49, acceptedChanValue) |
| var lastOutOfWindowAckTimeValue unixTime = e.saveLastOutOfWindowAckTime() |
| stateSinkObject.SaveValue(61, lastOutOfWindowAckTimeValue) |
| stateSinkObject.Save(0, &e.EndpointInfo) |
| stateSinkObject.Save(1, &e.DefaultSocketOptionsHandler) |
| stateSinkObject.Save(2, &e.waiterQueue) |
| stateSinkObject.Save(3, &e.uniqueID) |
| stateSinkObject.Save(4, &e.hardError) |
| stateSinkObject.Save(5, &e.lastError) |
| stateSinkObject.Save(6, &e.rcvList) |
| stateSinkObject.Save(7, &e.rcvClosed) |
| stateSinkObject.Save(8, &e.rcvBufSize) |
| stateSinkObject.Save(9, &e.rcvBufUsed) |
| stateSinkObject.Save(10, &e.rcvAutoParams) |
| stateSinkObject.Save(11, &e.rcvMemUsed) |
| stateSinkObject.Save(12, &e.ownedByUser) |
| stateSinkObject.Save(14, &e.boundNICID) |
| stateSinkObject.Save(15, &e.ttl) |
| stateSinkObject.Save(16, &e.isConnectNotified) |
| 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.tcpRecovery) |
| stateSinkObject.Save(30, &e.sackPermitted) |
| stateSinkObject.Save(31, &e.sack) |
| stateSinkObject.Save(32, &e.delay) |
| stateSinkObject.Save(33, &e.scoreboard) |
| stateSinkObject.Save(34, &e.segmentQueue) |
| stateSinkObject.Save(35, &e.synRcvdCount) |
| stateSinkObject.Save(36, &e.userMSS) |
| stateSinkObject.Save(37, &e.maxSynRetries) |
| stateSinkObject.Save(38, &e.windowClamp) |
| stateSinkObject.Save(39, &e.sndBufUsed) |
| stateSinkObject.Save(40, &e.sndClosed) |
| stateSinkObject.Save(41, &e.sndBufInQueue) |
| stateSinkObject.Save(42, &e.sndQueue) |
| stateSinkObject.Save(43, &e.cc) |
| stateSinkObject.Save(44, &e.packetTooBigCount) |
| stateSinkObject.Save(45, &e.sndMTU) |
| stateSinkObject.Save(46, &e.keepalive) |
| stateSinkObject.Save(47, &e.userTimeout) |
| stateSinkObject.Save(48, &e.deferAccept) |
| stateSinkObject.Save(50, &e.rcv) |
| stateSinkObject.Save(51, &e.snd) |
| stateSinkObject.Save(52, &e.connectingAddress) |
| stateSinkObject.Save(53, &e.amss) |
| stateSinkObject.Save(54, &e.sendTOS) |
| stateSinkObject.Save(55, &e.gso) |
| stateSinkObject.Save(56, &e.tcpLingerTimeout) |
| stateSinkObject.Save(57, &e.closed) |
| stateSinkObject.Save(58, &e.txHash) |
| stateSinkObject.Save(59, &e.owner) |
| stateSinkObject.Save(60, &e.ops) |
| } |
| |
| // +checklocksignore |
| func (e *endpoint) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &e.EndpointInfo) |
| stateSourceObject.Load(1, &e.DefaultSocketOptionsHandler) |
| stateSourceObject.LoadWait(2, &e.waiterQueue) |
| stateSourceObject.Load(3, &e.uniqueID) |
| stateSourceObject.Load(4, &e.hardError) |
| stateSourceObject.Load(5, &e.lastError) |
| stateSourceObject.LoadWait(6, &e.rcvList) |
| stateSourceObject.Load(7, &e.rcvClosed) |
| stateSourceObject.Load(8, &e.rcvBufSize) |
| stateSourceObject.Load(9, &e.rcvBufUsed) |
| stateSourceObject.Load(10, &e.rcvAutoParams) |
| stateSourceObject.Load(11, &e.rcvMemUsed) |
| stateSourceObject.Load(12, &e.ownedByUser) |
| stateSourceObject.Load(14, &e.boundNICID) |
| stateSourceObject.Load(15, &e.ttl) |
| stateSourceObject.Load(16, &e.isConnectNotified) |
| 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.tcpRecovery) |
| stateSourceObject.Load(30, &e.sackPermitted) |
| stateSourceObject.Load(31, &e.sack) |
| stateSourceObject.Load(32, &e.delay) |
| stateSourceObject.Load(33, &e.scoreboard) |
| stateSourceObject.LoadWait(34, &e.segmentQueue) |
| stateSourceObject.Load(35, &e.synRcvdCount) |
| stateSourceObject.Load(36, &e.userMSS) |
| stateSourceObject.Load(37, &e.maxSynRetries) |
| stateSourceObject.Load(38, &e.windowClamp) |
| stateSourceObject.Load(39, &e.sndBufUsed) |
| stateSourceObject.Load(40, &e.sndClosed) |
| stateSourceObject.Load(41, &e.sndBufInQueue) |
| stateSourceObject.LoadWait(42, &e.sndQueue) |
| stateSourceObject.Load(43, &e.cc) |
| stateSourceObject.Load(44, &e.packetTooBigCount) |
| stateSourceObject.Load(45, &e.sndMTU) |
| stateSourceObject.Load(46, &e.keepalive) |
| stateSourceObject.Load(47, &e.userTimeout) |
| stateSourceObject.Load(48, &e.deferAccept) |
| stateSourceObject.LoadWait(50, &e.rcv) |
| stateSourceObject.LoadWait(51, &e.snd) |
| stateSourceObject.Load(52, &e.connectingAddress) |
| stateSourceObject.Load(53, &e.amss) |
| stateSourceObject.Load(54, &e.sendTOS) |
| stateSourceObject.Load(55, &e.gso) |
| stateSourceObject.Load(56, &e.tcpLingerTimeout) |
| stateSourceObject.Load(57, &e.closed) |
| stateSourceObject.Load(58, &e.txHash) |
| stateSourceObject.Load(59, &e.owner) |
| stateSourceObject.Load(60, &e.ops) |
| stateSourceObject.LoadValue(13, new(EndpointState), func(y interface{}) { e.loadState(y.(EndpointState)) }) |
| stateSourceObject.LoadValue(26, new(unixTime), func(y interface{}) { e.loadRecentTSTime(y.(unixTime)) }) |
| stateSourceObject.LoadValue(49, new([]*endpoint), func(y interface{}) { e.loadAcceptedChan(y.([]*endpoint)) }) |
| stateSourceObject.LoadValue(61, new(unixTime), func(y interface{}) { e.loadLastOutOfWindowAckTime(y.(unixTime)) }) |
| stateSourceObject.AfterLoad(e.afterLoad) |
| } |
| |
| func (k *keepalive) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.keepalive" |
| } |
| |
| func (k *keepalive) StateFields() []string { |
| return []string{ |
| "idle", |
| "interval", |
| "count", |
| "unacked", |
| } |
| } |
| |
| func (k *keepalive) beforeSave() {} |
| |
| // +checklocksignore |
| func (k *keepalive) StateSave(stateSinkObject state.Sink) { |
| k.beforeSave() |
| stateSinkObject.Save(0, &k.idle) |
| stateSinkObject.Save(1, &k.interval) |
| stateSinkObject.Save(2, &k.count) |
| stateSinkObject.Save(3, &k.unacked) |
| } |
| |
| func (k *keepalive) afterLoad() {} |
| |
| // +checklocksignore |
| func (k *keepalive) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &k.idle) |
| stateSourceObject.Load(1, &k.interval) |
| stateSourceObject.Load(2, &k.count) |
| stateSourceObject.Load(3, &k.unacked) |
| } |
| |
| func (rc *rackControl) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.rackControl" |
| } |
| |
| func (rc *rackControl) StateFields() []string { |
| return []string{ |
| "dsackSeen", |
| "endSequence", |
| "exitedRecovery", |
| "fack", |
| "minRTT", |
| "reorderSeen", |
| "reoWnd", |
| "reoWndIncr", |
| "reoWndPersist", |
| "rtt", |
| "rttSeq", |
| "xmitTime", |
| "tlpRxtOut", |
| "tlpHighRxt", |
| "snd", |
| } |
| } |
| |
| func (rc *rackControl) beforeSave() {} |
| |
| // +checklocksignore |
| func (rc *rackControl) StateSave(stateSinkObject state.Sink) { |
| rc.beforeSave() |
| var xmitTimeValue unixTime = rc.saveXmitTime() |
| stateSinkObject.SaveValue(11, xmitTimeValue) |
| stateSinkObject.Save(0, &rc.dsackSeen) |
| stateSinkObject.Save(1, &rc.endSequence) |
| stateSinkObject.Save(2, &rc.exitedRecovery) |
| stateSinkObject.Save(3, &rc.fack) |
| stateSinkObject.Save(4, &rc.minRTT) |
| stateSinkObject.Save(5, &rc.reorderSeen) |
| stateSinkObject.Save(6, &rc.reoWnd) |
| stateSinkObject.Save(7, &rc.reoWndIncr) |
| stateSinkObject.Save(8, &rc.reoWndPersist) |
| stateSinkObject.Save(9, &rc.rtt) |
| stateSinkObject.Save(10, &rc.rttSeq) |
| stateSinkObject.Save(12, &rc.tlpRxtOut) |
| stateSinkObject.Save(13, &rc.tlpHighRxt) |
| stateSinkObject.Save(14, &rc.snd) |
| } |
| |
| func (rc *rackControl) afterLoad() {} |
| |
| // +checklocksignore |
| func (rc *rackControl) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &rc.dsackSeen) |
| stateSourceObject.Load(1, &rc.endSequence) |
| stateSourceObject.Load(2, &rc.exitedRecovery) |
| stateSourceObject.Load(3, &rc.fack) |
| stateSourceObject.Load(4, &rc.minRTT) |
| stateSourceObject.Load(5, &rc.reorderSeen) |
| stateSourceObject.Load(6, &rc.reoWnd) |
| stateSourceObject.Load(7, &rc.reoWndIncr) |
| stateSourceObject.Load(8, &rc.reoWndPersist) |
| stateSourceObject.Load(9, &rc.rtt) |
| stateSourceObject.Load(10, &rc.rttSeq) |
| stateSourceObject.Load(12, &rc.tlpRxtOut) |
| stateSourceObject.Load(13, &rc.tlpHighRxt) |
| stateSourceObject.Load(14, &rc.snd) |
| stateSourceObject.LoadValue(11, new(unixTime), func(y interface{}) { rc.loadXmitTime(y.(unixTime)) }) |
| } |
| |
| func (r *receiver) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.receiver" |
| } |
| |
| func (r *receiver) StateFields() []string { |
| return []string{ |
| "ep", |
| "rcvNxt", |
| "rcvAcc", |
| "rcvWnd", |
| "rcvWUP", |
| "rcvWndScale", |
| "prevBufUsed", |
| "closed", |
| "pendingRcvdSegments", |
| "pendingBufUsed", |
| "lastRcvdAckTime", |
| } |
| } |
| |
| func (r *receiver) beforeSave() {} |
| |
| // +checklocksignore |
| func (r *receiver) StateSave(stateSinkObject state.Sink) { |
| r.beforeSave() |
| var lastRcvdAckTimeValue unixTime = r.saveLastRcvdAckTime() |
| stateSinkObject.SaveValue(10, 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.rcvWUP) |
| stateSinkObject.Save(5, &r.rcvWndScale) |
| stateSinkObject.Save(6, &r.prevBufUsed) |
| stateSinkObject.Save(7, &r.closed) |
| stateSinkObject.Save(8, &r.pendingRcvdSegments) |
| stateSinkObject.Save(9, &r.pendingBufUsed) |
| } |
| |
| func (r *receiver) afterLoad() {} |
| |
| // +checklocksignore |
| 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.rcvWUP) |
| stateSourceObject.Load(5, &r.rcvWndScale) |
| stateSourceObject.Load(6, &r.prevBufUsed) |
| stateSourceObject.Load(7, &r.closed) |
| stateSourceObject.Load(8, &r.pendingRcvdSegments) |
| stateSourceObject.Load(9, &r.pendingBufUsed) |
| stateSourceObject.LoadValue(10, new(unixTime), func(y interface{}) { r.loadLastRcvdAckTime(y.(unixTime)) }) |
| } |
| |
| func (r *renoState) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.renoState" |
| } |
| |
| func (r *renoState) StateFields() []string { |
| return []string{ |
| "s", |
| } |
| } |
| |
| func (r *renoState) beforeSave() {} |
| |
| // +checklocksignore |
| func (r *renoState) StateSave(stateSinkObject state.Sink) { |
| r.beforeSave() |
| stateSinkObject.Save(0, &r.s) |
| } |
| |
| func (r *renoState) afterLoad() {} |
| |
| // +checklocksignore |
| func (r *renoState) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &r.s) |
| } |
| |
| func (rr *renoRecovery) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.renoRecovery" |
| } |
| |
| func (rr *renoRecovery) StateFields() []string { |
| return []string{ |
| "s", |
| } |
| } |
| |
| func (rr *renoRecovery) beforeSave() {} |
| |
| // +checklocksignore |
| func (rr *renoRecovery) StateSave(stateSinkObject state.Sink) { |
| rr.beforeSave() |
| stateSinkObject.Save(0, &rr.s) |
| } |
| |
| func (rr *renoRecovery) afterLoad() {} |
| |
| // +checklocksignore |
| func (rr *renoRecovery) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &rr.s) |
| } |
| |
| func (sr *sackRecovery) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.sackRecovery" |
| } |
| |
| func (sr *sackRecovery) StateFields() []string { |
| return []string{ |
| "s", |
| } |
| } |
| |
| func (sr *sackRecovery) beforeSave() {} |
| |
| // +checklocksignore |
| func (sr *sackRecovery) StateSave(stateSinkObject state.Sink) { |
| sr.beforeSave() |
| stateSinkObject.Save(0, &sr.s) |
| } |
| |
| func (sr *sackRecovery) afterLoad() {} |
| |
| // +checklocksignore |
| func (sr *sackRecovery) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &sr.s) |
| } |
| |
| func (s *SACKScoreboard) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.SACKScoreboard" |
| } |
| |
| func (s *SACKScoreboard) StateFields() []string { |
| return []string{ |
| "smss", |
| "maxSACKED", |
| } |
| } |
| |
| func (s *SACKScoreboard) beforeSave() {} |
| |
| // +checklocksignore |
| func (s *SACKScoreboard) StateSave(stateSinkObject state.Sink) { |
| s.beforeSave() |
| stateSinkObject.Save(0, &s.smss) |
| stateSinkObject.Save(1, &s.maxSACKED) |
| } |
| |
| func (s *SACKScoreboard) afterLoad() {} |
| |
| // +checklocksignore |
| func (s *SACKScoreboard) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &s.smss) |
| stateSourceObject.Load(1, &s.maxSACKED) |
| } |
| |
| func (s *segment) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.segment" |
| } |
| |
| func (s *segment) StateFields() []string { |
| return []string{ |
| "segmentEntry", |
| "refCnt", |
| "ep", |
| "qFlags", |
| "srcAddr", |
| "dstAddr", |
| "netProto", |
| "nicID", |
| "data", |
| "hdr", |
| "sequenceNumber", |
| "ackNumber", |
| "flags", |
| "window", |
| "csum", |
| "csumValid", |
| "parsedOptions", |
| "options", |
| "hasNewSACKInfo", |
| "rcvdTime", |
| "xmitTime", |
| "xmitCount", |
| "acked", |
| "dataMemSize", |
| "lost", |
| } |
| } |
| |
| func (s *segment) beforeSave() {} |
| |
| // +checklocksignore |
| func (s *segment) StateSave(stateSinkObject state.Sink) { |
| s.beforeSave() |
| var dataValue buffer.VectorisedView = s.saveData() |
| stateSinkObject.SaveValue(8, dataValue) |
| var optionsValue []byte = s.saveOptions() |
| stateSinkObject.SaveValue(17, optionsValue) |
| var rcvdTimeValue unixTime = s.saveRcvdTime() |
| stateSinkObject.SaveValue(19, rcvdTimeValue) |
| var xmitTimeValue unixTime = s.saveXmitTime() |
| stateSinkObject.SaveValue(20, xmitTimeValue) |
| stateSinkObject.Save(0, &s.segmentEntry) |
| stateSinkObject.Save(1, &s.refCnt) |
| stateSinkObject.Save(2, &s.ep) |
| stateSinkObject.Save(3, &s.qFlags) |
| stateSinkObject.Save(4, &s.srcAddr) |
| stateSinkObject.Save(5, &s.dstAddr) |
| stateSinkObject.Save(6, &s.netProto) |
| stateSinkObject.Save(7, &s.nicID) |
| stateSinkObject.Save(9, &s.hdr) |
| stateSinkObject.Save(10, &s.sequenceNumber) |
| stateSinkObject.Save(11, &s.ackNumber) |
| stateSinkObject.Save(12, &s.flags) |
| stateSinkObject.Save(13, &s.window) |
| stateSinkObject.Save(14, &s.csum) |
| stateSinkObject.Save(15, &s.csumValid) |
| stateSinkObject.Save(16, &s.parsedOptions) |
| stateSinkObject.Save(18, &s.hasNewSACKInfo) |
| stateSinkObject.Save(21, &s.xmitCount) |
| stateSinkObject.Save(22, &s.acked) |
| stateSinkObject.Save(23, &s.dataMemSize) |
| stateSinkObject.Save(24, &s.lost) |
| } |
| |
| func (s *segment) afterLoad() {} |
| |
| // +checklocksignore |
| 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(4, &s.srcAddr) |
| stateSourceObject.Load(5, &s.dstAddr) |
| stateSourceObject.Load(6, &s.netProto) |
| stateSourceObject.Load(7, &s.nicID) |
| stateSourceObject.Load(9, &s.hdr) |
| stateSourceObject.Load(10, &s.sequenceNumber) |
| stateSourceObject.Load(11, &s.ackNumber) |
| stateSourceObject.Load(12, &s.flags) |
| stateSourceObject.Load(13, &s.window) |
| stateSourceObject.Load(14, &s.csum) |
| stateSourceObject.Load(15, &s.csumValid) |
| stateSourceObject.Load(16, &s.parsedOptions) |
| stateSourceObject.Load(18, &s.hasNewSACKInfo) |
| stateSourceObject.Load(21, &s.xmitCount) |
| stateSourceObject.Load(22, &s.acked) |
| stateSourceObject.Load(23, &s.dataMemSize) |
| stateSourceObject.Load(24, &s.lost) |
| stateSourceObject.LoadValue(8, new(buffer.VectorisedView), func(y interface{}) { s.loadData(y.(buffer.VectorisedView)) }) |
| stateSourceObject.LoadValue(17, new([]byte), func(y interface{}) { s.loadOptions(y.([]byte)) }) |
| stateSourceObject.LoadValue(19, new(unixTime), func(y interface{}) { s.loadRcvdTime(y.(unixTime)) }) |
| stateSourceObject.LoadValue(20, new(unixTime), func(y interface{}) { s.loadXmitTime(y.(unixTime)) }) |
| } |
| |
| func (q *segmentQueue) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.segmentQueue" |
| } |
| |
| func (q *segmentQueue) StateFields() []string { |
| return []string{ |
| "list", |
| "ep", |
| "frozen", |
| } |
| } |
| |
| func (q *segmentQueue) beforeSave() {} |
| |
| // +checklocksignore |
| func (q *segmentQueue) StateSave(stateSinkObject state.Sink) { |
| q.beforeSave() |
| stateSinkObject.Save(0, &q.list) |
| stateSinkObject.Save(1, &q.ep) |
| stateSinkObject.Save(2, &q.frozen) |
| } |
| |
| func (q *segmentQueue) afterLoad() {} |
| |
| // +checklocksignore |
| func (q *segmentQueue) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.LoadWait(0, &q.list) |
| stateSourceObject.Load(1, &q.ep) |
| stateSourceObject.Load(2, &q.frozen) |
| } |
| |
| func (s *sender) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.sender" |
| } |
| |
| func (s *sender) StateFields() []string { |
| return []string{ |
| "ep", |
| "lastSendTime", |
| "dupAckCount", |
| "fr", |
| "lr", |
| "sndCwnd", |
| "sndSsthresh", |
| "sndCAAckCount", |
| "outstanding", |
| "sackedOut", |
| "sndWnd", |
| "sndUna", |
| "sndNxt", |
| "rttMeasureSeqNum", |
| "rttMeasureTime", |
| "firstRetransmittedSegXmitTime", |
| "closed", |
| "writeNext", |
| "writeList", |
| "rtt", |
| "rto", |
| "minRTO", |
| "maxRTO", |
| "maxRetries", |
| "maxPayloadSize", |
| "gso", |
| "sndWndScale", |
| "maxSentAck", |
| "state", |
| "cc", |
| "rc", |
| } |
| } |
| |
| func (s *sender) beforeSave() {} |
| |
| // +checklocksignore |
| 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(14, rttMeasureTimeValue) |
| var firstRetransmittedSegXmitTimeValue unixTime = s.saveFirstRetransmittedSegXmitTime() |
| stateSinkObject.SaveValue(15, firstRetransmittedSegXmitTimeValue) |
| stateSinkObject.Save(0, &s.ep) |
| stateSinkObject.Save(2, &s.dupAckCount) |
| stateSinkObject.Save(3, &s.fr) |
| stateSinkObject.Save(4, &s.lr) |
| stateSinkObject.Save(5, &s.sndCwnd) |
| stateSinkObject.Save(6, &s.sndSsthresh) |
| stateSinkObject.Save(7, &s.sndCAAckCount) |
| stateSinkObject.Save(8, &s.outstanding) |
| stateSinkObject.Save(9, &s.sackedOut) |
| stateSinkObject.Save(10, &s.sndWnd) |
| stateSinkObject.Save(11, &s.sndUna) |
| stateSinkObject.Save(12, &s.sndNxt) |
| stateSinkObject.Save(13, &s.rttMeasureSeqNum) |
| stateSinkObject.Save(16, &s.closed) |
| stateSinkObject.Save(17, &s.writeNext) |
| stateSinkObject.Save(18, &s.writeList) |
| stateSinkObject.Save(19, &s.rtt) |
| stateSinkObject.Save(20, &s.rto) |
| stateSinkObject.Save(21, &s.minRTO) |
| stateSinkObject.Save(22, &s.maxRTO) |
| stateSinkObject.Save(23, &s.maxRetries) |
| stateSinkObject.Save(24, &s.maxPayloadSize) |
| stateSinkObject.Save(25, &s.gso) |
| stateSinkObject.Save(26, &s.sndWndScale) |
| stateSinkObject.Save(27, &s.maxSentAck) |
| stateSinkObject.Save(28, &s.state) |
| stateSinkObject.Save(29, &s.cc) |
| stateSinkObject.Save(30, &s.rc) |
| } |
| |
| // +checklocksignore |
| 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.lr) |
| stateSourceObject.Load(5, &s.sndCwnd) |
| stateSourceObject.Load(6, &s.sndSsthresh) |
| stateSourceObject.Load(7, &s.sndCAAckCount) |
| stateSourceObject.Load(8, &s.outstanding) |
| stateSourceObject.Load(9, &s.sackedOut) |
| stateSourceObject.Load(10, &s.sndWnd) |
| stateSourceObject.Load(11, &s.sndUna) |
| stateSourceObject.Load(12, &s.sndNxt) |
| stateSourceObject.Load(13, &s.rttMeasureSeqNum) |
| stateSourceObject.Load(16, &s.closed) |
| stateSourceObject.Load(17, &s.writeNext) |
| stateSourceObject.Load(18, &s.writeList) |
| stateSourceObject.Load(19, &s.rtt) |
| stateSourceObject.Load(20, &s.rto) |
| stateSourceObject.Load(21, &s.minRTO) |
| stateSourceObject.Load(22, &s.maxRTO) |
| stateSourceObject.Load(23, &s.maxRetries) |
| stateSourceObject.Load(24, &s.maxPayloadSize) |
| stateSourceObject.Load(25, &s.gso) |
| stateSourceObject.Load(26, &s.sndWndScale) |
| stateSourceObject.Load(27, &s.maxSentAck) |
| stateSourceObject.Load(28, &s.state) |
| stateSourceObject.Load(29, &s.cc) |
| stateSourceObject.Load(30, &s.rc) |
| stateSourceObject.LoadValue(1, new(unixTime), func(y interface{}) { s.loadLastSendTime(y.(unixTime)) }) |
| stateSourceObject.LoadValue(14, new(unixTime), func(y interface{}) { s.loadRttMeasureTime(y.(unixTime)) }) |
| stateSourceObject.LoadValue(15, 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 (r *rtt) StateFields() []string { |
| return []string{ |
| "srtt", |
| "rttvar", |
| "srttInited", |
| } |
| } |
| |
| func (r *rtt) beforeSave() {} |
| |
| // +checklocksignore |
| 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 (r *rtt) afterLoad() {} |
| |
| // +checklocksignore |
| func (r *rtt) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &r.srtt) |
| stateSourceObject.Load(1, &r.rttvar) |
| stateSourceObject.Load(2, &r.srttInited) |
| } |
| |
| func (f *fastRecovery) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.fastRecovery" |
| } |
| |
| func (f *fastRecovery) StateFields() []string { |
| return []string{ |
| "active", |
| "first", |
| "last", |
| "maxCwnd", |
| "highRxt", |
| "rescueRxt", |
| } |
| } |
| |
| func (f *fastRecovery) beforeSave() {} |
| |
| // +checklocksignore |
| 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 (f *fastRecovery) afterLoad() {} |
| |
| // +checklocksignore |
| 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 (u *unixTime) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.unixTime" |
| } |
| |
| func (u *unixTime) StateFields() []string { |
| return []string{ |
| "second", |
| "nano", |
| } |
| } |
| |
| func (u *unixTime) beforeSave() {} |
| |
| // +checklocksignore |
| func (u *unixTime) StateSave(stateSinkObject state.Sink) { |
| u.beforeSave() |
| stateSinkObject.Save(0, &u.second) |
| stateSinkObject.Save(1, &u.nano) |
| } |
| |
| func (u *unixTime) afterLoad() {} |
| |
| // +checklocksignore |
| func (u *unixTime) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &u.second) |
| stateSourceObject.Load(1, &u.nano) |
| } |
| |
| func (l *endpointList) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.endpointList" |
| } |
| |
| func (l *endpointList) StateFields() []string { |
| return []string{ |
| "head", |
| "tail", |
| } |
| } |
| |
| func (l *endpointList) beforeSave() {} |
| |
| // +checklocksignore |
| func (l *endpointList) StateSave(stateSinkObject state.Sink) { |
| l.beforeSave() |
| stateSinkObject.Save(0, &l.head) |
| stateSinkObject.Save(1, &l.tail) |
| } |
| |
| func (l *endpointList) afterLoad() {} |
| |
| // +checklocksignore |
| func (l *endpointList) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &l.head) |
| stateSourceObject.Load(1, &l.tail) |
| } |
| |
| func (e *endpointEntry) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.endpointEntry" |
| } |
| |
| func (e *endpointEntry) StateFields() []string { |
| return []string{ |
| "next", |
| "prev", |
| } |
| } |
| |
| func (e *endpointEntry) beforeSave() {} |
| |
| // +checklocksignore |
| func (e *endpointEntry) StateSave(stateSinkObject state.Sink) { |
| e.beforeSave() |
| stateSinkObject.Save(0, &e.next) |
| stateSinkObject.Save(1, &e.prev) |
| } |
| |
| func (e *endpointEntry) afterLoad() {} |
| |
| // +checklocksignore |
| func (e *endpointEntry) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &e.next) |
| stateSourceObject.Load(1, &e.prev) |
| } |
| |
| func (l *segmentList) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.segmentList" |
| } |
| |
| func (l *segmentList) StateFields() []string { |
| return []string{ |
| "head", |
| "tail", |
| } |
| } |
| |
| func (l *segmentList) beforeSave() {} |
| |
| // +checklocksignore |
| func (l *segmentList) StateSave(stateSinkObject state.Sink) { |
| l.beforeSave() |
| stateSinkObject.Save(0, &l.head) |
| stateSinkObject.Save(1, &l.tail) |
| } |
| |
| func (l *segmentList) afterLoad() {} |
| |
| // +checklocksignore |
| func (l *segmentList) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &l.head) |
| stateSourceObject.Load(1, &l.tail) |
| } |
| |
| func (e *segmentEntry) StateTypeName() string { |
| return "pkg/tcpip/transport/tcp.segmentEntry" |
| } |
| |
| func (e *segmentEntry) StateFields() []string { |
| return []string{ |
| "next", |
| "prev", |
| } |
| } |
| |
| func (e *segmentEntry) beforeSave() {} |
| |
| // +checklocksignore |
| func (e *segmentEntry) StateSave(stateSinkObject state.Sink) { |
| e.beforeSave() |
| stateSinkObject.Save(0, &e.next) |
| stateSinkObject.Save(1, &e.prev) |
| } |
| |
| func (e *segmentEntry) afterLoad() {} |
| |
| // +checklocksignore |
| func (e *segmentEntry) StateLoad(stateSourceObject state.Source) { |
| stateSourceObject.Load(0, &e.next) |
| stateSourceObject.Load(1, &e.prev) |
| } |
| |
| func init() { |
| state.Register((*cubicState)(nil)) |
| state.Register((*SACKInfo)(nil)) |
| state.Register((*rcvBufAutoTuneParams)(nil)) |
| state.Register((*EndpointInfo)(nil)) |
| state.Register((*endpoint)(nil)) |
| state.Register((*keepalive)(nil)) |
| state.Register((*rackControl)(nil)) |
| state.Register((*receiver)(nil)) |
| state.Register((*renoState)(nil)) |
| state.Register((*renoRecovery)(nil)) |
| state.Register((*sackRecovery)(nil)) |
| state.Register((*SACKScoreboard)(nil)) |
| state.Register((*segment)(nil)) |
| state.Register((*segmentQueue)(nil)) |
| state.Register((*sender)(nil)) |
| state.Register((*rtt)(nil)) |
| state.Register((*fastRecovery)(nil)) |
| state.Register((*unixTime)(nil)) |
| state.Register((*endpointList)(nil)) |
| state.Register((*endpointEntry)(nil)) |
| state.Register((*segmentList)(nil)) |
| state.Register((*segmentEntry)(nil)) |
| } |
