Merge release-20200608.0-119-g364ac92ba (automated)

11 files changed, 1340 insertions, 683 deletions

diff --git a/pkg/tcpip/transport/icmp/icmp_packet_list.go b/pkg/tcpip/transport/icmp/icmp_packet_list.go
index 42d63f976..f69543bda 100644
--- a/pkg/tcpip/transport/icmp/icmp_packet_list.go
+++ b/pkg/tcpip/transport/icmp/icmp_packet_list.go
@@ -56,7 +56,7 @@ func (l *icmpPacketList) Back() *icmpPacket {
 //
 // NOTE: This is an O(n) operation.
 func (l *icmpPacketList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (icmpPacketElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *icmpPacketList) Remove(e *icmpPacket) {
 
 	if prev != nil {
 		icmpPacketElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		icmpPacketElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/icmp/icmp_state_autogen.go b/pkg/tcpip/transport/icmp/icmp_state_autogen.go
index c26460a4b..c6b278677 100644
--- a/pkg/tcpip/transport/icmp/icmp_state_autogen.go
+++ b/pkg/tcpip/transport/icmp/icmp_state_autogen.go
@@ -7,88 +7,151 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 )
 
+func (x *icmpPacket) StateTypeName() string {
+	return "pkg/tcpip/transport/icmp.icmpPacket"
+}
+
+func (x *icmpPacket) StateFields() []string {
+	return []string{
+		"icmpPacketEntry",
+		"senderAddress",
+		"data",
+		"timestamp",
+	}
+}
+
 func (x *icmpPacket) beforeSave() {}
-func (x *icmpPacket) save(m state.Map) {
+
+func (x *icmpPacket) StateSave(m state.Sink) {
 	x.beforeSave()
 	var data buffer.VectorisedView = x.saveData()
-	m.SaveValue("data", data)
-	m.Save("icmpPacketEntry", &x.icmpPacketEntry)
-	m.Save("senderAddress", &x.senderAddress)
-	m.Save("timestamp", &x.timestamp)
+	m.SaveValue(2, data)
+	m.Save(0, &x.icmpPacketEntry)
+	m.Save(1, &x.senderAddress)
+	m.Save(3, &x.timestamp)
 }
 
 func (x *icmpPacket) afterLoad() {}
-func (x *icmpPacket) load(m state.Map) {
-	m.Load("icmpPacketEntry", &x.icmpPacketEntry)
-	m.Load("senderAddress", &x.senderAddress)
-	m.Load("timestamp", &x.timestamp)
-	m.LoadValue("data", new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+
+func (x *icmpPacket) StateLoad(m state.Source) {
+	m.Load(0, &x.icmpPacketEntry)
+	m.Load(1, &x.senderAddress)
+	m.Load(3, &x.timestamp)
+	m.LoadValue(2, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
 }
 
-func (x *endpoint) save(m state.Map) {
+func (x *endpoint) StateTypeName() string {
+	return "pkg/tcpip/transport/icmp.endpoint"
+}
+
+func (x *endpoint) StateFields() []string {
+	return []string{
+		"TransportEndpointInfo",
+		"waiterQueue",
+		"uniqueID",
+		"rcvReady",
+		"rcvList",
+		"rcvBufSizeMax",
+		"rcvBufSize",
+		"rcvClosed",
+		"sndBufSize",
+		"shutdownFlags",
+		"state",
+		"ttl",
+		"owner",
+	}
+}
+
+func (x *endpoint) StateSave(m state.Sink) {
 	x.beforeSave()
 	var rcvBufSizeMax int = x.saveRcvBufSizeMax()
-	m.SaveValue("rcvBufSizeMax", rcvBufSizeMax)
-	m.Save("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Save("waiterQueue", &x.waiterQueue)
-	m.Save("uniqueID", &x.uniqueID)
-	m.Save("rcvReady", &x.rcvReady)
-	m.Save("rcvList", &x.rcvList)
-	m.Save("rcvBufSize", &x.rcvBufSize)
-	m.Save("rcvClosed", &x.rcvClosed)
-	m.Save("sndBufSize", &x.sndBufSize)
-	m.Save("shutdownFlags", &x.shutdownFlags)
-	m.Save("state", &x.state)
-	m.Save("ttl", &x.ttl)
-	m.Save("owner", &x.owner)
-}
-
-func (x *endpoint) load(m state.Map) {
-	m.Load("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Load("waiterQueue", &x.waiterQueue)
-	m.Load("uniqueID", &x.uniqueID)
-	m.Load("rcvReady", &x.rcvReady)
-	m.Load("rcvList", &x.rcvList)
-	m.Load("rcvBufSize", &x.rcvBufSize)
-	m.Load("rcvClosed", &x.rcvClosed)
-	m.Load("sndBufSize", &x.sndBufSize)
-	m.Load("shutdownFlags", &x.shutdownFlags)
-	m.Load("state", &x.state)
-	m.Load("ttl", &x.ttl)
-	m.Load("owner", &x.owner)
-	m.LoadValue("rcvBufSizeMax", new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
+	m.SaveValue(5, rcvBufSizeMax)
+	m.Save(0, &x.TransportEndpointInfo)
+	m.Save(1, &x.waiterQueue)
+	m.Save(2, &x.uniqueID)
+	m.Save(3, &x.rcvReady)
+	m.Save(4, &x.rcvList)
+	m.Save(6, &x.rcvBufSize)
+	m.Save(7, &x.rcvClosed)
+	m.Save(8, &x.sndBufSize)
+	m.Save(9, &x.shutdownFlags)
+	m.Save(10, &x.state)
+	m.Save(11, &x.ttl)
+	m.Save(12, &x.owner)
+}
+
+func (x *endpoint) StateLoad(m state.Source) {
+	m.Load(0, &x.TransportEndpointInfo)
+	m.Load(1, &x.waiterQueue)
+	m.Load(2, &x.uniqueID)
+	m.Load(3, &x.rcvReady)
+	m.Load(4, &x.rcvList)
+	m.Load(6, &x.rcvBufSize)
+	m.Load(7, &x.rcvClosed)
+	m.Load(8, &x.sndBufSize)
+	m.Load(9, &x.shutdownFlags)
+	m.Load(10, &x.state)
+	m.Load(11, &x.ttl)
+	m.Load(12, &x.owner)
+	m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *icmpPacketList) StateTypeName() string {
+	return "pkg/tcpip/transport/icmp.icmpPacketList"
+}
+
+func (x *icmpPacketList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
+}
+
 func (x *icmpPacketList) beforeSave() {}
-func (x *icmpPacketList) save(m state.Map) {
+
+func (x *icmpPacketList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *icmpPacketList) afterLoad() {}
-func (x *icmpPacketList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *icmpPacketList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *icmpPacketEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/icmp.icmpPacketEntry"
+}
+
+func (x *icmpPacketEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *icmpPacketEntry) beforeSave() {}
-func (x *icmpPacketEntry) save(m state.Map) {
+
+func (x *icmpPacketEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *icmpPacketEntry) afterLoad() {}
-func (x *icmpPacketEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *icmpPacketEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
 }
 
 func init() {
-	state.Register("pkg/tcpip/transport/icmp.icmpPacket", (*icmpPacket)(nil), state.Fns{Save: (*icmpPacket).save, Load: (*icmpPacket).load})
-	state.Register("pkg/tcpip/transport/icmp.endpoint", (*endpoint)(nil), state.Fns{Save: (*endpoint).save, Load: (*endpoint).load})
-	state.Register("pkg/tcpip/transport/icmp.icmpPacketList", (*icmpPacketList)(nil), state.Fns{Save: (*icmpPacketList).save, Load: (*icmpPacketList).load})
-	state.Register("pkg/tcpip/transport/icmp.icmpPacketEntry", (*icmpPacketEntry)(nil), state.Fns{Save: (*icmpPacketEntry).save, Load: (*icmpPacketEntry).load})
+	state.Register((*icmpPacket)(nil))
+	state.Register((*endpoint)(nil))
+	state.Register((*icmpPacketList)(nil))
+	state.Register((*icmpPacketEntry)(nil))
 }
diff --git a/pkg/tcpip/transport/packet/packet_list.go b/pkg/tcpip/transport/packet/packet_list.go
index 5231b066f..22a41872a 100644
--- a/pkg/tcpip/transport/packet/packet_list.go
+++ b/pkg/tcpip/transport/packet/packet_list.go
@@ -56,7 +56,7 @@ func (l *packetList) Back() *packet {
 //
 // NOTE: This is an O(n) operation.
 func (l *packetList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (packetElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *packetList) Remove(e *packet) {
 
 	if prev != nil {
 		packetElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		packetElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/packet/packet_state_autogen.go b/pkg/tcpip/transport/packet/packet_state_autogen.go
index 8ff339e08..209b6dcb0 100644
--- a/pkg/tcpip/transport/packet/packet_state_autogen.go
+++ b/pkg/tcpip/transport/packet/packet_state_autogen.go
@@ -7,84 +7,145 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 )
 
+func (x *packet) StateTypeName() string {
+	return "pkg/tcpip/transport/packet.packet"
+}
+
+func (x *packet) StateFields() []string {
+	return []string{
+		"packetEntry",
+		"data",
+		"timestampNS",
+		"senderAddr",
+	}
+}
+
 func (x *packet) beforeSave() {}
-func (x *packet) save(m state.Map) {
+
+func (x *packet) StateSave(m state.Sink) {
 	x.beforeSave()
 	var data buffer.VectorisedView = x.saveData()
-	m.SaveValue("data", data)
-	m.Save("packetEntry", &x.packetEntry)
-	m.Save("timestampNS", &x.timestampNS)
-	m.Save("senderAddr", &x.senderAddr)
+	m.SaveValue(1, data)
+	m.Save(0, &x.packetEntry)
+	m.Save(2, &x.timestampNS)
+	m.Save(3, &x.senderAddr)
 }
 
 func (x *packet) afterLoad() {}
-func (x *packet) load(m state.Map) {
-	m.Load("packetEntry", &x.packetEntry)
-	m.Load("timestampNS", &x.timestampNS)
-	m.Load("senderAddr", &x.senderAddr)
-	m.LoadValue("data", new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+
+func (x *packet) StateLoad(m state.Source) {
+	m.Load(0, &x.packetEntry)
+	m.Load(2, &x.timestampNS)
+	m.Load(3, &x.senderAddr)
+	m.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
 }
 
-func (x *endpoint) save(m state.Map) {
+func (x *endpoint) StateTypeName() string {
+	return "pkg/tcpip/transport/packet.endpoint"
+}
+
+func (x *endpoint) StateFields() []string {
+	return []string{
+		"TransportEndpointInfo",
+		"netProto",
+		"waiterQueue",
+		"cooked",
+		"rcvList",
+		"rcvBufSizeMax",
+		"rcvBufSize",
+		"rcvClosed",
+		"sndBufSize",
+		"closed",
+		"bound",
+	}
+}
+
+func (x *endpoint) StateSave(m state.Sink) {
 	x.beforeSave()
 	var rcvBufSizeMax int = x.saveRcvBufSizeMax()
-	m.SaveValue("rcvBufSizeMax", rcvBufSizeMax)
-	m.Save("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Save("netProto", &x.netProto)
-	m.Save("waiterQueue", &x.waiterQueue)
-	m.Save("cooked", &x.cooked)
-	m.Save("rcvList", &x.rcvList)
-	m.Save("rcvBufSize", &x.rcvBufSize)
-	m.Save("rcvClosed", &x.rcvClosed)
-	m.Save("sndBufSize", &x.sndBufSize)
-	m.Save("closed", &x.closed)
-	m.Save("bound", &x.bound)
-}
-
-func (x *endpoint) load(m state.Map) {
-	m.Load("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Load("netProto", &x.netProto)
-	m.Load("waiterQueue", &x.waiterQueue)
-	m.Load("cooked", &x.cooked)
-	m.Load("rcvList", &x.rcvList)
-	m.Load("rcvBufSize", &x.rcvBufSize)
-	m.Load("rcvClosed", &x.rcvClosed)
-	m.Load("sndBufSize", &x.sndBufSize)
-	m.Load("closed", &x.closed)
-	m.Load("bound", &x.bound)
-	m.LoadValue("rcvBufSizeMax", new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
+	m.SaveValue(5, rcvBufSizeMax)
+	m.Save(0, &x.TransportEndpointInfo)
+	m.Save(1, &x.netProto)
+	m.Save(2, &x.waiterQueue)
+	m.Save(3, &x.cooked)
+	m.Save(4, &x.rcvList)
+	m.Save(6, &x.rcvBufSize)
+	m.Save(7, &x.rcvClosed)
+	m.Save(8, &x.sndBufSize)
+	m.Save(9, &x.closed)
+	m.Save(10, &x.bound)
+}
+
+func (x *endpoint) StateLoad(m state.Source) {
+	m.Load(0, &x.TransportEndpointInfo)
+	m.Load(1, &x.netProto)
+	m.Load(2, &x.waiterQueue)
+	m.Load(3, &x.cooked)
+	m.Load(4, &x.rcvList)
+	m.Load(6, &x.rcvBufSize)
+	m.Load(7, &x.rcvClosed)
+	m.Load(8, &x.sndBufSize)
+	m.Load(9, &x.closed)
+	m.Load(10, &x.bound)
+	m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *packetList) StateTypeName() string {
+	return "pkg/tcpip/transport/packet.packetList"
+}
+
+func (x *packetList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
+}
+
 func (x *packetList) beforeSave() {}
-func (x *packetList) save(m state.Map) {
+
+func (x *packetList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *packetList) afterLoad() {}
-func (x *packetList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *packetList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *packetEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/packet.packetEntry"
+}
+
+func (x *packetEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *packetEntry) beforeSave() {}
-func (x *packetEntry) save(m state.Map) {
+
+func (x *packetEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *packetEntry) afterLoad() {}
-func (x *packetEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *packetEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
 }
 
 func init() {
-	state.Register("pkg/tcpip/transport/packet.packet", (*packet)(nil), state.Fns{Save: (*packet).save, Load: (*packet).load})
-	state.Register("pkg/tcpip/transport/packet.endpoint", (*endpoint)(nil), state.Fns{Save: (*endpoint).save, Load: (*endpoint).load})
-	state.Register("pkg/tcpip/transport/packet.packetList", (*packetList)(nil), state.Fns{Save: (*packetList).save, Load: (*packetList).load})
-	state.Register("pkg/tcpip/transport/packet.packetEntry", (*packetEntry)(nil), state.Fns{Save: (*packetEntry).save, Load: (*packetEntry).load})
+	state.Register((*packet)(nil))
+	state.Register((*endpoint)(nil))
+	state.Register((*packetList)(nil))
+	state.Register((*packetEntry)(nil))
 }
diff --git a/pkg/tcpip/transport/raw/raw_packet_list.go b/pkg/tcpip/transport/raw/raw_packet_list.go
index 15a8c845b..5f955e86a 100644
--- a/pkg/tcpip/transport/raw/raw_packet_list.go
+++ b/pkg/tcpip/transport/raw/raw_packet_list.go
@@ -56,7 +56,7 @@ func (l *rawPacketList) Back() *rawPacket {
 //
 // NOTE: This is an O(n) operation.
 func (l *rawPacketList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (rawPacketElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *rawPacketList) Remove(e *rawPacket) {
 
 	if prev != nil {
 		rawPacketElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		rawPacketElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/raw/raw_state_autogen.go b/pkg/tcpip/transport/raw/raw_state_autogen.go
index 875ebda36..669477cf9 100644
--- a/pkg/tcpip/transport/raw/raw_state_autogen.go
+++ b/pkg/tcpip/transport/raw/raw_state_autogen.go
@@ -7,88 +7,151 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 )
 
+func (x *rawPacket) StateTypeName() string {
+	return "pkg/tcpip/transport/raw.rawPacket"
+}
+
+func (x *rawPacket) StateFields() []string {
+	return []string{
+		"rawPacketEntry",
+		"data",
+		"timestampNS",
+		"senderAddr",
+	}
+}
+
 func (x *rawPacket) beforeSave() {}
-func (x *rawPacket) save(m state.Map) {
+
+func (x *rawPacket) StateSave(m state.Sink) {
 	x.beforeSave()
 	var data buffer.VectorisedView = x.saveData()
-	m.SaveValue("data", data)
-	m.Save("rawPacketEntry", &x.rawPacketEntry)
-	m.Save("timestampNS", &x.timestampNS)
-	m.Save("senderAddr", &x.senderAddr)
+	m.SaveValue(1, data)
+	m.Save(0, &x.rawPacketEntry)
+	m.Save(2, &x.timestampNS)
+	m.Save(3, &x.senderAddr)
 }
 
 func (x *rawPacket) afterLoad() {}
-func (x *rawPacket) load(m state.Map) {
-	m.Load("rawPacketEntry", &x.rawPacketEntry)
-	m.Load("timestampNS", &x.timestampNS)
-	m.Load("senderAddr", &x.senderAddr)
-	m.LoadValue("data", new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+
+func (x *rawPacket) StateLoad(m state.Source) {
+	m.Load(0, &x.rawPacketEntry)
+	m.Load(2, &x.timestampNS)
+	m.Load(3, &x.senderAddr)
+	m.LoadValue(1, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
 }
 
-func (x *endpoint) save(m state.Map) {
+func (x *endpoint) StateTypeName() string {
+	return "pkg/tcpip/transport/raw.endpoint"
+}
+
+func (x *endpoint) StateFields() []string {
+	return []string{
+		"TransportEndpointInfo",
+		"waiterQueue",
+		"associated",
+		"rcvList",
+		"rcvBufSize",
+		"rcvBufSizeMax",
+		"rcvClosed",
+		"sndBufSize",
+		"sndBufSizeMax",
+		"closed",
+		"connected",
+		"bound",
+		"owner",
+	}
+}
+
+func (x *endpoint) StateSave(m state.Sink) {
 	x.beforeSave()
 	var rcvBufSizeMax int = x.saveRcvBufSizeMax()
-	m.SaveValue("rcvBufSizeMax", rcvBufSizeMax)
-	m.Save("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Save("waiterQueue", &x.waiterQueue)
-	m.Save("associated", &x.associated)
-	m.Save("rcvList", &x.rcvList)
-	m.Save("rcvBufSize", &x.rcvBufSize)
-	m.Save("rcvClosed", &x.rcvClosed)
-	m.Save("sndBufSize", &x.sndBufSize)
-	m.Save("sndBufSizeMax", &x.sndBufSizeMax)
-	m.Save("closed", &x.closed)
-	m.Save("connected", &x.connected)
-	m.Save("bound", &x.bound)
-	m.Save("owner", &x.owner)
-}
-
-func (x *endpoint) load(m state.Map) {
-	m.Load("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Load("waiterQueue", &x.waiterQueue)
-	m.Load("associated", &x.associated)
-	m.Load("rcvList", &x.rcvList)
-	m.Load("rcvBufSize", &x.rcvBufSize)
-	m.Load("rcvClosed", &x.rcvClosed)
-	m.Load("sndBufSize", &x.sndBufSize)
-	m.Load("sndBufSizeMax", &x.sndBufSizeMax)
-	m.Load("closed", &x.closed)
-	m.Load("connected", &x.connected)
-	m.Load("bound", &x.bound)
-	m.Load("owner", &x.owner)
-	m.LoadValue("rcvBufSizeMax", new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
+	m.SaveValue(5, rcvBufSizeMax)
+	m.Save(0, &x.TransportEndpointInfo)
+	m.Save(1, &x.waiterQueue)
+	m.Save(2, &x.associated)
+	m.Save(3, &x.rcvList)
+	m.Save(4, &x.rcvBufSize)
+	m.Save(6, &x.rcvClosed)
+	m.Save(7, &x.sndBufSize)
+	m.Save(8, &x.sndBufSizeMax)
+	m.Save(9, &x.closed)
+	m.Save(10, &x.connected)
+	m.Save(11, &x.bound)
+	m.Save(12, &x.owner)
+}
+
+func (x *endpoint) StateLoad(m state.Source) {
+	m.Load(0, &x.TransportEndpointInfo)
+	m.Load(1, &x.waiterQueue)
+	m.Load(2, &x.associated)
+	m.Load(3, &x.rcvList)
+	m.Load(4, &x.rcvBufSize)
+	m.Load(6, &x.rcvClosed)
+	m.Load(7, &x.sndBufSize)
+	m.Load(8, &x.sndBufSizeMax)
+	m.Load(9, &x.closed)
+	m.Load(10, &x.connected)
+	m.Load(11, &x.bound)
+	m.Load(12, &x.owner)
+	m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *rawPacketList) StateTypeName() string {
+	return "pkg/tcpip/transport/raw.rawPacketList"
+}
+
+func (x *rawPacketList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
+}
+
 func (x *rawPacketList) beforeSave() {}
-func (x *rawPacketList) save(m state.Map) {
+
+func (x *rawPacketList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *rawPacketList) afterLoad() {}
-func (x *rawPacketList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *rawPacketList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *rawPacketEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/raw.rawPacketEntry"
+}
+
+func (x *rawPacketEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *rawPacketEntry) beforeSave() {}
-func (x *rawPacketEntry) save(m state.Map) {
+
+func (x *rawPacketEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *rawPacketEntry) afterLoad() {}
-func (x *rawPacketEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *rawPacketEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
 }
 
 func init() {
-	state.Register("pkg/tcpip/transport/raw.rawPacket", (*rawPacket)(nil), state.Fns{Save: (*rawPacket).save, Load: (*rawPacket).load})
-	state.Register("pkg/tcpip/transport/raw.endpoint", (*endpoint)(nil), state.Fns{Save: (*endpoint).save, Load: (*endpoint).load})
-	state.Register("pkg/tcpip/transport/raw.rawPacketList", (*rawPacketList)(nil), state.Fns{Save: (*rawPacketList).save, Load: (*rawPacketList).load})
-	state.Register("pkg/tcpip/transport/raw.rawPacketEntry", (*rawPacketEntry)(nil), state.Fns{Save: (*rawPacketEntry).save, Load: (*rawPacketEntry).load})
+	state.Register((*rawPacket)(nil))
+	state.Register((*endpoint)(nil))
+	state.Register((*rawPacketList)(nil))
+	state.Register((*rawPacketEntry)(nil))
 }
diff --git a/pkg/tcpip/transport/tcp/tcp_endpoint_list.go b/pkg/tcpip/transport/tcp/tcp_endpoint_list.go
index fb7046d8f..71ae11c81 100644
--- a/pkg/tcpip/transport/tcp/tcp_endpoint_list.go
+++ b/pkg/tcpip/transport/tcp/tcp_endpoint_list.go
@@ -56,7 +56,7 @@ func (l *endpointList) Back() *endpoint {
 //
 // NOTE: This is an O(n) operation.
 func (l *endpointList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (endpointElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *endpointList) Remove(e *endpoint) {
 
 	if prev != nil {
 		endpointElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		endpointElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/tcp/tcp_segment_list.go b/pkg/tcpip/transport/tcp/tcp_segment_list.go
index 21638041c..fcd0c7ec1 100644
--- a/pkg/tcpip/transport/tcp/tcp_segment_list.go
+++ b/pkg/tcpip/transport/tcp/tcp_segment_list.go
@@ -56,7 +56,7 @@ func (l *segmentList) Back() *segment {
 //
 // NOTE: This is an O(n) operation.
 func (l *segmentList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (segmentElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *segmentList) Remove(e *segment) {
 
 	if prev != nil {
 		segmentElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		segmentElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/tcp/tcp_state_autogen.go b/pkg/tcpip/transport/tcp/tcp_state_autogen.go
index 8f9e742fc..4b513121f 100644
--- a/pkg/tcpip/transport/tcp/tcp_state_autogen.go
+++ b/pkg/tcpip/transport/tcp/tcp_state_autogen.go
@@ -7,543 +7,916 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 )
 
+func (x *cubicState) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.cubicState"
+}
+
+func (x *cubicState) StateFields() []string {
+	return []string{
+		"wLastMax",
+		"wMax",
+		"t",
+		"numCongestionEvents",
+		"c",
+		"k",
+		"beta",
+		"wC",
+		"wEst",
+		"s",
+	}
+}
+
 func (x *cubicState) beforeSave() {}
-func (x *cubicState) save(m state.Map) {
+
+func (x *cubicState) StateSave(m state.Sink) {
 	x.beforeSave()
 	var t unixTime = x.saveT()
-	m.SaveValue("t", t)
-	m.Save("wLastMax", &x.wLastMax)
-	m.Save("wMax", &x.wMax)
-	m.Save("numCongestionEvents", &x.numCongestionEvents)
-	m.Save("c", &x.c)
-	m.Save("k", &x.k)
-	m.Save("beta", &x.beta)
-	m.Save("wC", &x.wC)
-	m.Save("wEst", &x.wEst)
-	m.Save("s", &x.s)
+	m.SaveValue(2, t)
+	m.Save(0, &x.wLastMax)
+	m.Save(1, &x.wMax)
+	m.Save(3, &x.numCongestionEvents)
+	m.Save(4, &x.c)
+	m.Save(5, &x.k)
+	m.Save(6, &x.beta)
+	m.Save(7, &x.wC)
+	m.Save(8, &x.wEst)
+	m.Save(9, &x.s)
 }
 
 func (x *cubicState) afterLoad() {}
-func (x *cubicState) load(m state.Map) {
-	m.Load("wLastMax", &x.wLastMax)
-	m.Load("wMax", &x.wMax)
-	m.Load("numCongestionEvents", &x.numCongestionEvents)
-	m.Load("c", &x.c)
-	m.Load("k", &x.k)
-	m.Load("beta", &x.beta)
-	m.Load("wC", &x.wC)
-	m.Load("wEst", &x.wEst)
-	m.Load("s", &x.s)
-	m.LoadValue("t", new(unixTime), func(y interface{}) { x.loadT(y.(unixTime)) })
+
+func (x *cubicState) StateLoad(m state.Source) {
+	m.Load(0, &x.wLastMax)
+	m.Load(1, &x.wMax)
+	m.Load(3, &x.numCongestionEvents)
+	m.Load(4, &x.c)
+	m.Load(5, &x.k)
+	m.Load(6, &x.beta)
+	m.Load(7, &x.wC)
+	m.Load(8, &x.wEst)
+	m.Load(9, &x.s)
+	m.LoadValue(2, new(unixTime), func(y interface{}) { x.loadT(y.(unixTime)) })
+}
+
+func (x *SACKInfo) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.SACKInfo"
+}
+
+func (x *SACKInfo) StateFields() []string {
+	return []string{
+		"Blocks",
+		"NumBlocks",
+	}
 }
 
 func (x *SACKInfo) beforeSave() {}
-func (x *SACKInfo) save(m state.Map) {
+
+func (x *SACKInfo) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("Blocks", &x.Blocks)
-	m.Save("NumBlocks", &x.NumBlocks)
+	m.Save(0, &x.Blocks)
+	m.Save(1, &x.NumBlocks)
 }
 
 func (x *SACKInfo) afterLoad() {}
-func (x *SACKInfo) load(m state.Map) {
-	m.Load("Blocks", &x.Blocks)
-	m.Load("NumBlocks", &x.NumBlocks)
+
+func (x *SACKInfo) StateLoad(m state.Source) {
+	m.Load(0, &x.Blocks)
+	m.Load(1, &x.NumBlocks)
+}
+
+func (x *rcvBufAutoTuneParams) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.rcvBufAutoTuneParams"
+}
+
+func (x *rcvBufAutoTuneParams) StateFields() []string {
+	return []string{
+		"measureTime",
+		"copied",
+		"prevCopied",
+		"rtt",
+		"rttMeasureSeqNumber",
+		"rttMeasureTime",
+		"disabled",
+	}
 }
 
 func (x *rcvBufAutoTuneParams) beforeSave() {}
-func (x *rcvBufAutoTuneParams) save(m state.Map) {
+
+func (x *rcvBufAutoTuneParams) StateSave(m state.Sink) {
 	x.beforeSave()
 	var measureTime unixTime = x.saveMeasureTime()
-	m.SaveValue("measureTime", measureTime)
+	m.SaveValue(0, measureTime)
 	var rttMeasureTime unixTime = x.saveRttMeasureTime()
-	m.SaveValue("rttMeasureTime", rttMeasureTime)
-	m.Save("copied", &x.copied)
-	m.Save("prevCopied", &x.prevCopied)
-	m.Save("rtt", &x.rtt)
-	m.Save("rttMeasureSeqNumber", &x.rttMeasureSeqNumber)
-	m.Save("disabled", &x.disabled)
+	m.SaveValue(5, rttMeasureTime)
+	m.Save(1, &x.copied)
+	m.Save(2, &x.prevCopied)
+	m.Save(3, &x.rtt)
+	m.Save(4, &x.rttMeasureSeqNumber)
+	m.Save(6, &x.disabled)
 }
 
 func (x *rcvBufAutoTuneParams) afterLoad() {}
-func (x *rcvBufAutoTuneParams) load(m state.Map) {
-	m.Load("copied", &x.copied)
-	m.Load("prevCopied", &x.prevCopied)
-	m.Load("rtt", &x.rtt)
-	m.Load("rttMeasureSeqNumber", &x.rttMeasureSeqNumber)
-	m.Load("disabled", &x.disabled)
-	m.LoadValue("measureTime", new(unixTime), func(y interface{}) { x.loadMeasureTime(y.(unixTime)) })
-	m.LoadValue("rttMeasureTime", new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
+
+func (x *rcvBufAutoTuneParams) StateLoad(m state.Source) {
+	m.Load(1, &x.copied)
+	m.Load(2, &x.prevCopied)
+	m.Load(3, &x.rtt)
+	m.Load(4, &x.rttMeasureSeqNumber)
+	m.Load(6, &x.disabled)
+	m.LoadValue(0, new(unixTime), func(y interface{}) { x.loadMeasureTime(y.(unixTime)) })
+	m.LoadValue(5, new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
+}
+
+func (x *EndpointInfo) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.EndpointInfo"
+}
+
+func (x *EndpointInfo) StateFields() []string {
+	return []string{
+		"TransportEndpointInfo",
+		"HardError",
+	}
 }
 
 func (x *EndpointInfo) beforeSave() {}
-func (x *EndpointInfo) save(m state.Map) {
+
+func (x *EndpointInfo) StateSave(m state.Sink) {
 	x.beforeSave()
 	var HardError string = x.saveHardError()
-	m.SaveValue("HardError", HardError)
-	m.Save("TransportEndpointInfo", &x.TransportEndpointInfo)
+	m.SaveValue(1, HardError)
+	m.Save(0, &x.TransportEndpointInfo)
 }
 
 func (x *EndpointInfo) afterLoad() {}
-func (x *EndpointInfo) load(m state.Map) {
-	m.Load("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.LoadValue("HardError", new(string), func(y interface{}) { x.loadHardError(y.(string)) })
-}
 
-func (x *endpoint) save(m state.Map) {
+func (x *EndpointInfo) StateLoad(m state.Source) {
+	m.Load(0, &x.TransportEndpointInfo)
+	m.LoadValue(1, new(string), func(y interface{}) { x.loadHardError(y.(string)) })
+}
+
+func (x *endpoint) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.endpoint"
+}
+
+func (x *endpoint) StateFields() []string {
+	return []string{
+		"EndpointInfo",
+		"waiterQueue",
+		"uniqueID",
+		"lastError",
+		"rcvList",
+		"rcvClosed",
+		"rcvBufSize",
+		"rcvBufUsed",
+		"rcvAutoParams",
+		"ownedByUser",
+		"state",
+		"boundNICID",
+		"ttl",
+		"v6only",
+		"isConnectNotified",
+		"broadcast",
+		"portFlags",
+		"boundBindToDevice",
+		"boundPortFlags",
+		"boundDest",
+		"effectiveNetProtos",
+		"workerRunning",
+		"workerCleanup",
+		"sendTSOk",
+		"recentTS",
+		"tsOffset",
+		"shutdownFlags",
+		"sackPermitted",
+		"sack",
+		"bindToDevice",
+		"delay",
+		"cork",
+		"scoreboard",
+		"slowAck",
+		"segmentQueue",
+		"synRcvdCount",
+		"userMSS",
+		"maxSynRetries",
+		"windowClamp",
+		"sndBufSize",
+		"sndBufUsed",
+		"sndClosed",
+		"sndBufInQueue",
+		"sndQueue",
+		"cc",
+		"packetTooBigCount",
+		"sndMTU",
+		"keepalive",
+		"userTimeout",
+		"deferAccept",
+		"acceptedChan",
+		"rcv",
+		"snd",
+		"connectingAddress",
+		"amss",
+		"sendTOS",
+		"gso",
+		"tcpLingerTimeout",
+		"closed",
+		"txHash",
+		"owner",
+	}
+}
+
+func (x *endpoint) StateSave(m state.Sink) {
 	x.beforeSave()
 	var lastError string = x.saveLastError()
-	m.SaveValue("lastError", lastError)
+	m.SaveValue(3, lastError)
 	var state EndpointState = x.saveState()
-	m.SaveValue("state", state)
+	m.SaveValue(10, state)
 	var acceptedChan []*endpoint = x.saveAcceptedChan()
-	m.SaveValue("acceptedChan", acceptedChan)
-	m.Save("EndpointInfo", &x.EndpointInfo)
-	m.Save("waiterQueue", &x.waiterQueue)
-	m.Save("uniqueID", &x.uniqueID)
-	m.Save("rcvList", &x.rcvList)
-	m.Save("rcvClosed", &x.rcvClosed)
-	m.Save("rcvBufSize", &x.rcvBufSize)
-	m.Save("rcvBufUsed", &x.rcvBufUsed)
-	m.Save("rcvAutoParams", &x.rcvAutoParams)
-	m.Save("ownedByUser", &x.ownedByUser)
-	m.Save("boundNICID", &x.boundNICID)
-	m.Save("ttl", &x.ttl)
-	m.Save("v6only", &x.v6only)
-	m.Save("isConnectNotified", &x.isConnectNotified)
-	m.Save("broadcast", &x.broadcast)
-	m.Save("portFlags", &x.portFlags)
-	m.Save("boundBindToDevice", &x.boundBindToDevice)
-	m.Save("boundPortFlags", &x.boundPortFlags)
-	m.Save("boundDest", &x.boundDest)
-	m.Save("effectiveNetProtos", &x.effectiveNetProtos)
-	m.Save("workerRunning", &x.workerRunning)
-	m.Save("workerCleanup", &x.workerCleanup)
-	m.Save("sendTSOk", &x.sendTSOk)
-	m.Save("recentTS", &x.recentTS)
-	m.Save("tsOffset", &x.tsOffset)
-	m.Save("shutdownFlags", &x.shutdownFlags)
-	m.Save("sackPermitted", &x.sackPermitted)
-	m.Save("sack", &x.sack)
-	m.Save("bindToDevice", &x.bindToDevice)
-	m.Save("delay", &x.delay)
-	m.Save("cork", &x.cork)
-	m.Save("scoreboard", &x.scoreboard)
-	m.Save("slowAck", &x.slowAck)
-	m.Save("segmentQueue", &x.segmentQueue)
-	m.Save("synRcvdCount", &x.synRcvdCount)
-	m.Save("userMSS", &x.userMSS)
-	m.Save("maxSynRetries", &x.maxSynRetries)
-	m.Save("windowClamp", &x.windowClamp)
-	m.Save("sndBufSize", &x.sndBufSize)
-	m.Save("sndBufUsed", &x.sndBufUsed)
-	m.Save("sndClosed", &x.sndClosed)
-	m.Save("sndBufInQueue", &x.sndBufInQueue)
-	m.Save("sndQueue", &x.sndQueue)
-	m.Save("cc", &x.cc)
-	m.Save("packetTooBigCount", &x.packetTooBigCount)
-	m.Save("sndMTU", &x.sndMTU)
-	m.Save("keepalive", &x.keepalive)
-	m.Save("userTimeout", &x.userTimeout)
-	m.Save("deferAccept", &x.deferAccept)
-	m.Save("rcv", &x.rcv)
-	m.Save("snd", &x.snd)
-	m.Save("connectingAddress", &x.connectingAddress)
-	m.Save("amss", &x.amss)
-	m.Save("sendTOS", &x.sendTOS)
-	m.Save("gso", &x.gso)
-	m.Save("tcpLingerTimeout", &x.tcpLingerTimeout)
-	m.Save("closed", &x.closed)
-	m.Save("txHash", &x.txHash)
-	m.Save("owner", &x.owner)
-}
-
-func (x *endpoint) load(m state.Map) {
-	m.Load("EndpointInfo", &x.EndpointInfo)
-	m.LoadWait("waiterQueue", &x.waiterQueue)
-	m.Load("uniqueID", &x.uniqueID)
-	m.LoadWait("rcvList", &x.rcvList)
-	m.Load("rcvClosed", &x.rcvClosed)
-	m.Load("rcvBufSize", &x.rcvBufSize)
-	m.Load("rcvBufUsed", &x.rcvBufUsed)
-	m.Load("rcvAutoParams", &x.rcvAutoParams)
-	m.Load("ownedByUser", &x.ownedByUser)
-	m.Load("boundNICID", &x.boundNICID)
-	m.Load("ttl", &x.ttl)
-	m.Load("v6only", &x.v6only)
-	m.Load("isConnectNotified", &x.isConnectNotified)
-	m.Load("broadcast", &x.broadcast)
-	m.Load("portFlags", &x.portFlags)
-	m.Load("boundBindToDevice", &x.boundBindToDevice)
-	m.Load("boundPortFlags", &x.boundPortFlags)
-	m.Load("boundDest", &x.boundDest)
-	m.Load("effectiveNetProtos", &x.effectiveNetProtos)
-	m.Load("workerRunning", &x.workerRunning)
-	m.Load("workerCleanup", &x.workerCleanup)
-	m.Load("sendTSOk", &x.sendTSOk)
-	m.Load("recentTS", &x.recentTS)
-	m.Load("tsOffset", &x.tsOffset)
-	m.Load("shutdownFlags", &x.shutdownFlags)
-	m.Load("sackPermitted", &x.sackPermitted)
-	m.Load("sack", &x.sack)
-	m.Load("bindToDevice", &x.bindToDevice)
-	m.Load("delay", &x.delay)
-	m.Load("cork", &x.cork)
-	m.Load("scoreboard", &x.scoreboard)
-	m.Load("slowAck", &x.slowAck)
-	m.LoadWait("segmentQueue", &x.segmentQueue)
-	m.Load("synRcvdCount", &x.synRcvdCount)
-	m.Load("userMSS", &x.userMSS)
-	m.Load("maxSynRetries", &x.maxSynRetries)
-	m.Load("windowClamp", &x.windowClamp)
-	m.Load("sndBufSize", &x.sndBufSize)
-	m.Load("sndBufUsed", &x.sndBufUsed)
-	m.Load("sndClosed", &x.sndClosed)
-	m.Load("sndBufInQueue", &x.sndBufInQueue)
-	m.LoadWait("sndQueue", &x.sndQueue)
-	m.Load("cc", &x.cc)
-	m.Load("packetTooBigCount", &x.packetTooBigCount)
-	m.Load("sndMTU", &x.sndMTU)
-	m.Load("keepalive", &x.keepalive)
-	m.Load("userTimeout", &x.userTimeout)
-	m.Load("deferAccept", &x.deferAccept)
-	m.LoadWait("rcv", &x.rcv)
-	m.LoadWait("snd", &x.snd)
-	m.Load("connectingAddress", &x.connectingAddress)
-	m.Load("amss", &x.amss)
-	m.Load("sendTOS", &x.sendTOS)
-	m.Load("gso", &x.gso)
-	m.Load("tcpLingerTimeout", &x.tcpLingerTimeout)
-	m.Load("closed", &x.closed)
-	m.Load("txHash", &x.txHash)
-	m.Load("owner", &x.owner)
-	m.LoadValue("lastError", new(string), func(y interface{}) { x.loadLastError(y.(string)) })
-	m.LoadValue("state", new(EndpointState), func(y interface{}) { x.loadState(y.(EndpointState)) })
-	m.LoadValue("acceptedChan", new([]*endpoint), func(y interface{}) { x.loadAcceptedChan(y.([]*endpoint)) })
+	m.SaveValue(50, acceptedChan)
+	m.Save(0, &x.EndpointInfo)
+	m.Save(1, &x.waiterQueue)
+	m.Save(2, &x.uniqueID)
+	m.Save(4, &x.rcvList)
+	m.Save(5, &x.rcvClosed)
+	m.Save(6, &x.rcvBufSize)
+	m.Save(7, &x.rcvBufUsed)
+	m.Save(8, &x.rcvAutoParams)
+	m.Save(9, &x.ownedByUser)
+	m.Save(11, &x.boundNICID)
+	m.Save(12, &x.ttl)
+	m.Save(13, &x.v6only)
+	m.Save(14, &x.isConnectNotified)
+	m.Save(15, &x.broadcast)
+	m.Save(16, &x.portFlags)
+	m.Save(17, &x.boundBindToDevice)
+	m.Save(18, &x.boundPortFlags)
+	m.Save(19, &x.boundDest)
+	m.Save(20, &x.effectiveNetProtos)
+	m.Save(21, &x.workerRunning)
+	m.Save(22, &x.workerCleanup)
+	m.Save(23, &x.sendTSOk)
+	m.Save(24, &x.recentTS)
+	m.Save(25, &x.tsOffset)
+	m.Save(26, &x.shutdownFlags)
+	m.Save(27, &x.sackPermitted)
+	m.Save(28, &x.sack)
+	m.Save(29, &x.bindToDevice)
+	m.Save(30, &x.delay)
+	m.Save(31, &x.cork)
+	m.Save(32, &x.scoreboard)
+	m.Save(33, &x.slowAck)
+	m.Save(34, &x.segmentQueue)
+	m.Save(35, &x.synRcvdCount)
+	m.Save(36, &x.userMSS)
+	m.Save(37, &x.maxSynRetries)
+	m.Save(38, &x.windowClamp)
+	m.Save(39, &x.sndBufSize)
+	m.Save(40, &x.sndBufUsed)
+	m.Save(41, &x.sndClosed)
+	m.Save(42, &x.sndBufInQueue)
+	m.Save(43, &x.sndQueue)
+	m.Save(44, &x.cc)
+	m.Save(45, &x.packetTooBigCount)
+	m.Save(46, &x.sndMTU)
+	m.Save(47, &x.keepalive)
+	m.Save(48, &x.userTimeout)
+	m.Save(49, &x.deferAccept)
+	m.Save(51, &x.rcv)
+	m.Save(52, &x.snd)
+	m.Save(53, &x.connectingAddress)
+	m.Save(54, &x.amss)
+	m.Save(55, &x.sendTOS)
+	m.Save(56, &x.gso)
+	m.Save(57, &x.tcpLingerTimeout)
+	m.Save(58, &x.closed)
+	m.Save(59, &x.txHash)
+	m.Save(60, &x.owner)
+}
+
+func (x *endpoint) StateLoad(m state.Source) {
+	m.Load(0, &x.EndpointInfo)
+	m.LoadWait(1, &x.waiterQueue)
+	m.Load(2, &x.uniqueID)
+	m.LoadWait(4, &x.rcvList)
+	m.Load(5, &x.rcvClosed)
+	m.Load(6, &x.rcvBufSize)
+	m.Load(7, &x.rcvBufUsed)
+	m.Load(8, &x.rcvAutoParams)
+	m.Load(9, &x.ownedByUser)
+	m.Load(11, &x.boundNICID)
+	m.Load(12, &x.ttl)
+	m.Load(13, &x.v6only)
+	m.Load(14, &x.isConnectNotified)
+	m.Load(15, &x.broadcast)
+	m.Load(16, &x.portFlags)
+	m.Load(17, &x.boundBindToDevice)
+	m.Load(18, &x.boundPortFlags)
+	m.Load(19, &x.boundDest)
+	m.Load(20, &x.effectiveNetProtos)
+	m.Load(21, &x.workerRunning)
+	m.Load(22, &x.workerCleanup)
+	m.Load(23, &x.sendTSOk)
+	m.Load(24, &x.recentTS)
+	m.Load(25, &x.tsOffset)
+	m.Load(26, &x.shutdownFlags)
+	m.Load(27, &x.sackPermitted)
+	m.Load(28, &x.sack)
+	m.Load(29, &x.bindToDevice)
+	m.Load(30, &x.delay)
+	m.Load(31, &x.cork)
+	m.Load(32, &x.scoreboard)
+	m.Load(33, &x.slowAck)
+	m.LoadWait(34, &x.segmentQueue)
+	m.Load(35, &x.synRcvdCount)
+	m.Load(36, &x.userMSS)
+	m.Load(37, &x.maxSynRetries)
+	m.Load(38, &x.windowClamp)
+	m.Load(39, &x.sndBufSize)
+	m.Load(40, &x.sndBufUsed)
+	m.Load(41, &x.sndClosed)
+	m.Load(42, &x.sndBufInQueue)
+	m.LoadWait(43, &x.sndQueue)
+	m.Load(44, &x.cc)
+	m.Load(45, &x.packetTooBigCount)
+	m.Load(46, &x.sndMTU)
+	m.Load(47, &x.keepalive)
+	m.Load(48, &x.userTimeout)
+	m.Load(49, &x.deferAccept)
+	m.LoadWait(51, &x.rcv)
+	m.LoadWait(52, &x.snd)
+	m.Load(53, &x.connectingAddress)
+	m.Load(54, &x.amss)
+	m.Load(55, &x.sendTOS)
+	m.Load(56, &x.gso)
+	m.Load(57, &x.tcpLingerTimeout)
+	m.Load(58, &x.closed)
+	m.Load(59, &x.txHash)
+	m.Load(60, &x.owner)
+	m.LoadValue(3, new(string), func(y interface{}) { x.loadLastError(y.(string)) })
+	m.LoadValue(10, new(EndpointState), func(y interface{}) { x.loadState(y.(EndpointState)) })
+	m.LoadValue(50, new([]*endpoint), func(y interface{}) { x.loadAcceptedChan(y.([]*endpoint)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *keepalive) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.keepalive"
+}
+
+func (x *keepalive) StateFields() []string {
+	return []string{
+		"enabled",
+		"idle",
+		"interval",
+		"count",
+		"unacked",
+	}
+}
+
 func (x *keepalive) beforeSave() {}
-func (x *keepalive) save(m state.Map) {
+
+func (x *keepalive) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("enabled", &x.enabled)
-	m.Save("idle", &x.idle)
-	m.Save("interval", &x.interval)
-	m.Save("count", &x.count)
-	m.Save("unacked", &x.unacked)
+	m.Save(0, &x.enabled)
+	m.Save(1, &x.idle)
+	m.Save(2, &x.interval)
+	m.Save(3, &x.count)
+	m.Save(4, &x.unacked)
 }
 
 func (x *keepalive) afterLoad() {}
-func (x *keepalive) load(m state.Map) {
-	m.Load("enabled", &x.enabled)
-	m.Load("idle", &x.idle)
-	m.Load("interval", &x.interval)
-	m.Load("count", &x.count)
-	m.Load("unacked", &x.unacked)
+
+func (x *keepalive) StateLoad(m state.Source) {
+	m.Load(0, &x.enabled)
+	m.Load(1, &x.idle)
+	m.Load(2, &x.interval)
+	m.Load(3, &x.count)
+	m.Load(4, &x.unacked)
+}
+
+func (x *receiver) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.receiver"
+}
+
+func (x *receiver) StateFields() []string {
+	return []string{
+		"ep",
+		"rcvNxt",
+		"rcvAcc",
+		"rcvWnd",
+		"rcvWndScale",
+		"closed",
+		"pendingRcvdSegments",
+		"pendingBufUsed",
+		"pendingBufSize",
+		"lastRcvdAckTime",
+	}
 }
 
 func (x *receiver) beforeSave() {}
-func (x *receiver) save(m state.Map) {
+
+func (x *receiver) StateSave(m state.Sink) {
 	x.beforeSave()
 	var lastRcvdAckTime unixTime = x.saveLastRcvdAckTime()
-	m.SaveValue("lastRcvdAckTime", lastRcvdAckTime)
-	m.Save("ep", &x.ep)
-	m.Save("rcvNxt", &x.rcvNxt)
-	m.Save("rcvAcc", &x.rcvAcc)
-	m.Save("rcvWnd", &x.rcvWnd)
-	m.Save("rcvWndScale", &x.rcvWndScale)
-	m.Save("closed", &x.closed)
-	m.Save("pendingRcvdSegments", &x.pendingRcvdSegments)
-	m.Save("pendingBufUsed", &x.pendingBufUsed)
-	m.Save("pendingBufSize", &x.pendingBufSize)
+	m.SaveValue(9, lastRcvdAckTime)
+	m.Save(0, &x.ep)
+	m.Save(1, &x.rcvNxt)
+	m.Save(2, &x.rcvAcc)
+	m.Save(3, &x.rcvWnd)
+	m.Save(4, &x.rcvWndScale)
+	m.Save(5, &x.closed)
+	m.Save(6, &x.pendingRcvdSegments)
+	m.Save(7, &x.pendingBufUsed)
+	m.Save(8, &x.pendingBufSize)
 }
 
 func (x *receiver) afterLoad() {}
-func (x *receiver) load(m state.Map) {
-	m.Load("ep", &x.ep)
-	m.Load("rcvNxt", &x.rcvNxt)
-	m.Load("rcvAcc", &x.rcvAcc)
-	m.Load("rcvWnd", &x.rcvWnd)
-	m.Load("rcvWndScale", &x.rcvWndScale)
-	m.Load("closed", &x.closed)
-	m.Load("pendingRcvdSegments", &x.pendingRcvdSegments)
-	m.Load("pendingBufUsed", &x.pendingBufUsed)
-	m.Load("pendingBufSize", &x.pendingBufSize)
-	m.LoadValue("lastRcvdAckTime", new(unixTime), func(y interface{}) { x.loadLastRcvdAckTime(y.(unixTime)) })
+
+func (x *receiver) StateLoad(m state.Source) {
+	m.Load(0, &x.ep)
+	m.Load(1, &x.rcvNxt)
+	m.Load(2, &x.rcvAcc)
+	m.Load(3, &x.rcvWnd)
+	m.Load(4, &x.rcvWndScale)
+	m.Load(5, &x.closed)
+	m.Load(6, &x.pendingRcvdSegments)
+	m.Load(7, &x.pendingBufUsed)
+	m.Load(8, &x.pendingBufSize)
+	m.LoadValue(9, new(unixTime), func(y interface{}) { x.loadLastRcvdAckTime(y.(unixTime)) })
+}
+
+func (x *renoState) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.renoState"
+}
+
+func (x *renoState) StateFields() []string {
+	return []string{
+		"s",
+	}
 }
 
 func (x *renoState) beforeSave() {}
-func (x *renoState) save(m state.Map) {
+
+func (x *renoState) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("s", &x.s)
+	m.Save(0, &x.s)
 }
 
 func (x *renoState) afterLoad() {}
-func (x *renoState) load(m state.Map) {
-	m.Load("s", &x.s)
+
+func (x *renoState) StateLoad(m state.Source) {
+	m.Load(0, &x.s)
+}
+
+func (x *SACKScoreboard) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.SACKScoreboard"
+}
+
+func (x *SACKScoreboard) StateFields() []string {
+	return []string{
+		"smss",
+		"maxSACKED",
+	}
 }
 
 func (x *SACKScoreboard) beforeSave() {}
-func (x *SACKScoreboard) save(m state.Map) {
+
+func (x *SACKScoreboard) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("smss", &x.smss)
-	m.Save("maxSACKED", &x.maxSACKED)
+	m.Save(0, &x.smss)
+	m.Save(1, &x.maxSACKED)
 }
 
 func (x *SACKScoreboard) afterLoad() {}
-func (x *SACKScoreboard) load(m state.Map) {
-	m.Load("smss", &x.smss)
-	m.Load("maxSACKED", &x.maxSACKED)
+
+func (x *SACKScoreboard) StateLoad(m state.Source) {
+	m.Load(0, &x.smss)
+	m.Load(1, &x.maxSACKED)
+}
+
+func (x *segment) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.segment"
+}
+
+func (x *segment) StateFields() []string {
+	return []string{
+		"segmentEntry",
+		"refCnt",
+		"data",
+		"hdr",
+		"viewToDeliver",
+		"sequenceNumber",
+		"ackNumber",
+		"flags",
+		"window",
+		"csum",
+		"csumValid",
+		"parsedOptions",
+		"options",
+		"hasNewSACKInfo",
+		"rcvdTime",
+		"xmitTime",
+		"xmitCount",
+	}
 }
 
 func (x *segment) beforeSave() {}
-func (x *segment) save(m state.Map) {
+
+func (x *segment) StateSave(m state.Sink) {
 	x.beforeSave()
 	var data buffer.VectorisedView = x.saveData()
-	m.SaveValue("data", data)
+	m.SaveValue(2, data)
 	var options []byte = x.saveOptions()
-	m.SaveValue("options", options)
+	m.SaveValue(12, options)
 	var rcvdTime unixTime = x.saveRcvdTime()
-	m.SaveValue("rcvdTime", rcvdTime)
+	m.SaveValue(14, rcvdTime)
 	var xmitTime unixTime = x.saveXmitTime()
-	m.SaveValue("xmitTime", xmitTime)
-	m.Save("segmentEntry", &x.segmentEntry)
-	m.Save("refCnt", &x.refCnt)
-	m.Save("hdr", &x.hdr)
-	m.Save("viewToDeliver", &x.viewToDeliver)
-	m.Save("sequenceNumber", &x.sequenceNumber)
-	m.Save("ackNumber", &x.ackNumber)
-	m.Save("flags", &x.flags)
-	m.Save("window", &x.window)
-	m.Save("csum", &x.csum)
-	m.Save("csumValid", &x.csumValid)
-	m.Save("parsedOptions", &x.parsedOptions)
-	m.Save("hasNewSACKInfo", &x.hasNewSACKInfo)
-	m.Save("xmitCount", &x.xmitCount)
+	m.SaveValue(15, xmitTime)
+	m.Save(0, &x.segmentEntry)
+	m.Save(1, &x.refCnt)
+	m.Save(3, &x.hdr)
+	m.Save(4, &x.viewToDeliver)
+	m.Save(5, &x.sequenceNumber)
+	m.Save(6, &x.ackNumber)
+	m.Save(7, &x.flags)
+	m.Save(8, &x.window)
+	m.Save(9, &x.csum)
+	m.Save(10, &x.csumValid)
+	m.Save(11, &x.parsedOptions)
+	m.Save(13, &x.hasNewSACKInfo)
+	m.Save(16, &x.xmitCount)
 }
 
 func (x *segment) afterLoad() {}
-func (x *segment) load(m state.Map) {
-	m.Load("segmentEntry", &x.segmentEntry)
-	m.Load("refCnt", &x.refCnt)
-	m.Load("hdr", &x.hdr)
-	m.Load("viewToDeliver", &x.viewToDeliver)
-	m.Load("sequenceNumber", &x.sequenceNumber)
-	m.Load("ackNumber", &x.ackNumber)
-	m.Load("flags", &x.flags)
-	m.Load("window", &x.window)
-	m.Load("csum", &x.csum)
-	m.Load("csumValid", &x.csumValid)
-	m.Load("parsedOptions", &x.parsedOptions)
-	m.Load("hasNewSACKInfo", &x.hasNewSACKInfo)
-	m.Load("xmitCount", &x.xmitCount)
-	m.LoadValue("data", new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
-	m.LoadValue("options", new([]byte), func(y interface{}) { x.loadOptions(y.([]byte)) })
-	m.LoadValue("rcvdTime", new(unixTime), func(y interface{}) { x.loadRcvdTime(y.(unixTime)) })
-	m.LoadValue("xmitTime", new(unixTime), func(y interface{}) { x.loadXmitTime(y.(unixTime)) })
+
+func (x *segment) StateLoad(m state.Source) {
+	m.Load(0, &x.segmentEntry)
+	m.Load(1, &x.refCnt)
+	m.Load(3, &x.hdr)
+	m.Load(4, &x.viewToDeliver)
+	m.Load(5, &x.sequenceNumber)
+	m.Load(6, &x.ackNumber)
+	m.Load(7, &x.flags)
+	m.Load(8, &x.window)
+	m.Load(9, &x.csum)
+	m.Load(10, &x.csumValid)
+	m.Load(11, &x.parsedOptions)
+	m.Load(13, &x.hasNewSACKInfo)
+	m.Load(16, &x.xmitCount)
+	m.LoadValue(2, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+	m.LoadValue(12, new([]byte), func(y interface{}) { x.loadOptions(y.([]byte)) })
+	m.LoadValue(14, new(unixTime), func(y interface{}) { x.loadRcvdTime(y.(unixTime)) })
+	m.LoadValue(15, new(unixTime), func(y interface{}) { x.loadXmitTime(y.(unixTime)) })
+}
+
+func (x *segmentQueue) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.segmentQueue"
+}
+
+func (x *segmentQueue) StateFields() []string {
+	return []string{
+		"list",
+		"limit",
+		"used",
+	}
 }
 
 func (x *segmentQueue) beforeSave() {}
-func (x *segmentQueue) save(m state.Map) {
+
+func (x *segmentQueue) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("list", &x.list)
-	m.Save("limit", &x.limit)
-	m.Save("used", &x.used)
+	m.Save(0, &x.list)
+	m.Save(1, &x.limit)
+	m.Save(2, &x.used)
 }
 
 func (x *segmentQueue) afterLoad() {}
-func (x *segmentQueue) load(m state.Map) {
-	m.LoadWait("list", &x.list)
-	m.Load("limit", &x.limit)
-	m.Load("used", &x.used)
+
+func (x *segmentQueue) StateLoad(m state.Source) {
+	m.LoadWait(0, &x.list)
+	m.Load(1, &x.limit)
+	m.Load(2, &x.used)
+}
+
+func (x *sender) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.sender"
+}
+
+func (x *sender) StateFields() []string {
+	return []string{
+		"ep",
+		"lastSendTime",
+		"dupAckCount",
+		"fr",
+		"sndCwnd",
+		"sndSsthresh",
+		"sndCAAckCount",
+		"outstanding",
+		"sndWnd",
+		"sndUna",
+		"sndNxt",
+		"rttMeasureSeqNum",
+		"rttMeasureTime",
+		"firstRetransmittedSegXmitTime",
+		"closed",
+		"writeNext",
+		"writeList",
+		"rtt",
+		"rto",
+		"minRTO",
+		"maxRTO",
+		"maxRetries",
+		"maxPayloadSize",
+		"gso",
+		"sndWndScale",
+		"maxSentAck",
+		"state",
+		"cc",
+	}
 }
 
 func (x *sender) beforeSave() {}
-func (x *sender) save(m state.Map) {
+
+func (x *sender) StateSave(m state.Sink) {
 	x.beforeSave()
 	var lastSendTime unixTime = x.saveLastSendTime()
-	m.SaveValue("lastSendTime", lastSendTime)
+	m.SaveValue(1, lastSendTime)
 	var rttMeasureTime unixTime = x.saveRttMeasureTime()
-	m.SaveValue("rttMeasureTime", rttMeasureTime)
+	m.SaveValue(12, rttMeasureTime)
 	var firstRetransmittedSegXmitTime unixTime = x.saveFirstRetransmittedSegXmitTime()
-	m.SaveValue("firstRetransmittedSegXmitTime", firstRetransmittedSegXmitTime)
-	m.Save("ep", &x.ep)
-	m.Save("dupAckCount", &x.dupAckCount)
-	m.Save("fr", &x.fr)
-	m.Save("sndCwnd", &x.sndCwnd)
-	m.Save("sndSsthresh", &x.sndSsthresh)
-	m.Save("sndCAAckCount", &x.sndCAAckCount)
-	m.Save("outstanding", &x.outstanding)
-	m.Save("sndWnd", &x.sndWnd)
-	m.Save("sndUna", &x.sndUna)
-	m.Save("sndNxt", &x.sndNxt)
-	m.Save("rttMeasureSeqNum", &x.rttMeasureSeqNum)
-	m.Save("closed", &x.closed)
-	m.Save("writeNext", &x.writeNext)
-	m.Save("writeList", &x.writeList)
-	m.Save("rtt", &x.rtt)
-	m.Save("rto", &x.rto)
-	m.Save("minRTO", &x.minRTO)
-	m.Save("maxRTO", &x.maxRTO)
-	m.Save("maxRetries", &x.maxRetries)
-	m.Save("maxPayloadSize", &x.maxPayloadSize)
-	m.Save("gso", &x.gso)
-	m.Save("sndWndScale", &x.sndWndScale)
-	m.Save("maxSentAck", &x.maxSentAck)
-	m.Save("state", &x.state)
-	m.Save("cc", &x.cc)
-}
-
-func (x *sender) load(m state.Map) {
-	m.Load("ep", &x.ep)
-	m.Load("dupAckCount", &x.dupAckCount)
-	m.Load("fr", &x.fr)
-	m.Load("sndCwnd", &x.sndCwnd)
-	m.Load("sndSsthresh", &x.sndSsthresh)
-	m.Load("sndCAAckCount", &x.sndCAAckCount)
-	m.Load("outstanding", &x.outstanding)
-	m.Load("sndWnd", &x.sndWnd)
-	m.Load("sndUna", &x.sndUna)
-	m.Load("sndNxt", &x.sndNxt)
-	m.Load("rttMeasureSeqNum", &x.rttMeasureSeqNum)
-	m.Load("closed", &x.closed)
-	m.Load("writeNext", &x.writeNext)
-	m.Load("writeList", &x.writeList)
-	m.Load("rtt", &x.rtt)
-	m.Load("rto", &x.rto)
-	m.Load("minRTO", &x.minRTO)
-	m.Load("maxRTO", &x.maxRTO)
-	m.Load("maxRetries", &x.maxRetries)
-	m.Load("maxPayloadSize", &x.maxPayloadSize)
-	m.Load("gso", &x.gso)
-	m.Load("sndWndScale", &x.sndWndScale)
-	m.Load("maxSentAck", &x.maxSentAck)
-	m.Load("state", &x.state)
-	m.Load("cc", &x.cc)
-	m.LoadValue("lastSendTime", new(unixTime), func(y interface{}) { x.loadLastSendTime(y.(unixTime)) })
-	m.LoadValue("rttMeasureTime", new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
-	m.LoadValue("firstRetransmittedSegXmitTime", new(unixTime), func(y interface{}) { x.loadFirstRetransmittedSegXmitTime(y.(unixTime)) })
+	m.SaveValue(13, firstRetransmittedSegXmitTime)
+	m.Save(0, &x.ep)
+	m.Save(2, &x.dupAckCount)
+	m.Save(3, &x.fr)
+	m.Save(4, &x.sndCwnd)
+	m.Save(5, &x.sndSsthresh)
+	m.Save(6, &x.sndCAAckCount)
+	m.Save(7, &x.outstanding)
+	m.Save(8, &x.sndWnd)
+	m.Save(9, &x.sndUna)
+	m.Save(10, &x.sndNxt)
+	m.Save(11, &x.rttMeasureSeqNum)
+	m.Save(14, &x.closed)
+	m.Save(15, &x.writeNext)
+	m.Save(16, &x.writeList)
+	m.Save(17, &x.rtt)
+	m.Save(18, &x.rto)
+	m.Save(19, &x.minRTO)
+	m.Save(20, &x.maxRTO)
+	m.Save(21, &x.maxRetries)
+	m.Save(22, &x.maxPayloadSize)
+	m.Save(23, &x.gso)
+	m.Save(24, &x.sndWndScale)
+	m.Save(25, &x.maxSentAck)
+	m.Save(26, &x.state)
+	m.Save(27, &x.cc)
+}
+
+func (x *sender) StateLoad(m state.Source) {
+	m.Load(0, &x.ep)
+	m.Load(2, &x.dupAckCount)
+	m.Load(3, &x.fr)
+	m.Load(4, &x.sndCwnd)
+	m.Load(5, &x.sndSsthresh)
+	m.Load(6, &x.sndCAAckCount)
+	m.Load(7, &x.outstanding)
+	m.Load(8, &x.sndWnd)
+	m.Load(9, &x.sndUna)
+	m.Load(10, &x.sndNxt)
+	m.Load(11, &x.rttMeasureSeqNum)
+	m.Load(14, &x.closed)
+	m.Load(15, &x.writeNext)
+	m.Load(16, &x.writeList)
+	m.Load(17, &x.rtt)
+	m.Load(18, &x.rto)
+	m.Load(19, &x.minRTO)
+	m.Load(20, &x.maxRTO)
+	m.Load(21, &x.maxRetries)
+	m.Load(22, &x.maxPayloadSize)
+	m.Load(23, &x.gso)
+	m.Load(24, &x.sndWndScale)
+	m.Load(25, &x.maxSentAck)
+	m.Load(26, &x.state)
+	m.Load(27, &x.cc)
+	m.LoadValue(1, new(unixTime), func(y interface{}) { x.loadLastSendTime(y.(unixTime)) })
+	m.LoadValue(12, new(unixTime), func(y interface{}) { x.loadRttMeasureTime(y.(unixTime)) })
+	m.LoadValue(13, new(unixTime), func(y interface{}) { x.loadFirstRetransmittedSegXmitTime(y.(unixTime)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *rtt) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.rtt"
+}
+
+func (x *rtt) StateFields() []string {
+	return []string{
+		"srtt",
+		"rttvar",
+		"srttInited",
+	}
+}
+
 func (x *rtt) beforeSave() {}
-func (x *rtt) save(m state.Map) {
+
+func (x *rtt) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("srtt", &x.srtt)
-	m.Save("rttvar", &x.rttvar)
-	m.Save("srttInited", &x.srttInited)
+	m.Save(0, &x.srtt)
+	m.Save(1, &x.rttvar)
+	m.Save(2, &x.srttInited)
 }
 
 func (x *rtt) afterLoad() {}
-func (x *rtt) load(m state.Map) {
-	m.Load("srtt", &x.srtt)
-	m.Load("rttvar", &x.rttvar)
-	m.Load("srttInited", &x.srttInited)
+
+func (x *rtt) StateLoad(m state.Source) {
+	m.Load(0, &x.srtt)
+	m.Load(1, &x.rttvar)
+	m.Load(2, &x.srttInited)
+}
+
+func (x *fastRecovery) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.fastRecovery"
+}
+
+func (x *fastRecovery) StateFields() []string {
+	return []string{
+		"active",
+		"first",
+		"last",
+		"maxCwnd",
+		"highRxt",
+		"rescueRxt",
+	}
 }
 
 func (x *fastRecovery) beforeSave() {}
-func (x *fastRecovery) save(m state.Map) {
+
+func (x *fastRecovery) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("active", &x.active)
-	m.Save("first", &x.first)
-	m.Save("last", &x.last)
-	m.Save("maxCwnd", &x.maxCwnd)
-	m.Save("highRxt", &x.highRxt)
-	m.Save("rescueRxt", &x.rescueRxt)
+	m.Save(0, &x.active)
+	m.Save(1, &x.first)
+	m.Save(2, &x.last)
+	m.Save(3, &x.maxCwnd)
+	m.Save(4, &x.highRxt)
+	m.Save(5, &x.rescueRxt)
 }
 
 func (x *fastRecovery) afterLoad() {}
-func (x *fastRecovery) load(m state.Map) {
-	m.Load("active", &x.active)
-	m.Load("first", &x.first)
-	m.Load("last", &x.last)
-	m.Load("maxCwnd", &x.maxCwnd)
-	m.Load("highRxt", &x.highRxt)
-	m.Load("rescueRxt", &x.rescueRxt)
+
+func (x *fastRecovery) StateLoad(m state.Source) {
+	m.Load(0, &x.active)
+	m.Load(1, &x.first)
+	m.Load(2, &x.last)
+	m.Load(3, &x.maxCwnd)
+	m.Load(4, &x.highRxt)
+	m.Load(5, &x.rescueRxt)
+}
+
+func (x *unixTime) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.unixTime"
+}
+
+func (x *unixTime) StateFields() []string {
+	return []string{
+		"second",
+		"nano",
+	}
 }
 
 func (x *unixTime) beforeSave() {}
-func (x *unixTime) save(m state.Map) {
+
+func (x *unixTime) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("second", &x.second)
-	m.Save("nano", &x.nano)
+	m.Save(0, &x.second)
+	m.Save(1, &x.nano)
 }
 
 func (x *unixTime) afterLoad() {}
-func (x *unixTime) load(m state.Map) {
-	m.Load("second", &x.second)
-	m.Load("nano", &x.nano)
+
+func (x *unixTime) StateLoad(m state.Source) {
+	m.Load(0, &x.second)
+	m.Load(1, &x.nano)
+}
+
+func (x *endpointList) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.endpointList"
+}
+
+func (x *endpointList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
 }
 
 func (x *endpointList) beforeSave() {}
-func (x *endpointList) save(m state.Map) {
+
+func (x *endpointList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *endpointList) afterLoad() {}
-func (x *endpointList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *endpointList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *endpointEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.endpointEntry"
+}
+
+func (x *endpointEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *endpointEntry) beforeSave() {}
-func (x *endpointEntry) save(m state.Map) {
+
+func (x *endpointEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *endpointEntry) afterLoad() {}
-func (x *endpointEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *endpointEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
+}
+
+func (x *segmentList) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.segmentList"
+}
+
+func (x *segmentList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
 }
 
 func (x *segmentList) beforeSave() {}
-func (x *segmentList) save(m state.Map) {
+
+func (x *segmentList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *segmentList) afterLoad() {}
-func (x *segmentList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *segmentList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *segmentEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/tcp.segmentEntry"
+}
+
+func (x *segmentEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *segmentEntry) beforeSave() {}
-func (x *segmentEntry) save(m state.Map) {
+
+func (x *segmentEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *segmentEntry) afterLoad() {}
-func (x *segmentEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *segmentEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
 }
 
 func init() {
-	state.Register("pkg/tcpip/transport/tcp.cubicState", (*cubicState)(nil), state.Fns{Save: (*cubicState).save, Load: (*cubicState).load})
-	state.Register("pkg/tcpip/transport/tcp.SACKInfo", (*SACKInfo)(nil), state.Fns{Save: (*SACKInfo).save, Load: (*SACKInfo).load})
-	state.Register("pkg/tcpip/transport/tcp.rcvBufAutoTuneParams", (*rcvBufAutoTuneParams)(nil), state.Fns{Save: (*rcvBufAutoTuneParams).save, Load: (*rcvBufAutoTuneParams).load})
-	state.Register("pkg/tcpip/transport/tcp.EndpointInfo", (*EndpointInfo)(nil), state.Fns{Save: (*EndpointInfo).save, Load: (*EndpointInfo).load})
-	state.Register("pkg/tcpip/transport/tcp.endpoint", (*endpoint)(nil), state.Fns{Save: (*endpoint).save, Load: (*endpoint).load})
-	state.Register("pkg/tcpip/transport/tcp.keepalive", (*keepalive)(nil), state.Fns{Save: (*keepalive).save, Load: (*keepalive).load})
-	state.Register("pkg/tcpip/transport/tcp.receiver", (*receiver)(nil), state.Fns{Save: (*receiver).save, Load: (*receiver).load})
-	state.Register("pkg/tcpip/transport/tcp.renoState", (*renoState)(nil), state.Fns{Save: (*renoState).save, Load: (*renoState).load})
-	state.Register("pkg/tcpip/transport/tcp.SACKScoreboard", (*SACKScoreboard)(nil), state.Fns{Save: (*SACKScoreboard).save, Load: (*SACKScoreboard).load})
-	state.Register("pkg/tcpip/transport/tcp.segment", (*segment)(nil), state.Fns{Save: (*segment).save, Load: (*segment).load})
-	state.Register("pkg/tcpip/transport/tcp.segmentQueue", (*segmentQueue)(nil), state.Fns{Save: (*segmentQueue).save, Load: (*segmentQueue).load})
-	state.Register("pkg/tcpip/transport/tcp.sender", (*sender)(nil), state.Fns{Save: (*sender).save, Load: (*sender).load})
-	state.Register("pkg/tcpip/transport/tcp.rtt", (*rtt)(nil), state.Fns{Save: (*rtt).save, Load: (*rtt).load})
-	state.Register("pkg/tcpip/transport/tcp.fastRecovery", (*fastRecovery)(nil), state.Fns{Save: (*fastRecovery).save, Load: (*fastRecovery).load})
-	state.Register("pkg/tcpip/transport/tcp.unixTime", (*unixTime)(nil), state.Fns{Save: (*unixTime).save, Load: (*unixTime).load})
-	state.Register("pkg/tcpip/transport/tcp.endpointList", (*endpointList)(nil), state.Fns{Save: (*endpointList).save, Load: (*endpointList).load})
-	state.Register("pkg/tcpip/transport/tcp.endpointEntry", (*endpointEntry)(nil), state.Fns{Save: (*endpointEntry).save, Load: (*endpointEntry).load})
-	state.Register("pkg/tcpip/transport/tcp.segmentList", (*segmentList)(nil), state.Fns{Save: (*segmentList).save, Load: (*segmentList).load})
-	state.Register("pkg/tcpip/transport/tcp.segmentEntry", (*segmentEntry)(nil), state.Fns{Save: (*segmentEntry).save, Load: (*segmentEntry).load})
+	state.Register((*cubicState)(nil))
+	state.Register((*SACKInfo)(nil))
+	state.Register((*rcvBufAutoTuneParams)(nil))
+	state.Register((*EndpointInfo)(nil))
+	state.Register((*endpoint)(nil))
+	state.Register((*keepalive)(nil))
+	state.Register((*receiver)(nil))
+	state.Register((*renoState)(nil))
+	state.Register((*SACKScoreboard)(nil))
+	state.Register((*segment)(nil))
+	state.Register((*segmentQueue)(nil))
+	state.Register((*sender)(nil))
+	state.Register((*rtt)(nil))
+	state.Register((*fastRecovery)(nil))
+	state.Register((*unixTime)(nil))
+	state.Register((*endpointList)(nil))
+	state.Register((*endpointEntry)(nil))
+	state.Register((*segmentList)(nil))
+	state.Register((*segmentEntry)(nil))
 }
diff --git a/pkg/tcpip/transport/udp/udp_packet_list.go b/pkg/tcpip/transport/udp/udp_packet_list.go
index a6513e1e4..5436b9de1 100644
--- a/pkg/tcpip/transport/udp/udp_packet_list.go
+++ b/pkg/tcpip/transport/udp/udp_packet_list.go
@@ -56,7 +56,7 @@ func (l *udpPacketList) Back() *udpPacket {
 //
 // NOTE: This is an O(n) operation.
 func (l *udpPacketList) Len() (count int) {
-	for e := l.Front(); e != nil; e = e.Next() {
+	for e := l.Front(); e != nil; e = (udpPacketElementMapper{}.linkerFor(e)).Next() {
 		count++
 	}
 	return count
@@ -148,13 +148,13 @@ func (l *udpPacketList) Remove(e *udpPacket) {
 
 	if prev != nil {
 		udpPacketElementMapper{}.linkerFor(prev).SetNext(next)
-	} else {
+	} else if l.head == e {
 		l.head = next
 	}
 
 	if next != nil {
 		udpPacketElementMapper{}.linkerFor(next).SetPrev(prev)
-	} else {
+	} else if l.tail == e {
 		l.tail = prev
 	}
 
diff --git a/pkg/tcpip/transport/udp/udp_state_autogen.go b/pkg/tcpip/transport/udp/udp_state_autogen.go
index 0dba38a58..943022c38 100644
--- a/pkg/tcpip/transport/udp/udp_state_autogen.go
+++ b/pkg/tcpip/transport/udp/udp_state_autogen.go
@@ -7,145 +7,242 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/buffer"
 )
 
+func (x *udpPacket) StateTypeName() string {
+	return "pkg/tcpip/transport/udp.udpPacket"
+}
+
+func (x *udpPacket) StateFields() []string {
+	return []string{
+		"udpPacketEntry",
+		"senderAddress",
+		"packetInfo",
+		"data",
+		"timestamp",
+		"tos",
+	}
+}
+
 func (x *udpPacket) beforeSave() {}
-func (x *udpPacket) save(m state.Map) {
+
+func (x *udpPacket) StateSave(m state.Sink) {
 	x.beforeSave()
 	var data buffer.VectorisedView = x.saveData()
-	m.SaveValue("data", data)
-	m.Save("udpPacketEntry", &x.udpPacketEntry)
-	m.Save("senderAddress", &x.senderAddress)
-	m.Save("packetInfo", &x.packetInfo)
-	m.Save("timestamp", &x.timestamp)
-	m.Save("tos", &x.tos)
+	m.SaveValue(3, data)
+	m.Save(0, &x.udpPacketEntry)
+	m.Save(1, &x.senderAddress)
+	m.Save(2, &x.packetInfo)
+	m.Save(4, &x.timestamp)
+	m.Save(5, &x.tos)
 }
 
 func (x *udpPacket) afterLoad() {}
-func (x *udpPacket) load(m state.Map) {
-	m.Load("udpPacketEntry", &x.udpPacketEntry)
-	m.Load("senderAddress", &x.senderAddress)
-	m.Load("packetInfo", &x.packetInfo)
-	m.Load("timestamp", &x.timestamp)
-	m.Load("tos", &x.tos)
-	m.LoadValue("data", new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+
+func (x *udpPacket) StateLoad(m state.Source) {
+	m.Load(0, &x.udpPacketEntry)
+	m.Load(1, &x.senderAddress)
+	m.Load(2, &x.packetInfo)
+	m.Load(4, &x.timestamp)
+	m.Load(5, &x.tos)
+	m.LoadValue(3, new(buffer.VectorisedView), func(y interface{}) { x.loadData(y.(buffer.VectorisedView)) })
+}
+
+func (x *endpoint) StateTypeName() string {
+	return "pkg/tcpip/transport/udp.endpoint"
 }
 
-func (x *endpoint) save(m state.Map) {
+func (x *endpoint) StateFields() []string {
+	return []string{
+		"TransportEndpointInfo",
+		"waiterQueue",
+		"uniqueID",
+		"rcvReady",
+		"rcvList",
+		"rcvBufSizeMax",
+		"rcvBufSize",
+		"rcvClosed",
+		"sndBufSize",
+		"sndBufSizeMax",
+		"state",
+		"dstPort",
+		"v6only",
+		"ttl",
+		"multicastTTL",
+		"multicastAddr",
+		"multicastNICID",
+		"multicastLoop",
+		"portFlags",
+		"bindToDevice",
+		"broadcast",
+		"lastError",
+		"boundBindToDevice",
+		"boundPortFlags",
+		"sendTOS",
+		"receiveTOS",
+		"receiveTClass",
+		"receiveIPPacketInfo",
+		"shutdownFlags",
+		"multicastMemberships",
+		"effectiveNetProtos",
+		"owner",
+	}
+}
+
+func (x *endpoint) StateSave(m state.Sink) {
 	x.beforeSave()
 	var rcvBufSizeMax int = x.saveRcvBufSizeMax()
-	m.SaveValue("rcvBufSizeMax", rcvBufSizeMax)
+	m.SaveValue(5, rcvBufSizeMax)
 	var lastError string = x.saveLastError()
-	m.SaveValue("lastError", lastError)
-	m.Save("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Save("waiterQueue", &x.waiterQueue)
-	m.Save("uniqueID", &x.uniqueID)
-	m.Save("rcvReady", &x.rcvReady)
-	m.Save("rcvList", &x.rcvList)
-	m.Save("rcvBufSize", &x.rcvBufSize)
-	m.Save("rcvClosed", &x.rcvClosed)
-	m.Save("sndBufSize", &x.sndBufSize)
-	m.Save("sndBufSizeMax", &x.sndBufSizeMax)
-	m.Save("state", &x.state)
-	m.Save("dstPort", &x.dstPort)
-	m.Save("v6only", &x.v6only)
-	m.Save("ttl", &x.ttl)
-	m.Save("multicastTTL", &x.multicastTTL)
-	m.Save("multicastAddr", &x.multicastAddr)
-	m.Save("multicastNICID", &x.multicastNICID)
-	m.Save("multicastLoop", &x.multicastLoop)
-	m.Save("portFlags", &x.portFlags)
-	m.Save("bindToDevice", &x.bindToDevice)
-	m.Save("broadcast", &x.broadcast)
-	m.Save("boundBindToDevice", &x.boundBindToDevice)
-	m.Save("boundPortFlags", &x.boundPortFlags)
-	m.Save("sendTOS", &x.sendTOS)
-	m.Save("receiveTOS", &x.receiveTOS)
-	m.Save("receiveTClass", &x.receiveTClass)
-	m.Save("receiveIPPacketInfo", &x.receiveIPPacketInfo)
-	m.Save("shutdownFlags", &x.shutdownFlags)
-	m.Save("multicastMemberships", &x.multicastMemberships)
-	m.Save("effectiveNetProtos", &x.effectiveNetProtos)
-	m.Save("owner", &x.owner)
-}
-
-func (x *endpoint) load(m state.Map) {
-	m.Load("TransportEndpointInfo", &x.TransportEndpointInfo)
-	m.Load("waiterQueue", &x.waiterQueue)
-	m.Load("uniqueID", &x.uniqueID)
-	m.Load("rcvReady", &x.rcvReady)
-	m.Load("rcvList", &x.rcvList)
-	m.Load("rcvBufSize", &x.rcvBufSize)
-	m.Load("rcvClosed", &x.rcvClosed)
-	m.Load("sndBufSize", &x.sndBufSize)
-	m.Load("sndBufSizeMax", &x.sndBufSizeMax)
-	m.Load("state", &x.state)
-	m.Load("dstPort", &x.dstPort)
-	m.Load("v6only", &x.v6only)
-	m.Load("ttl", &x.ttl)
-	m.Load("multicastTTL", &x.multicastTTL)
-	m.Load("multicastAddr", &x.multicastAddr)
-	m.Load("multicastNICID", &x.multicastNICID)
-	m.Load("multicastLoop", &x.multicastLoop)
-	m.Load("portFlags", &x.portFlags)
-	m.Load("bindToDevice", &x.bindToDevice)
-	m.Load("broadcast", &x.broadcast)
-	m.Load("boundBindToDevice", &x.boundBindToDevice)
-	m.Load("boundPortFlags", &x.boundPortFlags)
-	m.Load("sendTOS", &x.sendTOS)
-	m.Load("receiveTOS", &x.receiveTOS)
-	m.Load("receiveTClass", &x.receiveTClass)
-	m.Load("receiveIPPacketInfo", &x.receiveIPPacketInfo)
-	m.Load("shutdownFlags", &x.shutdownFlags)
-	m.Load("multicastMemberships", &x.multicastMemberships)
-	m.Load("effectiveNetProtos", &x.effectiveNetProtos)
-	m.Load("owner", &x.owner)
-	m.LoadValue("rcvBufSizeMax", new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
-	m.LoadValue("lastError", new(string), func(y interface{}) { x.loadLastError(y.(string)) })
+	m.SaveValue(21, lastError)
+	m.Save(0, &x.TransportEndpointInfo)
+	m.Save(1, &x.waiterQueue)
+	m.Save(2, &x.uniqueID)
+	m.Save(3, &x.rcvReady)
+	m.Save(4, &x.rcvList)
+	m.Save(6, &x.rcvBufSize)
+	m.Save(7, &x.rcvClosed)
+	m.Save(8, &x.sndBufSize)
+	m.Save(9, &x.sndBufSizeMax)
+	m.Save(10, &x.state)
+	m.Save(11, &x.dstPort)
+	m.Save(12, &x.v6only)
+	m.Save(13, &x.ttl)
+	m.Save(14, &x.multicastTTL)
+	m.Save(15, &x.multicastAddr)
+	m.Save(16, &x.multicastNICID)
+	m.Save(17, &x.multicastLoop)
+	m.Save(18, &x.portFlags)
+	m.Save(19, &x.bindToDevice)
+	m.Save(20, &x.broadcast)
+	m.Save(22, &x.boundBindToDevice)
+	m.Save(23, &x.boundPortFlags)
+	m.Save(24, &x.sendTOS)
+	m.Save(25, &x.receiveTOS)
+	m.Save(26, &x.receiveTClass)
+	m.Save(27, &x.receiveIPPacketInfo)
+	m.Save(28, &x.shutdownFlags)
+	m.Save(29, &x.multicastMemberships)
+	m.Save(30, &x.effectiveNetProtos)
+	m.Save(31, &x.owner)
+}
+
+func (x *endpoint) StateLoad(m state.Source) {
+	m.Load(0, &x.TransportEndpointInfo)
+	m.Load(1, &x.waiterQueue)
+	m.Load(2, &x.uniqueID)
+	m.Load(3, &x.rcvReady)
+	m.Load(4, &x.rcvList)
+	m.Load(6, &x.rcvBufSize)
+	m.Load(7, &x.rcvClosed)
+	m.Load(8, &x.sndBufSize)
+	m.Load(9, &x.sndBufSizeMax)
+	m.Load(10, &x.state)
+	m.Load(11, &x.dstPort)
+	m.Load(12, &x.v6only)
+	m.Load(13, &x.ttl)
+	m.Load(14, &x.multicastTTL)
+	m.Load(15, &x.multicastAddr)
+	m.Load(16, &x.multicastNICID)
+	m.Load(17, &x.multicastLoop)
+	m.Load(18, &x.portFlags)
+	m.Load(19, &x.bindToDevice)
+	m.Load(20, &x.broadcast)
+	m.Load(22, &x.boundBindToDevice)
+	m.Load(23, &x.boundPortFlags)
+	m.Load(24, &x.sendTOS)
+	m.Load(25, &x.receiveTOS)
+	m.Load(26, &x.receiveTClass)
+	m.Load(27, &x.receiveIPPacketInfo)
+	m.Load(28, &x.shutdownFlags)
+	m.Load(29, &x.multicastMemberships)
+	m.Load(30, &x.effectiveNetProtos)
+	m.Load(31, &x.owner)
+	m.LoadValue(5, new(int), func(y interface{}) { x.loadRcvBufSizeMax(y.(int)) })
+	m.LoadValue(21, new(string), func(y interface{}) { x.loadLastError(y.(string)) })
 	m.AfterLoad(x.afterLoad)
 }
 
+func (x *multicastMembership) StateTypeName() string {
+	return "pkg/tcpip/transport/udp.multicastMembership"
+}
+
+func (x *multicastMembership) StateFields() []string {
+	return []string{
+		"nicID",
+		"multicastAddr",
+	}
+}
+
 func (x *multicastMembership) beforeSave() {}
-func (x *multicastMembership) save(m state.Map) {
+
+func (x *multicastMembership) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("nicID", &x.nicID)
-	m.Save("multicastAddr", &x.multicastAddr)
+	m.Save(0, &x.nicID)
+	m.Save(1, &x.multicastAddr)
 }
 
 func (x *multicastMembership) afterLoad() {}
-func (x *multicastMembership) load(m state.Map) {
-	m.Load("nicID", &x.nicID)
-	m.Load("multicastAddr", &x.multicastAddr)
+
+func (x *multicastMembership) StateLoad(m state.Source) {
+	m.Load(0, &x.nicID)
+	m.Load(1, &x.multicastAddr)
+}
+
+func (x *udpPacketList) StateTypeName() string {
+	return "pkg/tcpip/transport/udp.udpPacketList"
+}
+
+func (x *udpPacketList) StateFields() []string {
+	return []string{
+		"head",
+		"tail",
+	}
 }
 
 func (x *udpPacketList) beforeSave() {}
-func (x *udpPacketList) save(m state.Map) {
+
+func (x *udpPacketList) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("head", &x.head)
-	m.Save("tail", &x.tail)
+	m.Save(0, &x.head)
+	m.Save(1, &x.tail)
 }
 
 func (x *udpPacketList) afterLoad() {}
-func (x *udpPacketList) load(m state.Map) {
-	m.Load("head", &x.head)
-	m.Load("tail", &x.tail)
+
+func (x *udpPacketList) StateLoad(m state.Source) {
+	m.Load(0, &x.head)
+	m.Load(1, &x.tail)
+}
+
+func (x *udpPacketEntry) StateTypeName() string {
+	return "pkg/tcpip/transport/udp.udpPacketEntry"
+}
+
+func (x *udpPacketEntry) StateFields() []string {
+	return []string{
+		"next",
+		"prev",
+	}
 }
 
 func (x *udpPacketEntry) beforeSave() {}
-func (x *udpPacketEntry) save(m state.Map) {
+
+func (x *udpPacketEntry) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("next", &x.next)
-	m.Save("prev", &x.prev)
+	m.Save(0, &x.next)
+	m.Save(1, &x.prev)
 }
 
 func (x *udpPacketEntry) afterLoad() {}
-func (x *udpPacketEntry) load(m state.Map) {
-	m.Load("next", &x.next)
-	m.Load("prev", &x.prev)
+
+func (x *udpPacketEntry) StateLoad(m state.Source) {
+	m.Load(0, &x.next)
+	m.Load(1, &x.prev)
 }
 
 func init() {
-	state.Register("pkg/tcpip/transport/udp.udpPacket", (*udpPacket)(nil), state.Fns{Save: (*udpPacket).save, Load: (*udpPacket).load})
-	state.Register("pkg/tcpip/transport/udp.endpoint", (*endpoint)(nil), state.Fns{Save: (*endpoint).save, Load: (*endpoint).load})
-	state.Register("pkg/tcpip/transport/udp.multicastMembership", (*multicastMembership)(nil), state.Fns{Save: (*multicastMembership).save, Load: (*multicastMembership).load})
-	state.Register("pkg/tcpip/transport/udp.udpPacketList", (*udpPacketList)(nil), state.Fns{Save: (*udpPacketList).save, Load: (*udpPacketList).load})
-	state.Register("pkg/tcpip/transport/udp.udpPacketEntry", (*udpPacketEntry)(nil), state.Fns{Save: (*udpPacketEntry).save, Load: (*udpPacketEntry).load})
+	state.Register((*udpPacket)(nil))
+	state.Register((*endpoint)(nil))
+	state.Register((*multicastMembership)(nil))
+	state.Register((*udpPacketList)(nil))
+	state.Register((*udpPacketEntry)(nil))
 }