Merge release-20200928.0-66-ga55bd73d4 (automated)

14 files changed, 1681 insertions, 1681 deletions

diff --git a/pkg/sentry/kernel/auth/auth_state_autogen.go b/pkg/sentry/kernel/auth/auth_state_autogen.go
index 7a710d06d..7381b79ea 100644
--- a/pkg/sentry/kernel/auth/auth_state_autogen.go
+++ b/pkg/sentry/kernel/auth/auth_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *Credentials) StateTypeName() string {
+func (c *Credentials) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.Credentials"
 }
 
-func (x *Credentials) StateFields() []string {
+func (c *Credentials) StateFields() []string {
 	return []string{
 		"RealKUID",
 		"EffectiveKUID",
@@ -28,48 +28,48 @@ func (x *Credentials) StateFields() []string {
 	}
 }
 
-func (x *Credentials) beforeSave() {}
-
-func (x *Credentials) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.RealKUID)
-	m.Save(1, &x.EffectiveKUID)
-	m.Save(2, &x.SavedKUID)
-	m.Save(3, &x.RealKGID)
-	m.Save(4, &x.EffectiveKGID)
-	m.Save(5, &x.SavedKGID)
-	m.Save(6, &x.ExtraKGIDs)
-	m.Save(7, &x.PermittedCaps)
-	m.Save(8, &x.InheritableCaps)
-	m.Save(9, &x.EffectiveCaps)
-	m.Save(10, &x.BoundingCaps)
-	m.Save(11, &x.KeepCaps)
-	m.Save(12, &x.UserNamespace)
+func (c *Credentials) beforeSave() {}
+
+func (c *Credentials) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.RealKUID)
+	stateSinkObject.Save(1, &c.EffectiveKUID)
+	stateSinkObject.Save(2, &c.SavedKUID)
+	stateSinkObject.Save(3, &c.RealKGID)
+	stateSinkObject.Save(4, &c.EffectiveKGID)
+	stateSinkObject.Save(5, &c.SavedKGID)
+	stateSinkObject.Save(6, &c.ExtraKGIDs)
+	stateSinkObject.Save(7, &c.PermittedCaps)
+	stateSinkObject.Save(8, &c.InheritableCaps)
+	stateSinkObject.Save(9, &c.EffectiveCaps)
+	stateSinkObject.Save(10, &c.BoundingCaps)
+	stateSinkObject.Save(11, &c.KeepCaps)
+	stateSinkObject.Save(12, &c.UserNamespace)
 }
 
-func (x *Credentials) afterLoad() {}
-
-func (x *Credentials) StateLoad(m state.Source) {
-	m.Load(0, &x.RealKUID)
-	m.Load(1, &x.EffectiveKUID)
-	m.Load(2, &x.SavedKUID)
-	m.Load(3, &x.RealKGID)
-	m.Load(4, &x.EffectiveKGID)
-	m.Load(5, &x.SavedKGID)
-	m.Load(6, &x.ExtraKGIDs)
-	m.Load(7, &x.PermittedCaps)
-	m.Load(8, &x.InheritableCaps)
-	m.Load(9, &x.EffectiveCaps)
-	m.Load(10, &x.BoundingCaps)
-	m.Load(11, &x.KeepCaps)
-	m.Load(12, &x.UserNamespace)
+func (c *Credentials) afterLoad() {}
+
+func (c *Credentials) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.RealKUID)
+	stateSourceObject.Load(1, &c.EffectiveKUID)
+	stateSourceObject.Load(2, &c.SavedKUID)
+	stateSourceObject.Load(3, &c.RealKGID)
+	stateSourceObject.Load(4, &c.EffectiveKGID)
+	stateSourceObject.Load(5, &c.SavedKGID)
+	stateSourceObject.Load(6, &c.ExtraKGIDs)
+	stateSourceObject.Load(7, &c.PermittedCaps)
+	stateSourceObject.Load(8, &c.InheritableCaps)
+	stateSourceObject.Load(9, &c.EffectiveCaps)
+	stateSourceObject.Load(10, &c.BoundingCaps)
+	stateSourceObject.Load(11, &c.KeepCaps)
+	stateSourceObject.Load(12, &c.UserNamespace)
 }
 
-func (x *IDMapEntry) StateTypeName() string {
+func (i *IDMapEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.IDMapEntry"
 }
 
-func (x *IDMapEntry) StateFields() []string {
+func (i *IDMapEntry) StateFields() []string {
 	return []string{
 		"FirstID",
 		"FirstParentID",
@@ -77,78 +77,78 @@ func (x *IDMapEntry) StateFields() []string {
 	}
 }
 
-func (x *IDMapEntry) beforeSave() {}
+func (i *IDMapEntry) beforeSave() {}
 
-func (x *IDMapEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FirstID)
-	m.Save(1, &x.FirstParentID)
-	m.Save(2, &x.Length)
+func (i *IDMapEntry) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.FirstID)
+	stateSinkObject.Save(1, &i.FirstParentID)
+	stateSinkObject.Save(2, &i.Length)
 }
 
-func (x *IDMapEntry) afterLoad() {}
+func (i *IDMapEntry) afterLoad() {}
 
-func (x *IDMapEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.FirstID)
-	m.Load(1, &x.FirstParentID)
-	m.Load(2, &x.Length)
+func (i *IDMapEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.FirstID)
+	stateSourceObject.Load(1, &i.FirstParentID)
+	stateSourceObject.Load(2, &i.Length)
 }
 
-func (x *idMapRange) StateTypeName() string {
+func (i *idMapRange) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapRange"
 }
 
-func (x *idMapRange) StateFields() []string {
+func (i *idMapRange) StateFields() []string {
 	return []string{
 		"Start",
 		"End",
 	}
 }
 
-func (x *idMapRange) beforeSave() {}
+func (i *idMapRange) beforeSave() {}
 
-func (x *idMapRange) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Start)
-	m.Save(1, &x.End)
+func (i *idMapRange) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.Start)
+	stateSinkObject.Save(1, &i.End)
 }
 
-func (x *idMapRange) afterLoad() {}
+func (i *idMapRange) afterLoad() {}
 
-func (x *idMapRange) StateLoad(m state.Source) {
-	m.Load(0, &x.Start)
-	m.Load(1, &x.End)
+func (i *idMapRange) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.Start)
+	stateSourceObject.Load(1, &i.End)
 }
 
-func (x *idMapSet) StateTypeName() string {
+func (i *idMapSet) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapSet"
 }
 
-func (x *idMapSet) StateFields() []string {
+func (i *idMapSet) StateFields() []string {
 	return []string{
 		"root",
 	}
 }
 
-func (x *idMapSet) beforeSave() {}
+func (i *idMapSet) beforeSave() {}
 
-func (x *idMapSet) StateSave(m state.Sink) {
-	x.beforeSave()
-	var root *idMapSegmentDataSlices = x.saveRoot()
-	m.SaveValue(0, root)
+func (i *idMapSet) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	var rootValue *idMapSegmentDataSlices = i.saveRoot()
+	stateSinkObject.SaveValue(0, rootValue)
 }
 
-func (x *idMapSet) afterLoad() {}
+func (i *idMapSet) afterLoad() {}
 
-func (x *idMapSet) StateLoad(m state.Source) {
-	m.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { x.loadRoot(y.(*idMapSegmentDataSlices)) })
+func (i *idMapSet) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { i.loadRoot(y.(*idMapSegmentDataSlices)) })
 }
 
-func (x *idMapnode) StateTypeName() string {
+func (i *idMapnode) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapnode"
 }
 
-func (x *idMapnode) StateFields() []string {
+func (i *idMapnode) StateFields() []string {
 	return []string{
 		"nrSegments",
 		"parent",
@@ -161,38 +161,38 @@ func (x *idMapnode) StateFields() []string {
 	}
 }
 
-func (x *idMapnode) beforeSave() {}
-
-func (x *idMapnode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.nrSegments)
-	m.Save(1, &x.parent)
-	m.Save(2, &x.parentIndex)
-	m.Save(3, &x.hasChildren)
-	m.Save(4, &x.maxGap)
-	m.Save(5, &x.keys)
-	m.Save(6, &x.values)
-	m.Save(7, &x.children)
+func (i *idMapnode) beforeSave() {}
+
+func (i *idMapnode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.nrSegments)
+	stateSinkObject.Save(1, &i.parent)
+	stateSinkObject.Save(2, &i.parentIndex)
+	stateSinkObject.Save(3, &i.hasChildren)
+	stateSinkObject.Save(4, &i.maxGap)
+	stateSinkObject.Save(5, &i.keys)
+	stateSinkObject.Save(6, &i.values)
+	stateSinkObject.Save(7, &i.children)
 }
 
-func (x *idMapnode) afterLoad() {}
-
-func (x *idMapnode) StateLoad(m state.Source) {
-	m.Load(0, &x.nrSegments)
-	m.Load(1, &x.parent)
-	m.Load(2, &x.parentIndex)
-	m.Load(3, &x.hasChildren)
-	m.Load(4, &x.maxGap)
-	m.Load(5, &x.keys)
-	m.Load(6, &x.values)
-	m.Load(7, &x.children)
+func (i *idMapnode) afterLoad() {}
+
+func (i *idMapnode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.nrSegments)
+	stateSourceObject.Load(1, &i.parent)
+	stateSourceObject.Load(2, &i.parentIndex)
+	stateSourceObject.Load(3, &i.hasChildren)
+	stateSourceObject.Load(4, &i.maxGap)
+	stateSourceObject.Load(5, &i.keys)
+	stateSourceObject.Load(6, &i.values)
+	stateSourceObject.Load(7, &i.children)
 }
 
-func (x *idMapSegmentDataSlices) StateTypeName() string {
+func (i *idMapSegmentDataSlices) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapSegmentDataSlices"
 }
 
-func (x *idMapSegmentDataSlices) StateFields() []string {
+func (i *idMapSegmentDataSlices) StateFields() []string {
 	return []string{
 		"Start",
 		"End",
@@ -200,28 +200,28 @@ func (x *idMapSegmentDataSlices) StateFields() []string {
 	}
 }
 
-func (x *idMapSegmentDataSlices) beforeSave() {}
+func (i *idMapSegmentDataSlices) beforeSave() {}
 
-func (x *idMapSegmentDataSlices) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Start)
-	m.Save(1, &x.End)
-	m.Save(2, &x.Values)
+func (i *idMapSegmentDataSlices) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.Start)
+	stateSinkObject.Save(1, &i.End)
+	stateSinkObject.Save(2, &i.Values)
 }
 
-func (x *idMapSegmentDataSlices) afterLoad() {}
+func (i *idMapSegmentDataSlices) afterLoad() {}
 
-func (x *idMapSegmentDataSlices) StateLoad(m state.Source) {
-	m.Load(0, &x.Start)
-	m.Load(1, &x.End)
-	m.Load(2, &x.Values)
+func (i *idMapSegmentDataSlices) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.Start)
+	stateSourceObject.Load(1, &i.End)
+	stateSourceObject.Load(2, &i.Values)
 }
 
-func (x *UserNamespace) StateTypeName() string {
+func (u *UserNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.UserNamespace"
 }
 
-func (x *UserNamespace) StateFields() []string {
+func (u *UserNamespace) StateFields() []string {
 	return []string{
 		"parent",
 		"owner",
@@ -232,27 +232,27 @@ func (x *UserNamespace) StateFields() []string {
 	}
 }
 
-func (x *UserNamespace) beforeSave() {}
+func (u *UserNamespace) beforeSave() {}
 
-func (x *UserNamespace) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.parent)
-	m.Save(1, &x.owner)
-	m.Save(2, &x.uidMapFromParent)
-	m.Save(3, &x.uidMapToParent)
-	m.Save(4, &x.gidMapFromParent)
-	m.Save(5, &x.gidMapToParent)
+func (u *UserNamespace) StateSave(stateSinkObject state.Sink) {
+	u.beforeSave()
+	stateSinkObject.Save(0, &u.parent)
+	stateSinkObject.Save(1, &u.owner)
+	stateSinkObject.Save(2, &u.uidMapFromParent)
+	stateSinkObject.Save(3, &u.uidMapToParent)
+	stateSinkObject.Save(4, &u.gidMapFromParent)
+	stateSinkObject.Save(5, &u.gidMapToParent)
 }
 
-func (x *UserNamespace) afterLoad() {}
+func (u *UserNamespace) afterLoad() {}
 
-func (x *UserNamespace) StateLoad(m state.Source) {
-	m.Load(0, &x.parent)
-	m.Load(1, &x.owner)
-	m.Load(2, &x.uidMapFromParent)
-	m.Load(3, &x.uidMapToParent)
-	m.Load(4, &x.gidMapFromParent)
-	m.Load(5, &x.gidMapToParent)
+func (u *UserNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &u.parent)
+	stateSourceObject.Load(1, &u.owner)
+	stateSourceObject.Load(2, &u.uidMapFromParent)
+	stateSourceObject.Load(3, &u.uidMapToParent)
+	stateSourceObject.Load(4, &u.gidMapFromParent)
+	stateSourceObject.Load(5, &u.gidMapToParent)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go b/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
index 0a3507dd5..4002e0cb2 100644
--- a/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
+++ b/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
@@ -6,28 +6,28 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *AtomicPtrCredentials) StateTypeName() string {
+func (a *AtomicPtrCredentials) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.AtomicPtrCredentials"
 }
 
-func (x *AtomicPtrCredentials) StateFields() []string {
+func (a *AtomicPtrCredentials) StateFields() []string {
 	return []string{
 		"ptr",
 	}
 }
 
-func (x *AtomicPtrCredentials) beforeSave() {}
+func (a *AtomicPtrCredentials) beforeSave() {}
 
-func (x *AtomicPtrCredentials) StateSave(m state.Sink) {
-	x.beforeSave()
-	var ptr *Credentials = x.savePtr()
-	m.SaveValue(0, ptr)
+func (a *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	var ptrValue *Credentials = a.savePtr()
+	stateSinkObject.SaveValue(0, ptrValue)
 }
 
-func (x *AtomicPtrCredentials) afterLoad() {}
+func (a *AtomicPtrCredentials) afterLoad() {}
 
-func (x *AtomicPtrCredentials) StateLoad(m state.Source) {
-	m.LoadValue(0, new(*Credentials), func(y interface{}) { x.loadPtr(y.(*Credentials)) })
+func (a *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { a.loadPtr(y.(*Credentials)) })
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/epoll/epoll_state_autogen.go b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
index 3b9d76751..cdeadd3e1 100644
--- a/pkg/sentry/kernel/epoll/epoll_state_autogen.go
+++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
@@ -6,37 +6,37 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *FileIdentifier) StateTypeName() string {
+func (f *FileIdentifier) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.FileIdentifier"
 }
 
-func (x *FileIdentifier) StateFields() []string {
+func (f *FileIdentifier) StateFields() []string {
 	return []string{
 		"File",
 		"Fd",
 	}
 }
 
-func (x *FileIdentifier) beforeSave() {}
+func (f *FileIdentifier) beforeSave() {}
 
-func (x *FileIdentifier) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.File)
-	m.Save(1, &x.Fd)
+func (f *FileIdentifier) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.File)
+	stateSinkObject.Save(1, &f.Fd)
 }
 
-func (x *FileIdentifier) afterLoad() {}
+func (f *FileIdentifier) afterLoad() {}
 
-func (x *FileIdentifier) StateLoad(m state.Source) {
-	m.LoadWait(0, &x.File)
-	m.Load(1, &x.Fd)
+func (f *FileIdentifier) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadWait(0, &f.File)
+	stateSourceObject.Load(1, &f.Fd)
 }
 
-func (x *pollEntry) StateTypeName() string {
+func (p *pollEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.pollEntry"
 }
 
-func (x *pollEntry) StateFields() []string {
+func (p *pollEntry) StateFields() []string {
 	return []string{
 		"pollEntryEntry",
 		"id",
@@ -47,33 +47,33 @@ func (x *pollEntry) StateFields() []string {
 	}
 }
 
-func (x *pollEntry) beforeSave() {}
+func (p *pollEntry) beforeSave() {}
 
-func (x *pollEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.pollEntryEntry)
-	m.Save(1, &x.id)
-	m.Save(2, &x.userData)
-	m.Save(3, &x.mask)
-	m.Save(4, &x.flags)
-	m.Save(5, &x.epoll)
+func (p *pollEntry) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.pollEntryEntry)
+	stateSinkObject.Save(1, &p.id)
+	stateSinkObject.Save(2, &p.userData)
+	stateSinkObject.Save(3, &p.mask)
+	stateSinkObject.Save(4, &p.flags)
+	stateSinkObject.Save(5, &p.epoll)
 }
 
-func (x *pollEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.pollEntryEntry)
-	m.LoadWait(1, &x.id)
-	m.Load(2, &x.userData)
-	m.Load(3, &x.mask)
-	m.Load(4, &x.flags)
-	m.Load(5, &x.epoll)
-	m.AfterLoad(x.afterLoad)
+func (p *pollEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.pollEntryEntry)
+	stateSourceObject.LoadWait(1, &p.id)
+	stateSourceObject.Load(2, &p.userData)
+	stateSourceObject.Load(3, &p.mask)
+	stateSourceObject.Load(4, &p.flags)
+	stateSourceObject.Load(5, &p.epoll)
+	stateSourceObject.AfterLoad(p.afterLoad)
 }
 
-func (x *EventPoll) StateTypeName() string {
+func (e *EventPoll) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.EventPoll"
 }
 
-func (x *EventPoll) StateFields() []string {
+func (e *EventPoll) StateFields() []string {
 	return []string{
 		"files",
 		"readyList",
@@ -82,95 +82,95 @@ func (x *EventPoll) StateFields() []string {
 	}
 }
 
-func (x *EventPoll) beforeSave() {}
+func (e *EventPoll) beforeSave() {}
 
-func (x *EventPoll) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.FilePipeSeek) {
-		state.Failf("FilePipeSeek is %#v, expected zero", &x.FilePipeSeek)
+func (e *EventPoll) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	if !state.IsZeroValue(&e.FilePipeSeek) {
+		state.Failf("FilePipeSeek is %#v, expected zero", &e.FilePipeSeek)
 	}
-	if !state.IsZeroValue(&x.FileNotDirReaddir) {
-		state.Failf("FileNotDirReaddir is %#v, expected zero", &x.FileNotDirReaddir)
+	if !state.IsZeroValue(&e.FileNotDirReaddir) {
+		state.Failf("FileNotDirReaddir is %#v, expected zero", &e.FileNotDirReaddir)
 	}
-	if !state.IsZeroValue(&x.FileNoFsync) {
-		state.Failf("FileNoFsync is %#v, expected zero", &x.FileNoFsync)
+	if !state.IsZeroValue(&e.FileNoFsync) {
+		state.Failf("FileNoFsync is %#v, expected zero", &e.FileNoFsync)
 	}
-	if !state.IsZeroValue(&x.FileNoopFlush) {
-		state.Failf("FileNoopFlush is %#v, expected zero", &x.FileNoopFlush)
+	if !state.IsZeroValue(&e.FileNoopFlush) {
+		state.Failf("FileNoopFlush is %#v, expected zero", &e.FileNoopFlush)
 	}
-	if !state.IsZeroValue(&x.FileNoIoctl) {
-		state.Failf("FileNoIoctl is %#v, expected zero", &x.FileNoIoctl)
+	if !state.IsZeroValue(&e.FileNoIoctl) {
+		state.Failf("FileNoIoctl is %#v, expected zero", &e.FileNoIoctl)
 	}
-	if !state.IsZeroValue(&x.FileNoMMap) {
-		state.Failf("FileNoMMap is %#v, expected zero", &x.FileNoMMap)
+	if !state.IsZeroValue(&e.FileNoMMap) {
+		state.Failf("FileNoMMap is %#v, expected zero", &e.FileNoMMap)
 	}
-	if !state.IsZeroValue(&x.Queue) {
-		state.Failf("Queue is %#v, expected zero", &x.Queue)
+	if !state.IsZeroValue(&e.Queue) {
+		state.Failf("Queue is %#v, expected zero", &e.Queue)
 	}
-	m.Save(0, &x.files)
-	m.Save(1, &x.readyList)
-	m.Save(2, &x.waitingList)
-	m.Save(3, &x.disabledList)
+	stateSinkObject.Save(0, &e.files)
+	stateSinkObject.Save(1, &e.readyList)
+	stateSinkObject.Save(2, &e.waitingList)
+	stateSinkObject.Save(3, &e.disabledList)
 }
 
-func (x *EventPoll) StateLoad(m state.Source) {
-	m.Load(0, &x.files)
-	m.Load(1, &x.readyList)
-	m.Load(2, &x.waitingList)
-	m.Load(3, &x.disabledList)
-	m.AfterLoad(x.afterLoad)
+func (e *EventPoll) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.files)
+	stateSourceObject.Load(1, &e.readyList)
+	stateSourceObject.Load(2, &e.waitingList)
+	stateSourceObject.Load(3, &e.disabledList)
+	stateSourceObject.AfterLoad(e.afterLoad)
 }
 
-func (x *pollEntryList) StateTypeName() string {
+func (p *pollEntryList) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.pollEntryList"
 }
 
-func (x *pollEntryList) StateFields() []string {
+func (p *pollEntryList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *pollEntryList) beforeSave() {}
+func (p *pollEntryList) beforeSave() {}
 
-func (x *pollEntryList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (p *pollEntryList) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.head)
+	stateSinkObject.Save(1, &p.tail)
 }
 
-func (x *pollEntryList) afterLoad() {}
+func (p *pollEntryList) afterLoad() {}
 
-func (x *pollEntryList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (p *pollEntryList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.head)
+	stateSourceObject.Load(1, &p.tail)
 }
 
-func (x *pollEntryEntry) StateTypeName() string {
+func (p *pollEntryEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.pollEntryEntry"
 }
 
-func (x *pollEntryEntry) StateFields() []string {
+func (p *pollEntryEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *pollEntryEntry) beforeSave() {}
+func (p *pollEntryEntry) beforeSave() {}
 
-func (x *pollEntryEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (p *pollEntryEntry) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.next)
+	stateSinkObject.Save(1, &p.prev)
 }
 
-func (x *pollEntryEntry) afterLoad() {}
+func (p *pollEntryEntry) afterLoad() {}
 
-func (x *pollEntryEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (p *pollEntryEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.next)
+	stateSourceObject.Load(1, &p.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
index 72a285daa..336262eed 100644
--- a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
+++ b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *EventOperations) StateTypeName() string {
+func (e *EventOperations) StateTypeName() string {
 	return "pkg/sentry/kernel/eventfd.EventOperations"
 }
 
-func (x *EventOperations) StateFields() []string {
+func (e *EventOperations) StateFields() []string {
 	return []string{
 		"val",
 		"semMode",
@@ -18,24 +18,24 @@ func (x *EventOperations) StateFields() []string {
 	}
 }
 
-func (x *EventOperations) beforeSave() {}
+func (e *EventOperations) beforeSave() {}
 
-func (x *EventOperations) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.wq) {
-		state.Failf("wq is %#v, expected zero", &x.wq)
+func (e *EventOperations) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	if !state.IsZeroValue(&e.wq) {
+		state.Failf("wq is %#v, expected zero", &e.wq)
 	}
-	m.Save(0, &x.val)
-	m.Save(1, &x.semMode)
-	m.Save(2, &x.hostfd)
+	stateSinkObject.Save(0, &e.val)
+	stateSinkObject.Save(1, &e.semMode)
+	stateSinkObject.Save(2, &e.hostfd)
 }
 
-func (x *EventOperations) afterLoad() {}
+func (e *EventOperations) afterLoad() {}
 
-func (x *EventOperations) StateLoad(m state.Source) {
-	m.Load(0, &x.val)
-	m.Load(1, &x.semMode)
-	m.Load(2, &x.hostfd)
+func (e *EventOperations) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.val)
+	stateSourceObject.Load(1, &e.semMode)
+	stateSourceObject.Load(2, &e.hostfd)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/fasync/fasync_state_autogen.go b/pkg/sentry/kernel/fasync/fasync_state_autogen.go
index 8da4a1b44..e4a0b5695 100644
--- a/pkg/sentry/kernel/fasync/fasync_state_autogen.go
+++ b/pkg/sentry/kernel/fasync/fasync_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *FileAsync) StateTypeName() string {
+func (f *FileAsync) StateTypeName() string {
 	return "pkg/sentry/kernel/fasync.FileAsync"
 }
 
-func (x *FileAsync) StateFields() []string {
+func (f *FileAsync) StateFields() []string {
 	return []string{
 		"e",
 		"requester",
@@ -21,27 +21,27 @@ func (x *FileAsync) StateFields() []string {
 	}
 }
 
-func (x *FileAsync) beforeSave() {}
+func (f *FileAsync) beforeSave() {}
 
-func (x *FileAsync) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.e)
-	m.Save(1, &x.requester)
-	m.Save(2, &x.registered)
-	m.Save(3, &x.recipientPG)
-	m.Save(4, &x.recipientTG)
-	m.Save(5, &x.recipientT)
+func (f *FileAsync) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.e)
+	stateSinkObject.Save(1, &f.requester)
+	stateSinkObject.Save(2, &f.registered)
+	stateSinkObject.Save(3, &f.recipientPG)
+	stateSinkObject.Save(4, &f.recipientTG)
+	stateSinkObject.Save(5, &f.recipientT)
 }
 
-func (x *FileAsync) afterLoad() {}
+func (f *FileAsync) afterLoad() {}
 
-func (x *FileAsync) StateLoad(m state.Source) {
-	m.Load(0, &x.e)
-	m.Load(1, &x.requester)
-	m.Load(2, &x.registered)
-	m.Load(3, &x.recipientPG)
-	m.Load(4, &x.recipientTG)
-	m.Load(5, &x.recipientT)
+func (f *FileAsync) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.e)
+	stateSourceObject.Load(1, &f.requester)
+	stateSourceObject.Load(2, &f.registered)
+	stateSourceObject.Load(3, &f.recipientPG)
+	stateSourceObject.Load(4, &f.recipientTG)
+	stateSourceObject.Load(5, &f.recipientT)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/futex/futex_state_autogen.go b/pkg/sentry/kernel/futex/futex_state_autogen.go
index 13e9a97d0..f36f5ccfc 100644
--- a/pkg/sentry/kernel/futex/futex_state_autogen.go
+++ b/pkg/sentry/kernel/futex/futex_state_autogen.go
@@ -6,104 +6,104 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *bucket) StateTypeName() string {
+func (b *bucket) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.bucket"
 }
 
-func (x *bucket) StateFields() []string {
+func (b *bucket) StateFields() []string {
 	return []string{}
 }
 
-func (x *bucket) beforeSave() {}
+func (b *bucket) beforeSave() {}
 
-func (x *bucket) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.waiters) {
-		state.Failf("waiters is %#v, expected zero", &x.waiters)
+func (b *bucket) StateSave(stateSinkObject state.Sink) {
+	b.beforeSave()
+	if !state.IsZeroValue(&b.waiters) {
+		state.Failf("waiters is %#v, expected zero", &b.waiters)
 	}
 }
 
-func (x *bucket) afterLoad() {}
+func (b *bucket) afterLoad() {}
 
-func (x *bucket) StateLoad(m state.Source) {
+func (b *bucket) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *Manager) StateTypeName() string {
+func (m *Manager) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.Manager"
 }
 
-func (x *Manager) StateFields() []string {
+func (m *Manager) StateFields() []string {
 	return []string{
 		"sharedBucket",
 	}
 }
 
-func (x *Manager) beforeSave() {}
+func (m *Manager) beforeSave() {}
 
-func (x *Manager) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.privateBuckets) {
-		state.Failf("privateBuckets is %#v, expected zero", &x.privateBuckets)
+func (m *Manager) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	if !state.IsZeroValue(&m.privateBuckets) {
+		state.Failf("privateBuckets is %#v, expected zero", &m.privateBuckets)
 	}
-	m.Save(0, &x.sharedBucket)
+	stateSinkObject.Save(0, &m.sharedBucket)
 }
 
-func (x *Manager) afterLoad() {}
+func (m *Manager) afterLoad() {}
 
-func (x *Manager) StateLoad(m state.Source) {
-	m.Load(0, &x.sharedBucket)
+func (m *Manager) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.sharedBucket)
 }
 
-func (x *waiterList) StateTypeName() string {
+func (w *waiterList) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.waiterList"
 }
 
-func (x *waiterList) StateFields() []string {
+func (w *waiterList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *waiterList) beforeSave() {}
+func (w *waiterList) beforeSave() {}
 
-func (x *waiterList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (w *waiterList) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.head)
+	stateSinkObject.Save(1, &w.tail)
 }
 
-func (x *waiterList) afterLoad() {}
+func (w *waiterList) afterLoad() {}
 
-func (x *waiterList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (w *waiterList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.head)
+	stateSourceObject.Load(1, &w.tail)
 }
 
-func (x *waiterEntry) StateTypeName() string {
+func (w *waiterEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.waiterEntry"
 }
 
-func (x *waiterEntry) StateFields() []string {
+func (w *waiterEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *waiterEntry) beforeSave() {}
+func (w *waiterEntry) beforeSave() {}
 
-func (x *waiterEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.next)
+	stateSinkObject.Save(1, &w.prev)
 }
 
-func (x *waiterEntry) afterLoad() {}
+func (w *waiterEntry) afterLoad() {}
 
-func (x *waiterEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.next)
+	stateSourceObject.Load(1, &w.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go b/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
index 244cdb502..6a9953ffa 100644
--- a/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
+++ b/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
@@ -6,28 +6,28 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *AtomicPtrBucket) StateTypeName() string {
+func (a *AtomicPtrBucket) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.AtomicPtrBucket"
 }
 
-func (x *AtomicPtrBucket) StateFields() []string {
+func (a *AtomicPtrBucket) StateFields() []string {
 	return []string{
 		"ptr",
 	}
 }
 
-func (x *AtomicPtrBucket) beforeSave() {}
+func (a *AtomicPtrBucket) beforeSave() {}
 
-func (x *AtomicPtrBucket) StateSave(m state.Sink) {
-	x.beforeSave()
-	var ptr *bucket = x.savePtr()
-	m.SaveValue(0, ptr)
+func (a *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	var ptrValue *bucket = a.savePtr()
+	stateSinkObject.SaveValue(0, ptrValue)
 }
 
-func (x *AtomicPtrBucket) afterLoad() {}
+func (a *AtomicPtrBucket) afterLoad() {}
 
-func (x *AtomicPtrBucket) StateLoad(m state.Source) {
-	m.LoadValue(0, new(*bucket), func(y interface{}) { x.loadPtr(y.(*bucket)) })
+func (a *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { a.loadPtr(y.(*bucket)) })
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/kernel_opts_state_autogen.go b/pkg/sentry/kernel/kernel_opts_state_autogen.go
index a01604159..7780c995f 100644
--- a/pkg/sentry/kernel/kernel_opts_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_opts_state_autogen.go
@@ -6,23 +6,23 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *SpecialOpts) StateTypeName() string {
+func (s *SpecialOpts) StateTypeName() string {
 	return "pkg/sentry/kernel.SpecialOpts"
 }
 
-func (x *SpecialOpts) StateFields() []string {
+func (s *SpecialOpts) StateFields() []string {
 	return []string{}
 }
 
-func (x *SpecialOpts) beforeSave() {}
+func (s *SpecialOpts) beforeSave() {}
 
-func (x *SpecialOpts) StateSave(m state.Sink) {
-	x.beforeSave()
+func (s *SpecialOpts) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
 }
 
-func (x *SpecialOpts) afterLoad() {}
+func (s *SpecialOpts) afterLoad() {}
 
-func (x *SpecialOpts) StateLoad(m state.Source) {
+func (s *SpecialOpts) StateLoad(stateSourceObject state.Source) {
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/kernel_state_autogen.go b/pkg/sentry/kernel/kernel_state_autogen.go
index 7ff5e1eb9..101c137de 100644
--- a/pkg/sentry/kernel/kernel_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_state_autogen.go
@@ -9,11 +9,11 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip"
 )
 
-func (x *abstractEndpoint) StateTypeName() string {
+func (a *abstractEndpoint) StateTypeName() string {
 	return "pkg/sentry/kernel.abstractEndpoint"
 }
 
-func (x *abstractEndpoint) StateFields() []string {
+func (a *abstractEndpoint) StateFields() []string {
 	return []string{
 		"ep",
 		"socket",
@@ -22,76 +22,76 @@ func (x *abstractEndpoint) StateFields() []string {
 	}
 }
 
-func (x *abstractEndpoint) beforeSave() {}
+func (a *abstractEndpoint) beforeSave() {}
 
-func (x *abstractEndpoint) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ep)
-	m.Save(1, &x.socket)
-	m.Save(2, &x.name)
-	m.Save(3, &x.ns)
+func (a *abstractEndpoint) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	stateSinkObject.Save(0, &a.ep)
+	stateSinkObject.Save(1, &a.socket)
+	stateSinkObject.Save(2, &a.name)
+	stateSinkObject.Save(3, &a.ns)
 }
 
-func (x *abstractEndpoint) afterLoad() {}
+func (a *abstractEndpoint) afterLoad() {}
 
-func (x *abstractEndpoint) StateLoad(m state.Source) {
-	m.Load(0, &x.ep)
-	m.Load(1, &x.socket)
-	m.Load(2, &x.name)
-	m.Load(3, &x.ns)
+func (a *abstractEndpoint) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &a.ep)
+	stateSourceObject.Load(1, &a.socket)
+	stateSourceObject.Load(2, &a.name)
+	stateSourceObject.Load(3, &a.ns)
 }
 
-func (x *AbstractSocketNamespace) StateTypeName() string {
+func (a *AbstractSocketNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel.AbstractSocketNamespace"
 }
 
-func (x *AbstractSocketNamespace) StateFields() []string {
+func (a *AbstractSocketNamespace) StateFields() []string {
 	return []string{
 		"endpoints",
 	}
 }
 
-func (x *AbstractSocketNamespace) beforeSave() {}
+func (a *AbstractSocketNamespace) beforeSave() {}
 
-func (x *AbstractSocketNamespace) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.endpoints)
+func (a *AbstractSocketNamespace) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	stateSinkObject.Save(0, &a.endpoints)
 }
 
-func (x *AbstractSocketNamespace) afterLoad() {}
+func (a *AbstractSocketNamespace) afterLoad() {}
 
-func (x *AbstractSocketNamespace) StateLoad(m state.Source) {
-	m.Load(0, &x.endpoints)
+func (a *AbstractSocketNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &a.endpoints)
 }
 
-func (x *FDFlags) StateTypeName() string {
+func (f *FDFlags) StateTypeName() string {
 	return "pkg/sentry/kernel.FDFlags"
 }
 
-func (x *FDFlags) StateFields() []string {
+func (f *FDFlags) StateFields() []string {
 	return []string{
 		"CloseOnExec",
 	}
 }
 
-func (x *FDFlags) beforeSave() {}
+func (f *FDFlags) beforeSave() {}
 
-func (x *FDFlags) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.CloseOnExec)
+func (f *FDFlags) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.CloseOnExec)
 }
 
-func (x *FDFlags) afterLoad() {}
+func (f *FDFlags) afterLoad() {}
 
-func (x *FDFlags) StateLoad(m state.Source) {
-	m.Load(0, &x.CloseOnExec)
+func (f *FDFlags) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.CloseOnExec)
 }
 
-func (x *descriptor) StateTypeName() string {
+func (d *descriptor) StateTypeName() string {
 	return "pkg/sentry/kernel.descriptor"
 }
 
-func (x *descriptor) StateFields() []string {
+func (d *descriptor) StateFields() []string {
 	return []string{
 		"file",
 		"fileVFS2",
@@ -99,28 +99,28 @@ func (x *descriptor) StateFields() []string {
 	}
 }
 
-func (x *descriptor) beforeSave() {}
+func (d *descriptor) beforeSave() {}
 
-func (x *descriptor) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.file)
-	m.Save(1, &x.fileVFS2)
-	m.Save(2, &x.flags)
+func (d *descriptor) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.file)
+	stateSinkObject.Save(1, &d.fileVFS2)
+	stateSinkObject.Save(2, &d.flags)
 }
 
-func (x *descriptor) afterLoad() {}
+func (d *descriptor) afterLoad() {}
 
-func (x *descriptor) StateLoad(m state.Source) {
-	m.Load(0, &x.file)
-	m.Load(1, &x.fileVFS2)
-	m.Load(2, &x.flags)
+func (d *descriptor) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.file)
+	stateSourceObject.Load(1, &d.fileVFS2)
+	stateSourceObject.Load(2, &d.flags)
 }
 
-func (x *FDTable) StateTypeName() string {
+func (f *FDTable) StateTypeName() string {
 	return "pkg/sentry/kernel.FDTable"
 }
 
-func (x *FDTable) StateFields() []string {
+func (f *FDTable) StateFields() []string {
 	return []string{
 		"FDTableRefs",
 		"k",
@@ -130,56 +130,56 @@ func (x *FDTable) StateFields() []string {
 	}
 }
 
-func (x *FDTable) beforeSave() {}
+func (f *FDTable) beforeSave() {}
 
-func (x *FDTable) StateSave(m state.Sink) {
-	x.beforeSave()
-	var descriptorTable map[int32]descriptor = x.saveDescriptorTable()
-	m.SaveValue(4, descriptorTable)
-	m.Save(0, &x.FDTableRefs)
-	m.Save(1, &x.k)
-	m.Save(2, &x.next)
-	m.Save(3, &x.used)
+func (f *FDTable) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	var descriptorTableValue map[int32]descriptor = f.saveDescriptorTable()
+	stateSinkObject.SaveValue(4, descriptorTableValue)
+	stateSinkObject.Save(0, &f.FDTableRefs)
+	stateSinkObject.Save(1, &f.k)
+	stateSinkObject.Save(2, &f.next)
+	stateSinkObject.Save(3, &f.used)
 }
 
-func (x *FDTable) afterLoad() {}
+func (f *FDTable) afterLoad() {}
 
-func (x *FDTable) StateLoad(m state.Source) {
-	m.Load(0, &x.FDTableRefs)
-	m.Load(1, &x.k)
-	m.Load(2, &x.next)
-	m.Load(3, &x.used)
-	m.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { x.loadDescriptorTable(y.(map[int32]descriptor)) })
+func (f *FDTable) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.FDTableRefs)
+	stateSourceObject.Load(1, &f.k)
+	stateSourceObject.Load(2, &f.next)
+	stateSourceObject.Load(3, &f.used)
+	stateSourceObject.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { f.loadDescriptorTable(y.(map[int32]descriptor)) })
 }
 
-func (x *FDTableRefs) StateTypeName() string {
+func (f *FDTableRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.FDTableRefs"
 }
 
-func (x *FDTableRefs) StateFields() []string {
+func (f *FDTableRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *FDTableRefs) beforeSave() {}
+func (f *FDTableRefs) beforeSave() {}
 
-func (x *FDTableRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (f *FDTableRefs) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.refCount)
 }
 
-func (x *FDTableRefs) afterLoad() {}
+func (f *FDTableRefs) afterLoad() {}
 
-func (x *FDTableRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (f *FDTableRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.refCount)
 }
 
-func (x *FSContext) StateTypeName() string {
+func (f *FSContext) StateTypeName() string {
 	return "pkg/sentry/kernel.FSContext"
 }
 
-func (x *FSContext) StateFields() []string {
+func (f *FSContext) StateFields() []string {
 	return []string{
 		"FSContextRefs",
 		"root",
@@ -190,57 +190,57 @@ func (x *FSContext) StateFields() []string {
 	}
 }
 
-func (x *FSContext) beforeSave() {}
+func (f *FSContext) beforeSave() {}
 
-func (x *FSContext) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FSContextRefs)
-	m.Save(1, &x.root)
-	m.Save(2, &x.rootVFS2)
-	m.Save(3, &x.cwd)
-	m.Save(4, &x.cwdVFS2)
-	m.Save(5, &x.umask)
+func (f *FSContext) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.FSContextRefs)
+	stateSinkObject.Save(1, &f.root)
+	stateSinkObject.Save(2, &f.rootVFS2)
+	stateSinkObject.Save(3, &f.cwd)
+	stateSinkObject.Save(4, &f.cwdVFS2)
+	stateSinkObject.Save(5, &f.umask)
 }
 
-func (x *FSContext) afterLoad() {}
+func (f *FSContext) afterLoad() {}
 
-func (x *FSContext) StateLoad(m state.Source) {
-	m.Load(0, &x.FSContextRefs)
-	m.Load(1, &x.root)
-	m.Load(2, &x.rootVFS2)
-	m.Load(3, &x.cwd)
-	m.Load(4, &x.cwdVFS2)
-	m.Load(5, &x.umask)
+func (f *FSContext) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.FSContextRefs)
+	stateSourceObject.Load(1, &f.root)
+	stateSourceObject.Load(2, &f.rootVFS2)
+	stateSourceObject.Load(3, &f.cwd)
+	stateSourceObject.Load(4, &f.cwdVFS2)
+	stateSourceObject.Load(5, &f.umask)
 }
 
-func (x *FSContextRefs) StateTypeName() string {
+func (f *FSContextRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.FSContextRefs"
 }
 
-func (x *FSContextRefs) StateFields() []string {
+func (f *FSContextRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *FSContextRefs) beforeSave() {}
+func (f *FSContextRefs) beforeSave() {}
 
-func (x *FSContextRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (f *FSContextRefs) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.refCount)
 }
 
-func (x *FSContextRefs) afterLoad() {}
+func (f *FSContextRefs) afterLoad() {}
 
-func (x *FSContextRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (f *FSContextRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.refCount)
 }
 
-func (x *IPCNamespace) StateTypeName() string {
+func (i *IPCNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel.IPCNamespace"
 }
 
-func (x *IPCNamespace) StateFields() []string {
+func (i *IPCNamespace) StateFields() []string {
 	return []string{
 		"userNS",
 		"semaphores",
@@ -248,28 +248,28 @@ func (x *IPCNamespace) StateFields() []string {
 	}
 }
 
-func (x *IPCNamespace) beforeSave() {}
+func (i *IPCNamespace) beforeSave() {}
 
-func (x *IPCNamespace) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.userNS)
-	m.Save(1, &x.semaphores)
-	m.Save(2, &x.shms)
+func (i *IPCNamespace) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.userNS)
+	stateSinkObject.Save(1, &i.semaphores)
+	stateSinkObject.Save(2, &i.shms)
 }
 
-func (x *IPCNamespace) afterLoad() {}
+func (i *IPCNamespace) afterLoad() {}
 
-func (x *IPCNamespace) StateLoad(m state.Source) {
-	m.Load(0, &x.userNS)
-	m.Load(1, &x.semaphores)
-	m.Load(2, &x.shms)
+func (i *IPCNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.userNS)
+	stateSourceObject.Load(1, &i.semaphores)
+	stateSourceObject.Load(2, &i.shms)
 }
 
-func (x *Kernel) StateTypeName() string {
+func (k *Kernel) StateTypeName() string {
 	return "pkg/sentry/kernel.Kernel"
 }
 
-func (x *Kernel) StateFields() []string {
+func (k *Kernel) StateFields() []string {
 	return []string{
 		"featureSet",
 		"timekeeper",
@@ -311,98 +311,98 @@ func (x *Kernel) StateFields() []string {
 	}
 }
 
-func (x *Kernel) beforeSave() {}
-
-func (x *Kernel) StateSave(m state.Sink) {
-	x.beforeSave()
-	var danglingEndpoints []tcpip.Endpoint = x.saveDanglingEndpoints()
-	m.SaveValue(24, danglingEndpoints)
-	var deviceRegistry *device.Registry = x.saveDeviceRegistry()
-	m.SaveValue(28, deviceRegistry)
-	m.Save(0, &x.featureSet)
-	m.Save(1, &x.timekeeper)
-	m.Save(2, &x.tasks)
-	m.Save(3, &x.rootUserNamespace)
-	m.Save(4, &x.rootNetworkNamespace)
-	m.Save(5, &x.applicationCores)
-	m.Save(6, &x.useHostCores)
-	m.Save(7, &x.extraAuxv)
-	m.Save(8, &x.vdso)
-	m.Save(9, &x.rootUTSNamespace)
-	m.Save(10, &x.rootIPCNamespace)
-	m.Save(11, &x.rootAbstractSocketNamespace)
-	m.Save(12, &x.futexes)
-	m.Save(13, &x.globalInit)
-	m.Save(14, &x.realtimeClock)
-	m.Save(15, &x.monotonicClock)
-	m.Save(16, &x.syslog)
-	m.Save(17, &x.runningTasks)
-	m.Save(18, &x.cpuClock)
-	m.Save(19, &x.cpuClockTickerDisabled)
-	m.Save(20, &x.cpuClockTickerSetting)
-	m.Save(21, &x.uniqueID)
-	m.Save(22, &x.nextInotifyCookie)
-	m.Save(23, &x.netlinkPorts)
-	m.Save(25, &x.sockets)
-	m.Save(26, &x.socketsVFS2)
-	m.Save(27, &x.nextSocketRecord)
-	m.Save(29, &x.DirentCacheLimiter)
-	m.Save(30, &x.SpecialOpts)
-	m.Save(31, &x.vfs)
-	m.Save(32, &x.hostMount)
-	m.Save(33, &x.pipeMount)
-	m.Save(34, &x.shmMount)
-	m.Save(35, &x.socketMount)
-	m.Save(36, &x.SleepForAddressSpaceActivation)
-}
-
-func (x *Kernel) afterLoad() {}
-
-func (x *Kernel) StateLoad(m state.Source) {
-	m.Load(0, &x.featureSet)
-	m.Load(1, &x.timekeeper)
-	m.Load(2, &x.tasks)
-	m.Load(3, &x.rootUserNamespace)
-	m.Load(4, &x.rootNetworkNamespace)
-	m.Load(5, &x.applicationCores)
-	m.Load(6, &x.useHostCores)
-	m.Load(7, &x.extraAuxv)
-	m.Load(8, &x.vdso)
-	m.Load(9, &x.rootUTSNamespace)
-	m.Load(10, &x.rootIPCNamespace)
-	m.Load(11, &x.rootAbstractSocketNamespace)
-	m.Load(12, &x.futexes)
-	m.Load(13, &x.globalInit)
-	m.Load(14, &x.realtimeClock)
-	m.Load(15, &x.monotonicClock)
-	m.Load(16, &x.syslog)
-	m.Load(17, &x.runningTasks)
-	m.Load(18, &x.cpuClock)
-	m.Load(19, &x.cpuClockTickerDisabled)
-	m.Load(20, &x.cpuClockTickerSetting)
-	m.Load(21, &x.uniqueID)
-	m.Load(22, &x.nextInotifyCookie)
-	m.Load(23, &x.netlinkPorts)
-	m.Load(25, &x.sockets)
-	m.Load(26, &x.socketsVFS2)
-	m.Load(27, &x.nextSocketRecord)
-	m.Load(29, &x.DirentCacheLimiter)
-	m.Load(30, &x.SpecialOpts)
-	m.Load(31, &x.vfs)
-	m.Load(32, &x.hostMount)
-	m.Load(33, &x.pipeMount)
-	m.Load(34, &x.shmMount)
-	m.Load(35, &x.socketMount)
-	m.Load(36, &x.SleepForAddressSpaceActivation)
-	m.LoadValue(24, new([]tcpip.Endpoint), func(y interface{}) { x.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
-	m.LoadValue(28, new(*device.Registry), func(y interface{}) { x.loadDeviceRegistry(y.(*device.Registry)) })
-}
-
-func (x *SocketRecord) StateTypeName() string {
+func (k *Kernel) beforeSave() {}
+
+func (k *Kernel) StateSave(stateSinkObject state.Sink) {
+	k.beforeSave()
+	var danglingEndpointsValue []tcpip.Endpoint = k.saveDanglingEndpoints()
+	stateSinkObject.SaveValue(24, danglingEndpointsValue)
+	var deviceRegistryValue *device.Registry = k.saveDeviceRegistry()
+	stateSinkObject.SaveValue(28, deviceRegistryValue)
+	stateSinkObject.Save(0, &k.featureSet)
+	stateSinkObject.Save(1, &k.timekeeper)
+	stateSinkObject.Save(2, &k.tasks)
+	stateSinkObject.Save(3, &k.rootUserNamespace)
+	stateSinkObject.Save(4, &k.rootNetworkNamespace)
+	stateSinkObject.Save(5, &k.applicationCores)
+	stateSinkObject.Save(6, &k.useHostCores)
+	stateSinkObject.Save(7, &k.extraAuxv)
+	stateSinkObject.Save(8, &k.vdso)
+	stateSinkObject.Save(9, &k.rootUTSNamespace)
+	stateSinkObject.Save(10, &k.rootIPCNamespace)
+	stateSinkObject.Save(11, &k.rootAbstractSocketNamespace)
+	stateSinkObject.Save(12, &k.futexes)
+	stateSinkObject.Save(13, &k.globalInit)
+	stateSinkObject.Save(14, &k.realtimeClock)
+	stateSinkObject.Save(15, &k.monotonicClock)
+	stateSinkObject.Save(16, &k.syslog)
+	stateSinkObject.Save(17, &k.runningTasks)
+	stateSinkObject.Save(18, &k.cpuClock)
+	stateSinkObject.Save(19, &k.cpuClockTickerDisabled)
+	stateSinkObject.Save(20, &k.cpuClockTickerSetting)
+	stateSinkObject.Save(21, &k.uniqueID)
+	stateSinkObject.Save(22, &k.nextInotifyCookie)
+	stateSinkObject.Save(23, &k.netlinkPorts)
+	stateSinkObject.Save(25, &k.sockets)
+	stateSinkObject.Save(26, &k.socketsVFS2)
+	stateSinkObject.Save(27, &k.nextSocketRecord)
+	stateSinkObject.Save(29, &k.DirentCacheLimiter)
+	stateSinkObject.Save(30, &k.SpecialOpts)
+	stateSinkObject.Save(31, &k.vfs)
+	stateSinkObject.Save(32, &k.hostMount)
+	stateSinkObject.Save(33, &k.pipeMount)
+	stateSinkObject.Save(34, &k.shmMount)
+	stateSinkObject.Save(35, &k.socketMount)
+	stateSinkObject.Save(36, &k.SleepForAddressSpaceActivation)
+}
+
+func (k *Kernel) afterLoad() {}
+
+func (k *Kernel) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &k.featureSet)
+	stateSourceObject.Load(1, &k.timekeeper)
+	stateSourceObject.Load(2, &k.tasks)
+	stateSourceObject.Load(3, &k.rootUserNamespace)
+	stateSourceObject.Load(4, &k.rootNetworkNamespace)
+	stateSourceObject.Load(5, &k.applicationCores)
+	stateSourceObject.Load(6, &k.useHostCores)
+	stateSourceObject.Load(7, &k.extraAuxv)
+	stateSourceObject.Load(8, &k.vdso)
+	stateSourceObject.Load(9, &k.rootUTSNamespace)
+	stateSourceObject.Load(10, &k.rootIPCNamespace)
+	stateSourceObject.Load(11, &k.rootAbstractSocketNamespace)
+	stateSourceObject.Load(12, &k.futexes)
+	stateSourceObject.Load(13, &k.globalInit)
+	stateSourceObject.Load(14, &k.realtimeClock)
+	stateSourceObject.Load(15, &k.monotonicClock)
+	stateSourceObject.Load(16, &k.syslog)
+	stateSourceObject.Load(17, &k.runningTasks)
+	stateSourceObject.Load(18, &k.cpuClock)
+	stateSourceObject.Load(19, &k.cpuClockTickerDisabled)
+	stateSourceObject.Load(20, &k.cpuClockTickerSetting)
+	stateSourceObject.Load(21, &k.uniqueID)
+	stateSourceObject.Load(22, &k.nextInotifyCookie)
+	stateSourceObject.Load(23, &k.netlinkPorts)
+	stateSourceObject.Load(25, &k.sockets)
+	stateSourceObject.Load(26, &k.socketsVFS2)
+	stateSourceObject.Load(27, &k.nextSocketRecord)
+	stateSourceObject.Load(29, &k.DirentCacheLimiter)
+	stateSourceObject.Load(30, &k.SpecialOpts)
+	stateSourceObject.Load(31, &k.vfs)
+	stateSourceObject.Load(32, &k.hostMount)
+	stateSourceObject.Load(33, &k.pipeMount)
+	stateSourceObject.Load(34, &k.shmMount)
+	stateSourceObject.Load(35, &k.socketMount)
+	stateSourceObject.Load(36, &k.SleepForAddressSpaceActivation)
+	stateSourceObject.LoadValue(24, new([]tcpip.Endpoint), func(y interface{}) { k.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
+	stateSourceObject.LoadValue(28, new(*device.Registry), func(y interface{}) { k.loadDeviceRegistry(y.(*device.Registry)) })
+}
+
+func (s *SocketRecord) StateTypeName() string {
 	return "pkg/sentry/kernel.SocketRecord"
 }
 
-func (x *SocketRecord) StateFields() []string {
+func (s *SocketRecord) StateFields() []string {
 	return []string{
 		"k",
 		"Sock",
@@ -411,106 +411,106 @@ func (x *SocketRecord) StateFields() []string {
 	}
 }
 
-func (x *SocketRecord) beforeSave() {}
+func (s *SocketRecord) beforeSave() {}
 
-func (x *SocketRecord) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.k)
-	m.Save(1, &x.Sock)
-	m.Save(2, &x.SockVFS2)
-	m.Save(3, &x.ID)
+func (s *SocketRecord) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.k)
+	stateSinkObject.Save(1, &s.Sock)
+	stateSinkObject.Save(2, &s.SockVFS2)
+	stateSinkObject.Save(3, &s.ID)
 }
 
-func (x *SocketRecord) afterLoad() {}
+func (s *SocketRecord) afterLoad() {}
 
-func (x *SocketRecord) StateLoad(m state.Source) {
-	m.Load(0, &x.k)
-	m.Load(1, &x.Sock)
-	m.Load(2, &x.SockVFS2)
-	m.Load(3, &x.ID)
+func (s *SocketRecord) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.k)
+	stateSourceObject.Load(1, &s.Sock)
+	stateSourceObject.Load(2, &s.SockVFS2)
+	stateSourceObject.Load(3, &s.ID)
 }
 
-func (x *SocketRecordVFS1) StateTypeName() string {
+func (s *SocketRecordVFS1) StateTypeName() string {
 	return "pkg/sentry/kernel.SocketRecordVFS1"
 }
 
-func (x *SocketRecordVFS1) StateFields() []string {
+func (s *SocketRecordVFS1) StateFields() []string {
 	return []string{
 		"socketEntry",
 		"SocketRecord",
 	}
 }
 
-func (x *SocketRecordVFS1) beforeSave() {}
+func (s *SocketRecordVFS1) beforeSave() {}
 
-func (x *SocketRecordVFS1) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.socketEntry)
-	m.Save(1, &x.SocketRecord)
+func (s *SocketRecordVFS1) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.socketEntry)
+	stateSinkObject.Save(1, &s.SocketRecord)
 }
 
-func (x *SocketRecordVFS1) afterLoad() {}
+func (s *SocketRecordVFS1) afterLoad() {}
 
-func (x *SocketRecordVFS1) StateLoad(m state.Source) {
-	m.Load(0, &x.socketEntry)
-	m.Load(1, &x.SocketRecord)
+func (s *SocketRecordVFS1) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.socketEntry)
+	stateSourceObject.Load(1, &s.SocketRecord)
 }
 
-func (x *pendingSignals) StateTypeName() string {
+func (p *pendingSignals) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignals"
 }
 
-func (x *pendingSignals) StateFields() []string {
+func (p *pendingSignals) StateFields() []string {
 	return []string{
 		"signals",
 	}
 }
 
-func (x *pendingSignals) beforeSave() {}
+func (p *pendingSignals) beforeSave() {}
 
-func (x *pendingSignals) StateSave(m state.Sink) {
-	x.beforeSave()
-	var signals []savedPendingSignal = x.saveSignals()
-	m.SaveValue(0, signals)
+func (p *pendingSignals) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	var signalsValue []savedPendingSignal = p.saveSignals()
+	stateSinkObject.SaveValue(0, signalsValue)
 }
 
-func (x *pendingSignals) afterLoad() {}
+func (p *pendingSignals) afterLoad() {}
 
-func (x *pendingSignals) StateLoad(m state.Source) {
-	m.LoadValue(0, new([]savedPendingSignal), func(y interface{}) { x.loadSignals(y.([]savedPendingSignal)) })
+func (p *pendingSignals) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new([]savedPendingSignal), func(y interface{}) { p.loadSignals(y.([]savedPendingSignal)) })
 }
 
-func (x *pendingSignalQueue) StateTypeName() string {
+func (p *pendingSignalQueue) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignalQueue"
 }
 
-func (x *pendingSignalQueue) StateFields() []string {
+func (p *pendingSignalQueue) StateFields() []string {
 	return []string{
 		"pendingSignalList",
 		"length",
 	}
 }
 
-func (x *pendingSignalQueue) beforeSave() {}
+func (p *pendingSignalQueue) beforeSave() {}
 
-func (x *pendingSignalQueue) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.pendingSignalList)
-	m.Save(1, &x.length)
+func (p *pendingSignalQueue) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.pendingSignalList)
+	stateSinkObject.Save(1, &p.length)
 }
 
-func (x *pendingSignalQueue) afterLoad() {}
+func (p *pendingSignalQueue) afterLoad() {}
 
-func (x *pendingSignalQueue) StateLoad(m state.Source) {
-	m.Load(0, &x.pendingSignalList)
-	m.Load(1, &x.length)
+func (p *pendingSignalQueue) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.pendingSignalList)
+	stateSourceObject.Load(1, &p.length)
 }
 
-func (x *pendingSignal) StateTypeName() string {
+func (p *pendingSignal) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignal"
 }
 
-func (x *pendingSignal) StateFields() []string {
+func (p *pendingSignal) StateFields() []string {
 	return []string{
 		"pendingSignalEntry",
 		"SignalInfo",
@@ -518,106 +518,106 @@ func (x *pendingSignal) StateFields() []string {
 	}
 }
 
-func (x *pendingSignal) beforeSave() {}
+func (p *pendingSignal) beforeSave() {}
 
-func (x *pendingSignal) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.pendingSignalEntry)
-	m.Save(1, &x.SignalInfo)
-	m.Save(2, &x.timer)
+func (p *pendingSignal) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.pendingSignalEntry)
+	stateSinkObject.Save(1, &p.SignalInfo)
+	stateSinkObject.Save(2, &p.timer)
 }
 
-func (x *pendingSignal) afterLoad() {}
+func (p *pendingSignal) afterLoad() {}
 
-func (x *pendingSignal) StateLoad(m state.Source) {
-	m.Load(0, &x.pendingSignalEntry)
-	m.Load(1, &x.SignalInfo)
-	m.Load(2, &x.timer)
+func (p *pendingSignal) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.pendingSignalEntry)
+	stateSourceObject.Load(1, &p.SignalInfo)
+	stateSourceObject.Load(2, &p.timer)
 }
 
-func (x *pendingSignalList) StateTypeName() string {
+func (p *pendingSignalList) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignalList"
 }
 
-func (x *pendingSignalList) StateFields() []string {
+func (p *pendingSignalList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *pendingSignalList) beforeSave() {}
+func (p *pendingSignalList) beforeSave() {}
 
-func (x *pendingSignalList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (p *pendingSignalList) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.head)
+	stateSinkObject.Save(1, &p.tail)
 }
 
-func (x *pendingSignalList) afterLoad() {}
+func (p *pendingSignalList) afterLoad() {}
 
-func (x *pendingSignalList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (p *pendingSignalList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.head)
+	stateSourceObject.Load(1, &p.tail)
 }
 
-func (x *pendingSignalEntry) StateTypeName() string {
+func (p *pendingSignalEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignalEntry"
 }
 
-func (x *pendingSignalEntry) StateFields() []string {
+func (p *pendingSignalEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *pendingSignalEntry) beforeSave() {}
+func (p *pendingSignalEntry) beforeSave() {}
 
-func (x *pendingSignalEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (p *pendingSignalEntry) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.next)
+	stateSinkObject.Save(1, &p.prev)
 }
 
-func (x *pendingSignalEntry) afterLoad() {}
+func (p *pendingSignalEntry) afterLoad() {}
 
-func (x *pendingSignalEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (p *pendingSignalEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.next)
+	stateSourceObject.Load(1, &p.prev)
 }
 
-func (x *savedPendingSignal) StateTypeName() string {
+func (s *savedPendingSignal) StateTypeName() string {
 	return "pkg/sentry/kernel.savedPendingSignal"
 }
 
-func (x *savedPendingSignal) StateFields() []string {
+func (s *savedPendingSignal) StateFields() []string {
 	return []string{
 		"si",
 		"timer",
 	}
 }
 
-func (x *savedPendingSignal) beforeSave() {}
+func (s *savedPendingSignal) beforeSave() {}
 
-func (x *savedPendingSignal) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.si)
-	m.Save(1, &x.timer)
+func (s *savedPendingSignal) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.si)
+	stateSinkObject.Save(1, &s.timer)
 }
 
-func (x *savedPendingSignal) afterLoad() {}
+func (s *savedPendingSignal) afterLoad() {}
 
-func (x *savedPendingSignal) StateLoad(m state.Source) {
-	m.Load(0, &x.si)
-	m.Load(1, &x.timer)
+func (s *savedPendingSignal) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.si)
+	stateSourceObject.Load(1, &s.timer)
 }
 
-func (x *IntervalTimer) StateTypeName() string {
+func (i *IntervalTimer) StateTypeName() string {
 	return "pkg/sentry/kernel.IntervalTimer"
 }
 
-func (x *IntervalTimer) StateFields() []string {
+func (i *IntervalTimer) StateFields() []string {
 	return []string{
 		"timer",
 		"target",
@@ -632,117 +632,117 @@ func (x *IntervalTimer) StateFields() []string {
 	}
 }
 
-func (x *IntervalTimer) beforeSave() {}
+func (i *IntervalTimer) beforeSave() {}
 
-func (x *IntervalTimer) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.timer)
-	m.Save(1, &x.target)
-	m.Save(2, &x.signo)
-	m.Save(3, &x.id)
-	m.Save(4, &x.sigval)
-	m.Save(5, &x.group)
-	m.Save(6, &x.sigpending)
-	m.Save(7, &x.sigorphan)
-	m.Save(8, &x.overrunCur)
-	m.Save(9, &x.overrunLast)
+func (i *IntervalTimer) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.timer)
+	stateSinkObject.Save(1, &i.target)
+	stateSinkObject.Save(2, &i.signo)
+	stateSinkObject.Save(3, &i.id)
+	stateSinkObject.Save(4, &i.sigval)
+	stateSinkObject.Save(5, &i.group)
+	stateSinkObject.Save(6, &i.sigpending)
+	stateSinkObject.Save(7, &i.sigorphan)
+	stateSinkObject.Save(8, &i.overrunCur)
+	stateSinkObject.Save(9, &i.overrunLast)
 }
 
-func (x *IntervalTimer) afterLoad() {}
+func (i *IntervalTimer) afterLoad() {}
 
-func (x *IntervalTimer) StateLoad(m state.Source) {
-	m.Load(0, &x.timer)
-	m.Load(1, &x.target)
-	m.Load(2, &x.signo)
-	m.Load(3, &x.id)
-	m.Load(4, &x.sigval)
-	m.Load(5, &x.group)
-	m.Load(6, &x.sigpending)
-	m.Load(7, &x.sigorphan)
-	m.Load(8, &x.overrunCur)
-	m.Load(9, &x.overrunLast)
+func (i *IntervalTimer) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.timer)
+	stateSourceObject.Load(1, &i.target)
+	stateSourceObject.Load(2, &i.signo)
+	stateSourceObject.Load(3, &i.id)
+	stateSourceObject.Load(4, &i.sigval)
+	stateSourceObject.Load(5, &i.group)
+	stateSourceObject.Load(6, &i.sigpending)
+	stateSourceObject.Load(7, &i.sigorphan)
+	stateSourceObject.Load(8, &i.overrunCur)
+	stateSourceObject.Load(9, &i.overrunLast)
 }
 
-func (x *processGroupList) StateTypeName() string {
+func (p *processGroupList) StateTypeName() string {
 	return "pkg/sentry/kernel.processGroupList"
 }
 
-func (x *processGroupList) StateFields() []string {
+func (p *processGroupList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *processGroupList) beforeSave() {}
+func (p *processGroupList) beforeSave() {}
 
-func (x *processGroupList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (p *processGroupList) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.head)
+	stateSinkObject.Save(1, &p.tail)
 }
 
-func (x *processGroupList) afterLoad() {}
+func (p *processGroupList) afterLoad() {}
 
-func (x *processGroupList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (p *processGroupList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.head)
+	stateSourceObject.Load(1, &p.tail)
 }
 
-func (x *processGroupEntry) StateTypeName() string {
+func (p *processGroupEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.processGroupEntry"
 }
 
-func (x *processGroupEntry) StateFields() []string {
+func (p *processGroupEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *processGroupEntry) beforeSave() {}
+func (p *processGroupEntry) beforeSave() {}
 
-func (x *processGroupEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (p *processGroupEntry) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.next)
+	stateSinkObject.Save(1, &p.prev)
 }
 
-func (x *processGroupEntry) afterLoad() {}
+func (p *processGroupEntry) afterLoad() {}
 
-func (x *processGroupEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (p *processGroupEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.next)
+	stateSourceObject.Load(1, &p.prev)
 }
 
-func (x *ProcessGroupRefs) StateTypeName() string {
+func (p *ProcessGroupRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.ProcessGroupRefs"
 }
 
-func (x *ProcessGroupRefs) StateFields() []string {
+func (p *ProcessGroupRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *ProcessGroupRefs) beforeSave() {}
+func (p *ProcessGroupRefs) beforeSave() {}
 
-func (x *ProcessGroupRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (p *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.refCount)
 }
 
-func (x *ProcessGroupRefs) afterLoad() {}
+func (p *ProcessGroupRefs) afterLoad() {}
 
-func (x *ProcessGroupRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (p *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.refCount)
 }
 
-func (x *ptraceOptions) StateTypeName() string {
+func (p *ptraceOptions) StateTypeName() string {
 	return "pkg/sentry/kernel.ptraceOptions"
 }
 
-func (x *ptraceOptions) StateFields() []string {
+func (p *ptraceOptions) StateFields() []string {
 	return []string{
 		"ExitKill",
 		"SysGood",
@@ -756,167 +756,167 @@ func (x *ptraceOptions) StateFields() []string {
 	}
 }
 
-func (x *ptraceOptions) beforeSave() {}
+func (p *ptraceOptions) beforeSave() {}
 
-func (x *ptraceOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ExitKill)
-	m.Save(1, &x.SysGood)
-	m.Save(2, &x.TraceClone)
-	m.Save(3, &x.TraceExec)
-	m.Save(4, &x.TraceExit)
-	m.Save(5, &x.TraceFork)
-	m.Save(6, &x.TraceSeccomp)
-	m.Save(7, &x.TraceVfork)
-	m.Save(8, &x.TraceVforkDone)
+func (p *ptraceOptions) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.ExitKill)
+	stateSinkObject.Save(1, &p.SysGood)
+	stateSinkObject.Save(2, &p.TraceClone)
+	stateSinkObject.Save(3, &p.TraceExec)
+	stateSinkObject.Save(4, &p.TraceExit)
+	stateSinkObject.Save(5, &p.TraceFork)
+	stateSinkObject.Save(6, &p.TraceSeccomp)
+	stateSinkObject.Save(7, &p.TraceVfork)
+	stateSinkObject.Save(8, &p.TraceVforkDone)
 }
 
-func (x *ptraceOptions) afterLoad() {}
+func (p *ptraceOptions) afterLoad() {}
 
-func (x *ptraceOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.ExitKill)
-	m.Load(1, &x.SysGood)
-	m.Load(2, &x.TraceClone)
-	m.Load(3, &x.TraceExec)
-	m.Load(4, &x.TraceExit)
-	m.Load(5, &x.TraceFork)
-	m.Load(6, &x.TraceSeccomp)
-	m.Load(7, &x.TraceVfork)
-	m.Load(8, &x.TraceVforkDone)
+func (p *ptraceOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.ExitKill)
+	stateSourceObject.Load(1, &p.SysGood)
+	stateSourceObject.Load(2, &p.TraceClone)
+	stateSourceObject.Load(3, &p.TraceExec)
+	stateSourceObject.Load(4, &p.TraceExit)
+	stateSourceObject.Load(5, &p.TraceFork)
+	stateSourceObject.Load(6, &p.TraceSeccomp)
+	stateSourceObject.Load(7, &p.TraceVfork)
+	stateSourceObject.Load(8, &p.TraceVforkDone)
 }
 
-func (x *ptraceStop) StateTypeName() string {
+func (p *ptraceStop) StateTypeName() string {
 	return "pkg/sentry/kernel.ptraceStop"
 }
 
-func (x *ptraceStop) StateFields() []string {
+func (p *ptraceStop) StateFields() []string {
 	return []string{
 		"frozen",
 		"listen",
 	}
 }
 
-func (x *ptraceStop) beforeSave() {}
+func (p *ptraceStop) beforeSave() {}
 
-func (x *ptraceStop) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.frozen)
-	m.Save(1, &x.listen)
+func (p *ptraceStop) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.frozen)
+	stateSinkObject.Save(1, &p.listen)
 }
 
-func (x *ptraceStop) afterLoad() {}
+func (p *ptraceStop) afterLoad() {}
 
-func (x *ptraceStop) StateLoad(m state.Source) {
-	m.Load(0, &x.frozen)
-	m.Load(1, &x.listen)
+func (p *ptraceStop) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.frozen)
+	stateSourceObject.Load(1, &p.listen)
 }
 
-func (x *OldRSeqCriticalRegion) StateTypeName() string {
+func (o *OldRSeqCriticalRegion) StateTypeName() string {
 	return "pkg/sentry/kernel.OldRSeqCriticalRegion"
 }
 
-func (x *OldRSeqCriticalRegion) StateFields() []string {
+func (o *OldRSeqCriticalRegion) StateFields() []string {
 	return []string{
 		"CriticalSection",
 		"Restart",
 	}
 }
 
-func (x *OldRSeqCriticalRegion) beforeSave() {}
+func (o *OldRSeqCriticalRegion) beforeSave() {}
 
-func (x *OldRSeqCriticalRegion) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.CriticalSection)
-	m.Save(1, &x.Restart)
+func (o *OldRSeqCriticalRegion) StateSave(stateSinkObject state.Sink) {
+	o.beforeSave()
+	stateSinkObject.Save(0, &o.CriticalSection)
+	stateSinkObject.Save(1, &o.Restart)
 }
 
-func (x *OldRSeqCriticalRegion) afterLoad() {}
+func (o *OldRSeqCriticalRegion) afterLoad() {}
 
-func (x *OldRSeqCriticalRegion) StateLoad(m state.Source) {
-	m.Load(0, &x.CriticalSection)
-	m.Load(1, &x.Restart)
+func (o *OldRSeqCriticalRegion) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &o.CriticalSection)
+	stateSourceObject.Load(1, &o.Restart)
 }
 
-func (x *sessionList) StateTypeName() string {
+func (s *sessionList) StateTypeName() string {
 	return "pkg/sentry/kernel.sessionList"
 }
 
-func (x *sessionList) StateFields() []string {
+func (s *sessionList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *sessionList) beforeSave() {}
+func (s *sessionList) beforeSave() {}
 
-func (x *sessionList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (s *sessionList) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.head)
+	stateSinkObject.Save(1, &s.tail)
 }
 
-func (x *sessionList) afterLoad() {}
+func (s *sessionList) afterLoad() {}
 
-func (x *sessionList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (s *sessionList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.head)
+	stateSourceObject.Load(1, &s.tail)
 }
 
-func (x *sessionEntry) StateTypeName() string {
+func (s *sessionEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.sessionEntry"
 }
 
-func (x *sessionEntry) StateFields() []string {
+func (s *sessionEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *sessionEntry) beforeSave() {}
+func (s *sessionEntry) beforeSave() {}
 
-func (x *sessionEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (s *sessionEntry) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.next)
+	stateSinkObject.Save(1, &s.prev)
 }
 
-func (x *sessionEntry) afterLoad() {}
+func (s *sessionEntry) afterLoad() {}
 
-func (x *sessionEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (s *sessionEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.next)
+	stateSourceObject.Load(1, &s.prev)
 }
 
-func (x *SessionRefs) StateTypeName() string {
+func (s *SessionRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.SessionRefs"
 }
 
-func (x *SessionRefs) StateFields() []string {
+func (s *SessionRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *SessionRefs) beforeSave() {}
+func (s *SessionRefs) beforeSave() {}
 
-func (x *SessionRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (s *SessionRefs) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.refCount)
 }
 
-func (x *SessionRefs) afterLoad() {}
+func (s *SessionRefs) afterLoad() {}
 
-func (x *SessionRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (s *SessionRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.refCount)
 }
 
-func (x *Session) StateTypeName() string {
+func (s *Session) StateTypeName() string {
 	return "pkg/sentry/kernel.Session"
 }
 
-func (x *Session) StateFields() []string {
+func (s *Session) StateFields() []string {
 	return []string{
 		"SessionRefs",
 		"leader",
@@ -927,34 +927,34 @@ func (x *Session) StateFields() []string {
 	}
 }
 
-func (x *Session) beforeSave() {}
+func (s *Session) beforeSave() {}
 
-func (x *Session) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.SessionRefs)
-	m.Save(1, &x.leader)
-	m.Save(2, &x.id)
-	m.Save(3, &x.foreground)
-	m.Save(4, &x.processGroups)
-	m.Save(5, &x.sessionEntry)
+func (s *Session) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.SessionRefs)
+	stateSinkObject.Save(1, &s.leader)
+	stateSinkObject.Save(2, &s.id)
+	stateSinkObject.Save(3, &s.foreground)
+	stateSinkObject.Save(4, &s.processGroups)
+	stateSinkObject.Save(5, &s.sessionEntry)
 }
 
-func (x *Session) afterLoad() {}
+func (s *Session) afterLoad() {}
 
-func (x *Session) StateLoad(m state.Source) {
-	m.Load(0, &x.SessionRefs)
-	m.Load(1, &x.leader)
-	m.Load(2, &x.id)
-	m.Load(3, &x.foreground)
-	m.Load(4, &x.processGroups)
-	m.Load(5, &x.sessionEntry)
+func (s *Session) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.SessionRefs)
+	stateSourceObject.Load(1, &s.leader)
+	stateSourceObject.Load(2, &s.id)
+	stateSourceObject.Load(3, &s.foreground)
+	stateSourceObject.Load(4, &s.processGroups)
+	stateSourceObject.Load(5, &s.sessionEntry)
 }
 
-func (x *ProcessGroup) StateTypeName() string {
+func (p *ProcessGroup) StateTypeName() string {
 	return "pkg/sentry/kernel.ProcessGroup"
 }
 
-func (x *ProcessGroup) StateFields() []string {
+func (p *ProcessGroup) StateFields() []string {
 	return []string{
 		"refs",
 		"originator",
@@ -965,158 +965,158 @@ func (x *ProcessGroup) StateFields() []string {
 	}
 }
 
-func (x *ProcessGroup) beforeSave() {}
+func (p *ProcessGroup) beforeSave() {}
 
-func (x *ProcessGroup) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refs)
-	m.Save(1, &x.originator)
-	m.Save(2, &x.id)
-	m.Save(3, &x.session)
-	m.Save(4, &x.ancestors)
-	m.Save(5, &x.processGroupEntry)
+func (p *ProcessGroup) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.refs)
+	stateSinkObject.Save(1, &p.originator)
+	stateSinkObject.Save(2, &p.id)
+	stateSinkObject.Save(3, &p.session)
+	stateSinkObject.Save(4, &p.ancestors)
+	stateSinkObject.Save(5, &p.processGroupEntry)
 }
 
-func (x *ProcessGroup) afterLoad() {}
+func (p *ProcessGroup) afterLoad() {}
 
-func (x *ProcessGroup) StateLoad(m state.Source) {
-	m.Load(0, &x.refs)
-	m.Load(1, &x.originator)
-	m.Load(2, &x.id)
-	m.Load(3, &x.session)
-	m.Load(4, &x.ancestors)
-	m.Load(5, &x.processGroupEntry)
+func (p *ProcessGroup) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.refs)
+	stateSourceObject.Load(1, &p.originator)
+	stateSourceObject.Load(2, &p.id)
+	stateSourceObject.Load(3, &p.session)
+	stateSourceObject.Load(4, &p.ancestors)
+	stateSourceObject.Load(5, &p.processGroupEntry)
 }
 
-func (x *SignalHandlers) StateTypeName() string {
+func (s *SignalHandlers) StateTypeName() string {
 	return "pkg/sentry/kernel.SignalHandlers"
 }
 
-func (x *SignalHandlers) StateFields() []string {
+func (s *SignalHandlers) StateFields() []string {
 	return []string{
 		"actions",
 	}
 }
 
-func (x *SignalHandlers) beforeSave() {}
+func (s *SignalHandlers) beforeSave() {}
 
-func (x *SignalHandlers) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.actions)
+func (s *SignalHandlers) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.actions)
 }
 
-func (x *SignalHandlers) afterLoad() {}
+func (s *SignalHandlers) afterLoad() {}
 
-func (x *SignalHandlers) StateLoad(m state.Source) {
-	m.Load(0, &x.actions)
+func (s *SignalHandlers) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.actions)
 }
 
-func (x *socketList) StateTypeName() string {
+func (s *socketList) StateTypeName() string {
 	return "pkg/sentry/kernel.socketList"
 }
 
-func (x *socketList) StateFields() []string {
+func (s *socketList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *socketList) beforeSave() {}
+func (s *socketList) beforeSave() {}
 
-func (x *socketList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (s *socketList) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.head)
+	stateSinkObject.Save(1, &s.tail)
 }
 
-func (x *socketList) afterLoad() {}
+func (s *socketList) afterLoad() {}
 
-func (x *socketList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (s *socketList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.head)
+	stateSourceObject.Load(1, &s.tail)
 }
 
-func (x *socketEntry) StateTypeName() string {
+func (s *socketEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.socketEntry"
 }
 
-func (x *socketEntry) StateFields() []string {
+func (s *socketEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *socketEntry) beforeSave() {}
+func (s *socketEntry) beforeSave() {}
 
-func (x *socketEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (s *socketEntry) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.next)
+	stateSinkObject.Save(1, &s.prev)
 }
 
-func (x *socketEntry) afterLoad() {}
+func (s *socketEntry) afterLoad() {}
 
-func (x *socketEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (s *socketEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.next)
+	stateSourceObject.Load(1, &s.prev)
 }
 
-func (x *syscallTableInfo) StateTypeName() string {
+func (s *syscallTableInfo) StateTypeName() string {
 	return "pkg/sentry/kernel.syscallTableInfo"
 }
 
-func (x *syscallTableInfo) StateFields() []string {
+func (s *syscallTableInfo) StateFields() []string {
 	return []string{
 		"OS",
 		"Arch",
 	}
 }
 
-func (x *syscallTableInfo) beforeSave() {}
+func (s *syscallTableInfo) beforeSave() {}
 
-func (x *syscallTableInfo) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.OS)
-	m.Save(1, &x.Arch)
+func (s *syscallTableInfo) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.OS)
+	stateSinkObject.Save(1, &s.Arch)
 }
 
-func (x *syscallTableInfo) afterLoad() {}
+func (s *syscallTableInfo) afterLoad() {}
 
-func (x *syscallTableInfo) StateLoad(m state.Source) {
-	m.Load(0, &x.OS)
-	m.Load(1, &x.Arch)
+func (s *syscallTableInfo) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.OS)
+	stateSourceObject.Load(1, &s.Arch)
 }
 
-func (x *syslog) StateTypeName() string {
+func (s *syslog) StateTypeName() string {
 	return "pkg/sentry/kernel.syslog"
 }
 
-func (x *syslog) StateFields() []string {
+func (s *syslog) StateFields() []string {
 	return []string{
 		"msg",
 	}
 }
 
-func (x *syslog) beforeSave() {}
+func (s *syslog) beforeSave() {}
 
-func (x *syslog) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.msg)
+func (s *syslog) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.msg)
 }
 
-func (x *syslog) afterLoad() {}
+func (s *syslog) afterLoad() {}
 
-func (x *syslog) StateLoad(m state.Source) {
-	m.Load(0, &x.msg)
+func (s *syslog) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.msg)
 }
 
-func (x *Task) StateTypeName() string {
+func (t *Task) StateTypeName() string {
 	return "pkg/sentry/kernel.Task"
 }
 
-func (x *Task) StateFields() []string {
+func (t *Task) StateFields() []string {
 	return []string{
 		"taskNode",
 		"runState",
@@ -1183,218 +1183,218 @@ func (x *Task) StateFields() []string {
 	}
 }
 
-func (x *Task) beforeSave() {}
+func (t *Task) beforeSave() {}
 
-func (x *Task) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.signalQueue) {
-		state.Failf("signalQueue is %#v, expected zero", &x.signalQueue)
+func (t *Task) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	if !state.IsZeroValue(&t.signalQueue) {
+		state.Failf("signalQueue is %#v, expected zero", &t.signalQueue)
 	}
-	var ptraceTracer *Task = x.savePtraceTracer()
-	m.SaveValue(31, ptraceTracer)
-	var syscallFilters []bpf.Program = x.saveSyscallFilters()
-	m.SaveValue(47, syscallFilters)
-	m.Save(0, &x.taskNode)
-	m.Save(1, &x.runState)
-	m.Save(2, &x.taskWorkCount)
-	m.Save(3, &x.taskWork)
-	m.Save(4, &x.haveSyscallReturn)
-	m.Save(5, &x.gosched)
-	m.Save(6, &x.yieldCount)
-	m.Save(7, &x.pendingSignals)
-	m.Save(8, &x.signalMask)
-	m.Save(9, &x.realSignalMask)
-	m.Save(10, &x.haveSavedSignalMask)
-	m.Save(11, &x.savedSignalMask)
-	m.Save(12, &x.signalStack)
-	m.Save(13, &x.groupStopPending)
-	m.Save(14, &x.groupStopAcknowledged)
-	m.Save(15, &x.trapStopPending)
-	m.Save(16, &x.trapNotifyPending)
-	m.Save(17, &x.stop)
-	m.Save(18, &x.exitStatus)
-	m.Save(19, &x.syscallRestartBlock)
-	m.Save(20, &x.k)
-	m.Save(21, &x.containerID)
-	m.Save(22, &x.tc)
-	m.Save(23, &x.fsContext)
-	m.Save(24, &x.fdTable)
-	m.Save(25, &x.vforkParent)
-	m.Save(26, &x.exitState)
-	m.Save(27, &x.exitTracerNotified)
-	m.Save(28, &x.exitTracerAcked)
-	m.Save(29, &x.exitParentNotified)
-	m.Save(30, &x.exitParentAcked)
-	m.Save(32, &x.ptraceTracees)
-	m.Save(33, &x.ptraceSeized)
-	m.Save(34, &x.ptraceOpts)
-	m.Save(35, &x.ptraceSyscallMode)
-	m.Save(36, &x.ptraceSinglestep)
-	m.Save(37, &x.ptraceCode)
-	m.Save(38, &x.ptraceSiginfo)
-	m.Save(39, &x.ptraceEventMsg)
-	m.Save(40, &x.ioUsage)
-	m.Save(41, &x.creds)
-	m.Save(42, &x.utsns)
-	m.Save(43, &x.ipcns)
-	m.Save(44, &x.abstractSockets)
-	m.Save(45, &x.mountNamespaceVFS2)
-	m.Save(46, &x.parentDeathSignal)
-	m.Save(48, &x.cleartid)
-	m.Save(49, &x.allowedCPUMask)
-	m.Save(50, &x.cpu)
-	m.Save(51, &x.niceness)
-	m.Save(52, &x.numaPolicy)
-	m.Save(53, &x.numaNodeMask)
-	m.Save(54, &x.netns)
-	m.Save(55, &x.rseqCPU)
-	m.Save(56, &x.oldRSeqCPUAddr)
-	m.Save(57, &x.rseqAddr)
-	m.Save(58, &x.rseqSignature)
-	m.Save(59, &x.robustList)
-	m.Save(60, &x.startTime)
-	m.Save(61, &x.kcov)
-}
-
-func (x *Task) StateLoad(m state.Source) {
-	m.Load(0, &x.taskNode)
-	m.Load(1, &x.runState)
-	m.Load(2, &x.taskWorkCount)
-	m.Load(3, &x.taskWork)
-	m.Load(4, &x.haveSyscallReturn)
-	m.Load(5, &x.gosched)
-	m.Load(6, &x.yieldCount)
-	m.Load(7, &x.pendingSignals)
-	m.Load(8, &x.signalMask)
-	m.Load(9, &x.realSignalMask)
-	m.Load(10, &x.haveSavedSignalMask)
-	m.Load(11, &x.savedSignalMask)
-	m.Load(12, &x.signalStack)
-	m.Load(13, &x.groupStopPending)
-	m.Load(14, &x.groupStopAcknowledged)
-	m.Load(15, &x.trapStopPending)
-	m.Load(16, &x.trapNotifyPending)
-	m.Load(17, &x.stop)
-	m.Load(18, &x.exitStatus)
-	m.Load(19, &x.syscallRestartBlock)
-	m.Load(20, &x.k)
-	m.Load(21, &x.containerID)
-	m.Load(22, &x.tc)
-	m.Load(23, &x.fsContext)
-	m.Load(24, &x.fdTable)
-	m.Load(25, &x.vforkParent)
-	m.Load(26, &x.exitState)
-	m.Load(27, &x.exitTracerNotified)
-	m.Load(28, &x.exitTracerAcked)
-	m.Load(29, &x.exitParentNotified)
-	m.Load(30, &x.exitParentAcked)
-	m.Load(32, &x.ptraceTracees)
-	m.Load(33, &x.ptraceSeized)
-	m.Load(34, &x.ptraceOpts)
-	m.Load(35, &x.ptraceSyscallMode)
-	m.Load(36, &x.ptraceSinglestep)
-	m.Load(37, &x.ptraceCode)
-	m.Load(38, &x.ptraceSiginfo)
-	m.Load(39, &x.ptraceEventMsg)
-	m.Load(40, &x.ioUsage)
-	m.Load(41, &x.creds)
-	m.Load(42, &x.utsns)
-	m.Load(43, &x.ipcns)
-	m.Load(44, &x.abstractSockets)
-	m.Load(45, &x.mountNamespaceVFS2)
-	m.Load(46, &x.parentDeathSignal)
-	m.Load(48, &x.cleartid)
-	m.Load(49, &x.allowedCPUMask)
-	m.Load(50, &x.cpu)
-	m.Load(51, &x.niceness)
-	m.Load(52, &x.numaPolicy)
-	m.Load(53, &x.numaNodeMask)
-	m.Load(54, &x.netns)
-	m.Load(55, &x.rseqCPU)
-	m.Load(56, &x.oldRSeqCPUAddr)
-	m.Load(57, &x.rseqAddr)
-	m.Load(58, &x.rseqSignature)
-	m.Load(59, &x.robustList)
-	m.Load(60, &x.startTime)
-	m.Load(61, &x.kcov)
-	m.LoadValue(31, new(*Task), func(y interface{}) { x.loadPtraceTracer(y.(*Task)) })
-	m.LoadValue(47, new([]bpf.Program), func(y interface{}) { x.loadSyscallFilters(y.([]bpf.Program)) })
-	m.AfterLoad(x.afterLoad)
-}
-
-func (x *runSyscallAfterPtraceEventClone) StateTypeName() string {
+	var ptraceTracerValue *Task = t.savePtraceTracer()
+	stateSinkObject.SaveValue(31, ptraceTracerValue)
+	var syscallFiltersValue []bpf.Program = t.saveSyscallFilters()
+	stateSinkObject.SaveValue(47, syscallFiltersValue)
+	stateSinkObject.Save(0, &t.taskNode)
+	stateSinkObject.Save(1, &t.runState)
+	stateSinkObject.Save(2, &t.taskWorkCount)
+	stateSinkObject.Save(3, &t.taskWork)
+	stateSinkObject.Save(4, &t.haveSyscallReturn)
+	stateSinkObject.Save(5, &t.gosched)
+	stateSinkObject.Save(6, &t.yieldCount)
+	stateSinkObject.Save(7, &t.pendingSignals)
+	stateSinkObject.Save(8, &t.signalMask)
+	stateSinkObject.Save(9, &t.realSignalMask)
+	stateSinkObject.Save(10, &t.haveSavedSignalMask)
+	stateSinkObject.Save(11, &t.savedSignalMask)
+	stateSinkObject.Save(12, &t.signalStack)
+	stateSinkObject.Save(13, &t.groupStopPending)
+	stateSinkObject.Save(14, &t.groupStopAcknowledged)
+	stateSinkObject.Save(15, &t.trapStopPending)
+	stateSinkObject.Save(16, &t.trapNotifyPending)
+	stateSinkObject.Save(17, &t.stop)
+	stateSinkObject.Save(18, &t.exitStatus)
+	stateSinkObject.Save(19, &t.syscallRestartBlock)
+	stateSinkObject.Save(20, &t.k)
+	stateSinkObject.Save(21, &t.containerID)
+	stateSinkObject.Save(22, &t.tc)
+	stateSinkObject.Save(23, &t.fsContext)
+	stateSinkObject.Save(24, &t.fdTable)
+	stateSinkObject.Save(25, &t.vforkParent)
+	stateSinkObject.Save(26, &t.exitState)
+	stateSinkObject.Save(27, &t.exitTracerNotified)
+	stateSinkObject.Save(28, &t.exitTracerAcked)
+	stateSinkObject.Save(29, &t.exitParentNotified)
+	stateSinkObject.Save(30, &t.exitParentAcked)
+	stateSinkObject.Save(32, &t.ptraceTracees)
+	stateSinkObject.Save(33, &t.ptraceSeized)
+	stateSinkObject.Save(34, &t.ptraceOpts)
+	stateSinkObject.Save(35, &t.ptraceSyscallMode)
+	stateSinkObject.Save(36, &t.ptraceSinglestep)
+	stateSinkObject.Save(37, &t.ptraceCode)
+	stateSinkObject.Save(38, &t.ptraceSiginfo)
+	stateSinkObject.Save(39, &t.ptraceEventMsg)
+	stateSinkObject.Save(40, &t.ioUsage)
+	stateSinkObject.Save(41, &t.creds)
+	stateSinkObject.Save(42, &t.utsns)
+	stateSinkObject.Save(43, &t.ipcns)
+	stateSinkObject.Save(44, &t.abstractSockets)
+	stateSinkObject.Save(45, &t.mountNamespaceVFS2)
+	stateSinkObject.Save(46, &t.parentDeathSignal)
+	stateSinkObject.Save(48, &t.cleartid)
+	stateSinkObject.Save(49, &t.allowedCPUMask)
+	stateSinkObject.Save(50, &t.cpu)
+	stateSinkObject.Save(51, &t.niceness)
+	stateSinkObject.Save(52, &t.numaPolicy)
+	stateSinkObject.Save(53, &t.numaNodeMask)
+	stateSinkObject.Save(54, &t.netns)
+	stateSinkObject.Save(55, &t.rseqCPU)
+	stateSinkObject.Save(56, &t.oldRSeqCPUAddr)
+	stateSinkObject.Save(57, &t.rseqAddr)
+	stateSinkObject.Save(58, &t.rseqSignature)
+	stateSinkObject.Save(59, &t.robustList)
+	stateSinkObject.Save(60, &t.startTime)
+	stateSinkObject.Save(61, &t.kcov)
+}
+
+func (t *Task) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.taskNode)
+	stateSourceObject.Load(1, &t.runState)
+	stateSourceObject.Load(2, &t.taskWorkCount)
+	stateSourceObject.Load(3, &t.taskWork)
+	stateSourceObject.Load(4, &t.haveSyscallReturn)
+	stateSourceObject.Load(5, &t.gosched)
+	stateSourceObject.Load(6, &t.yieldCount)
+	stateSourceObject.Load(7, &t.pendingSignals)
+	stateSourceObject.Load(8, &t.signalMask)
+	stateSourceObject.Load(9, &t.realSignalMask)
+	stateSourceObject.Load(10, &t.haveSavedSignalMask)
+	stateSourceObject.Load(11, &t.savedSignalMask)
+	stateSourceObject.Load(12, &t.signalStack)
+	stateSourceObject.Load(13, &t.groupStopPending)
+	stateSourceObject.Load(14, &t.groupStopAcknowledged)
+	stateSourceObject.Load(15, &t.trapStopPending)
+	stateSourceObject.Load(16, &t.trapNotifyPending)
+	stateSourceObject.Load(17, &t.stop)
+	stateSourceObject.Load(18, &t.exitStatus)
+	stateSourceObject.Load(19, &t.syscallRestartBlock)
+	stateSourceObject.Load(20, &t.k)
+	stateSourceObject.Load(21, &t.containerID)
+	stateSourceObject.Load(22, &t.tc)
+	stateSourceObject.Load(23, &t.fsContext)
+	stateSourceObject.Load(24, &t.fdTable)
+	stateSourceObject.Load(25, &t.vforkParent)
+	stateSourceObject.Load(26, &t.exitState)
+	stateSourceObject.Load(27, &t.exitTracerNotified)
+	stateSourceObject.Load(28, &t.exitTracerAcked)
+	stateSourceObject.Load(29, &t.exitParentNotified)
+	stateSourceObject.Load(30, &t.exitParentAcked)
+	stateSourceObject.Load(32, &t.ptraceTracees)
+	stateSourceObject.Load(33, &t.ptraceSeized)
+	stateSourceObject.Load(34, &t.ptraceOpts)
+	stateSourceObject.Load(35, &t.ptraceSyscallMode)
+	stateSourceObject.Load(36, &t.ptraceSinglestep)
+	stateSourceObject.Load(37, &t.ptraceCode)
+	stateSourceObject.Load(38, &t.ptraceSiginfo)
+	stateSourceObject.Load(39, &t.ptraceEventMsg)
+	stateSourceObject.Load(40, &t.ioUsage)
+	stateSourceObject.Load(41, &t.creds)
+	stateSourceObject.Load(42, &t.utsns)
+	stateSourceObject.Load(43, &t.ipcns)
+	stateSourceObject.Load(44, &t.abstractSockets)
+	stateSourceObject.Load(45, &t.mountNamespaceVFS2)
+	stateSourceObject.Load(46, &t.parentDeathSignal)
+	stateSourceObject.Load(48, &t.cleartid)
+	stateSourceObject.Load(49, &t.allowedCPUMask)
+	stateSourceObject.Load(50, &t.cpu)
+	stateSourceObject.Load(51, &t.niceness)
+	stateSourceObject.Load(52, &t.numaPolicy)
+	stateSourceObject.Load(53, &t.numaNodeMask)
+	stateSourceObject.Load(54, &t.netns)
+	stateSourceObject.Load(55, &t.rseqCPU)
+	stateSourceObject.Load(56, &t.oldRSeqCPUAddr)
+	stateSourceObject.Load(57, &t.rseqAddr)
+	stateSourceObject.Load(58, &t.rseqSignature)
+	stateSourceObject.Load(59, &t.robustList)
+	stateSourceObject.Load(60, &t.startTime)
+	stateSourceObject.Load(61, &t.kcov)
+	stateSourceObject.LoadValue(31, new(*Task), func(y interface{}) { t.loadPtraceTracer(y.(*Task)) })
+	stateSourceObject.LoadValue(47, new([]bpf.Program), func(y interface{}) { t.loadSyscallFilters(y.([]bpf.Program)) })
+	stateSourceObject.AfterLoad(t.afterLoad)
+}
+
+func (r *runSyscallAfterPtraceEventClone) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallAfterPtraceEventClone"
 }
 
-func (x *runSyscallAfterPtraceEventClone) StateFields() []string {
+func (r *runSyscallAfterPtraceEventClone) StateFields() []string {
 	return []string{
 		"vforkChild",
 		"vforkChildTID",
 	}
 }
 
-func (x *runSyscallAfterPtraceEventClone) beforeSave() {}
+func (r *runSyscallAfterPtraceEventClone) beforeSave() {}
 
-func (x *runSyscallAfterPtraceEventClone) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vforkChild)
-	m.Save(1, &x.vforkChildTID)
+func (r *runSyscallAfterPtraceEventClone) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.vforkChild)
+	stateSinkObject.Save(1, &r.vforkChildTID)
 }
 
-func (x *runSyscallAfterPtraceEventClone) afterLoad() {}
+func (r *runSyscallAfterPtraceEventClone) afterLoad() {}
 
-func (x *runSyscallAfterPtraceEventClone) StateLoad(m state.Source) {
-	m.Load(0, &x.vforkChild)
-	m.Load(1, &x.vforkChildTID)
+func (r *runSyscallAfterPtraceEventClone) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.vforkChild)
+	stateSourceObject.Load(1, &r.vforkChildTID)
 }
 
-func (x *runSyscallAfterVforkStop) StateTypeName() string {
+func (r *runSyscallAfterVforkStop) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallAfterVforkStop"
 }
 
-func (x *runSyscallAfterVforkStop) StateFields() []string {
+func (r *runSyscallAfterVforkStop) StateFields() []string {
 	return []string{
 		"childTID",
 	}
 }
 
-func (x *runSyscallAfterVforkStop) beforeSave() {}
+func (r *runSyscallAfterVforkStop) beforeSave() {}
 
-func (x *runSyscallAfterVforkStop) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.childTID)
+func (r *runSyscallAfterVforkStop) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.childTID)
 }
 
-func (x *runSyscallAfterVforkStop) afterLoad() {}
+func (r *runSyscallAfterVforkStop) afterLoad() {}
 
-func (x *runSyscallAfterVforkStop) StateLoad(m state.Source) {
-	m.Load(0, &x.childTID)
+func (r *runSyscallAfterVforkStop) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.childTID)
 }
 
-func (x *vforkStop) StateTypeName() string {
+func (v *vforkStop) StateTypeName() string {
 	return "pkg/sentry/kernel.vforkStop"
 }
 
-func (x *vforkStop) StateFields() []string {
+func (v *vforkStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *vforkStop) beforeSave() {}
+func (v *vforkStop) beforeSave() {}
 
-func (x *vforkStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (v *vforkStop) StateSave(stateSinkObject state.Sink) {
+	v.beforeSave()
 }
 
-func (x *vforkStop) afterLoad() {}
+func (v *vforkStop) afterLoad() {}
 
-func (x *vforkStop) StateLoad(m state.Source) {
+func (v *vforkStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *TaskContext) StateTypeName() string {
+func (t *TaskContext) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskContext"
 }
 
-func (x *TaskContext) StateFields() []string {
+func (t *TaskContext) StateFields() []string {
 	return []string{
 		"Name",
 		"Arch",
@@ -1404,229 +1404,229 @@ func (x *TaskContext) StateFields() []string {
 	}
 }
 
-func (x *TaskContext) beforeSave() {}
+func (t *TaskContext) beforeSave() {}
 
-func (x *TaskContext) StateSave(m state.Sink) {
-	x.beforeSave()
-	var st syscallTableInfo = x.saveSt()
-	m.SaveValue(4, st)
-	m.Save(0, &x.Name)
-	m.Save(1, &x.Arch)
-	m.Save(2, &x.MemoryManager)
-	m.Save(3, &x.fu)
+func (t *TaskContext) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	var stValue syscallTableInfo = t.saveSt()
+	stateSinkObject.SaveValue(4, stValue)
+	stateSinkObject.Save(0, &t.Name)
+	stateSinkObject.Save(1, &t.Arch)
+	stateSinkObject.Save(2, &t.MemoryManager)
+	stateSinkObject.Save(3, &t.fu)
 }
 
-func (x *TaskContext) afterLoad() {}
+func (t *TaskContext) afterLoad() {}
 
-func (x *TaskContext) StateLoad(m state.Source) {
-	m.Load(0, &x.Name)
-	m.Load(1, &x.Arch)
-	m.Load(2, &x.MemoryManager)
-	m.Load(3, &x.fu)
-	m.LoadValue(4, new(syscallTableInfo), func(y interface{}) { x.loadSt(y.(syscallTableInfo)) })
+func (t *TaskContext) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.Name)
+	stateSourceObject.Load(1, &t.Arch)
+	stateSourceObject.Load(2, &t.MemoryManager)
+	stateSourceObject.Load(3, &t.fu)
+	stateSourceObject.LoadValue(4, new(syscallTableInfo), func(y interface{}) { t.loadSt(y.(syscallTableInfo)) })
 }
 
-func (x *execStop) StateTypeName() string {
+func (e *execStop) StateTypeName() string {
 	return "pkg/sentry/kernel.execStop"
 }
 
-func (x *execStop) StateFields() []string {
+func (e *execStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *execStop) beforeSave() {}
+func (e *execStop) beforeSave() {}
 
-func (x *execStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (e *execStop) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
 }
 
-func (x *execStop) afterLoad() {}
+func (e *execStop) afterLoad() {}
 
-func (x *execStop) StateLoad(m state.Source) {
+func (e *execStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runSyscallAfterExecStop) StateTypeName() string {
+func (r *runSyscallAfterExecStop) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallAfterExecStop"
 }
 
-func (x *runSyscallAfterExecStop) StateFields() []string {
+func (r *runSyscallAfterExecStop) StateFields() []string {
 	return []string{
 		"tc",
 	}
 }
 
-func (x *runSyscallAfterExecStop) beforeSave() {}
+func (r *runSyscallAfterExecStop) beforeSave() {}
 
-func (x *runSyscallAfterExecStop) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.tc)
+func (r *runSyscallAfterExecStop) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.tc)
 }
 
-func (x *runSyscallAfterExecStop) afterLoad() {}
+func (r *runSyscallAfterExecStop) afterLoad() {}
 
-func (x *runSyscallAfterExecStop) StateLoad(m state.Source) {
-	m.Load(0, &x.tc)
+func (r *runSyscallAfterExecStop) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.tc)
 }
 
-func (x *ExitStatus) StateTypeName() string {
+func (e *ExitStatus) StateTypeName() string {
 	return "pkg/sentry/kernel.ExitStatus"
 }
 
-func (x *ExitStatus) StateFields() []string {
+func (e *ExitStatus) StateFields() []string {
 	return []string{
 		"Code",
 		"Signo",
 	}
 }
 
-func (x *ExitStatus) beforeSave() {}
+func (e *ExitStatus) beforeSave() {}
 
-func (x *ExitStatus) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Code)
-	m.Save(1, &x.Signo)
+func (e *ExitStatus) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.Code)
+	stateSinkObject.Save(1, &e.Signo)
 }
 
-func (x *ExitStatus) afterLoad() {}
+func (e *ExitStatus) afterLoad() {}
 
-func (x *ExitStatus) StateLoad(m state.Source) {
-	m.Load(0, &x.Code)
-	m.Load(1, &x.Signo)
+func (e *ExitStatus) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.Code)
+	stateSourceObject.Load(1, &e.Signo)
 }
 
-func (x *runExit) StateTypeName() string {
+func (r *runExit) StateTypeName() string {
 	return "pkg/sentry/kernel.runExit"
 }
 
-func (x *runExit) StateFields() []string {
+func (r *runExit) StateFields() []string {
 	return []string{}
 }
 
-func (x *runExit) beforeSave() {}
+func (r *runExit) beforeSave() {}
 
-func (x *runExit) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runExit) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runExit) afterLoad() {}
+func (r *runExit) afterLoad() {}
 
-func (x *runExit) StateLoad(m state.Source) {
+func (r *runExit) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runExitMain) StateTypeName() string {
+func (r *runExitMain) StateTypeName() string {
 	return "pkg/sentry/kernel.runExitMain"
 }
 
-func (x *runExitMain) StateFields() []string {
+func (r *runExitMain) StateFields() []string {
 	return []string{}
 }
 
-func (x *runExitMain) beforeSave() {}
+func (r *runExitMain) beforeSave() {}
 
-func (x *runExitMain) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runExitMain) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runExitMain) afterLoad() {}
+func (r *runExitMain) afterLoad() {}
 
-func (x *runExitMain) StateLoad(m state.Source) {
+func (r *runExitMain) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runExitNotify) StateTypeName() string {
+func (r *runExitNotify) StateTypeName() string {
 	return "pkg/sentry/kernel.runExitNotify"
 }
 
-func (x *runExitNotify) StateFields() []string {
+func (r *runExitNotify) StateFields() []string {
 	return []string{}
 }
 
-func (x *runExitNotify) beforeSave() {}
+func (r *runExitNotify) beforeSave() {}
 
-func (x *runExitNotify) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runExitNotify) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runExitNotify) afterLoad() {}
+func (r *runExitNotify) afterLoad() {}
 
-func (x *runExitNotify) StateLoad(m state.Source) {
+func (r *runExitNotify) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *taskList) StateTypeName() string {
+func (t *taskList) StateTypeName() string {
 	return "pkg/sentry/kernel.taskList"
 }
 
-func (x *taskList) StateFields() []string {
+func (t *taskList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *taskList) beforeSave() {}
+func (t *taskList) beforeSave() {}
 
-func (x *taskList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (t *taskList) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.head)
+	stateSinkObject.Save(1, &t.tail)
 }
 
-func (x *taskList) afterLoad() {}
+func (t *taskList) afterLoad() {}
 
-func (x *taskList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (t *taskList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.head)
+	stateSourceObject.Load(1, &t.tail)
 }
 
-func (x *taskEntry) StateTypeName() string {
+func (t *taskEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.taskEntry"
 }
 
-func (x *taskEntry) StateFields() []string {
+func (t *taskEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *taskEntry) beforeSave() {}
+func (t *taskEntry) beforeSave() {}
 
-func (x *taskEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (t *taskEntry) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.next)
+	stateSinkObject.Save(1, &t.prev)
 }
 
-func (x *taskEntry) afterLoad() {}
+func (t *taskEntry) afterLoad() {}
 
-func (x *taskEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (t *taskEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.next)
+	stateSourceObject.Load(1, &t.prev)
 }
 
-func (x *runApp) StateTypeName() string {
+func (r *runApp) StateTypeName() string {
 	return "pkg/sentry/kernel.runApp"
 }
 
-func (x *runApp) StateFields() []string {
+func (r *runApp) StateFields() []string {
 	return []string{}
 }
 
-func (x *runApp) beforeSave() {}
+func (r *runApp) beforeSave() {}
 
-func (x *runApp) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runApp) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runApp) afterLoad() {}
+func (r *runApp) afterLoad() {}
 
-func (x *runApp) StateLoad(m state.Source) {
+func (r *runApp) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *TaskGoroutineSchedInfo) StateTypeName() string {
+func (t *TaskGoroutineSchedInfo) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskGoroutineSchedInfo"
 }
 
-func (x *TaskGoroutineSchedInfo) StateFields() []string {
+func (t *TaskGoroutineSchedInfo) StateFields() []string {
 	return []string{
 		"Timestamp",
 		"State",
@@ -1635,215 +1635,215 @@ func (x *TaskGoroutineSchedInfo) StateFields() []string {
 	}
 }
 
-func (x *TaskGoroutineSchedInfo) beforeSave() {}
+func (t *TaskGoroutineSchedInfo) beforeSave() {}
 
-func (x *TaskGoroutineSchedInfo) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Timestamp)
-	m.Save(1, &x.State)
-	m.Save(2, &x.UserTicks)
-	m.Save(3, &x.SysTicks)
+func (t *TaskGoroutineSchedInfo) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.Timestamp)
+	stateSinkObject.Save(1, &t.State)
+	stateSinkObject.Save(2, &t.UserTicks)
+	stateSinkObject.Save(3, &t.SysTicks)
 }
 
-func (x *TaskGoroutineSchedInfo) afterLoad() {}
+func (t *TaskGoroutineSchedInfo) afterLoad() {}
 
-func (x *TaskGoroutineSchedInfo) StateLoad(m state.Source) {
-	m.Load(0, &x.Timestamp)
-	m.Load(1, &x.State)
-	m.Load(2, &x.UserTicks)
-	m.Load(3, &x.SysTicks)
+func (t *TaskGoroutineSchedInfo) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.Timestamp)
+	stateSourceObject.Load(1, &t.State)
+	stateSourceObject.Load(2, &t.UserTicks)
+	stateSourceObject.Load(3, &t.SysTicks)
 }
 
-func (x *taskClock) StateTypeName() string {
+func (t *taskClock) StateTypeName() string {
 	return "pkg/sentry/kernel.taskClock"
 }
 
-func (x *taskClock) StateFields() []string {
+func (t *taskClock) StateFields() []string {
 	return []string{
 		"t",
 		"includeSys",
 	}
 }
 
-func (x *taskClock) beforeSave() {}
+func (t *taskClock) beforeSave() {}
 
-func (x *taskClock) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.t)
-	m.Save(1, &x.includeSys)
+func (t *taskClock) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.t)
+	stateSinkObject.Save(1, &t.includeSys)
 }
 
-func (x *taskClock) afterLoad() {}
+func (t *taskClock) afterLoad() {}
 
-func (x *taskClock) StateLoad(m state.Source) {
-	m.Load(0, &x.t)
-	m.Load(1, &x.includeSys)
+func (t *taskClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.t)
+	stateSourceObject.Load(1, &t.includeSys)
 }
 
-func (x *tgClock) StateTypeName() string {
+func (t *tgClock) StateTypeName() string {
 	return "pkg/sentry/kernel.tgClock"
 }
 
-func (x *tgClock) StateFields() []string {
+func (t *tgClock) StateFields() []string {
 	return []string{
 		"tg",
 		"includeSys",
 	}
 }
 
-func (x *tgClock) beforeSave() {}
+func (t *tgClock) beforeSave() {}
 
-func (x *tgClock) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.tg)
-	m.Save(1, &x.includeSys)
+func (t *tgClock) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.tg)
+	stateSinkObject.Save(1, &t.includeSys)
 }
 
-func (x *tgClock) afterLoad() {}
+func (t *tgClock) afterLoad() {}
 
-func (x *tgClock) StateLoad(m state.Source) {
-	m.Load(0, &x.tg)
-	m.Load(1, &x.includeSys)
+func (t *tgClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.tg)
+	stateSourceObject.Load(1, &t.includeSys)
 }
 
-func (x *groupStop) StateTypeName() string {
+func (g *groupStop) StateTypeName() string {
 	return "pkg/sentry/kernel.groupStop"
 }
 
-func (x *groupStop) StateFields() []string {
+func (g *groupStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *groupStop) beforeSave() {}
+func (g *groupStop) beforeSave() {}
 
-func (x *groupStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (g *groupStop) StateSave(stateSinkObject state.Sink) {
+	g.beforeSave()
 }
 
-func (x *groupStop) afterLoad() {}
+func (g *groupStop) afterLoad() {}
 
-func (x *groupStop) StateLoad(m state.Source) {
+func (g *groupStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runInterrupt) StateTypeName() string {
+func (r *runInterrupt) StateTypeName() string {
 	return "pkg/sentry/kernel.runInterrupt"
 }
 
-func (x *runInterrupt) StateFields() []string {
+func (r *runInterrupt) StateFields() []string {
 	return []string{}
 }
 
-func (x *runInterrupt) beforeSave() {}
+func (r *runInterrupt) beforeSave() {}
 
-func (x *runInterrupt) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runInterrupt) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runInterrupt) afterLoad() {}
+func (r *runInterrupt) afterLoad() {}
 
-func (x *runInterrupt) StateLoad(m state.Source) {
+func (r *runInterrupt) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runInterruptAfterSignalDeliveryStop) StateTypeName() string {
+func (r *runInterruptAfterSignalDeliveryStop) StateTypeName() string {
 	return "pkg/sentry/kernel.runInterruptAfterSignalDeliveryStop"
 }
 
-func (x *runInterruptAfterSignalDeliveryStop) StateFields() []string {
+func (r *runInterruptAfterSignalDeliveryStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *runInterruptAfterSignalDeliveryStop) beforeSave() {}
+func (r *runInterruptAfterSignalDeliveryStop) beforeSave() {}
 
-func (x *runInterruptAfterSignalDeliveryStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runInterruptAfterSignalDeliveryStop) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runInterruptAfterSignalDeliveryStop) afterLoad() {}
+func (r *runInterruptAfterSignalDeliveryStop) afterLoad() {}
 
-func (x *runInterruptAfterSignalDeliveryStop) StateLoad(m state.Source) {
+func (r *runInterruptAfterSignalDeliveryStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runSyscallAfterSyscallEnterStop) StateTypeName() string {
+func (r *runSyscallAfterSyscallEnterStop) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallAfterSyscallEnterStop"
 }
 
-func (x *runSyscallAfterSyscallEnterStop) StateFields() []string {
+func (r *runSyscallAfterSyscallEnterStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *runSyscallAfterSyscallEnterStop) beforeSave() {}
+func (r *runSyscallAfterSyscallEnterStop) beforeSave() {}
 
-func (x *runSyscallAfterSyscallEnterStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runSyscallAfterSyscallEnterStop) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runSyscallAfterSyscallEnterStop) afterLoad() {}
+func (r *runSyscallAfterSyscallEnterStop) afterLoad() {}
 
-func (x *runSyscallAfterSyscallEnterStop) StateLoad(m state.Source) {
+func (r *runSyscallAfterSyscallEnterStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runSyscallAfterSysemuStop) StateTypeName() string {
+func (r *runSyscallAfterSysemuStop) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallAfterSysemuStop"
 }
 
-func (x *runSyscallAfterSysemuStop) StateFields() []string {
+func (r *runSyscallAfterSysemuStop) StateFields() []string {
 	return []string{}
 }
 
-func (x *runSyscallAfterSysemuStop) beforeSave() {}
+func (r *runSyscallAfterSysemuStop) beforeSave() {}
 
-func (x *runSyscallAfterSysemuStop) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runSyscallAfterSysemuStop) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runSyscallAfterSysemuStop) afterLoad() {}
+func (r *runSyscallAfterSysemuStop) afterLoad() {}
 
-func (x *runSyscallAfterSysemuStop) StateLoad(m state.Source) {
+func (r *runSyscallAfterSysemuStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runSyscallReinvoke) StateTypeName() string {
+func (r *runSyscallReinvoke) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallReinvoke"
 }
 
-func (x *runSyscallReinvoke) StateFields() []string {
+func (r *runSyscallReinvoke) StateFields() []string {
 	return []string{}
 }
 
-func (x *runSyscallReinvoke) beforeSave() {}
+func (r *runSyscallReinvoke) beforeSave() {}
 
-func (x *runSyscallReinvoke) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runSyscallReinvoke) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runSyscallReinvoke) afterLoad() {}
+func (r *runSyscallReinvoke) afterLoad() {}
 
-func (x *runSyscallReinvoke) StateLoad(m state.Source) {
+func (r *runSyscallReinvoke) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *runSyscallExit) StateTypeName() string {
+func (r *runSyscallExit) StateTypeName() string {
 	return "pkg/sentry/kernel.runSyscallExit"
 }
 
-func (x *runSyscallExit) StateFields() []string {
+func (r *runSyscallExit) StateFields() []string {
 	return []string{}
 }
 
-func (x *runSyscallExit) beforeSave() {}
+func (r *runSyscallExit) beforeSave() {}
 
-func (x *runSyscallExit) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *runSyscallExit) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *runSyscallExit) afterLoad() {}
+func (r *runSyscallExit) afterLoad() {}
 
-func (x *runSyscallExit) StateLoad(m state.Source) {
+func (r *runSyscallExit) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *ThreadGroup) StateTypeName() string {
+func (t *ThreadGroup) StateTypeName() string {
 	return "pkg/sentry/kernel.ThreadGroup"
 }
 
-func (x *ThreadGroup) StateFields() []string {
+func (t *ThreadGroup) StateFields() []string {
 	return []string{
 		"threadGroupNode",
 		"signalHandlers",
@@ -1881,138 +1881,138 @@ func (x *ThreadGroup) StateFields() []string {
 	}
 }
 
-func (x *ThreadGroup) beforeSave() {}
-
-func (x *ThreadGroup) StateSave(m state.Sink) {
-	x.beforeSave()
-	var oldRSeqCritical *OldRSeqCriticalRegion = x.saveOldRSeqCritical()
-	m.SaveValue(29, oldRSeqCritical)
-	m.Save(0, &x.threadGroupNode)
-	m.Save(1, &x.signalHandlers)
-	m.Save(2, &x.pendingSignals)
-	m.Save(3, &x.groupStopDequeued)
-	m.Save(4, &x.groupStopSignal)
-	m.Save(5, &x.groupStopPendingCount)
-	m.Save(6, &x.groupStopComplete)
-	m.Save(7, &x.groupStopWaitable)
-	m.Save(8, &x.groupContNotify)
-	m.Save(9, &x.groupContInterrupted)
-	m.Save(10, &x.groupContWaitable)
-	m.Save(11, &x.exiting)
-	m.Save(12, &x.exitStatus)
-	m.Save(13, &x.terminationSignal)
-	m.Save(14, &x.itimerRealTimer)
-	m.Save(15, &x.itimerVirtSetting)
-	m.Save(16, &x.itimerProfSetting)
-	m.Save(17, &x.rlimitCPUSoftSetting)
-	m.Save(18, &x.cpuTimersEnabled)
-	m.Save(19, &x.timers)
-	m.Save(20, &x.nextTimerID)
-	m.Save(21, &x.exitedCPUStats)
-	m.Save(22, &x.childCPUStats)
-	m.Save(23, &x.ioUsage)
-	m.Save(24, &x.maxRSS)
-	m.Save(25, &x.childMaxRSS)
-	m.Save(26, &x.limits)
-	m.Save(27, &x.processGroup)
-	m.Save(28, &x.execed)
-	m.Save(30, &x.mounts)
-	m.Save(31, &x.tty)
-	m.Save(32, &x.oomScoreAdj)
-}
-
-func (x *ThreadGroup) afterLoad() {}
-
-func (x *ThreadGroup) StateLoad(m state.Source) {
-	m.Load(0, &x.threadGroupNode)
-	m.Load(1, &x.signalHandlers)
-	m.Load(2, &x.pendingSignals)
-	m.Load(3, &x.groupStopDequeued)
-	m.Load(4, &x.groupStopSignal)
-	m.Load(5, &x.groupStopPendingCount)
-	m.Load(6, &x.groupStopComplete)
-	m.Load(7, &x.groupStopWaitable)
-	m.Load(8, &x.groupContNotify)
-	m.Load(9, &x.groupContInterrupted)
-	m.Load(10, &x.groupContWaitable)
-	m.Load(11, &x.exiting)
-	m.Load(12, &x.exitStatus)
-	m.Load(13, &x.terminationSignal)
-	m.Load(14, &x.itimerRealTimer)
-	m.Load(15, &x.itimerVirtSetting)
-	m.Load(16, &x.itimerProfSetting)
-	m.Load(17, &x.rlimitCPUSoftSetting)
-	m.Load(18, &x.cpuTimersEnabled)
-	m.Load(19, &x.timers)
-	m.Load(20, &x.nextTimerID)
-	m.Load(21, &x.exitedCPUStats)
-	m.Load(22, &x.childCPUStats)
-	m.Load(23, &x.ioUsage)
-	m.Load(24, &x.maxRSS)
-	m.Load(25, &x.childMaxRSS)
-	m.Load(26, &x.limits)
-	m.Load(27, &x.processGroup)
-	m.Load(28, &x.execed)
-	m.Load(30, &x.mounts)
-	m.Load(31, &x.tty)
-	m.Load(32, &x.oomScoreAdj)
-	m.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { x.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
-}
-
-func (x *itimerRealListener) StateTypeName() string {
+func (t *ThreadGroup) beforeSave() {}
+
+func (t *ThreadGroup) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	var oldRSeqCriticalValue *OldRSeqCriticalRegion = t.saveOldRSeqCritical()
+	stateSinkObject.SaveValue(29, oldRSeqCriticalValue)
+	stateSinkObject.Save(0, &t.threadGroupNode)
+	stateSinkObject.Save(1, &t.signalHandlers)
+	stateSinkObject.Save(2, &t.pendingSignals)
+	stateSinkObject.Save(3, &t.groupStopDequeued)
+	stateSinkObject.Save(4, &t.groupStopSignal)
+	stateSinkObject.Save(5, &t.groupStopPendingCount)
+	stateSinkObject.Save(6, &t.groupStopComplete)
+	stateSinkObject.Save(7, &t.groupStopWaitable)
+	stateSinkObject.Save(8, &t.groupContNotify)
+	stateSinkObject.Save(9, &t.groupContInterrupted)
+	stateSinkObject.Save(10, &t.groupContWaitable)
+	stateSinkObject.Save(11, &t.exiting)
+	stateSinkObject.Save(12, &t.exitStatus)
+	stateSinkObject.Save(13, &t.terminationSignal)
+	stateSinkObject.Save(14, &t.itimerRealTimer)
+	stateSinkObject.Save(15, &t.itimerVirtSetting)
+	stateSinkObject.Save(16, &t.itimerProfSetting)
+	stateSinkObject.Save(17, &t.rlimitCPUSoftSetting)
+	stateSinkObject.Save(18, &t.cpuTimersEnabled)
+	stateSinkObject.Save(19, &t.timers)
+	stateSinkObject.Save(20, &t.nextTimerID)
+	stateSinkObject.Save(21, &t.exitedCPUStats)
+	stateSinkObject.Save(22, &t.childCPUStats)
+	stateSinkObject.Save(23, &t.ioUsage)
+	stateSinkObject.Save(24, &t.maxRSS)
+	stateSinkObject.Save(25, &t.childMaxRSS)
+	stateSinkObject.Save(26, &t.limits)
+	stateSinkObject.Save(27, &t.processGroup)
+	stateSinkObject.Save(28, &t.execed)
+	stateSinkObject.Save(30, &t.mounts)
+	stateSinkObject.Save(31, &t.tty)
+	stateSinkObject.Save(32, &t.oomScoreAdj)
+}
+
+func (t *ThreadGroup) afterLoad() {}
+
+func (t *ThreadGroup) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.threadGroupNode)
+	stateSourceObject.Load(1, &t.signalHandlers)
+	stateSourceObject.Load(2, &t.pendingSignals)
+	stateSourceObject.Load(3, &t.groupStopDequeued)
+	stateSourceObject.Load(4, &t.groupStopSignal)
+	stateSourceObject.Load(5, &t.groupStopPendingCount)
+	stateSourceObject.Load(6, &t.groupStopComplete)
+	stateSourceObject.Load(7, &t.groupStopWaitable)
+	stateSourceObject.Load(8, &t.groupContNotify)
+	stateSourceObject.Load(9, &t.groupContInterrupted)
+	stateSourceObject.Load(10, &t.groupContWaitable)
+	stateSourceObject.Load(11, &t.exiting)
+	stateSourceObject.Load(12, &t.exitStatus)
+	stateSourceObject.Load(13, &t.terminationSignal)
+	stateSourceObject.Load(14, &t.itimerRealTimer)
+	stateSourceObject.Load(15, &t.itimerVirtSetting)
+	stateSourceObject.Load(16, &t.itimerProfSetting)
+	stateSourceObject.Load(17, &t.rlimitCPUSoftSetting)
+	stateSourceObject.Load(18, &t.cpuTimersEnabled)
+	stateSourceObject.Load(19, &t.timers)
+	stateSourceObject.Load(20, &t.nextTimerID)
+	stateSourceObject.Load(21, &t.exitedCPUStats)
+	stateSourceObject.Load(22, &t.childCPUStats)
+	stateSourceObject.Load(23, &t.ioUsage)
+	stateSourceObject.Load(24, &t.maxRSS)
+	stateSourceObject.Load(25, &t.childMaxRSS)
+	stateSourceObject.Load(26, &t.limits)
+	stateSourceObject.Load(27, &t.processGroup)
+	stateSourceObject.Load(28, &t.execed)
+	stateSourceObject.Load(30, &t.mounts)
+	stateSourceObject.Load(31, &t.tty)
+	stateSourceObject.Load(32, &t.oomScoreAdj)
+	stateSourceObject.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { t.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
+}
+
+func (i *itimerRealListener) StateTypeName() string {
 	return "pkg/sentry/kernel.itimerRealListener"
 }
 
-func (x *itimerRealListener) StateFields() []string {
+func (i *itimerRealListener) StateFields() []string {
 	return []string{
 		"tg",
 	}
 }
 
-func (x *itimerRealListener) beforeSave() {}
+func (i *itimerRealListener) beforeSave() {}
 
-func (x *itimerRealListener) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.tg)
+func (i *itimerRealListener) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.tg)
 }
 
-func (x *itimerRealListener) afterLoad() {}
+func (i *itimerRealListener) afterLoad() {}
 
-func (x *itimerRealListener) StateLoad(m state.Source) {
-	m.Load(0, &x.tg)
+func (i *itimerRealListener) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.tg)
 }
 
-func (x *TaskSet) StateTypeName() string {
+func (t *TaskSet) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskSet"
 }
 
-func (x *TaskSet) StateFields() []string {
+func (t *TaskSet) StateFields() []string {
 	return []string{
 		"Root",
 		"sessions",
 	}
 }
 
-func (x *TaskSet) beforeSave() {}
+func (t *TaskSet) beforeSave() {}
 
-func (x *TaskSet) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Root)
-	m.Save(1, &x.sessions)
+func (t *TaskSet) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.Root)
+	stateSinkObject.Save(1, &t.sessions)
 }
 
-func (x *TaskSet) afterLoad() {}
+func (t *TaskSet) afterLoad() {}
 
-func (x *TaskSet) StateLoad(m state.Source) {
-	m.Load(0, &x.Root)
-	m.Load(1, &x.sessions)
+func (t *TaskSet) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.Root)
+	stateSourceObject.Load(1, &t.sessions)
 }
 
-func (x *PIDNamespace) StateTypeName() string {
+func (p *PIDNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel.PIDNamespace"
 }
 
-func (x *PIDNamespace) StateFields() []string {
+func (p *PIDNamespace) StateFields() []string {
 	return []string{
 		"owner",
 		"parent",
@@ -2029,46 +2029,46 @@ func (x *PIDNamespace) StateFields() []string {
 	}
 }
 
-func (x *PIDNamespace) beforeSave() {}
-
-func (x *PIDNamespace) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.owner)
-	m.Save(1, &x.parent)
-	m.Save(2, &x.userns)
-	m.Save(3, &x.last)
-	m.Save(4, &x.tasks)
-	m.Save(5, &x.tids)
-	m.Save(6, &x.tgids)
-	m.Save(7, &x.sessions)
-	m.Save(8, &x.sids)
-	m.Save(9, &x.processGroups)
-	m.Save(10, &x.pgids)
-	m.Save(11, &x.exiting)
-}
-
-func (x *PIDNamespace) afterLoad() {}
-
-func (x *PIDNamespace) StateLoad(m state.Source) {
-	m.Load(0, &x.owner)
-	m.Load(1, &x.parent)
-	m.Load(2, &x.userns)
-	m.Load(3, &x.last)
-	m.Load(4, &x.tasks)
-	m.Load(5, &x.tids)
-	m.Load(6, &x.tgids)
-	m.Load(7, &x.sessions)
-	m.Load(8, &x.sids)
-	m.Load(9, &x.processGroups)
-	m.Load(10, &x.pgids)
-	m.Load(11, &x.exiting)
-}
-
-func (x *threadGroupNode) StateTypeName() string {
+func (p *PIDNamespace) beforeSave() {}
+
+func (p *PIDNamespace) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.owner)
+	stateSinkObject.Save(1, &p.parent)
+	stateSinkObject.Save(2, &p.userns)
+	stateSinkObject.Save(3, &p.last)
+	stateSinkObject.Save(4, &p.tasks)
+	stateSinkObject.Save(5, &p.tids)
+	stateSinkObject.Save(6, &p.tgids)
+	stateSinkObject.Save(7, &p.sessions)
+	stateSinkObject.Save(8, &p.sids)
+	stateSinkObject.Save(9, &p.processGroups)
+	stateSinkObject.Save(10, &p.pgids)
+	stateSinkObject.Save(11, &p.exiting)
+}
+
+func (p *PIDNamespace) afterLoad() {}
+
+func (p *PIDNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.owner)
+	stateSourceObject.Load(1, &p.parent)
+	stateSourceObject.Load(2, &p.userns)
+	stateSourceObject.Load(3, &p.last)
+	stateSourceObject.Load(4, &p.tasks)
+	stateSourceObject.Load(5, &p.tids)
+	stateSourceObject.Load(6, &p.tgids)
+	stateSourceObject.Load(7, &p.sessions)
+	stateSourceObject.Load(8, &p.sids)
+	stateSourceObject.Load(9, &p.processGroups)
+	stateSourceObject.Load(10, &p.pgids)
+	stateSourceObject.Load(11, &p.exiting)
+}
+
+func (t *threadGroupNode) StateTypeName() string {
 	return "pkg/sentry/kernel.threadGroupNode"
 }
 
-func (x *threadGroupNode) StateFields() []string {
+func (t *threadGroupNode) StateFields() []string {
 	return []string{
 		"pidns",
 		"leader",
@@ -2080,36 +2080,36 @@ func (x *threadGroupNode) StateFields() []string {
 	}
 }
 
-func (x *threadGroupNode) beforeSave() {}
+func (t *threadGroupNode) beforeSave() {}
 
-func (x *threadGroupNode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.pidns)
-	m.Save(1, &x.leader)
-	m.Save(2, &x.execing)
-	m.Save(3, &x.tasks)
-	m.Save(4, &x.tasksCount)
-	m.Save(5, &x.liveTasks)
-	m.Save(6, &x.activeTasks)
+func (t *threadGroupNode) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.pidns)
+	stateSinkObject.Save(1, &t.leader)
+	stateSinkObject.Save(2, &t.execing)
+	stateSinkObject.Save(3, &t.tasks)
+	stateSinkObject.Save(4, &t.tasksCount)
+	stateSinkObject.Save(5, &t.liveTasks)
+	stateSinkObject.Save(6, &t.activeTasks)
 }
 
-func (x *threadGroupNode) afterLoad() {}
+func (t *threadGroupNode) afterLoad() {}
 
-func (x *threadGroupNode) StateLoad(m state.Source) {
-	m.Load(0, &x.pidns)
-	m.Load(1, &x.leader)
-	m.Load(2, &x.execing)
-	m.Load(3, &x.tasks)
-	m.Load(4, &x.tasksCount)
-	m.Load(5, &x.liveTasks)
-	m.Load(6, &x.activeTasks)
+func (t *threadGroupNode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.pidns)
+	stateSourceObject.Load(1, &t.leader)
+	stateSourceObject.Load(2, &t.execing)
+	stateSourceObject.Load(3, &t.tasks)
+	stateSourceObject.Load(4, &t.tasksCount)
+	stateSourceObject.Load(5, &t.liveTasks)
+	stateSourceObject.Load(6, &t.activeTasks)
 }
 
-func (x *taskNode) StateTypeName() string {
+func (t *taskNode) StateTypeName() string {
 	return "pkg/sentry/kernel.taskNode"
 }
 
-func (x *taskNode) StateFields() []string {
+func (t *taskNode) StateFields() []string {
 	return []string{
 		"tg",
 		"taskEntry",
@@ -2119,32 +2119,32 @@ func (x *taskNode) StateFields() []string {
 	}
 }
 
-func (x *taskNode) beforeSave() {}
+func (t *taskNode) beforeSave() {}
 
-func (x *taskNode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.tg)
-	m.Save(1, &x.taskEntry)
-	m.Save(2, &x.parent)
-	m.Save(3, &x.children)
-	m.Save(4, &x.childPIDNamespace)
+func (t *taskNode) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.tg)
+	stateSinkObject.Save(1, &t.taskEntry)
+	stateSinkObject.Save(2, &t.parent)
+	stateSinkObject.Save(3, &t.children)
+	stateSinkObject.Save(4, &t.childPIDNamespace)
 }
 
-func (x *taskNode) afterLoad() {}
+func (t *taskNode) afterLoad() {}
 
-func (x *taskNode) StateLoad(m state.Source) {
-	m.LoadWait(0, &x.tg)
-	m.Load(1, &x.taskEntry)
-	m.Load(2, &x.parent)
-	m.Load(3, &x.children)
-	m.Load(4, &x.childPIDNamespace)
+func (t *taskNode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadWait(0, &t.tg)
+	stateSourceObject.Load(1, &t.taskEntry)
+	stateSourceObject.Load(2, &t.parent)
+	stateSourceObject.Load(3, &t.children)
+	stateSourceObject.Load(4, &t.childPIDNamespace)
 }
 
-func (x *Timekeeper) StateTypeName() string {
+func (t *Timekeeper) StateTypeName() string {
 	return "pkg/sentry/kernel.Timekeeper"
 }
 
-func (x *Timekeeper) StateFields() []string {
+func (t *Timekeeper) StateFields() []string {
 	return []string{
 		"bootTime",
 		"saveMonotonic",
@@ -2153,79 +2153,79 @@ func (x *Timekeeper) StateFields() []string {
 	}
 }
 
-func (x *Timekeeper) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.bootTime)
-	m.Save(1, &x.saveMonotonic)
-	m.Save(2, &x.saveRealtime)
-	m.Save(3, &x.params)
+func (t *Timekeeper) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.bootTime)
+	stateSinkObject.Save(1, &t.saveMonotonic)
+	stateSinkObject.Save(2, &t.saveRealtime)
+	stateSinkObject.Save(3, &t.params)
 }
 
-func (x *Timekeeper) StateLoad(m state.Source) {
-	m.Load(0, &x.bootTime)
-	m.Load(1, &x.saveMonotonic)
-	m.Load(2, &x.saveRealtime)
-	m.Load(3, &x.params)
-	m.AfterLoad(x.afterLoad)
+func (t *Timekeeper) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.bootTime)
+	stateSourceObject.Load(1, &t.saveMonotonic)
+	stateSourceObject.Load(2, &t.saveRealtime)
+	stateSourceObject.Load(3, &t.params)
+	stateSourceObject.AfterLoad(t.afterLoad)
 }
 
-func (x *timekeeperClock) StateTypeName() string {
+func (t *timekeeperClock) StateTypeName() string {
 	return "pkg/sentry/kernel.timekeeperClock"
 }
 
-func (x *timekeeperClock) StateFields() []string {
+func (t *timekeeperClock) StateFields() []string {
 	return []string{
 		"tk",
 		"c",
 	}
 }
 
-func (x *timekeeperClock) beforeSave() {}
+func (t *timekeeperClock) beforeSave() {}
 
-func (x *timekeeperClock) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.tk)
-	m.Save(1, &x.c)
+func (t *timekeeperClock) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.tk)
+	stateSinkObject.Save(1, &t.c)
 }
 
-func (x *timekeeperClock) afterLoad() {}
+func (t *timekeeperClock) afterLoad() {}
 
-func (x *timekeeperClock) StateLoad(m state.Source) {
-	m.Load(0, &x.tk)
-	m.Load(1, &x.c)
+func (t *timekeeperClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.tk)
+	stateSourceObject.Load(1, &t.c)
 }
 
-func (x *TTY) StateTypeName() string {
+func (t *TTY) StateTypeName() string {
 	return "pkg/sentry/kernel.TTY"
 }
 
-func (x *TTY) StateFields() []string {
+func (t *TTY) StateFields() []string {
 	return []string{
 		"Index",
 		"tg",
 	}
 }
 
-func (x *TTY) beforeSave() {}
+func (t *TTY) beforeSave() {}
 
-func (x *TTY) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Index)
-	m.Save(1, &x.tg)
+func (t *TTY) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.Index)
+	stateSinkObject.Save(1, &t.tg)
 }
 
-func (x *TTY) afterLoad() {}
+func (t *TTY) afterLoad() {}
 
-func (x *TTY) StateLoad(m state.Source) {
-	m.Load(0, &x.Index)
-	m.Load(1, &x.tg)
+func (t *TTY) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.Index)
+	stateSourceObject.Load(1, &t.tg)
 }
 
-func (x *UTSNamespace) StateTypeName() string {
+func (u *UTSNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel.UTSNamespace"
 }
 
-func (x *UTSNamespace) StateFields() []string {
+func (u *UTSNamespace) StateFields() []string {
 	return []string{
 		"hostName",
 		"domainName",
@@ -2233,28 +2233,28 @@ func (x *UTSNamespace) StateFields() []string {
 	}
 }
 
-func (x *UTSNamespace) beforeSave() {}
+func (u *UTSNamespace) beforeSave() {}
 
-func (x *UTSNamespace) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.hostName)
-	m.Save(1, &x.domainName)
-	m.Save(2, &x.userns)
+func (u *UTSNamespace) StateSave(stateSinkObject state.Sink) {
+	u.beforeSave()
+	stateSinkObject.Save(0, &u.hostName)
+	stateSinkObject.Save(1, &u.domainName)
+	stateSinkObject.Save(2, &u.userns)
 }
 
-func (x *UTSNamespace) afterLoad() {}
+func (u *UTSNamespace) afterLoad() {}
 
-func (x *UTSNamespace) StateLoad(m state.Source) {
-	m.Load(0, &x.hostName)
-	m.Load(1, &x.domainName)
-	m.Load(2, &x.userns)
+func (u *UTSNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &u.hostName)
+	stateSourceObject.Load(1, &u.domainName)
+	stateSourceObject.Load(2, &u.userns)
 }
 
-func (x *VDSOParamPage) StateTypeName() string {
+func (v *VDSOParamPage) StateTypeName() string {
 	return "pkg/sentry/kernel.VDSOParamPage"
 }
 
-func (x *VDSOParamPage) StateFields() []string {
+func (v *VDSOParamPage) StateFields() []string {
 	return []string{
 		"mfp",
 		"fr",
@@ -2263,23 +2263,23 @@ func (x *VDSOParamPage) StateFields() []string {
 	}
 }
 
-func (x *VDSOParamPage) beforeSave() {}
+func (v *VDSOParamPage) beforeSave() {}
 
-func (x *VDSOParamPage) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.mfp)
-	m.Save(1, &x.fr)
-	m.Save(2, &x.seq)
-	m.Save(3, &x.copyScratchBuffer)
+func (v *VDSOParamPage) StateSave(stateSinkObject state.Sink) {
+	v.beforeSave()
+	stateSinkObject.Save(0, &v.mfp)
+	stateSinkObject.Save(1, &v.fr)
+	stateSinkObject.Save(2, &v.seq)
+	stateSinkObject.Save(3, &v.copyScratchBuffer)
 }
 
-func (x *VDSOParamPage) afterLoad() {}
+func (v *VDSOParamPage) afterLoad() {}
 
-func (x *VDSOParamPage) StateLoad(m state.Source) {
-	m.Load(0, &x.mfp)
-	m.Load(1, &x.fr)
-	m.Load(2, &x.seq)
-	m.Load(3, &x.copyScratchBuffer)
+func (v *VDSOParamPage) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &v.mfp)
+	stateSourceObject.Load(1, &v.fr)
+	stateSourceObject.Load(2, &v.seq)
+	stateSourceObject.Load(3, &v.copyScratchBuffer)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
index df55abce6..031ea2cc2 100644
--- a/pkg/sentry/kernel/pipe/pipe_state_autogen.go
+++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
@@ -6,37 +6,37 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *inodeOperations) StateTypeName() string {
+func (i *inodeOperations) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.inodeOperations"
 }
 
-func (x *inodeOperations) StateFields() []string {
+func (i *inodeOperations) StateFields() []string {
 	return []string{
 		"InodeSimpleAttributes",
 		"p",
 	}
 }
 
-func (x *inodeOperations) beforeSave() {}
+func (i *inodeOperations) beforeSave() {}
 
-func (x *inodeOperations) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeSimpleAttributes)
-	m.Save(1, &x.p)
+func (i *inodeOperations) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.InodeSimpleAttributes)
+	stateSinkObject.Save(1, &i.p)
 }
 
-func (x *inodeOperations) afterLoad() {}
+func (i *inodeOperations) afterLoad() {}
 
-func (x *inodeOperations) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeSimpleAttributes)
-	m.Load(1, &x.p)
+func (i *inodeOperations) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.InodeSimpleAttributes)
+	stateSourceObject.Load(1, &i.p)
 }
 
-func (x *Pipe) StateTypeName() string {
+func (p *Pipe) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.Pipe"
 }
 
-func (x *Pipe) StateFields() []string {
+func (p *Pipe) StateFields() []string {
 	return []string{
 		"isNamed",
 		"atomicIOBytes",
@@ -48,98 +48,98 @@ func (x *Pipe) StateFields() []string {
 	}
 }
 
-func (x *Pipe) beforeSave() {}
+func (p *Pipe) beforeSave() {}
 
-func (x *Pipe) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.isNamed)
-	m.Save(1, &x.atomicIOBytes)
-	m.Save(2, &x.readers)
-	m.Save(3, &x.writers)
-	m.Save(4, &x.view)
-	m.Save(5, &x.max)
-	m.Save(6, &x.hadWriter)
+func (p *Pipe) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	stateSinkObject.Save(0, &p.isNamed)
+	stateSinkObject.Save(1, &p.atomicIOBytes)
+	stateSinkObject.Save(2, &p.readers)
+	stateSinkObject.Save(3, &p.writers)
+	stateSinkObject.Save(4, &p.view)
+	stateSinkObject.Save(5, &p.max)
+	stateSinkObject.Save(6, &p.hadWriter)
 }
 
-func (x *Pipe) afterLoad() {}
+func (p *Pipe) afterLoad() {}
 
-func (x *Pipe) StateLoad(m state.Source) {
-	m.Load(0, &x.isNamed)
-	m.Load(1, &x.atomicIOBytes)
-	m.Load(2, &x.readers)
-	m.Load(3, &x.writers)
-	m.Load(4, &x.view)
-	m.Load(5, &x.max)
-	m.Load(6, &x.hadWriter)
+func (p *Pipe) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &p.isNamed)
+	stateSourceObject.Load(1, &p.atomicIOBytes)
+	stateSourceObject.Load(2, &p.readers)
+	stateSourceObject.Load(3, &p.writers)
+	stateSourceObject.Load(4, &p.view)
+	stateSourceObject.Load(5, &p.max)
+	stateSourceObject.Load(6, &p.hadWriter)
 }
 
-func (x *Reader) StateTypeName() string {
+func (r *Reader) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.Reader"
 }
 
-func (x *Reader) StateFields() []string {
+func (r *Reader) StateFields() []string {
 	return []string{
 		"ReaderWriter",
 	}
 }
 
-func (x *Reader) beforeSave() {}
+func (r *Reader) beforeSave() {}
 
-func (x *Reader) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ReaderWriter)
+func (r *Reader) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.ReaderWriter)
 }
 
-func (x *Reader) afterLoad() {}
+func (r *Reader) afterLoad() {}
 
-func (x *Reader) StateLoad(m state.Source) {
-	m.Load(0, &x.ReaderWriter)
+func (r *Reader) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.ReaderWriter)
 }
 
-func (x *ReaderWriter) StateTypeName() string {
+func (r *ReaderWriter) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.ReaderWriter"
 }
 
-func (x *ReaderWriter) StateFields() []string {
+func (r *ReaderWriter) StateFields() []string {
 	return []string{
 		"Pipe",
 	}
 }
 
-func (x *ReaderWriter) beforeSave() {}
+func (r *ReaderWriter) beforeSave() {}
 
-func (x *ReaderWriter) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Pipe)
+func (r *ReaderWriter) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.Pipe)
 }
 
-func (x *ReaderWriter) afterLoad() {}
+func (r *ReaderWriter) afterLoad() {}
 
-func (x *ReaderWriter) StateLoad(m state.Source) {
-	m.Load(0, &x.Pipe)
+func (r *ReaderWriter) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.Pipe)
 }
 
-func (x *Writer) StateTypeName() string {
+func (w *Writer) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.Writer"
 }
 
-func (x *Writer) StateFields() []string {
+func (w *Writer) StateFields() []string {
 	return []string{
 		"ReaderWriter",
 	}
 }
 
-func (x *Writer) beforeSave() {}
+func (w *Writer) beforeSave() {}
 
-func (x *Writer) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ReaderWriter)
+func (w *Writer) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.ReaderWriter)
 }
 
-func (x *Writer) afterLoad() {}
+func (w *Writer) afterLoad() {}
 
-func (x *Writer) StateLoad(m state.Source) {
-	m.Load(0, &x.ReaderWriter)
+func (w *Writer) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.ReaderWriter)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
index fe5adfbee..80358c6e3 100644
--- a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
+++ b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *Registry) StateTypeName() string {
+func (r *Registry) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.Registry"
 }
 
-func (x *Registry) StateFields() []string {
+func (r *Registry) StateFields() []string {
 	return []string{
 		"userNS",
 		"semaphores",
@@ -18,28 +18,28 @@ func (x *Registry) StateFields() []string {
 	}
 }
 
-func (x *Registry) beforeSave() {}
+func (r *Registry) beforeSave() {}
 
-func (x *Registry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.userNS)
-	m.Save(1, &x.semaphores)
-	m.Save(2, &x.lastIDUsed)
+func (r *Registry) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.userNS)
+	stateSinkObject.Save(1, &r.semaphores)
+	stateSinkObject.Save(2, &r.lastIDUsed)
 }
 
-func (x *Registry) afterLoad() {}
+func (r *Registry) afterLoad() {}
 
-func (x *Registry) StateLoad(m state.Source) {
-	m.Load(0, &x.userNS)
-	m.Load(1, &x.semaphores)
-	m.Load(2, &x.lastIDUsed)
+func (r *Registry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.userNS)
+	stateSourceObject.Load(1, &r.semaphores)
+	stateSourceObject.Load(2, &r.lastIDUsed)
 }
 
-func (x *Set) StateTypeName() string {
+func (s *Set) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.Set"
 }
 
-func (x *Set) StateFields() []string {
+func (s *Set) StateFields() []string {
 	return []string{
 		"registry",
 		"ID",
@@ -54,71 +54,71 @@ func (x *Set) StateFields() []string {
 	}
 }
 
-func (x *Set) beforeSave() {}
+func (s *Set) beforeSave() {}
 
-func (x *Set) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.registry)
-	m.Save(1, &x.ID)
-	m.Save(2, &x.key)
-	m.Save(3, &x.creator)
-	m.Save(4, &x.owner)
-	m.Save(5, &x.perms)
-	m.Save(6, &x.opTime)
-	m.Save(7, &x.changeTime)
-	m.Save(8, &x.sems)
-	m.Save(9, &x.dead)
+func (s *Set) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.registry)
+	stateSinkObject.Save(1, &s.ID)
+	stateSinkObject.Save(2, &s.key)
+	stateSinkObject.Save(3, &s.creator)
+	stateSinkObject.Save(4, &s.owner)
+	stateSinkObject.Save(5, &s.perms)
+	stateSinkObject.Save(6, &s.opTime)
+	stateSinkObject.Save(7, &s.changeTime)
+	stateSinkObject.Save(8, &s.sems)
+	stateSinkObject.Save(9, &s.dead)
 }
 
-func (x *Set) afterLoad() {}
+func (s *Set) afterLoad() {}
 
-func (x *Set) StateLoad(m state.Source) {
-	m.Load(0, &x.registry)
-	m.Load(1, &x.ID)
-	m.Load(2, &x.key)
-	m.Load(3, &x.creator)
-	m.Load(4, &x.owner)
-	m.Load(5, &x.perms)
-	m.Load(6, &x.opTime)
-	m.Load(7, &x.changeTime)
-	m.Load(8, &x.sems)
-	m.Load(9, &x.dead)
+func (s *Set) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.registry)
+	stateSourceObject.Load(1, &s.ID)
+	stateSourceObject.Load(2, &s.key)
+	stateSourceObject.Load(3, &s.creator)
+	stateSourceObject.Load(4, &s.owner)
+	stateSourceObject.Load(5, &s.perms)
+	stateSourceObject.Load(6, &s.opTime)
+	stateSourceObject.Load(7, &s.changeTime)
+	stateSourceObject.Load(8, &s.sems)
+	stateSourceObject.Load(9, &s.dead)
 }
 
-func (x *sem) StateTypeName() string {
+func (s *sem) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.sem"
 }
 
-func (x *sem) StateFields() []string {
+func (s *sem) StateFields() []string {
 	return []string{
 		"value",
 		"pid",
 	}
 }
 
-func (x *sem) beforeSave() {}
+func (s *sem) beforeSave() {}
 
-func (x *sem) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.waiters) {
-		state.Failf("waiters is %#v, expected zero", &x.waiters)
+func (s *sem) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	if !state.IsZeroValue(&s.waiters) {
+		state.Failf("waiters is %#v, expected zero", &s.waiters)
 	}
-	m.Save(0, &x.value)
-	m.Save(1, &x.pid)
+	stateSinkObject.Save(0, &s.value)
+	stateSinkObject.Save(1, &s.pid)
 }
 
-func (x *sem) afterLoad() {}
+func (s *sem) afterLoad() {}
 
-func (x *sem) StateLoad(m state.Source) {
-	m.Load(0, &x.value)
-	m.Load(1, &x.pid)
+func (s *sem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.value)
+	stateSourceObject.Load(1, &s.pid)
 }
 
-func (x *waiter) StateTypeName() string {
+func (w *waiter) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.waiter"
 }
 
-func (x *waiter) StateFields() []string {
+func (w *waiter) StateFields() []string {
 	return []string{
 		"waiterEntry",
 		"value",
@@ -126,73 +126,73 @@ func (x *waiter) StateFields() []string {
 	}
 }
 
-func (x *waiter) beforeSave() {}
+func (w *waiter) beforeSave() {}
 
-func (x *waiter) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.waiterEntry)
-	m.Save(1, &x.value)
-	m.Save(2, &x.ch)
+func (w *waiter) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.waiterEntry)
+	stateSinkObject.Save(1, &w.value)
+	stateSinkObject.Save(2, &w.ch)
 }
 
-func (x *waiter) afterLoad() {}
+func (w *waiter) afterLoad() {}
 
-func (x *waiter) StateLoad(m state.Source) {
-	m.Load(0, &x.waiterEntry)
-	m.Load(1, &x.value)
-	m.Load(2, &x.ch)
+func (w *waiter) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.waiterEntry)
+	stateSourceObject.Load(1, &w.value)
+	stateSourceObject.Load(2, &w.ch)
 }
 
-func (x *waiterList) StateTypeName() string {
+func (w *waiterList) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.waiterList"
 }
 
-func (x *waiterList) StateFields() []string {
+func (w *waiterList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *waiterList) beforeSave() {}
+func (w *waiterList) beforeSave() {}
 
-func (x *waiterList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (w *waiterList) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.head)
+	stateSinkObject.Save(1, &w.tail)
 }
 
-func (x *waiterList) afterLoad() {}
+func (w *waiterList) afterLoad() {}
 
-func (x *waiterList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (w *waiterList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.head)
+	stateSourceObject.Load(1, &w.tail)
 }
 
-func (x *waiterEntry) StateTypeName() string {
+func (w *waiterEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.waiterEntry"
 }
 
-func (x *waiterEntry) StateFields() []string {
+func (w *waiterEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *waiterEntry) beforeSave() {}
+func (w *waiterEntry) beforeSave() {}
 
-func (x *waiterEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
+	w.beforeSave()
+	stateSinkObject.Save(0, &w.next)
+	stateSinkObject.Save(1, &w.prev)
 }
 
-func (x *waiterEntry) afterLoad() {}
+func (w *waiterEntry) afterLoad() {}
 
-func (x *waiterEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &w.next)
+	stateSourceObject.Load(1, &w.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/shm/shm_state_autogen.go b/pkg/sentry/kernel/shm/shm_state_autogen.go
index fa80353b6..846cbc2d5 100644
--- a/pkg/sentry/kernel/shm/shm_state_autogen.go
+++ b/pkg/sentry/kernel/shm/shm_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *Registry) StateTypeName() string {
+func (r *Registry) StateTypeName() string {
 	return "pkg/sentry/kernel/shm.Registry"
 }
 
-func (x *Registry) StateFields() []string {
+func (r *Registry) StateFields() []string {
 	return []string{
 		"userNS",
 		"shms",
@@ -20,32 +20,32 @@ func (x *Registry) StateFields() []string {
 	}
 }
 
-func (x *Registry) beforeSave() {}
+func (r *Registry) beforeSave() {}
 
-func (x *Registry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.userNS)
-	m.Save(1, &x.shms)
-	m.Save(2, &x.keysToShms)
-	m.Save(3, &x.totalPages)
-	m.Save(4, &x.lastIDUsed)
+func (r *Registry) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.userNS)
+	stateSinkObject.Save(1, &r.shms)
+	stateSinkObject.Save(2, &r.keysToShms)
+	stateSinkObject.Save(3, &r.totalPages)
+	stateSinkObject.Save(4, &r.lastIDUsed)
 }
 
-func (x *Registry) afterLoad() {}
+func (r *Registry) afterLoad() {}
 
-func (x *Registry) StateLoad(m state.Source) {
-	m.Load(0, &x.userNS)
-	m.Load(1, &x.shms)
-	m.Load(2, &x.keysToShms)
-	m.Load(3, &x.totalPages)
-	m.Load(4, &x.lastIDUsed)
+func (r *Registry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.userNS)
+	stateSourceObject.Load(1, &r.shms)
+	stateSourceObject.Load(2, &r.keysToShms)
+	stateSourceObject.Load(3, &r.totalPages)
+	stateSourceObject.Load(4, &r.lastIDUsed)
 }
 
-func (x *Shm) StateTypeName() string {
+func (s *Shm) StateTypeName() string {
 	return "pkg/sentry/kernel/shm.Shm"
 }
 
-func (x *Shm) StateFields() []string {
+func (s *Shm) StateFields() []string {
 	return []string{
 		"ShmRefs",
 		"mfp",
@@ -67,72 +67,72 @@ func (x *Shm) StateFields() []string {
 	}
 }
 
-func (x *Shm) beforeSave() {}
-
-func (x *Shm) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ShmRefs)
-	m.Save(1, &x.mfp)
-	m.Save(2, &x.registry)
-	m.Save(3, &x.ID)
-	m.Save(4, &x.creator)
-	m.Save(5, &x.size)
-	m.Save(6, &x.effectiveSize)
-	m.Save(7, &x.fr)
-	m.Save(8, &x.key)
-	m.Save(9, &x.perms)
-	m.Save(10, &x.owner)
-	m.Save(11, &x.attachTime)
-	m.Save(12, &x.detachTime)
-	m.Save(13, &x.changeTime)
-	m.Save(14, &x.creatorPID)
-	m.Save(15, &x.lastAttachDetachPID)
-	m.Save(16, &x.pendingDestruction)
+func (s *Shm) beforeSave() {}
+
+func (s *Shm) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.ShmRefs)
+	stateSinkObject.Save(1, &s.mfp)
+	stateSinkObject.Save(2, &s.registry)
+	stateSinkObject.Save(3, &s.ID)
+	stateSinkObject.Save(4, &s.creator)
+	stateSinkObject.Save(5, &s.size)
+	stateSinkObject.Save(6, &s.effectiveSize)
+	stateSinkObject.Save(7, &s.fr)
+	stateSinkObject.Save(8, &s.key)
+	stateSinkObject.Save(9, &s.perms)
+	stateSinkObject.Save(10, &s.owner)
+	stateSinkObject.Save(11, &s.attachTime)
+	stateSinkObject.Save(12, &s.detachTime)
+	stateSinkObject.Save(13, &s.changeTime)
+	stateSinkObject.Save(14, &s.creatorPID)
+	stateSinkObject.Save(15, &s.lastAttachDetachPID)
+	stateSinkObject.Save(16, &s.pendingDestruction)
 }
 
-func (x *Shm) afterLoad() {}
-
-func (x *Shm) StateLoad(m state.Source) {
-	m.Load(0, &x.ShmRefs)
-	m.Load(1, &x.mfp)
-	m.Load(2, &x.registry)
-	m.Load(3, &x.ID)
-	m.Load(4, &x.creator)
-	m.Load(5, &x.size)
-	m.Load(6, &x.effectiveSize)
-	m.Load(7, &x.fr)
-	m.Load(8, &x.key)
-	m.Load(9, &x.perms)
-	m.Load(10, &x.owner)
-	m.Load(11, &x.attachTime)
-	m.Load(12, &x.detachTime)
-	m.Load(13, &x.changeTime)
-	m.Load(14, &x.creatorPID)
-	m.Load(15, &x.lastAttachDetachPID)
-	m.Load(16, &x.pendingDestruction)
+func (s *Shm) afterLoad() {}
+
+func (s *Shm) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.ShmRefs)
+	stateSourceObject.Load(1, &s.mfp)
+	stateSourceObject.Load(2, &s.registry)
+	stateSourceObject.Load(3, &s.ID)
+	stateSourceObject.Load(4, &s.creator)
+	stateSourceObject.Load(5, &s.size)
+	stateSourceObject.Load(6, &s.effectiveSize)
+	stateSourceObject.Load(7, &s.fr)
+	stateSourceObject.Load(8, &s.key)
+	stateSourceObject.Load(9, &s.perms)
+	stateSourceObject.Load(10, &s.owner)
+	stateSourceObject.Load(11, &s.attachTime)
+	stateSourceObject.Load(12, &s.detachTime)
+	stateSourceObject.Load(13, &s.changeTime)
+	stateSourceObject.Load(14, &s.creatorPID)
+	stateSourceObject.Load(15, &s.lastAttachDetachPID)
+	stateSourceObject.Load(16, &s.pendingDestruction)
 }
 
-func (x *ShmRefs) StateTypeName() string {
+func (s *ShmRefs) StateTypeName() string {
 	return "pkg/sentry/kernel/shm.ShmRefs"
 }
 
-func (x *ShmRefs) StateFields() []string {
+func (s *ShmRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *ShmRefs) beforeSave() {}
+func (s *ShmRefs) beforeSave() {}
 
-func (x *ShmRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (s *ShmRefs) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.refCount)
 }
 
-func (x *ShmRefs) afterLoad() {}
+func (s *ShmRefs) afterLoad() {}
 
-func (x *ShmRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (s *ShmRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.refCount)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go b/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
index 089a35b60..6c608aaa4 100644
--- a/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
+++ b/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
@@ -6,30 +6,30 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *SignalOperations) StateTypeName() string {
+func (s *SignalOperations) StateTypeName() string {
 	return "pkg/sentry/kernel/signalfd.SignalOperations"
 }
 
-func (x *SignalOperations) StateFields() []string {
+func (s *SignalOperations) StateFields() []string {
 	return []string{
 		"target",
 		"mask",
 	}
 }
 
-func (x *SignalOperations) beforeSave() {}
+func (s *SignalOperations) beforeSave() {}
 
-func (x *SignalOperations) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.target)
-	m.Save(1, &x.mask)
+func (s *SignalOperations) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.target)
+	stateSinkObject.Save(1, &s.mask)
 }
 
-func (x *SignalOperations) afterLoad() {}
+func (s *SignalOperations) afterLoad() {}
 
-func (x *SignalOperations) StateLoad(m state.Source) {
-	m.Load(0, &x.target)
-	m.Load(1, &x.mask)
+func (s *SignalOperations) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.target)
+	stateSourceObject.Load(1, &s.mask)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/time/time_state_autogen.go b/pkg/sentry/kernel/time/time_state_autogen.go
index 4fb37df9a..1a30539f0 100644
--- a/pkg/sentry/kernel/time/time_state_autogen.go
+++ b/pkg/sentry/kernel/time/time_state_autogen.go
@@ -6,34 +6,34 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *Time) StateTypeName() string {
+func (t *Time) StateTypeName() string {
 	return "pkg/sentry/kernel/time.Time"
 }
 
-func (x *Time) StateFields() []string {
+func (t *Time) StateFields() []string {
 	return []string{
 		"ns",
 	}
 }
 
-func (x *Time) beforeSave() {}
+func (t *Time) beforeSave() {}
 
-func (x *Time) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ns)
+func (t *Time) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.ns)
 }
 
-func (x *Time) afterLoad() {}
+func (t *Time) afterLoad() {}
 
-func (x *Time) StateLoad(m state.Source) {
-	m.Load(0, &x.ns)
+func (t *Time) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.ns)
 }
 
-func (x *Setting) StateTypeName() string {
+func (s *Setting) StateTypeName() string {
 	return "pkg/sentry/kernel/time.Setting"
 }
 
-func (x *Setting) StateFields() []string {
+func (s *Setting) StateFields() []string {
 	return []string{
 		"Enabled",
 		"Next",
@@ -41,28 +41,28 @@ func (x *Setting) StateFields() []string {
 	}
 }
 
-func (x *Setting) beforeSave() {}
+func (s *Setting) beforeSave() {}
 
-func (x *Setting) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Enabled)
-	m.Save(1, &x.Next)
-	m.Save(2, &x.Period)
+func (s *Setting) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.Enabled)
+	stateSinkObject.Save(1, &s.Next)
+	stateSinkObject.Save(2, &s.Period)
 }
 
-func (x *Setting) afterLoad() {}
+func (s *Setting) afterLoad() {}
 
-func (x *Setting) StateLoad(m state.Source) {
-	m.Load(0, &x.Enabled)
-	m.Load(1, &x.Next)
-	m.Load(2, &x.Period)
+func (s *Setting) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.Enabled)
+	stateSourceObject.Load(1, &s.Next)
+	stateSourceObject.Load(2, &s.Period)
 }
 
-func (x *Timer) StateTypeName() string {
+func (t *Timer) StateTypeName() string {
 	return "pkg/sentry/kernel/time.Timer"
 }
 
-func (x *Timer) StateFields() []string {
+func (t *Timer) StateFields() []string {
 	return []string{
 		"clock",
 		"listener",
@@ -71,23 +71,23 @@ func (x *Timer) StateFields() []string {
 	}
 }
 
-func (x *Timer) beforeSave() {}
+func (t *Timer) beforeSave() {}
 
-func (x *Timer) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.clock)
-	m.Save(1, &x.listener)
-	m.Save(2, &x.setting)
-	m.Save(3, &x.paused)
+func (t *Timer) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.clock)
+	stateSinkObject.Save(1, &t.listener)
+	stateSinkObject.Save(2, &t.setting)
+	stateSinkObject.Save(3, &t.paused)
 }
 
-func (x *Timer) afterLoad() {}
+func (t *Timer) afterLoad() {}
 
-func (x *Timer) StateLoad(m state.Source) {
-	m.Load(0, &x.clock)
-	m.Load(1, &x.listener)
-	m.Load(2, &x.setting)
-	m.Load(3, &x.paused)
+func (t *Timer) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.clock)
+	stateSourceObject.Load(1, &t.listener)
+	stateSourceObject.Load(2, &t.setting)
+	stateSourceObject.Load(3, &t.paused)
 }
 
 func init() {