2c4ae3b0a4
Содержимое пина, зафиксированного в go.mod sing-box-lx, одним коммитом без истории. Полная история SagerNet/gvisor — 1.45 ГБ и клонируется в каждой CI-джобе; наша дельта — одна вставка в одну функцию, история для неё не нужна. Module path github.com/sagernet/gvisor сохранён намеренно: на него опирается replace-директива суперпроекта. Патч поверх — отдельным коммитом, чтобы дельта читалась одним git show и переносилась на новый пин копированием. SPECS/TASKS/048-GVISOR_HANDSHAKE_NIL_CRASH
3386 lines
89 KiB
Go
3386 lines
89 KiB
Go
// automatically generated by stateify.
|
|
|
|
package tcpip
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/sagernet/gvisor/pkg/state"
|
|
)
|
|
|
|
func (e *ErrAborted) StateTypeName() string {
|
|
return "pkg/tcpip.ErrAborted"
|
|
}
|
|
|
|
func (e *ErrAborted) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrAborted) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAborted) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrAborted) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrAddressFamilyNotSupported) StateTypeName() string {
|
|
return "pkg/tcpip.ErrAddressFamilyNotSupported"
|
|
}
|
|
|
|
func (e *ErrAddressFamilyNotSupported) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrAddressFamilyNotSupported) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAddressFamilyNotSupported) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrAddressFamilyNotSupported) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAddressFamilyNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrAlreadyBound) StateTypeName() string {
|
|
return "pkg/tcpip.ErrAlreadyBound"
|
|
}
|
|
|
|
func (e *ErrAlreadyBound) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrAlreadyBound) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyBound) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrAlreadyBound) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyBound) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrAlreadyConnected) StateTypeName() string {
|
|
return "pkg/tcpip.ErrAlreadyConnected"
|
|
}
|
|
|
|
func (e *ErrAlreadyConnected) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrAlreadyConnected) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyConnected) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrAlreadyConnected) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrAlreadyConnecting) StateTypeName() string {
|
|
return "pkg/tcpip.ErrAlreadyConnecting"
|
|
}
|
|
|
|
func (e *ErrAlreadyConnecting) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrAlreadyConnecting) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyConnecting) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrAlreadyConnecting) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrAlreadyConnecting) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrBadAddress) StateTypeName() string {
|
|
return "pkg/tcpip.ErrBadAddress"
|
|
}
|
|
|
|
func (e *ErrBadAddress) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrBadAddress) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadAddress) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrBadAddress) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrBadBuffer) StateTypeName() string {
|
|
return "pkg/tcpip.ErrBadBuffer"
|
|
}
|
|
|
|
func (e *ErrBadBuffer) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrBadBuffer) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadBuffer) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrBadBuffer) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadBuffer) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrBadLocalAddress) StateTypeName() string {
|
|
return "pkg/tcpip.ErrBadLocalAddress"
|
|
}
|
|
|
|
func (e *ErrBadLocalAddress) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrBadLocalAddress) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadLocalAddress) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrBadLocalAddress) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBadLocalAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrBroadcastDisabled) StateTypeName() string {
|
|
return "pkg/tcpip.ErrBroadcastDisabled"
|
|
}
|
|
|
|
func (e *ErrBroadcastDisabled) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrBroadcastDisabled) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBroadcastDisabled) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrBroadcastDisabled) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrBroadcastDisabled) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrClosedForReceive) StateTypeName() string {
|
|
return "pkg/tcpip.ErrClosedForReceive"
|
|
}
|
|
|
|
func (e *ErrClosedForReceive) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrClosedForReceive) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrClosedForReceive) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrClosedForReceive) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrClosedForReceive) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrClosedForSend) StateTypeName() string {
|
|
return "pkg/tcpip.ErrClosedForSend"
|
|
}
|
|
|
|
func (e *ErrClosedForSend) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrClosedForSend) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrClosedForSend) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrClosedForSend) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrClosedForSend) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrConnectStarted) StateTypeName() string {
|
|
return "pkg/tcpip.ErrConnectStarted"
|
|
}
|
|
|
|
func (e *ErrConnectStarted) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrConnectStarted) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectStarted) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrConnectStarted) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectStarted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrConnectionAborted) StateTypeName() string {
|
|
return "pkg/tcpip.ErrConnectionAborted"
|
|
}
|
|
|
|
func (e *ErrConnectionAborted) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrConnectionAborted) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionAborted) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrConnectionAborted) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrConnectionRefused) StateTypeName() string {
|
|
return "pkg/tcpip.ErrConnectionRefused"
|
|
}
|
|
|
|
func (e *ErrConnectionRefused) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrConnectionRefused) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionRefused) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrConnectionRefused) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionRefused) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrConnectionReset) StateTypeName() string {
|
|
return "pkg/tcpip.ErrConnectionReset"
|
|
}
|
|
|
|
func (e *ErrConnectionReset) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrConnectionReset) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionReset) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrConnectionReset) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrConnectionReset) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrDestinationRequired) StateTypeName() string {
|
|
return "pkg/tcpip.ErrDestinationRequired"
|
|
}
|
|
|
|
func (e *ErrDestinationRequired) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrDestinationRequired) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDestinationRequired) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrDestinationRequired) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDestinationRequired) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrDuplicateAddress) StateTypeName() string {
|
|
return "pkg/tcpip.ErrDuplicateAddress"
|
|
}
|
|
|
|
func (e *ErrDuplicateAddress) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrDuplicateAddress) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDuplicateAddress) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrDuplicateAddress) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDuplicateAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrDuplicateNICID) StateTypeName() string {
|
|
return "pkg/tcpip.ErrDuplicateNICID"
|
|
}
|
|
|
|
func (e *ErrDuplicateNICID) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrDuplicateNICID) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDuplicateNICID) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrDuplicateNICID) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrDuplicateNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrInvalidNICID) StateTypeName() string {
|
|
return "pkg/tcpip.ErrInvalidNICID"
|
|
}
|
|
|
|
func (e *ErrInvalidNICID) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrInvalidNICID) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidNICID) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrInvalidNICID) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrInvalidEndpointState) StateTypeName() string {
|
|
return "pkg/tcpip.ErrInvalidEndpointState"
|
|
}
|
|
|
|
func (e *ErrInvalidEndpointState) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrInvalidEndpointState) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidEndpointState) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrInvalidEndpointState) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidEndpointState) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrInvalidOptionValue) StateTypeName() string {
|
|
return "pkg/tcpip.ErrInvalidOptionValue"
|
|
}
|
|
|
|
func (e *ErrInvalidOptionValue) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrInvalidOptionValue) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidOptionValue) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrInvalidOptionValue) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidOptionValue) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrInvalidPortRange) StateTypeName() string {
|
|
return "pkg/tcpip.ErrInvalidPortRange"
|
|
}
|
|
|
|
func (e *ErrInvalidPortRange) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrInvalidPortRange) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidPortRange) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrInvalidPortRange) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrInvalidPortRange) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrMalformedHeader) StateTypeName() string {
|
|
return "pkg/tcpip.ErrMalformedHeader"
|
|
}
|
|
|
|
func (e *ErrMalformedHeader) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrMalformedHeader) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMalformedHeader) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrMalformedHeader) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMalformedHeader) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrMessageTooLong) StateTypeName() string {
|
|
return "pkg/tcpip.ErrMessageTooLong"
|
|
}
|
|
|
|
func (e *ErrMessageTooLong) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrMessageTooLong) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMessageTooLong) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrMessageTooLong) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMessageTooLong) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNetworkUnreachable) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNetworkUnreachable"
|
|
}
|
|
|
|
func (e *ErrNetworkUnreachable) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNetworkUnreachable) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNetworkUnreachable) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNetworkUnreachable) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNetworkUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNoBufferSpace) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNoBufferSpace"
|
|
}
|
|
|
|
func (e *ErrNoBufferSpace) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNoBufferSpace) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoBufferSpace) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNoBufferSpace) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoBufferSpace) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNoPortAvailable) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNoPortAvailable"
|
|
}
|
|
|
|
func (e *ErrNoPortAvailable) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNoPortAvailable) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoPortAvailable) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNoPortAvailable) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoPortAvailable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrHostUnreachable) StateTypeName() string {
|
|
return "pkg/tcpip.ErrHostUnreachable"
|
|
}
|
|
|
|
func (e *ErrHostUnreachable) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrHostUnreachable) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrHostUnreachable) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrHostUnreachable) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrHostUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrHostDown) StateTypeName() string {
|
|
return "pkg/tcpip.ErrHostDown"
|
|
}
|
|
|
|
func (e *ErrHostDown) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrHostDown) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrHostDown) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrHostDown) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrHostDown) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNoNet) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNoNet"
|
|
}
|
|
|
|
func (e *ErrNoNet) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNoNet) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoNet) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNoNet) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoNet) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNoSuchFile) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNoSuchFile"
|
|
}
|
|
|
|
func (e *ErrNoSuchFile) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNoSuchFile) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoSuchFile) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNoSuchFile) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNoSuchFile) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNotConnected) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNotConnected"
|
|
}
|
|
|
|
func (e *ErrNotConnected) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNotConnected) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotConnected) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNotConnected) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNotPermitted) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNotPermitted"
|
|
}
|
|
|
|
func (e *ErrNotPermitted) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNotPermitted) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotPermitted) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNotPermitted) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotPermitted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrNotSupported) StateTypeName() string {
|
|
return "pkg/tcpip.ErrNotSupported"
|
|
}
|
|
|
|
func (e *ErrNotSupported) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrNotSupported) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotSupported) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrNotSupported) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrPortInUse) StateTypeName() string {
|
|
return "pkg/tcpip.ErrPortInUse"
|
|
}
|
|
|
|
func (e *ErrPortInUse) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrPortInUse) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrPortInUse) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrPortInUse) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrPortInUse) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrQueueSizeNotSupported) StateTypeName() string {
|
|
return "pkg/tcpip.ErrQueueSizeNotSupported"
|
|
}
|
|
|
|
func (e *ErrQueueSizeNotSupported) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrQueueSizeNotSupported) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrQueueSizeNotSupported) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrQueueSizeNotSupported) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrQueueSizeNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrTimeout) StateTypeName() string {
|
|
return "pkg/tcpip.ErrTimeout"
|
|
}
|
|
|
|
func (e *ErrTimeout) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrTimeout) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrTimeout) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrTimeout) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrTimeout) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrUnknownDevice) StateTypeName() string {
|
|
return "pkg/tcpip.ErrUnknownDevice"
|
|
}
|
|
|
|
func (e *ErrUnknownDevice) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrUnknownDevice) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownDevice) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrUnknownDevice) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownDevice) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrUnknownNICID) StateTypeName() string {
|
|
return "pkg/tcpip.ErrUnknownNICID"
|
|
}
|
|
|
|
func (e *ErrUnknownNICID) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrUnknownNICID) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownNICID) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrUnknownNICID) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrUnknownProtocol) StateTypeName() string {
|
|
return "pkg/tcpip.ErrUnknownProtocol"
|
|
}
|
|
|
|
func (e *ErrUnknownProtocol) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrUnknownProtocol) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownProtocol) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrUnknownProtocol) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownProtocol) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrUnknownProtocolOption) StateTypeName() string {
|
|
return "pkg/tcpip.ErrUnknownProtocolOption"
|
|
}
|
|
|
|
func (e *ErrUnknownProtocolOption) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrUnknownProtocolOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownProtocolOption) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrUnknownProtocolOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrUnknownProtocolOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrWouldBlock) StateTypeName() string {
|
|
return "pkg/tcpip.ErrWouldBlock"
|
|
}
|
|
|
|
func (e *ErrWouldBlock) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrWouldBlock) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrWouldBlock) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrWouldBlock) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrWouldBlock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrMissingRequiredFields) StateTypeName() string {
|
|
return "pkg/tcpip.ErrMissingRequiredFields"
|
|
}
|
|
|
|
func (e *ErrMissingRequiredFields) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrMissingRequiredFields) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMissingRequiredFields) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrMissingRequiredFields) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMissingRequiredFields) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrMulticastInputCannotBeOutput) StateTypeName() string {
|
|
return "pkg/tcpip.ErrMulticastInputCannotBeOutput"
|
|
}
|
|
|
|
func (e *ErrMulticastInputCannotBeOutput) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrMulticastInputCannotBeOutput) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMulticastInputCannotBeOutput) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrMulticastInputCannotBeOutput) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrMulticastInputCannotBeOutput) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (e *ErrEndpointBusy) StateTypeName() string {
|
|
return "pkg/tcpip.ErrEndpointBusy"
|
|
}
|
|
|
|
func (e *ErrEndpointBusy) StateFields() []string {
|
|
return []string{}
|
|
}
|
|
|
|
func (e *ErrEndpointBusy) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrEndpointBusy) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
}
|
|
|
|
func (e *ErrEndpointBusy) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *ErrEndpointBusy) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
}
|
|
|
|
func (l *RouteList) StateTypeName() string {
|
|
return "pkg/tcpip.RouteList"
|
|
}
|
|
|
|
func (l *RouteList) StateFields() []string {
|
|
return []string{
|
|
"head",
|
|
"tail",
|
|
}
|
|
}
|
|
|
|
func (l *RouteList) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (l *RouteList) StateSave(stateSinkObject state.Sink) {
|
|
l.beforeSave()
|
|
stateSinkObject.Save(0, &l.head)
|
|
stateSinkObject.Save(1, &l.tail)
|
|
}
|
|
|
|
func (l *RouteList) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (l *RouteList) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &l.head)
|
|
stateSourceObject.Load(1, &l.tail)
|
|
}
|
|
|
|
func (e *RouteEntry) StateTypeName() string {
|
|
return "pkg/tcpip.RouteEntry"
|
|
}
|
|
|
|
func (e *RouteEntry) StateFields() []string {
|
|
return []string{
|
|
"next",
|
|
"prev",
|
|
}
|
|
}
|
|
|
|
func (e *RouteEntry) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *RouteEntry) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
stateSinkObject.Save(0, &e.next)
|
|
stateSinkObject.Save(1, &e.prev)
|
|
}
|
|
|
|
func (e *RouteEntry) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *RouteEntry) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &e.next)
|
|
stateSourceObject.Load(1, &e.prev)
|
|
}
|
|
|
|
func (l *sockErrorList) StateTypeName() string {
|
|
return "pkg/tcpip.sockErrorList"
|
|
}
|
|
|
|
func (l *sockErrorList) StateFields() []string {
|
|
return []string{
|
|
"head",
|
|
"tail",
|
|
}
|
|
}
|
|
|
|
func (l *sockErrorList) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (l *sockErrorList) StateSave(stateSinkObject state.Sink) {
|
|
l.beforeSave()
|
|
stateSinkObject.Save(0, &l.head)
|
|
stateSinkObject.Save(1, &l.tail)
|
|
}
|
|
|
|
func (l *sockErrorList) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (l *sockErrorList) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &l.head)
|
|
stateSourceObject.Load(1, &l.tail)
|
|
}
|
|
|
|
func (e *sockErrorEntry) StateTypeName() string {
|
|
return "pkg/tcpip.sockErrorEntry"
|
|
}
|
|
|
|
func (e *sockErrorEntry) StateFields() []string {
|
|
return []string{
|
|
"next",
|
|
"prev",
|
|
}
|
|
}
|
|
|
|
func (e *sockErrorEntry) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (e *sockErrorEntry) StateSave(stateSinkObject state.Sink) {
|
|
e.beforeSave()
|
|
stateSinkObject.Save(0, &e.next)
|
|
stateSinkObject.Save(1, &e.prev)
|
|
}
|
|
|
|
func (e *sockErrorEntry) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (e *sockErrorEntry) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &e.next)
|
|
stateSourceObject.Load(1, &e.prev)
|
|
}
|
|
|
|
func (so *SocketOptions) StateTypeName() string {
|
|
return "pkg/tcpip.SocketOptions"
|
|
}
|
|
|
|
func (so *SocketOptions) StateFields() []string {
|
|
return []string{
|
|
"handler",
|
|
"broadcastEnabled",
|
|
"passCredEnabled",
|
|
"noChecksumEnabled",
|
|
"reuseAddressEnabled",
|
|
"reusePortEnabled",
|
|
"keepAliveEnabled",
|
|
"multicastLoopEnabled",
|
|
"receiveTOSEnabled",
|
|
"receiveTTLEnabled",
|
|
"receiveHopLimitEnabled",
|
|
"receiveTClassEnabled",
|
|
"receivePacketInfoEnabled",
|
|
"receiveIPv6PacketInfoEnabled",
|
|
"hdrIncludedEnabled",
|
|
"v6OnlyEnabled",
|
|
"quickAckEnabled",
|
|
"delayOptionEnabled",
|
|
"corkOptionEnabled",
|
|
"receiveOriginalDstAddress",
|
|
"ipv4RecvErrEnabled",
|
|
"ipv6RecvErrEnabled",
|
|
"errQueue",
|
|
"bindToDevice",
|
|
"sendBufferSize",
|
|
"receiveBufferSize",
|
|
"linger",
|
|
"rcvlowat",
|
|
"experimentOptionValue",
|
|
}
|
|
}
|
|
|
|
func (so *SocketOptions) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (so *SocketOptions) StateSave(stateSinkObject state.Sink) {
|
|
so.beforeSave()
|
|
stateSinkObject.Save(0, &so.handler)
|
|
stateSinkObject.Save(1, &so.broadcastEnabled)
|
|
stateSinkObject.Save(2, &so.passCredEnabled)
|
|
stateSinkObject.Save(3, &so.noChecksumEnabled)
|
|
stateSinkObject.Save(4, &so.reuseAddressEnabled)
|
|
stateSinkObject.Save(5, &so.reusePortEnabled)
|
|
stateSinkObject.Save(6, &so.keepAliveEnabled)
|
|
stateSinkObject.Save(7, &so.multicastLoopEnabled)
|
|
stateSinkObject.Save(8, &so.receiveTOSEnabled)
|
|
stateSinkObject.Save(9, &so.receiveTTLEnabled)
|
|
stateSinkObject.Save(10, &so.receiveHopLimitEnabled)
|
|
stateSinkObject.Save(11, &so.receiveTClassEnabled)
|
|
stateSinkObject.Save(12, &so.receivePacketInfoEnabled)
|
|
stateSinkObject.Save(13, &so.receiveIPv6PacketInfoEnabled)
|
|
stateSinkObject.Save(14, &so.hdrIncludedEnabled)
|
|
stateSinkObject.Save(15, &so.v6OnlyEnabled)
|
|
stateSinkObject.Save(16, &so.quickAckEnabled)
|
|
stateSinkObject.Save(17, &so.delayOptionEnabled)
|
|
stateSinkObject.Save(18, &so.corkOptionEnabled)
|
|
stateSinkObject.Save(19, &so.receiveOriginalDstAddress)
|
|
stateSinkObject.Save(20, &so.ipv4RecvErrEnabled)
|
|
stateSinkObject.Save(21, &so.ipv6RecvErrEnabled)
|
|
stateSinkObject.Save(22, &so.errQueue)
|
|
stateSinkObject.Save(23, &so.bindToDevice)
|
|
stateSinkObject.Save(24, &so.sendBufferSize)
|
|
stateSinkObject.Save(25, &so.receiveBufferSize)
|
|
stateSinkObject.Save(26, &so.linger)
|
|
stateSinkObject.Save(27, &so.rcvlowat)
|
|
stateSinkObject.Save(28, &so.experimentOptionValue)
|
|
}
|
|
|
|
func (so *SocketOptions) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (so *SocketOptions) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &so.handler)
|
|
stateSourceObject.Load(1, &so.broadcastEnabled)
|
|
stateSourceObject.Load(2, &so.passCredEnabled)
|
|
stateSourceObject.Load(3, &so.noChecksumEnabled)
|
|
stateSourceObject.Load(4, &so.reuseAddressEnabled)
|
|
stateSourceObject.Load(5, &so.reusePortEnabled)
|
|
stateSourceObject.Load(6, &so.keepAliveEnabled)
|
|
stateSourceObject.Load(7, &so.multicastLoopEnabled)
|
|
stateSourceObject.Load(8, &so.receiveTOSEnabled)
|
|
stateSourceObject.Load(9, &so.receiveTTLEnabled)
|
|
stateSourceObject.Load(10, &so.receiveHopLimitEnabled)
|
|
stateSourceObject.Load(11, &so.receiveTClassEnabled)
|
|
stateSourceObject.Load(12, &so.receivePacketInfoEnabled)
|
|
stateSourceObject.Load(13, &so.receiveIPv6PacketInfoEnabled)
|
|
stateSourceObject.Load(14, &so.hdrIncludedEnabled)
|
|
stateSourceObject.Load(15, &so.v6OnlyEnabled)
|
|
stateSourceObject.Load(16, &so.quickAckEnabled)
|
|
stateSourceObject.Load(17, &so.delayOptionEnabled)
|
|
stateSourceObject.Load(18, &so.corkOptionEnabled)
|
|
stateSourceObject.Load(19, &so.receiveOriginalDstAddress)
|
|
stateSourceObject.Load(20, &so.ipv4RecvErrEnabled)
|
|
stateSourceObject.Load(21, &so.ipv6RecvErrEnabled)
|
|
stateSourceObject.Load(22, &so.errQueue)
|
|
stateSourceObject.Load(23, &so.bindToDevice)
|
|
stateSourceObject.Load(24, &so.sendBufferSize)
|
|
stateSourceObject.Load(25, &so.receiveBufferSize)
|
|
stateSourceObject.Load(26, &so.linger)
|
|
stateSourceObject.Load(27, &so.rcvlowat)
|
|
stateSourceObject.Load(28, &so.experimentOptionValue)
|
|
}
|
|
|
|
func (l *LocalSockError) StateTypeName() string {
|
|
return "pkg/tcpip.LocalSockError"
|
|
}
|
|
|
|
func (l *LocalSockError) StateFields() []string {
|
|
return []string{
|
|
"info",
|
|
}
|
|
}
|
|
|
|
func (l *LocalSockError) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (l *LocalSockError) StateSave(stateSinkObject state.Sink) {
|
|
l.beforeSave()
|
|
stateSinkObject.Save(0, &l.info)
|
|
}
|
|
|
|
func (l *LocalSockError) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (l *LocalSockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &l.info)
|
|
}
|
|
|
|
func (s *SockError) StateTypeName() string {
|
|
return "pkg/tcpip.SockError"
|
|
}
|
|
|
|
func (s *SockError) StateFields() []string {
|
|
return []string{
|
|
"sockErrorEntry",
|
|
"Err",
|
|
"Cause",
|
|
"Payload",
|
|
"Dst",
|
|
"Offender",
|
|
"NetProto",
|
|
}
|
|
}
|
|
|
|
func (s *SockError) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *SockError) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.sockErrorEntry)
|
|
stateSinkObject.Save(1, &s.Err)
|
|
stateSinkObject.Save(2, &s.Cause)
|
|
stateSinkObject.Save(3, &s.Payload)
|
|
stateSinkObject.Save(4, &s.Dst)
|
|
stateSinkObject.Save(5, &s.Offender)
|
|
stateSinkObject.Save(6, &s.NetProto)
|
|
}
|
|
|
|
func (s *SockError) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *SockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.sockErrorEntry)
|
|
stateSourceObject.Load(1, &s.Err)
|
|
stateSourceObject.Load(2, &s.Cause)
|
|
stateSourceObject.Load(3, &s.Payload)
|
|
stateSourceObject.Load(4, &s.Dst)
|
|
stateSourceObject.Load(5, &s.Offender)
|
|
stateSourceObject.Load(6, &s.NetProto)
|
|
}
|
|
|
|
func (s *stdClock) StateTypeName() string {
|
|
return "pkg/tcpip.stdClock"
|
|
}
|
|
|
|
func (s *stdClock) StateFields() []string {
|
|
return []string{
|
|
"monotonicOffset",
|
|
}
|
|
}
|
|
|
|
// +checklocksignore
|
|
func (s *stdClock) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.monotonicOffset)
|
|
}
|
|
|
|
// +checklocksignore
|
|
func (s *stdClock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.monotonicOffset)
|
|
stateSourceObject.AfterLoad(func() { s.afterLoad(ctx) })
|
|
}
|
|
|
|
func (st *stdTimer) StateTypeName() string {
|
|
return "pkg/tcpip.stdTimer"
|
|
}
|
|
|
|
func (st *stdTimer) StateFields() []string {
|
|
return []string{
|
|
"t",
|
|
}
|
|
}
|
|
|
|
func (st *stdTimer) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (st *stdTimer) StateSave(stateSinkObject state.Sink) {
|
|
st.beforeSave()
|
|
stateSinkObject.Save(0, &st.t)
|
|
}
|
|
|
|
func (st *stdTimer) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (st *stdTimer) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &st.t)
|
|
}
|
|
|
|
func (mt *MonotonicTime) StateTypeName() string {
|
|
return "pkg/tcpip.MonotonicTime"
|
|
}
|
|
|
|
func (mt *MonotonicTime) StateFields() []string {
|
|
return []string{
|
|
"nanoseconds",
|
|
}
|
|
}
|
|
|
|
func (mt *MonotonicTime) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (mt *MonotonicTime) StateSave(stateSinkObject state.Sink) {
|
|
mt.beforeSave()
|
|
stateSinkObject.Save(0, &mt.nanoseconds)
|
|
}
|
|
|
|
func (mt *MonotonicTime) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (mt *MonotonicTime) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &mt.nanoseconds)
|
|
}
|
|
|
|
func (a *Address) StateTypeName() string {
|
|
return "pkg/tcpip.Address"
|
|
}
|
|
|
|
func (a *Address) StateFields() []string {
|
|
return []string{
|
|
"addr",
|
|
"length",
|
|
}
|
|
}
|
|
|
|
func (a *Address) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (a *Address) StateSave(stateSinkObject state.Sink) {
|
|
a.beforeSave()
|
|
stateSinkObject.Save(0, &a.addr)
|
|
stateSinkObject.Save(1, &a.length)
|
|
}
|
|
|
|
func (a *Address) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (a *Address) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &a.addr)
|
|
stateSourceObject.Load(1, &a.length)
|
|
}
|
|
|
|
func (m *AddressMask) StateTypeName() string {
|
|
return "pkg/tcpip.AddressMask"
|
|
}
|
|
|
|
func (m *AddressMask) StateFields() []string {
|
|
return []string{
|
|
"mask",
|
|
"length",
|
|
}
|
|
}
|
|
|
|
func (m *AddressMask) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (m *AddressMask) StateSave(stateSinkObject state.Sink) {
|
|
m.beforeSave()
|
|
stateSinkObject.Save(0, &m.mask)
|
|
stateSinkObject.Save(1, &m.length)
|
|
}
|
|
|
|
func (m *AddressMask) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (m *AddressMask) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &m.mask)
|
|
stateSourceObject.Load(1, &m.length)
|
|
}
|
|
|
|
func (s *Subnet) StateTypeName() string {
|
|
return "pkg/tcpip.Subnet"
|
|
}
|
|
|
|
func (s *Subnet) StateFields() []string {
|
|
return []string{
|
|
"address",
|
|
"mask",
|
|
}
|
|
}
|
|
|
|
func (s *Subnet) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *Subnet) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.address)
|
|
stateSinkObject.Save(1, &s.mask)
|
|
}
|
|
|
|
func (s *Subnet) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *Subnet) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.address)
|
|
stateSourceObject.Load(1, &s.mask)
|
|
}
|
|
|
|
func (f *FullAddress) StateTypeName() string {
|
|
return "pkg/tcpip.FullAddress"
|
|
}
|
|
|
|
func (f *FullAddress) StateFields() []string {
|
|
return []string{
|
|
"NIC",
|
|
"Addr",
|
|
"Port",
|
|
"LinkAddr",
|
|
}
|
|
}
|
|
|
|
func (f *FullAddress) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (f *FullAddress) StateSave(stateSinkObject state.Sink) {
|
|
f.beforeSave()
|
|
stateSinkObject.Save(0, &f.NIC)
|
|
stateSinkObject.Save(1, &f.Addr)
|
|
stateSinkObject.Save(2, &f.Port)
|
|
stateSinkObject.Save(3, &f.LinkAddr)
|
|
}
|
|
|
|
func (f *FullAddress) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (f *FullAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &f.NIC)
|
|
stateSourceObject.Load(1, &f.Addr)
|
|
stateSourceObject.Load(2, &f.Port)
|
|
stateSourceObject.Load(3, &f.LinkAddr)
|
|
}
|
|
|
|
func (s *SendableControlMessages) StateTypeName() string {
|
|
return "pkg/tcpip.SendableControlMessages"
|
|
}
|
|
|
|
func (s *SendableControlMessages) StateFields() []string {
|
|
return []string{
|
|
"HasTTL",
|
|
"TTL",
|
|
"HasHopLimit",
|
|
"HopLimit",
|
|
"HasIPv6PacketInfo",
|
|
"IPv6PacketInfo",
|
|
}
|
|
}
|
|
|
|
func (s *SendableControlMessages) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendableControlMessages) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.HasTTL)
|
|
stateSinkObject.Save(1, &s.TTL)
|
|
stateSinkObject.Save(2, &s.HasHopLimit)
|
|
stateSinkObject.Save(3, &s.HopLimit)
|
|
stateSinkObject.Save(4, &s.HasIPv6PacketInfo)
|
|
stateSinkObject.Save(5, &s.IPv6PacketInfo)
|
|
}
|
|
|
|
func (s *SendableControlMessages) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.HasTTL)
|
|
stateSourceObject.Load(1, &s.TTL)
|
|
stateSourceObject.Load(2, &s.HasHopLimit)
|
|
stateSourceObject.Load(3, &s.HopLimit)
|
|
stateSourceObject.Load(4, &s.HasIPv6PacketInfo)
|
|
stateSourceObject.Load(5, &s.IPv6PacketInfo)
|
|
}
|
|
|
|
func (c *ReceivableControlMessages) StateTypeName() string {
|
|
return "pkg/tcpip.ReceivableControlMessages"
|
|
}
|
|
|
|
func (c *ReceivableControlMessages) StateFields() []string {
|
|
return []string{
|
|
"Timestamp",
|
|
"HasInq",
|
|
"Inq",
|
|
"HasTOS",
|
|
"TOS",
|
|
"HasTTL",
|
|
"TTL",
|
|
"HasHopLimit",
|
|
"HopLimit",
|
|
"HasTimestamp",
|
|
"HasTClass",
|
|
"TClass",
|
|
"HasIPPacketInfo",
|
|
"PacketInfo",
|
|
"HasIPv6PacketInfo",
|
|
"IPv6PacketInfo",
|
|
"HasOriginalDstAddress",
|
|
"OriginalDstAddress",
|
|
"SockErr",
|
|
}
|
|
}
|
|
|
|
func (c *ReceivableControlMessages) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (c *ReceivableControlMessages) StateSave(stateSinkObject state.Sink) {
|
|
c.beforeSave()
|
|
var TimestampValue int64
|
|
TimestampValue = c.saveTimestamp()
|
|
stateSinkObject.SaveValue(0, TimestampValue)
|
|
stateSinkObject.Save(1, &c.HasInq)
|
|
stateSinkObject.Save(2, &c.Inq)
|
|
stateSinkObject.Save(3, &c.HasTOS)
|
|
stateSinkObject.Save(4, &c.TOS)
|
|
stateSinkObject.Save(5, &c.HasTTL)
|
|
stateSinkObject.Save(6, &c.TTL)
|
|
stateSinkObject.Save(7, &c.HasHopLimit)
|
|
stateSinkObject.Save(8, &c.HopLimit)
|
|
stateSinkObject.Save(9, &c.HasTimestamp)
|
|
stateSinkObject.Save(10, &c.HasTClass)
|
|
stateSinkObject.Save(11, &c.TClass)
|
|
stateSinkObject.Save(12, &c.HasIPPacketInfo)
|
|
stateSinkObject.Save(13, &c.PacketInfo)
|
|
stateSinkObject.Save(14, &c.HasIPv6PacketInfo)
|
|
stateSinkObject.Save(15, &c.IPv6PacketInfo)
|
|
stateSinkObject.Save(16, &c.HasOriginalDstAddress)
|
|
stateSinkObject.Save(17, &c.OriginalDstAddress)
|
|
stateSinkObject.Save(18, &c.SockErr)
|
|
}
|
|
|
|
func (c *ReceivableControlMessages) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (c *ReceivableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(1, &c.HasInq)
|
|
stateSourceObject.Load(2, &c.Inq)
|
|
stateSourceObject.Load(3, &c.HasTOS)
|
|
stateSourceObject.Load(4, &c.TOS)
|
|
stateSourceObject.Load(5, &c.HasTTL)
|
|
stateSourceObject.Load(6, &c.TTL)
|
|
stateSourceObject.Load(7, &c.HasHopLimit)
|
|
stateSourceObject.Load(8, &c.HopLimit)
|
|
stateSourceObject.Load(9, &c.HasTimestamp)
|
|
stateSourceObject.Load(10, &c.HasTClass)
|
|
stateSourceObject.Load(11, &c.TClass)
|
|
stateSourceObject.Load(12, &c.HasIPPacketInfo)
|
|
stateSourceObject.Load(13, &c.PacketInfo)
|
|
stateSourceObject.Load(14, &c.HasIPv6PacketInfo)
|
|
stateSourceObject.Load(15, &c.IPv6PacketInfo)
|
|
stateSourceObject.Load(16, &c.HasOriginalDstAddress)
|
|
stateSourceObject.Load(17, &c.OriginalDstAddress)
|
|
stateSourceObject.Load(18, &c.SockErr)
|
|
stateSourceObject.LoadValue(0, new(int64), func(y any) { c.loadTimestamp(ctx, y.(int64)) })
|
|
}
|
|
|
|
func (l *LinkPacketInfo) StateTypeName() string {
|
|
return "pkg/tcpip.LinkPacketInfo"
|
|
}
|
|
|
|
func (l *LinkPacketInfo) StateFields() []string {
|
|
return []string{
|
|
"Protocol",
|
|
"PktType",
|
|
}
|
|
}
|
|
|
|
func (l *LinkPacketInfo) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (l *LinkPacketInfo) StateSave(stateSinkObject state.Sink) {
|
|
l.beforeSave()
|
|
stateSinkObject.Save(0, &l.Protocol)
|
|
stateSinkObject.Save(1, &l.PktType)
|
|
}
|
|
|
|
func (l *LinkPacketInfo) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (l *LinkPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &l.Protocol)
|
|
stateSourceObject.Load(1, &l.PktType)
|
|
}
|
|
|
|
func (t *TCPSendBufferSizeRangeOption) StateTypeName() string {
|
|
return "pkg/tcpip.TCPSendBufferSizeRangeOption"
|
|
}
|
|
|
|
func (t *TCPSendBufferSizeRangeOption) StateFields() []string {
|
|
return []string{
|
|
"Min",
|
|
"Default",
|
|
"Max",
|
|
}
|
|
}
|
|
|
|
func (t *TCPSendBufferSizeRangeOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPSendBufferSizeRangeOption) StateSave(stateSinkObject state.Sink) {
|
|
t.beforeSave()
|
|
stateSinkObject.Save(0, &t.Min)
|
|
stateSinkObject.Save(1, &t.Default)
|
|
stateSinkObject.Save(2, &t.Max)
|
|
}
|
|
|
|
func (t *TCPSendBufferSizeRangeOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPSendBufferSizeRangeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &t.Min)
|
|
stateSourceObject.Load(1, &t.Default)
|
|
stateSourceObject.Load(2, &t.Max)
|
|
}
|
|
|
|
func (t *TCPReceiveBufferSizeRangeOption) StateTypeName() string {
|
|
return "pkg/tcpip.TCPReceiveBufferSizeRangeOption"
|
|
}
|
|
|
|
func (t *TCPReceiveBufferSizeRangeOption) StateFields() []string {
|
|
return []string{
|
|
"Min",
|
|
"Default",
|
|
"Max",
|
|
}
|
|
}
|
|
|
|
func (t *TCPReceiveBufferSizeRangeOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPReceiveBufferSizeRangeOption) StateSave(stateSinkObject state.Sink) {
|
|
t.beforeSave()
|
|
stateSinkObject.Save(0, &t.Min)
|
|
stateSinkObject.Save(1, &t.Default)
|
|
stateSinkObject.Save(2, &t.Max)
|
|
}
|
|
|
|
func (t *TCPReceiveBufferSizeRangeOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPReceiveBufferSizeRangeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &t.Min)
|
|
stateSourceObject.Load(1, &t.Default)
|
|
stateSourceObject.Load(2, &t.Max)
|
|
}
|
|
|
|
func (f *ICMPv6Filter) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv6Filter"
|
|
}
|
|
|
|
func (f *ICMPv6Filter) StateFields() []string {
|
|
return []string{
|
|
"DenyType",
|
|
}
|
|
}
|
|
|
|
func (f *ICMPv6Filter) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (f *ICMPv6Filter) StateSave(stateSinkObject state.Sink) {
|
|
f.beforeSave()
|
|
stateSinkObject.Save(0, &f.DenyType)
|
|
}
|
|
|
|
func (f *ICMPv6Filter) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (f *ICMPv6Filter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &f.DenyType)
|
|
}
|
|
|
|
func (t *TpacketReq) StateTypeName() string {
|
|
return "pkg/tcpip.TpacketReq"
|
|
}
|
|
|
|
func (t *TpacketReq) StateFields() []string {
|
|
return []string{
|
|
"TpBlockSize",
|
|
"TpBlockNr",
|
|
"TpFrameSize",
|
|
"TpFrameNr",
|
|
}
|
|
}
|
|
|
|
func (t *TpacketReq) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (t *TpacketReq) StateSave(stateSinkObject state.Sink) {
|
|
t.beforeSave()
|
|
stateSinkObject.Save(0, &t.TpBlockSize)
|
|
stateSinkObject.Save(1, &t.TpBlockNr)
|
|
stateSinkObject.Save(2, &t.TpFrameSize)
|
|
stateSinkObject.Save(3, &t.TpFrameNr)
|
|
}
|
|
|
|
func (t *TpacketReq) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (t *TpacketReq) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &t.TpBlockSize)
|
|
stateSourceObject.Load(1, &t.TpBlockNr)
|
|
stateSourceObject.Load(2, &t.TpFrameSize)
|
|
stateSourceObject.Load(3, &t.TpFrameNr)
|
|
}
|
|
|
|
func (t *TpacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.TpacketStats"
|
|
}
|
|
|
|
func (t *TpacketStats) StateFields() []string {
|
|
return []string{
|
|
"Packets",
|
|
"Dropped",
|
|
}
|
|
}
|
|
|
|
func (t *TpacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (t *TpacketStats) StateSave(stateSinkObject state.Sink) {
|
|
t.beforeSave()
|
|
stateSinkObject.Save(0, &t.Packets)
|
|
stateSinkObject.Save(1, &t.Dropped)
|
|
}
|
|
|
|
func (t *TpacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (t *TpacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &t.Packets)
|
|
stateSourceObject.Load(1, &t.Dropped)
|
|
}
|
|
|
|
func (l *LingerOption) StateTypeName() string {
|
|
return "pkg/tcpip.LingerOption"
|
|
}
|
|
|
|
func (l *LingerOption) StateFields() []string {
|
|
return []string{
|
|
"Enabled",
|
|
"Timeout",
|
|
}
|
|
}
|
|
|
|
func (l *LingerOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (l *LingerOption) StateSave(stateSinkObject state.Sink) {
|
|
l.beforeSave()
|
|
stateSinkObject.Save(0, &l.Enabled)
|
|
stateSinkObject.Save(1, &l.Timeout)
|
|
}
|
|
|
|
func (l *LingerOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (l *LingerOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &l.Enabled)
|
|
stateSourceObject.Load(1, &l.Timeout)
|
|
}
|
|
|
|
func (i *IPPacketInfo) StateTypeName() string {
|
|
return "pkg/tcpip.IPPacketInfo"
|
|
}
|
|
|
|
func (i *IPPacketInfo) StateFields() []string {
|
|
return []string{
|
|
"NIC",
|
|
"LocalAddr",
|
|
"DestinationAddr",
|
|
}
|
|
}
|
|
|
|
func (i *IPPacketInfo) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPPacketInfo) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.NIC)
|
|
stateSinkObject.Save(1, &i.LocalAddr)
|
|
stateSinkObject.Save(2, &i.DestinationAddr)
|
|
}
|
|
|
|
func (i *IPPacketInfo) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.NIC)
|
|
stateSourceObject.Load(1, &i.LocalAddr)
|
|
stateSourceObject.Load(2, &i.DestinationAddr)
|
|
}
|
|
|
|
func (i *IPv6PacketInfo) StateTypeName() string {
|
|
return "pkg/tcpip.IPv6PacketInfo"
|
|
}
|
|
|
|
func (i *IPv6PacketInfo) StateFields() []string {
|
|
return []string{
|
|
"Addr",
|
|
"NIC",
|
|
}
|
|
}
|
|
|
|
func (i *IPv6PacketInfo) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPv6PacketInfo) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.Addr)
|
|
stateSinkObject.Save(1, &i.NIC)
|
|
}
|
|
|
|
func (i *IPv6PacketInfo) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPv6PacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.Addr)
|
|
stateSourceObject.Load(1, &i.NIC)
|
|
}
|
|
|
|
func (s *SendBufferSizeOption) StateTypeName() string {
|
|
return "pkg/tcpip.SendBufferSizeOption"
|
|
}
|
|
|
|
func (s *SendBufferSizeOption) StateFields() []string {
|
|
return []string{
|
|
"Min",
|
|
"Default",
|
|
"Max",
|
|
}
|
|
}
|
|
|
|
func (s *SendBufferSizeOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendBufferSizeOption) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.Min)
|
|
stateSinkObject.Save(1, &s.Default)
|
|
stateSinkObject.Save(2, &s.Max)
|
|
}
|
|
|
|
func (s *SendBufferSizeOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendBufferSizeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.Min)
|
|
stateSourceObject.Load(1, &s.Default)
|
|
stateSourceObject.Load(2, &s.Max)
|
|
}
|
|
|
|
func (r *ReceiveBufferSizeOption) StateTypeName() string {
|
|
return "pkg/tcpip.ReceiveBufferSizeOption"
|
|
}
|
|
|
|
func (r *ReceiveBufferSizeOption) StateFields() []string {
|
|
return []string{
|
|
"Min",
|
|
"Default",
|
|
"Max",
|
|
}
|
|
}
|
|
|
|
func (r *ReceiveBufferSizeOption) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReceiveBufferSizeOption) StateSave(stateSinkObject state.Sink) {
|
|
r.beforeSave()
|
|
stateSinkObject.Save(0, &r.Min)
|
|
stateSinkObject.Save(1, &r.Default)
|
|
stateSinkObject.Save(2, &r.Max)
|
|
}
|
|
|
|
func (r *ReceiveBufferSizeOption) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReceiveBufferSizeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &r.Min)
|
|
stateSourceObject.Load(1, &r.Default)
|
|
stateSourceObject.Load(2, &r.Max)
|
|
}
|
|
|
|
func (r *Route) StateTypeName() string {
|
|
return "pkg/tcpip.Route"
|
|
}
|
|
|
|
func (r *Route) StateFields() []string {
|
|
return []string{
|
|
"RouteEntry",
|
|
"Destination",
|
|
"Gateway",
|
|
"NIC",
|
|
"SourceHint",
|
|
"MTU",
|
|
}
|
|
}
|
|
|
|
func (r *Route) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (r *Route) StateSave(stateSinkObject state.Sink) {
|
|
r.beforeSave()
|
|
stateSinkObject.Save(0, &r.RouteEntry)
|
|
stateSinkObject.Save(1, &r.Destination)
|
|
stateSinkObject.Save(2, &r.Gateway)
|
|
stateSinkObject.Save(3, &r.NIC)
|
|
stateSinkObject.Save(4, &r.SourceHint)
|
|
stateSinkObject.Save(5, &r.MTU)
|
|
}
|
|
|
|
func (r *Route) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (r *Route) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &r.RouteEntry)
|
|
stateSourceObject.Load(1, &r.Destination)
|
|
stateSourceObject.Load(2, &r.Gateway)
|
|
stateSourceObject.Load(3, &r.NIC)
|
|
stateSourceObject.Load(4, &r.SourceHint)
|
|
stateSourceObject.Load(5, &r.MTU)
|
|
}
|
|
|
|
func (s *StatCounter) StateTypeName() string {
|
|
return "pkg/tcpip.StatCounter"
|
|
}
|
|
|
|
func (s *StatCounter) StateFields() []string {
|
|
return []string{
|
|
"count",
|
|
}
|
|
}
|
|
|
|
func (s *StatCounter) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *StatCounter) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.count)
|
|
}
|
|
|
|
func (s *StatCounter) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *StatCounter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.count)
|
|
}
|
|
|
|
func (m *MultiCounterStat) StateTypeName() string {
|
|
return "pkg/tcpip.MultiCounterStat"
|
|
}
|
|
|
|
func (m *MultiCounterStat) StateFields() []string {
|
|
return []string{
|
|
"a",
|
|
"b",
|
|
}
|
|
}
|
|
|
|
func (m *MultiCounterStat) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (m *MultiCounterStat) StateSave(stateSinkObject state.Sink) {
|
|
m.beforeSave()
|
|
stateSinkObject.Save(0, &m.a)
|
|
stateSinkObject.Save(1, &m.b)
|
|
}
|
|
|
|
func (m *MultiCounterStat) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (m *MultiCounterStat) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &m.a)
|
|
stateSourceObject.Load(1, &m.b)
|
|
}
|
|
|
|
func (i *ICMPv4PacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv4PacketStats"
|
|
}
|
|
|
|
func (i *ICMPv4PacketStats) StateFields() []string {
|
|
return []string{
|
|
"EchoRequest",
|
|
"EchoReply",
|
|
"DstUnreachable",
|
|
"SrcQuench",
|
|
"Redirect",
|
|
"TimeExceeded",
|
|
"ParamProblem",
|
|
"Timestamp",
|
|
"TimestampReply",
|
|
"InfoRequest",
|
|
"InfoReply",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv4PacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4PacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.EchoRequest)
|
|
stateSinkObject.Save(1, &i.EchoReply)
|
|
stateSinkObject.Save(2, &i.DstUnreachable)
|
|
stateSinkObject.Save(3, &i.SrcQuench)
|
|
stateSinkObject.Save(4, &i.Redirect)
|
|
stateSinkObject.Save(5, &i.TimeExceeded)
|
|
stateSinkObject.Save(6, &i.ParamProblem)
|
|
stateSinkObject.Save(7, &i.Timestamp)
|
|
stateSinkObject.Save(8, &i.TimestampReply)
|
|
stateSinkObject.Save(9, &i.InfoRequest)
|
|
stateSinkObject.Save(10, &i.InfoReply)
|
|
}
|
|
|
|
func (i *ICMPv4PacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4PacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.EchoRequest)
|
|
stateSourceObject.Load(1, &i.EchoReply)
|
|
stateSourceObject.Load(2, &i.DstUnreachable)
|
|
stateSourceObject.Load(3, &i.SrcQuench)
|
|
stateSourceObject.Load(4, &i.Redirect)
|
|
stateSourceObject.Load(5, &i.TimeExceeded)
|
|
stateSourceObject.Load(6, &i.ParamProblem)
|
|
stateSourceObject.Load(7, &i.Timestamp)
|
|
stateSourceObject.Load(8, &i.TimestampReply)
|
|
stateSourceObject.Load(9, &i.InfoRequest)
|
|
stateSourceObject.Load(10, &i.InfoReply)
|
|
}
|
|
|
|
func (i *ICMPv4SentPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv4SentPacketStats"
|
|
}
|
|
|
|
func (i *ICMPv4SentPacketStats) StateFields() []string {
|
|
return []string{
|
|
"ICMPv4PacketStats",
|
|
"Dropped",
|
|
"RateLimited",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv4SentPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4SentPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.ICMPv4PacketStats)
|
|
stateSinkObject.Save(1, &i.Dropped)
|
|
stateSinkObject.Save(2, &i.RateLimited)
|
|
}
|
|
|
|
func (i *ICMPv4SentPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4SentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.ICMPv4PacketStats)
|
|
stateSourceObject.Load(1, &i.Dropped)
|
|
stateSourceObject.Load(2, &i.RateLimited)
|
|
}
|
|
|
|
func (i *ICMPv4ReceivedPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv4ReceivedPacketStats"
|
|
}
|
|
|
|
func (i *ICMPv4ReceivedPacketStats) StateFields() []string {
|
|
return []string{
|
|
"ICMPv4PacketStats",
|
|
"Invalid",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv4ReceivedPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4ReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.ICMPv4PacketStats)
|
|
stateSinkObject.Save(1, &i.Invalid)
|
|
}
|
|
|
|
func (i *ICMPv4ReceivedPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4ReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.ICMPv4PacketStats)
|
|
stateSourceObject.Load(1, &i.Invalid)
|
|
}
|
|
|
|
func (i *ICMPv4Stats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv4Stats"
|
|
}
|
|
|
|
func (i *ICMPv4Stats) StateFields() []string {
|
|
return []string{
|
|
"PacketsSent",
|
|
"PacketsReceived",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv4Stats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4Stats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.PacketsSent)
|
|
stateSinkObject.Save(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *ICMPv4Stats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv4Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.PacketsSent)
|
|
stateSourceObject.Load(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *ICMPv6PacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv6PacketStats"
|
|
}
|
|
|
|
func (i *ICMPv6PacketStats) StateFields() []string {
|
|
return []string{
|
|
"EchoRequest",
|
|
"EchoReply",
|
|
"DstUnreachable",
|
|
"PacketTooBig",
|
|
"TimeExceeded",
|
|
"ParamProblem",
|
|
"RouterSolicit",
|
|
"RouterAdvert",
|
|
"NeighborSolicit",
|
|
"NeighborAdvert",
|
|
"RedirectMsg",
|
|
"MulticastListenerQuery",
|
|
"MulticastListenerReport",
|
|
"MulticastListenerReportV2",
|
|
"MulticastListenerDone",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv6PacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6PacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.EchoRequest)
|
|
stateSinkObject.Save(1, &i.EchoReply)
|
|
stateSinkObject.Save(2, &i.DstUnreachable)
|
|
stateSinkObject.Save(3, &i.PacketTooBig)
|
|
stateSinkObject.Save(4, &i.TimeExceeded)
|
|
stateSinkObject.Save(5, &i.ParamProblem)
|
|
stateSinkObject.Save(6, &i.RouterSolicit)
|
|
stateSinkObject.Save(7, &i.RouterAdvert)
|
|
stateSinkObject.Save(8, &i.NeighborSolicit)
|
|
stateSinkObject.Save(9, &i.NeighborAdvert)
|
|
stateSinkObject.Save(10, &i.RedirectMsg)
|
|
stateSinkObject.Save(11, &i.MulticastListenerQuery)
|
|
stateSinkObject.Save(12, &i.MulticastListenerReport)
|
|
stateSinkObject.Save(13, &i.MulticastListenerReportV2)
|
|
stateSinkObject.Save(14, &i.MulticastListenerDone)
|
|
}
|
|
|
|
func (i *ICMPv6PacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6PacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.EchoRequest)
|
|
stateSourceObject.Load(1, &i.EchoReply)
|
|
stateSourceObject.Load(2, &i.DstUnreachable)
|
|
stateSourceObject.Load(3, &i.PacketTooBig)
|
|
stateSourceObject.Load(4, &i.TimeExceeded)
|
|
stateSourceObject.Load(5, &i.ParamProblem)
|
|
stateSourceObject.Load(6, &i.RouterSolicit)
|
|
stateSourceObject.Load(7, &i.RouterAdvert)
|
|
stateSourceObject.Load(8, &i.NeighborSolicit)
|
|
stateSourceObject.Load(9, &i.NeighborAdvert)
|
|
stateSourceObject.Load(10, &i.RedirectMsg)
|
|
stateSourceObject.Load(11, &i.MulticastListenerQuery)
|
|
stateSourceObject.Load(12, &i.MulticastListenerReport)
|
|
stateSourceObject.Load(13, &i.MulticastListenerReportV2)
|
|
stateSourceObject.Load(14, &i.MulticastListenerDone)
|
|
}
|
|
|
|
func (i *ICMPv6SentPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv6SentPacketStats"
|
|
}
|
|
|
|
func (i *ICMPv6SentPacketStats) StateFields() []string {
|
|
return []string{
|
|
"ICMPv6PacketStats",
|
|
"Dropped",
|
|
"RateLimited",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv6SentPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6SentPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.ICMPv6PacketStats)
|
|
stateSinkObject.Save(1, &i.Dropped)
|
|
stateSinkObject.Save(2, &i.RateLimited)
|
|
}
|
|
|
|
func (i *ICMPv6SentPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6SentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.ICMPv6PacketStats)
|
|
stateSourceObject.Load(1, &i.Dropped)
|
|
stateSourceObject.Load(2, &i.RateLimited)
|
|
}
|
|
|
|
func (i *ICMPv6ReceivedPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv6ReceivedPacketStats"
|
|
}
|
|
|
|
func (i *ICMPv6ReceivedPacketStats) StateFields() []string {
|
|
return []string{
|
|
"ICMPv6PacketStats",
|
|
"Unrecognized",
|
|
"Invalid",
|
|
"RouterOnlyPacketsDroppedByHost",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv6ReceivedPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6ReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.ICMPv6PacketStats)
|
|
stateSinkObject.Save(1, &i.Unrecognized)
|
|
stateSinkObject.Save(2, &i.Invalid)
|
|
stateSinkObject.Save(3, &i.RouterOnlyPacketsDroppedByHost)
|
|
}
|
|
|
|
func (i *ICMPv6ReceivedPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6ReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.ICMPv6PacketStats)
|
|
stateSourceObject.Load(1, &i.Unrecognized)
|
|
stateSourceObject.Load(2, &i.Invalid)
|
|
stateSourceObject.Load(3, &i.RouterOnlyPacketsDroppedByHost)
|
|
}
|
|
|
|
func (i *ICMPv6Stats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPv6Stats"
|
|
}
|
|
|
|
func (i *ICMPv6Stats) StateFields() []string {
|
|
return []string{
|
|
"PacketsSent",
|
|
"PacketsReceived",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPv6Stats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6Stats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.PacketsSent)
|
|
stateSinkObject.Save(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *ICMPv6Stats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPv6Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.PacketsSent)
|
|
stateSourceObject.Load(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *ICMPStats) StateTypeName() string {
|
|
return "pkg/tcpip.ICMPStats"
|
|
}
|
|
|
|
func (i *ICMPStats) StateFields() []string {
|
|
return []string{
|
|
"V4",
|
|
"V6",
|
|
}
|
|
}
|
|
|
|
func (i *ICMPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.V4)
|
|
stateSinkObject.Save(1, &i.V6)
|
|
}
|
|
|
|
func (i *ICMPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *ICMPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.V4)
|
|
stateSourceObject.Load(1, &i.V6)
|
|
}
|
|
|
|
func (i *IGMPPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.IGMPPacketStats"
|
|
}
|
|
|
|
func (i *IGMPPacketStats) StateFields() []string {
|
|
return []string{
|
|
"MembershipQuery",
|
|
"V1MembershipReport",
|
|
"V2MembershipReport",
|
|
"V3MembershipReport",
|
|
"LeaveGroup",
|
|
}
|
|
}
|
|
|
|
func (i *IGMPPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.MembershipQuery)
|
|
stateSinkObject.Save(1, &i.V1MembershipReport)
|
|
stateSinkObject.Save(2, &i.V2MembershipReport)
|
|
stateSinkObject.Save(3, &i.V3MembershipReport)
|
|
stateSinkObject.Save(4, &i.LeaveGroup)
|
|
}
|
|
|
|
func (i *IGMPPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.MembershipQuery)
|
|
stateSourceObject.Load(1, &i.V1MembershipReport)
|
|
stateSourceObject.Load(2, &i.V2MembershipReport)
|
|
stateSourceObject.Load(3, &i.V3MembershipReport)
|
|
stateSourceObject.Load(4, &i.LeaveGroup)
|
|
}
|
|
|
|
func (i *IGMPSentPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.IGMPSentPacketStats"
|
|
}
|
|
|
|
func (i *IGMPSentPacketStats) StateFields() []string {
|
|
return []string{
|
|
"IGMPPacketStats",
|
|
"Dropped",
|
|
}
|
|
}
|
|
|
|
func (i *IGMPSentPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPSentPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.IGMPPacketStats)
|
|
stateSinkObject.Save(1, &i.Dropped)
|
|
}
|
|
|
|
func (i *IGMPSentPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPSentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.IGMPPacketStats)
|
|
stateSourceObject.Load(1, &i.Dropped)
|
|
}
|
|
|
|
func (i *IGMPReceivedPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.IGMPReceivedPacketStats"
|
|
}
|
|
|
|
func (i *IGMPReceivedPacketStats) StateFields() []string {
|
|
return []string{
|
|
"IGMPPacketStats",
|
|
"Invalid",
|
|
"ChecksumErrors",
|
|
"Unrecognized",
|
|
}
|
|
}
|
|
|
|
func (i *IGMPReceivedPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.IGMPPacketStats)
|
|
stateSinkObject.Save(1, &i.Invalid)
|
|
stateSinkObject.Save(2, &i.ChecksumErrors)
|
|
stateSinkObject.Save(3, &i.Unrecognized)
|
|
}
|
|
|
|
func (i *IGMPReceivedPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.IGMPPacketStats)
|
|
stateSourceObject.Load(1, &i.Invalid)
|
|
stateSourceObject.Load(2, &i.ChecksumErrors)
|
|
stateSourceObject.Load(3, &i.Unrecognized)
|
|
}
|
|
|
|
func (i *IGMPStats) StateTypeName() string {
|
|
return "pkg/tcpip.IGMPStats"
|
|
}
|
|
|
|
func (i *IGMPStats) StateFields() []string {
|
|
return []string{
|
|
"PacketsSent",
|
|
"PacketsReceived",
|
|
}
|
|
}
|
|
|
|
func (i *IGMPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.PacketsSent)
|
|
stateSinkObject.Save(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *IGMPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IGMPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.PacketsSent)
|
|
stateSourceObject.Load(1, &i.PacketsReceived)
|
|
}
|
|
|
|
func (i *IPForwardingStats) StateTypeName() string {
|
|
return "pkg/tcpip.IPForwardingStats"
|
|
}
|
|
|
|
func (i *IPForwardingStats) StateFields() []string {
|
|
return []string{
|
|
"Unrouteable",
|
|
"ExhaustedTTL",
|
|
"InitializingSource",
|
|
"LinkLocalSource",
|
|
"LinkLocalDestination",
|
|
"PacketTooBig",
|
|
"HostUnreachable",
|
|
"ExtensionHeaderProblem",
|
|
"UnexpectedMulticastInputInterface",
|
|
"UnknownOutputEndpoint",
|
|
"NoMulticastPendingQueueBufferSpace",
|
|
"OutgoingDeviceNoBufferSpace",
|
|
"Errors",
|
|
"OutgoingDeviceClosedForSend",
|
|
}
|
|
}
|
|
|
|
func (i *IPForwardingStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPForwardingStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.Unrouteable)
|
|
stateSinkObject.Save(1, &i.ExhaustedTTL)
|
|
stateSinkObject.Save(2, &i.InitializingSource)
|
|
stateSinkObject.Save(3, &i.LinkLocalSource)
|
|
stateSinkObject.Save(4, &i.LinkLocalDestination)
|
|
stateSinkObject.Save(5, &i.PacketTooBig)
|
|
stateSinkObject.Save(6, &i.HostUnreachable)
|
|
stateSinkObject.Save(7, &i.ExtensionHeaderProblem)
|
|
stateSinkObject.Save(8, &i.UnexpectedMulticastInputInterface)
|
|
stateSinkObject.Save(9, &i.UnknownOutputEndpoint)
|
|
stateSinkObject.Save(10, &i.NoMulticastPendingQueueBufferSpace)
|
|
stateSinkObject.Save(11, &i.OutgoingDeviceNoBufferSpace)
|
|
stateSinkObject.Save(12, &i.Errors)
|
|
stateSinkObject.Save(13, &i.OutgoingDeviceClosedForSend)
|
|
}
|
|
|
|
func (i *IPForwardingStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPForwardingStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.Unrouteable)
|
|
stateSourceObject.Load(1, &i.ExhaustedTTL)
|
|
stateSourceObject.Load(2, &i.InitializingSource)
|
|
stateSourceObject.Load(3, &i.LinkLocalSource)
|
|
stateSourceObject.Load(4, &i.LinkLocalDestination)
|
|
stateSourceObject.Load(5, &i.PacketTooBig)
|
|
stateSourceObject.Load(6, &i.HostUnreachable)
|
|
stateSourceObject.Load(7, &i.ExtensionHeaderProblem)
|
|
stateSourceObject.Load(8, &i.UnexpectedMulticastInputInterface)
|
|
stateSourceObject.Load(9, &i.UnknownOutputEndpoint)
|
|
stateSourceObject.Load(10, &i.NoMulticastPendingQueueBufferSpace)
|
|
stateSourceObject.Load(11, &i.OutgoingDeviceNoBufferSpace)
|
|
stateSourceObject.Load(12, &i.Errors)
|
|
stateSourceObject.Load(13, &i.OutgoingDeviceClosedForSend)
|
|
}
|
|
|
|
func (i *IPStats) StateTypeName() string {
|
|
return "pkg/tcpip.IPStats"
|
|
}
|
|
|
|
func (i *IPStats) StateFields() []string {
|
|
return []string{
|
|
"PacketsReceived",
|
|
"ValidPacketsReceived",
|
|
"DisabledPacketsReceived",
|
|
"InvalidDestinationAddressesReceived",
|
|
"InvalidSourceAddressesReceived",
|
|
"PacketsDelivered",
|
|
"PacketsSent",
|
|
"OutgoingPacketErrors",
|
|
"MalformedPacketsReceived",
|
|
"MalformedFragmentsReceived",
|
|
"IPTablesPreroutingDropped",
|
|
"IPTablesInputDropped",
|
|
"IPTablesForwardDropped",
|
|
"IPTablesOutputDropped",
|
|
"IPTablesPostroutingDropped",
|
|
"OptionTimestampReceived",
|
|
"OptionRecordRouteReceived",
|
|
"OptionRouterAlertReceived",
|
|
"OptionUnknownReceived",
|
|
"Forwarding",
|
|
}
|
|
}
|
|
|
|
func (i *IPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPStats) StateSave(stateSinkObject state.Sink) {
|
|
i.beforeSave()
|
|
stateSinkObject.Save(0, &i.PacketsReceived)
|
|
stateSinkObject.Save(1, &i.ValidPacketsReceived)
|
|
stateSinkObject.Save(2, &i.DisabledPacketsReceived)
|
|
stateSinkObject.Save(3, &i.InvalidDestinationAddressesReceived)
|
|
stateSinkObject.Save(4, &i.InvalidSourceAddressesReceived)
|
|
stateSinkObject.Save(5, &i.PacketsDelivered)
|
|
stateSinkObject.Save(6, &i.PacketsSent)
|
|
stateSinkObject.Save(7, &i.OutgoingPacketErrors)
|
|
stateSinkObject.Save(8, &i.MalformedPacketsReceived)
|
|
stateSinkObject.Save(9, &i.MalformedFragmentsReceived)
|
|
stateSinkObject.Save(10, &i.IPTablesPreroutingDropped)
|
|
stateSinkObject.Save(11, &i.IPTablesInputDropped)
|
|
stateSinkObject.Save(12, &i.IPTablesForwardDropped)
|
|
stateSinkObject.Save(13, &i.IPTablesOutputDropped)
|
|
stateSinkObject.Save(14, &i.IPTablesPostroutingDropped)
|
|
stateSinkObject.Save(15, &i.OptionTimestampReceived)
|
|
stateSinkObject.Save(16, &i.OptionRecordRouteReceived)
|
|
stateSinkObject.Save(17, &i.OptionRouterAlertReceived)
|
|
stateSinkObject.Save(18, &i.OptionUnknownReceived)
|
|
stateSinkObject.Save(19, &i.Forwarding)
|
|
}
|
|
|
|
func (i *IPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (i *IPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &i.PacketsReceived)
|
|
stateSourceObject.Load(1, &i.ValidPacketsReceived)
|
|
stateSourceObject.Load(2, &i.DisabledPacketsReceived)
|
|
stateSourceObject.Load(3, &i.InvalidDestinationAddressesReceived)
|
|
stateSourceObject.Load(4, &i.InvalidSourceAddressesReceived)
|
|
stateSourceObject.Load(5, &i.PacketsDelivered)
|
|
stateSourceObject.Load(6, &i.PacketsSent)
|
|
stateSourceObject.Load(7, &i.OutgoingPacketErrors)
|
|
stateSourceObject.Load(8, &i.MalformedPacketsReceived)
|
|
stateSourceObject.Load(9, &i.MalformedFragmentsReceived)
|
|
stateSourceObject.Load(10, &i.IPTablesPreroutingDropped)
|
|
stateSourceObject.Load(11, &i.IPTablesInputDropped)
|
|
stateSourceObject.Load(12, &i.IPTablesForwardDropped)
|
|
stateSourceObject.Load(13, &i.IPTablesOutputDropped)
|
|
stateSourceObject.Load(14, &i.IPTablesPostroutingDropped)
|
|
stateSourceObject.Load(15, &i.OptionTimestampReceived)
|
|
stateSourceObject.Load(16, &i.OptionRecordRouteReceived)
|
|
stateSourceObject.Load(17, &i.OptionRouterAlertReceived)
|
|
stateSourceObject.Load(18, &i.OptionUnknownReceived)
|
|
stateSourceObject.Load(19, &i.Forwarding)
|
|
}
|
|
|
|
func (a *ARPStats) StateTypeName() string {
|
|
return "pkg/tcpip.ARPStats"
|
|
}
|
|
|
|
func (a *ARPStats) StateFields() []string {
|
|
return []string{
|
|
"PacketsReceived",
|
|
"DisabledPacketsReceived",
|
|
"MalformedPacketsReceived",
|
|
"RequestsReceived",
|
|
"RequestsReceivedUnknownTargetAddress",
|
|
"OutgoingRequestInterfaceHasNoLocalAddressErrors",
|
|
"OutgoingRequestBadLocalAddressErrors",
|
|
"OutgoingRequestsDropped",
|
|
"OutgoingRequestsSent",
|
|
"RepliesReceived",
|
|
"OutgoingRepliesDropped",
|
|
"OutgoingRepliesSent",
|
|
}
|
|
}
|
|
|
|
func (a *ARPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (a *ARPStats) StateSave(stateSinkObject state.Sink) {
|
|
a.beforeSave()
|
|
stateSinkObject.Save(0, &a.PacketsReceived)
|
|
stateSinkObject.Save(1, &a.DisabledPacketsReceived)
|
|
stateSinkObject.Save(2, &a.MalformedPacketsReceived)
|
|
stateSinkObject.Save(3, &a.RequestsReceived)
|
|
stateSinkObject.Save(4, &a.RequestsReceivedUnknownTargetAddress)
|
|
stateSinkObject.Save(5, &a.OutgoingRequestInterfaceHasNoLocalAddressErrors)
|
|
stateSinkObject.Save(6, &a.OutgoingRequestBadLocalAddressErrors)
|
|
stateSinkObject.Save(7, &a.OutgoingRequestsDropped)
|
|
stateSinkObject.Save(8, &a.OutgoingRequestsSent)
|
|
stateSinkObject.Save(9, &a.RepliesReceived)
|
|
stateSinkObject.Save(10, &a.OutgoingRepliesDropped)
|
|
stateSinkObject.Save(11, &a.OutgoingRepliesSent)
|
|
}
|
|
|
|
func (a *ARPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (a *ARPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &a.PacketsReceived)
|
|
stateSourceObject.Load(1, &a.DisabledPacketsReceived)
|
|
stateSourceObject.Load(2, &a.MalformedPacketsReceived)
|
|
stateSourceObject.Load(3, &a.RequestsReceived)
|
|
stateSourceObject.Load(4, &a.RequestsReceivedUnknownTargetAddress)
|
|
stateSourceObject.Load(5, &a.OutgoingRequestInterfaceHasNoLocalAddressErrors)
|
|
stateSourceObject.Load(6, &a.OutgoingRequestBadLocalAddressErrors)
|
|
stateSourceObject.Load(7, &a.OutgoingRequestsDropped)
|
|
stateSourceObject.Load(8, &a.OutgoingRequestsSent)
|
|
stateSourceObject.Load(9, &a.RepliesReceived)
|
|
stateSourceObject.Load(10, &a.OutgoingRepliesDropped)
|
|
stateSourceObject.Load(11, &a.OutgoingRepliesSent)
|
|
}
|
|
|
|
func (t *TCPStats) StateTypeName() string {
|
|
return "pkg/tcpip.TCPStats"
|
|
}
|
|
|
|
func (t *TCPStats) StateFields() []string {
|
|
return []string{
|
|
"ActiveConnectionOpenings",
|
|
"PassiveConnectionOpenings",
|
|
"CurrentEstablished",
|
|
"CurrentConnected",
|
|
"EstablishedResets",
|
|
"EstablishedClosed",
|
|
"EstablishedTimedout",
|
|
"ListenOverflowSynDrop",
|
|
"ListenOverflowAckDrop",
|
|
"ListenOverflowSynCookieSent",
|
|
"ListenOverflowSynCookieRcvd",
|
|
"ListenOverflowInvalidSynCookieRcvd",
|
|
"FailedConnectionAttempts",
|
|
"ValidSegmentsReceived",
|
|
"InvalidSegmentsReceived",
|
|
"SegmentsSent",
|
|
"SegmentSendErrors",
|
|
"ResetsSent",
|
|
"ResetsReceived",
|
|
"Retransmits",
|
|
"FastRecovery",
|
|
"SACKRecovery",
|
|
"TLPRecovery",
|
|
"SlowStartRetransmits",
|
|
"FastRetransmit",
|
|
"Timeouts",
|
|
"ChecksumErrors",
|
|
"FailedPortReservations",
|
|
"SegmentsAckedWithDSACK",
|
|
"SpuriousRecovery",
|
|
"SpuriousRTORecovery",
|
|
"ForwardMaxInFlightDrop",
|
|
}
|
|
}
|
|
|
|
func (t *TCPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPStats) StateSave(stateSinkObject state.Sink) {
|
|
t.beforeSave()
|
|
stateSinkObject.Save(0, &t.ActiveConnectionOpenings)
|
|
stateSinkObject.Save(1, &t.PassiveConnectionOpenings)
|
|
stateSinkObject.Save(2, &t.CurrentEstablished)
|
|
stateSinkObject.Save(3, &t.CurrentConnected)
|
|
stateSinkObject.Save(4, &t.EstablishedResets)
|
|
stateSinkObject.Save(5, &t.EstablishedClosed)
|
|
stateSinkObject.Save(6, &t.EstablishedTimedout)
|
|
stateSinkObject.Save(7, &t.ListenOverflowSynDrop)
|
|
stateSinkObject.Save(8, &t.ListenOverflowAckDrop)
|
|
stateSinkObject.Save(9, &t.ListenOverflowSynCookieSent)
|
|
stateSinkObject.Save(10, &t.ListenOverflowSynCookieRcvd)
|
|
stateSinkObject.Save(11, &t.ListenOverflowInvalidSynCookieRcvd)
|
|
stateSinkObject.Save(12, &t.FailedConnectionAttempts)
|
|
stateSinkObject.Save(13, &t.ValidSegmentsReceived)
|
|
stateSinkObject.Save(14, &t.InvalidSegmentsReceived)
|
|
stateSinkObject.Save(15, &t.SegmentsSent)
|
|
stateSinkObject.Save(16, &t.SegmentSendErrors)
|
|
stateSinkObject.Save(17, &t.ResetsSent)
|
|
stateSinkObject.Save(18, &t.ResetsReceived)
|
|
stateSinkObject.Save(19, &t.Retransmits)
|
|
stateSinkObject.Save(20, &t.FastRecovery)
|
|
stateSinkObject.Save(21, &t.SACKRecovery)
|
|
stateSinkObject.Save(22, &t.TLPRecovery)
|
|
stateSinkObject.Save(23, &t.SlowStartRetransmits)
|
|
stateSinkObject.Save(24, &t.FastRetransmit)
|
|
stateSinkObject.Save(25, &t.Timeouts)
|
|
stateSinkObject.Save(26, &t.ChecksumErrors)
|
|
stateSinkObject.Save(27, &t.FailedPortReservations)
|
|
stateSinkObject.Save(28, &t.SegmentsAckedWithDSACK)
|
|
stateSinkObject.Save(29, &t.SpuriousRecovery)
|
|
stateSinkObject.Save(30, &t.SpuriousRTORecovery)
|
|
stateSinkObject.Save(31, &t.ForwardMaxInFlightDrop)
|
|
}
|
|
|
|
func (t *TCPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (t *TCPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &t.ActiveConnectionOpenings)
|
|
stateSourceObject.Load(1, &t.PassiveConnectionOpenings)
|
|
stateSourceObject.Load(2, &t.CurrentEstablished)
|
|
stateSourceObject.Load(3, &t.CurrentConnected)
|
|
stateSourceObject.Load(4, &t.EstablishedResets)
|
|
stateSourceObject.Load(5, &t.EstablishedClosed)
|
|
stateSourceObject.Load(6, &t.EstablishedTimedout)
|
|
stateSourceObject.Load(7, &t.ListenOverflowSynDrop)
|
|
stateSourceObject.Load(8, &t.ListenOverflowAckDrop)
|
|
stateSourceObject.Load(9, &t.ListenOverflowSynCookieSent)
|
|
stateSourceObject.Load(10, &t.ListenOverflowSynCookieRcvd)
|
|
stateSourceObject.Load(11, &t.ListenOverflowInvalidSynCookieRcvd)
|
|
stateSourceObject.Load(12, &t.FailedConnectionAttempts)
|
|
stateSourceObject.Load(13, &t.ValidSegmentsReceived)
|
|
stateSourceObject.Load(14, &t.InvalidSegmentsReceived)
|
|
stateSourceObject.Load(15, &t.SegmentsSent)
|
|
stateSourceObject.Load(16, &t.SegmentSendErrors)
|
|
stateSourceObject.Load(17, &t.ResetsSent)
|
|
stateSourceObject.Load(18, &t.ResetsReceived)
|
|
stateSourceObject.Load(19, &t.Retransmits)
|
|
stateSourceObject.Load(20, &t.FastRecovery)
|
|
stateSourceObject.Load(21, &t.SACKRecovery)
|
|
stateSourceObject.Load(22, &t.TLPRecovery)
|
|
stateSourceObject.Load(23, &t.SlowStartRetransmits)
|
|
stateSourceObject.Load(24, &t.FastRetransmit)
|
|
stateSourceObject.Load(25, &t.Timeouts)
|
|
stateSourceObject.Load(26, &t.ChecksumErrors)
|
|
stateSourceObject.Load(27, &t.FailedPortReservations)
|
|
stateSourceObject.Load(28, &t.SegmentsAckedWithDSACK)
|
|
stateSourceObject.Load(29, &t.SpuriousRecovery)
|
|
stateSourceObject.Load(30, &t.SpuriousRTORecovery)
|
|
stateSourceObject.Load(31, &t.ForwardMaxInFlightDrop)
|
|
}
|
|
|
|
func (u *UDPStats) StateTypeName() string {
|
|
return "pkg/tcpip.UDPStats"
|
|
}
|
|
|
|
func (u *UDPStats) StateFields() []string {
|
|
return []string{
|
|
"PacketsReceived",
|
|
"UnknownPortErrors",
|
|
"ReceiveBufferErrors",
|
|
"MalformedPacketsReceived",
|
|
"PacketsSent",
|
|
"PacketSendErrors",
|
|
"ChecksumErrors",
|
|
}
|
|
}
|
|
|
|
func (u *UDPStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (u *UDPStats) StateSave(stateSinkObject state.Sink) {
|
|
u.beforeSave()
|
|
stateSinkObject.Save(0, &u.PacketsReceived)
|
|
stateSinkObject.Save(1, &u.UnknownPortErrors)
|
|
stateSinkObject.Save(2, &u.ReceiveBufferErrors)
|
|
stateSinkObject.Save(3, &u.MalformedPacketsReceived)
|
|
stateSinkObject.Save(4, &u.PacketsSent)
|
|
stateSinkObject.Save(5, &u.PacketSendErrors)
|
|
stateSinkObject.Save(6, &u.ChecksumErrors)
|
|
}
|
|
|
|
func (u *UDPStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (u *UDPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &u.PacketsReceived)
|
|
stateSourceObject.Load(1, &u.UnknownPortErrors)
|
|
stateSourceObject.Load(2, &u.ReceiveBufferErrors)
|
|
stateSourceObject.Load(3, &u.MalformedPacketsReceived)
|
|
stateSourceObject.Load(4, &u.PacketsSent)
|
|
stateSourceObject.Load(5, &u.PacketSendErrors)
|
|
stateSourceObject.Load(6, &u.ChecksumErrors)
|
|
}
|
|
|
|
func (n *NICNeighborStats) StateTypeName() string {
|
|
return "pkg/tcpip.NICNeighborStats"
|
|
}
|
|
|
|
func (n *NICNeighborStats) StateFields() []string {
|
|
return []string{
|
|
"UnreachableEntryLookups",
|
|
"DroppedConfirmationForNoninitiatedNeighbor",
|
|
"DroppedInvalidLinkAddressConfirmations",
|
|
}
|
|
}
|
|
|
|
func (n *NICNeighborStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (n *NICNeighborStats) StateSave(stateSinkObject state.Sink) {
|
|
n.beforeSave()
|
|
stateSinkObject.Save(0, &n.UnreachableEntryLookups)
|
|
stateSinkObject.Save(1, &n.DroppedConfirmationForNoninitiatedNeighbor)
|
|
stateSinkObject.Save(2, &n.DroppedInvalidLinkAddressConfirmations)
|
|
}
|
|
|
|
func (n *NICNeighborStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (n *NICNeighborStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &n.UnreachableEntryLookups)
|
|
stateSourceObject.Load(1, &n.DroppedConfirmationForNoninitiatedNeighbor)
|
|
stateSourceObject.Load(2, &n.DroppedInvalidLinkAddressConfirmations)
|
|
}
|
|
|
|
func (n *NICPacketStats) StateTypeName() string {
|
|
return "pkg/tcpip.NICPacketStats"
|
|
}
|
|
|
|
func (n *NICPacketStats) StateFields() []string {
|
|
return []string{
|
|
"Packets",
|
|
"Bytes",
|
|
}
|
|
}
|
|
|
|
func (n *NICPacketStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (n *NICPacketStats) StateSave(stateSinkObject state.Sink) {
|
|
n.beforeSave()
|
|
stateSinkObject.Save(0, &n.Packets)
|
|
stateSinkObject.Save(1, &n.Bytes)
|
|
}
|
|
|
|
func (n *NICPacketStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (n *NICPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &n.Packets)
|
|
stateSourceObject.Load(1, &n.Bytes)
|
|
}
|
|
|
|
func (m *IntegralStatCounterMap) StateTypeName() string {
|
|
return "pkg/tcpip.IntegralStatCounterMap"
|
|
}
|
|
|
|
func (m *IntegralStatCounterMap) StateFields() []string {
|
|
return []string{
|
|
"counterMap",
|
|
}
|
|
}
|
|
|
|
func (m *IntegralStatCounterMap) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (m *IntegralStatCounterMap) StateSave(stateSinkObject state.Sink) {
|
|
m.beforeSave()
|
|
stateSinkObject.Save(0, &m.counterMap)
|
|
}
|
|
|
|
func (m *IntegralStatCounterMap) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (m *IntegralStatCounterMap) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &m.counterMap)
|
|
}
|
|
|
|
func (m *MultiIntegralStatCounterMap) StateTypeName() string {
|
|
return "pkg/tcpip.MultiIntegralStatCounterMap"
|
|
}
|
|
|
|
func (m *MultiIntegralStatCounterMap) StateFields() []string {
|
|
return []string{
|
|
"a",
|
|
"b",
|
|
}
|
|
}
|
|
|
|
func (m *MultiIntegralStatCounterMap) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (m *MultiIntegralStatCounterMap) StateSave(stateSinkObject state.Sink) {
|
|
m.beforeSave()
|
|
stateSinkObject.Save(0, &m.a)
|
|
stateSinkObject.Save(1, &m.b)
|
|
}
|
|
|
|
func (m *MultiIntegralStatCounterMap) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (m *MultiIntegralStatCounterMap) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &m.a)
|
|
stateSourceObject.Load(1, &m.b)
|
|
}
|
|
|
|
func (s *NICStats) StateTypeName() string {
|
|
return "pkg/tcpip.NICStats"
|
|
}
|
|
|
|
func (s *NICStats) StateFields() []string {
|
|
return []string{
|
|
"UnknownL3ProtocolRcvdPacketCounts",
|
|
"UnknownL4ProtocolRcvdPacketCounts",
|
|
"MalformedL4RcvdPackets",
|
|
"Tx",
|
|
"TxPacketsDroppedNoBufferSpace",
|
|
"Rx",
|
|
"DisabledRx",
|
|
"Neighbor",
|
|
}
|
|
}
|
|
|
|
func (s *NICStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *NICStats) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.UnknownL3ProtocolRcvdPacketCounts)
|
|
stateSinkObject.Save(1, &s.UnknownL4ProtocolRcvdPacketCounts)
|
|
stateSinkObject.Save(2, &s.MalformedL4RcvdPackets)
|
|
stateSinkObject.Save(3, &s.Tx)
|
|
stateSinkObject.Save(4, &s.TxPacketsDroppedNoBufferSpace)
|
|
stateSinkObject.Save(5, &s.Rx)
|
|
stateSinkObject.Save(6, &s.DisabledRx)
|
|
stateSinkObject.Save(7, &s.Neighbor)
|
|
}
|
|
|
|
func (s *NICStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *NICStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.UnknownL3ProtocolRcvdPacketCounts)
|
|
stateSourceObject.Load(1, &s.UnknownL4ProtocolRcvdPacketCounts)
|
|
stateSourceObject.Load(2, &s.MalformedL4RcvdPackets)
|
|
stateSourceObject.Load(3, &s.Tx)
|
|
stateSourceObject.Load(4, &s.TxPacketsDroppedNoBufferSpace)
|
|
stateSourceObject.Load(5, &s.Rx)
|
|
stateSourceObject.Load(6, &s.DisabledRx)
|
|
stateSourceObject.Load(7, &s.Neighbor)
|
|
}
|
|
|
|
func (s *Stats) StateTypeName() string {
|
|
return "pkg/tcpip.Stats"
|
|
}
|
|
|
|
func (s *Stats) StateFields() []string {
|
|
return []string{
|
|
"DroppedPackets",
|
|
"NICs",
|
|
"ICMP",
|
|
"IGMP",
|
|
"IP",
|
|
"ARP",
|
|
"TCP",
|
|
"UDP",
|
|
}
|
|
}
|
|
|
|
func (s *Stats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *Stats) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.DroppedPackets)
|
|
stateSinkObject.Save(1, &s.NICs)
|
|
stateSinkObject.Save(2, &s.ICMP)
|
|
stateSinkObject.Save(3, &s.IGMP)
|
|
stateSinkObject.Save(4, &s.IP)
|
|
stateSinkObject.Save(5, &s.ARP)
|
|
stateSinkObject.Save(6, &s.TCP)
|
|
stateSinkObject.Save(7, &s.UDP)
|
|
}
|
|
|
|
func (s *Stats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.DroppedPackets)
|
|
stateSourceObject.Load(1, &s.NICs)
|
|
stateSourceObject.Load(2, &s.ICMP)
|
|
stateSourceObject.Load(3, &s.IGMP)
|
|
stateSourceObject.Load(4, &s.IP)
|
|
stateSourceObject.Load(5, &s.ARP)
|
|
stateSourceObject.Load(6, &s.TCP)
|
|
stateSourceObject.Load(7, &s.UDP)
|
|
}
|
|
|
|
func (r *ReceiveErrors) StateTypeName() string {
|
|
return "pkg/tcpip.ReceiveErrors"
|
|
}
|
|
|
|
func (r *ReceiveErrors) StateFields() []string {
|
|
return []string{
|
|
"ReceiveBufferOverflow",
|
|
"MalformedPacketsReceived",
|
|
"ClosedReceiver",
|
|
"ChecksumErrors",
|
|
}
|
|
}
|
|
|
|
func (r *ReceiveErrors) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReceiveErrors) StateSave(stateSinkObject state.Sink) {
|
|
r.beforeSave()
|
|
stateSinkObject.Save(0, &r.ReceiveBufferOverflow)
|
|
stateSinkObject.Save(1, &r.MalformedPacketsReceived)
|
|
stateSinkObject.Save(2, &r.ClosedReceiver)
|
|
stateSinkObject.Save(3, &r.ChecksumErrors)
|
|
}
|
|
|
|
func (r *ReceiveErrors) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReceiveErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &r.ReceiveBufferOverflow)
|
|
stateSourceObject.Load(1, &r.MalformedPacketsReceived)
|
|
stateSourceObject.Load(2, &r.ClosedReceiver)
|
|
stateSourceObject.Load(3, &r.ChecksumErrors)
|
|
}
|
|
|
|
func (s *SendErrors) StateTypeName() string {
|
|
return "pkg/tcpip.SendErrors"
|
|
}
|
|
|
|
func (s *SendErrors) StateFields() []string {
|
|
return []string{
|
|
"SendToNetworkFailed",
|
|
"NoRoute",
|
|
}
|
|
}
|
|
|
|
func (s *SendErrors) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendErrors) StateSave(stateSinkObject state.Sink) {
|
|
s.beforeSave()
|
|
stateSinkObject.Save(0, &s.SendToNetworkFailed)
|
|
stateSinkObject.Save(1, &s.NoRoute)
|
|
}
|
|
|
|
func (s *SendErrors) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (s *SendErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &s.SendToNetworkFailed)
|
|
stateSourceObject.Load(1, &s.NoRoute)
|
|
}
|
|
|
|
func (r *ReadErrors) StateTypeName() string {
|
|
return "pkg/tcpip.ReadErrors"
|
|
}
|
|
|
|
func (r *ReadErrors) StateFields() []string {
|
|
return []string{
|
|
"ReadClosed",
|
|
"InvalidEndpointState",
|
|
"NotConnected",
|
|
}
|
|
}
|
|
|
|
func (r *ReadErrors) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReadErrors) StateSave(stateSinkObject state.Sink) {
|
|
r.beforeSave()
|
|
stateSinkObject.Save(0, &r.ReadClosed)
|
|
stateSinkObject.Save(1, &r.InvalidEndpointState)
|
|
stateSinkObject.Save(2, &r.NotConnected)
|
|
}
|
|
|
|
func (r *ReadErrors) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (r *ReadErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &r.ReadClosed)
|
|
stateSourceObject.Load(1, &r.InvalidEndpointState)
|
|
stateSourceObject.Load(2, &r.NotConnected)
|
|
}
|
|
|
|
func (w *WriteErrors) StateTypeName() string {
|
|
return "pkg/tcpip.WriteErrors"
|
|
}
|
|
|
|
func (w *WriteErrors) StateFields() []string {
|
|
return []string{
|
|
"WriteClosed",
|
|
"InvalidEndpointState",
|
|
"InvalidArgs",
|
|
}
|
|
}
|
|
|
|
func (w *WriteErrors) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (w *WriteErrors) StateSave(stateSinkObject state.Sink) {
|
|
w.beforeSave()
|
|
stateSinkObject.Save(0, &w.WriteClosed)
|
|
stateSinkObject.Save(1, &w.InvalidEndpointState)
|
|
stateSinkObject.Save(2, &w.InvalidArgs)
|
|
}
|
|
|
|
func (w *WriteErrors) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (w *WriteErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &w.WriteClosed)
|
|
stateSourceObject.Load(1, &w.InvalidEndpointState)
|
|
stateSourceObject.Load(2, &w.InvalidArgs)
|
|
}
|
|
|
|
func (src *TransportEndpointStats) StateTypeName() string {
|
|
return "pkg/tcpip.TransportEndpointStats"
|
|
}
|
|
|
|
func (src *TransportEndpointStats) StateFields() []string {
|
|
return []string{
|
|
"PacketsReceived",
|
|
"PacketsSent",
|
|
"ReceiveErrors",
|
|
"ReadErrors",
|
|
"SendErrors",
|
|
"WriteErrors",
|
|
}
|
|
}
|
|
|
|
func (src *TransportEndpointStats) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (src *TransportEndpointStats) StateSave(stateSinkObject state.Sink) {
|
|
src.beforeSave()
|
|
stateSinkObject.Save(0, &src.PacketsReceived)
|
|
stateSinkObject.Save(1, &src.PacketsSent)
|
|
stateSinkObject.Save(2, &src.ReceiveErrors)
|
|
stateSinkObject.Save(3, &src.ReadErrors)
|
|
stateSinkObject.Save(4, &src.SendErrors)
|
|
stateSinkObject.Save(5, &src.WriteErrors)
|
|
}
|
|
|
|
func (src *TransportEndpointStats) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (src *TransportEndpointStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &src.PacketsReceived)
|
|
stateSourceObject.Load(1, &src.PacketsSent)
|
|
stateSourceObject.Load(2, &src.ReceiveErrors)
|
|
stateSourceObject.Load(3, &src.ReadErrors)
|
|
stateSourceObject.Load(4, &src.SendErrors)
|
|
stateSourceObject.Load(5, &src.WriteErrors)
|
|
}
|
|
|
|
func (a *AddressWithPrefix) StateTypeName() string {
|
|
return "pkg/tcpip.AddressWithPrefix"
|
|
}
|
|
|
|
func (a *AddressWithPrefix) StateFields() []string {
|
|
return []string{
|
|
"Address",
|
|
"PrefixLen",
|
|
}
|
|
}
|
|
|
|
func (a *AddressWithPrefix) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (a *AddressWithPrefix) StateSave(stateSinkObject state.Sink) {
|
|
a.beforeSave()
|
|
stateSinkObject.Save(0, &a.Address)
|
|
stateSinkObject.Save(1, &a.PrefixLen)
|
|
}
|
|
|
|
func (a *AddressWithPrefix) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (a *AddressWithPrefix) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &a.Address)
|
|
stateSourceObject.Load(1, &a.PrefixLen)
|
|
}
|
|
|
|
func (p *ProtocolAddress) StateTypeName() string {
|
|
return "pkg/tcpip.ProtocolAddress"
|
|
}
|
|
|
|
func (p *ProtocolAddress) StateFields() []string {
|
|
return []string{
|
|
"Protocol",
|
|
"AddressWithPrefix",
|
|
}
|
|
}
|
|
|
|
func (p *ProtocolAddress) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (p *ProtocolAddress) StateSave(stateSinkObject state.Sink) {
|
|
p.beforeSave()
|
|
stateSinkObject.Save(0, &p.Protocol)
|
|
stateSinkObject.Save(1, &p.AddressWithPrefix)
|
|
}
|
|
|
|
func (p *ProtocolAddress) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (p *ProtocolAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &p.Protocol)
|
|
stateSourceObject.Load(1, &p.AddressWithPrefix)
|
|
}
|
|
|
|
func (j *jobInstance) StateTypeName() string {
|
|
return "pkg/tcpip.jobInstance"
|
|
}
|
|
|
|
func (j *jobInstance) StateFields() []string {
|
|
return []string{
|
|
"timer",
|
|
"earlyReturn",
|
|
}
|
|
}
|
|
|
|
func (j *jobInstance) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (j *jobInstance) StateSave(stateSinkObject state.Sink) {
|
|
j.beforeSave()
|
|
stateSinkObject.Save(0, &j.timer)
|
|
stateSinkObject.Save(1, &j.earlyReturn)
|
|
}
|
|
|
|
func (j *jobInstance) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (j *jobInstance) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &j.timer)
|
|
stateSourceObject.Load(1, &j.earlyReturn)
|
|
}
|
|
|
|
func (j *Job) StateTypeName() string {
|
|
return "pkg/tcpip.Job"
|
|
}
|
|
|
|
func (j *Job) StateFields() []string {
|
|
return []string{
|
|
"clock",
|
|
"instance",
|
|
}
|
|
}
|
|
|
|
func (j *Job) beforeSave() {}
|
|
|
|
// +checklocksignore
|
|
func (j *Job) StateSave(stateSinkObject state.Sink) {
|
|
j.beforeSave()
|
|
stateSinkObject.Save(0, &j.clock)
|
|
stateSinkObject.Save(1, &j.instance)
|
|
}
|
|
|
|
func (j *Job) afterLoad(context.Context) {}
|
|
|
|
// +checklocksignore
|
|
func (j *Job) StateLoad(ctx context.Context, stateSourceObject state.Source) {
|
|
stateSourceObject.Load(0, &j.clock)
|
|
stateSourceObject.Load(1, &j.instance)
|
|
}
|
|
|
|
func init() {
|
|
state.Register((*ErrAborted)(nil))
|
|
state.Register((*ErrAddressFamilyNotSupported)(nil))
|
|
state.Register((*ErrAlreadyBound)(nil))
|
|
state.Register((*ErrAlreadyConnected)(nil))
|
|
state.Register((*ErrAlreadyConnecting)(nil))
|
|
state.Register((*ErrBadAddress)(nil))
|
|
state.Register((*ErrBadBuffer)(nil))
|
|
state.Register((*ErrBadLocalAddress)(nil))
|
|
state.Register((*ErrBroadcastDisabled)(nil))
|
|
state.Register((*ErrClosedForReceive)(nil))
|
|
state.Register((*ErrClosedForSend)(nil))
|
|
state.Register((*ErrConnectStarted)(nil))
|
|
state.Register((*ErrConnectionAborted)(nil))
|
|
state.Register((*ErrConnectionRefused)(nil))
|
|
state.Register((*ErrConnectionReset)(nil))
|
|
state.Register((*ErrDestinationRequired)(nil))
|
|
state.Register((*ErrDuplicateAddress)(nil))
|
|
state.Register((*ErrDuplicateNICID)(nil))
|
|
state.Register((*ErrInvalidNICID)(nil))
|
|
state.Register((*ErrInvalidEndpointState)(nil))
|
|
state.Register((*ErrInvalidOptionValue)(nil))
|
|
state.Register((*ErrInvalidPortRange)(nil))
|
|
state.Register((*ErrMalformedHeader)(nil))
|
|
state.Register((*ErrMessageTooLong)(nil))
|
|
state.Register((*ErrNetworkUnreachable)(nil))
|
|
state.Register((*ErrNoBufferSpace)(nil))
|
|
state.Register((*ErrNoPortAvailable)(nil))
|
|
state.Register((*ErrHostUnreachable)(nil))
|
|
state.Register((*ErrHostDown)(nil))
|
|
state.Register((*ErrNoNet)(nil))
|
|
state.Register((*ErrNoSuchFile)(nil))
|
|
state.Register((*ErrNotConnected)(nil))
|
|
state.Register((*ErrNotPermitted)(nil))
|
|
state.Register((*ErrNotSupported)(nil))
|
|
state.Register((*ErrPortInUse)(nil))
|
|
state.Register((*ErrQueueSizeNotSupported)(nil))
|
|
state.Register((*ErrTimeout)(nil))
|
|
state.Register((*ErrUnknownDevice)(nil))
|
|
state.Register((*ErrUnknownNICID)(nil))
|
|
state.Register((*ErrUnknownProtocol)(nil))
|
|
state.Register((*ErrUnknownProtocolOption)(nil))
|
|
state.Register((*ErrWouldBlock)(nil))
|
|
state.Register((*ErrMissingRequiredFields)(nil))
|
|
state.Register((*ErrMulticastInputCannotBeOutput)(nil))
|
|
state.Register((*ErrEndpointBusy)(nil))
|
|
state.Register((*RouteList)(nil))
|
|
state.Register((*RouteEntry)(nil))
|
|
state.Register((*sockErrorList)(nil))
|
|
state.Register((*sockErrorEntry)(nil))
|
|
state.Register((*SocketOptions)(nil))
|
|
state.Register((*LocalSockError)(nil))
|
|
state.Register((*SockError)(nil))
|
|
state.Register((*stdClock)(nil))
|
|
state.Register((*stdTimer)(nil))
|
|
state.Register((*MonotonicTime)(nil))
|
|
state.Register((*Address)(nil))
|
|
state.Register((*AddressMask)(nil))
|
|
state.Register((*Subnet)(nil))
|
|
state.Register((*FullAddress)(nil))
|
|
state.Register((*SendableControlMessages)(nil))
|
|
state.Register((*ReceivableControlMessages)(nil))
|
|
state.Register((*LinkPacketInfo)(nil))
|
|
state.Register((*TCPSendBufferSizeRangeOption)(nil))
|
|
state.Register((*TCPReceiveBufferSizeRangeOption)(nil))
|
|
state.Register((*ICMPv6Filter)(nil))
|
|
state.Register((*TpacketReq)(nil))
|
|
state.Register((*TpacketStats)(nil))
|
|
state.Register((*LingerOption)(nil))
|
|
state.Register((*IPPacketInfo)(nil))
|
|
state.Register((*IPv6PacketInfo)(nil))
|
|
state.Register((*SendBufferSizeOption)(nil))
|
|
state.Register((*ReceiveBufferSizeOption)(nil))
|
|
state.Register((*Route)(nil))
|
|
state.Register((*StatCounter)(nil))
|
|
state.Register((*MultiCounterStat)(nil))
|
|
state.Register((*ICMPv4PacketStats)(nil))
|
|
state.Register((*ICMPv4SentPacketStats)(nil))
|
|
state.Register((*ICMPv4ReceivedPacketStats)(nil))
|
|
state.Register((*ICMPv4Stats)(nil))
|
|
state.Register((*ICMPv6PacketStats)(nil))
|
|
state.Register((*ICMPv6SentPacketStats)(nil))
|
|
state.Register((*ICMPv6ReceivedPacketStats)(nil))
|
|
state.Register((*ICMPv6Stats)(nil))
|
|
state.Register((*ICMPStats)(nil))
|
|
state.Register((*IGMPPacketStats)(nil))
|
|
state.Register((*IGMPSentPacketStats)(nil))
|
|
state.Register((*IGMPReceivedPacketStats)(nil))
|
|
state.Register((*IGMPStats)(nil))
|
|
state.Register((*IPForwardingStats)(nil))
|
|
state.Register((*IPStats)(nil))
|
|
state.Register((*ARPStats)(nil))
|
|
state.Register((*TCPStats)(nil))
|
|
state.Register((*UDPStats)(nil))
|
|
state.Register((*NICNeighborStats)(nil))
|
|
state.Register((*NICPacketStats)(nil))
|
|
state.Register((*IntegralStatCounterMap)(nil))
|
|
state.Register((*MultiIntegralStatCounterMap)(nil))
|
|
state.Register((*NICStats)(nil))
|
|
state.Register((*Stats)(nil))
|
|
state.Register((*ReceiveErrors)(nil))
|
|
state.Register((*SendErrors)(nil))
|
|
state.Register((*ReadErrors)(nil))
|
|
state.Register((*WriteErrors)(nil))
|
|
state.Register((*TransportEndpointStats)(nil))
|
|
state.Register((*AddressWithPrefix)(nil))
|
|
state.Register((*ProtocolAddress)(nil))
|
|
state.Register((*jobInstance)(nil))
|
|
state.Register((*Job)(nil))
|
|
}
|