Merge release-20200928.0-66-ga55bd73d4 (automated)

15 files changed, 2752 insertions, 2752 deletions

diff --git a/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go
index 61e4f6fdf..d02c88a3b 100644
--- a/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go
+++ b/pkg/sentry/fsimpl/devpts/devpts_state_autogen.go
@@ -6,56 +6,56 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *rootInode) StateTypeName() string {
+func (r *rootInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.rootInode"
 }
 
-func (x *rootInode) StateFields() []string {
+func (r *rootInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"AlwaysValid",
@@ -73,67 +73,67 @@ func (x *rootInode) StateFields() []string {
 	}
 }
 
-func (x *rootInode) beforeSave() {}
-
-func (x *rootInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.AlwaysValid)
-	m.Save(2, &x.InodeAttrs)
-	m.Save(3, &x.InodeDirectoryNoNewChildren)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.rootInodeRefs)
-	m.Save(7, &x.locks)
-	m.Save(8, &x.dentry)
-	m.Save(9, &x.master)
-	m.Save(10, &x.root)
-	m.Save(11, &x.replicas)
-	m.Save(12, &x.nextIdx)
-}
-
-func (x *rootInode) afterLoad() {}
-
-func (x *rootInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.AlwaysValid)
-	m.Load(2, &x.InodeAttrs)
-	m.Load(3, &x.InodeDirectoryNoNewChildren)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.rootInodeRefs)
-	m.Load(7, &x.locks)
-	m.Load(8, &x.dentry)
-	m.Load(9, &x.master)
-	m.Load(10, &x.root)
-	m.Load(11, &x.replicas)
-	m.Load(12, &x.nextIdx)
-}
-
-func (x *implStatFS) StateTypeName() string {
+func (r *rootInode) beforeSave() {}
+
+func (r *rootInode) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.implStatFS)
+	stateSinkObject.Save(1, &r.AlwaysValid)
+	stateSinkObject.Save(2, &r.InodeAttrs)
+	stateSinkObject.Save(3, &r.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(4, &r.InodeNotSymlink)
+	stateSinkObject.Save(5, &r.OrderedChildren)
+	stateSinkObject.Save(6, &r.rootInodeRefs)
+	stateSinkObject.Save(7, &r.locks)
+	stateSinkObject.Save(8, &r.dentry)
+	stateSinkObject.Save(9, &r.master)
+	stateSinkObject.Save(10, &r.root)
+	stateSinkObject.Save(11, &r.replicas)
+	stateSinkObject.Save(12, &r.nextIdx)
+}
+
+func (r *rootInode) afterLoad() {}
+
+func (r *rootInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.implStatFS)
+	stateSourceObject.Load(1, &r.AlwaysValid)
+	stateSourceObject.Load(2, &r.InodeAttrs)
+	stateSourceObject.Load(3, &r.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(4, &r.InodeNotSymlink)
+	stateSourceObject.Load(5, &r.OrderedChildren)
+	stateSourceObject.Load(6, &r.rootInodeRefs)
+	stateSourceObject.Load(7, &r.locks)
+	stateSourceObject.Load(8, &r.dentry)
+	stateSourceObject.Load(9, &r.master)
+	stateSourceObject.Load(10, &r.root)
+	stateSourceObject.Load(11, &r.replicas)
+	stateSourceObject.Load(12, &r.nextIdx)
+}
+
+func (i *implStatFS) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.implStatFS"
 }
 
-func (x *implStatFS) StateFields() []string {
+func (i *implStatFS) StateFields() []string {
 	return []string{}
 }
 
-func (x *implStatFS) beforeSave() {}
+func (i *implStatFS) beforeSave() {}
 
-func (x *implStatFS) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *implStatFS) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *implStatFS) afterLoad() {}
+func (i *implStatFS) afterLoad() {}
 
-func (x *implStatFS) StateLoad(m state.Source) {
+func (i *implStatFS) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *lineDiscipline) StateTypeName() string {
+func (l *lineDiscipline) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.lineDiscipline"
 }
 
-func (x *lineDiscipline) StateFields() []string {
+func (l *lineDiscipline) StateFields() []string {
 	return []string{
 		"size",
 		"inQueue",
@@ -143,76 +143,76 @@ func (x *lineDiscipline) StateFields() []string {
 	}
 }
 
-func (x *lineDiscipline) beforeSave() {}
+func (l *lineDiscipline) beforeSave() {}
 
-func (x *lineDiscipline) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.masterWaiter) {
-		state.Failf("masterWaiter is %#v, expected zero", &x.masterWaiter)
+func (l *lineDiscipline) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	if !state.IsZeroValue(&l.masterWaiter) {
+		state.Failf("masterWaiter is %#v, expected zero", &l.masterWaiter)
 	}
-	if !state.IsZeroValue(&x.replicaWaiter) {
-		state.Failf("replicaWaiter is %#v, expected zero", &x.replicaWaiter)
+	if !state.IsZeroValue(&l.replicaWaiter) {
+		state.Failf("replicaWaiter is %#v, expected zero", &l.replicaWaiter)
 	}
-	m.Save(0, &x.size)
-	m.Save(1, &x.inQueue)
-	m.Save(2, &x.outQueue)
-	m.Save(3, &x.termios)
-	m.Save(4, &x.column)
+	stateSinkObject.Save(0, &l.size)
+	stateSinkObject.Save(1, &l.inQueue)
+	stateSinkObject.Save(2, &l.outQueue)
+	stateSinkObject.Save(3, &l.termios)
+	stateSinkObject.Save(4, &l.column)
 }
 
-func (x *lineDiscipline) afterLoad() {}
+func (l *lineDiscipline) afterLoad() {}
 
-func (x *lineDiscipline) StateLoad(m state.Source) {
-	m.Load(0, &x.size)
-	m.Load(1, &x.inQueue)
-	m.Load(2, &x.outQueue)
-	m.Load(3, &x.termios)
-	m.Load(4, &x.column)
+func (l *lineDiscipline) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.size)
+	stateSourceObject.Load(1, &l.inQueue)
+	stateSourceObject.Load(2, &l.outQueue)
+	stateSourceObject.Load(3, &l.termios)
+	stateSourceObject.Load(4, &l.column)
 }
 
-func (x *outputQueueTransformer) StateTypeName() string {
+func (o *outputQueueTransformer) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.outputQueueTransformer"
 }
 
-func (x *outputQueueTransformer) StateFields() []string {
+func (o *outputQueueTransformer) StateFields() []string {
 	return []string{}
 }
 
-func (x *outputQueueTransformer) beforeSave() {}
+func (o *outputQueueTransformer) beforeSave() {}
 
-func (x *outputQueueTransformer) StateSave(m state.Sink) {
-	x.beforeSave()
+func (o *outputQueueTransformer) StateSave(stateSinkObject state.Sink) {
+	o.beforeSave()
 }
 
-func (x *outputQueueTransformer) afterLoad() {}
+func (o *outputQueueTransformer) afterLoad() {}
 
-func (x *outputQueueTransformer) StateLoad(m state.Source) {
+func (o *outputQueueTransformer) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *inputQueueTransformer) StateTypeName() string {
+func (i *inputQueueTransformer) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.inputQueueTransformer"
 }
 
-func (x *inputQueueTransformer) StateFields() []string {
+func (i *inputQueueTransformer) StateFields() []string {
 	return []string{}
 }
 
-func (x *inputQueueTransformer) beforeSave() {}
+func (i *inputQueueTransformer) beforeSave() {}
 
-func (x *inputQueueTransformer) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *inputQueueTransformer) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *inputQueueTransformer) afterLoad() {}
+func (i *inputQueueTransformer) afterLoad() {}
 
-func (x *inputQueueTransformer) StateLoad(m state.Source) {
+func (i *inputQueueTransformer) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *masterInode) StateTypeName() string {
+func (m *masterInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.masterInode"
 }
 
-func (x *masterInode) StateFields() []string {
+func (m *masterInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -225,38 +225,38 @@ func (x *masterInode) StateFields() []string {
 	}
 }
 
-func (x *masterInode) beforeSave() {}
+func (m *masterInode) beforeSave() {}
 
-func (x *masterInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeNotDirectory)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.locks)
-	m.Save(6, &x.dentry)
-	m.Save(7, &x.root)
+func (m *masterInode) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.implStatFS)
+	stateSinkObject.Save(1, &m.InodeAttrs)
+	stateSinkObject.Save(2, &m.InodeNoopRefCount)
+	stateSinkObject.Save(3, &m.InodeNotDirectory)
+	stateSinkObject.Save(4, &m.InodeNotSymlink)
+	stateSinkObject.Save(5, &m.locks)
+	stateSinkObject.Save(6, &m.dentry)
+	stateSinkObject.Save(7, &m.root)
 }
 
-func (x *masterInode) afterLoad() {}
+func (m *masterInode) afterLoad() {}
 
-func (x *masterInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeNotDirectory)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.locks)
-	m.Load(6, &x.dentry)
-	m.Load(7, &x.root)
+func (m *masterInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.implStatFS)
+	stateSourceObject.Load(1, &m.InodeAttrs)
+	stateSourceObject.Load(2, &m.InodeNoopRefCount)
+	stateSourceObject.Load(3, &m.InodeNotDirectory)
+	stateSourceObject.Load(4, &m.InodeNotSymlink)
+	stateSourceObject.Load(5, &m.locks)
+	stateSourceObject.Load(6, &m.dentry)
+	stateSourceObject.Load(7, &m.root)
 }
 
-func (x *masterFileDescription) StateTypeName() string {
+func (m *masterFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.masterFileDescription"
 }
 
-func (x *masterFileDescription) StateFields() []string {
+func (m *masterFileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -266,32 +266,32 @@ func (x *masterFileDescription) StateFields() []string {
 	}
 }
 
-func (x *masterFileDescription) beforeSave() {}
+func (m *masterFileDescription) beforeSave() {}
 
-func (x *masterFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
-	m.Save(3, &x.inode)
-	m.Save(4, &x.t)
+func (m *masterFileDescription) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.vfsfd)
+	stateSinkObject.Save(1, &m.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &m.LockFD)
+	stateSinkObject.Save(3, &m.inode)
+	stateSinkObject.Save(4, &m.t)
 }
 
-func (x *masterFileDescription) afterLoad() {}
+func (m *masterFileDescription) afterLoad() {}
 
-func (x *masterFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
-	m.Load(3, &x.inode)
-	m.Load(4, &x.t)
+func (m *masterFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.vfsfd)
+	stateSourceObject.Load(1, &m.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &m.LockFD)
+	stateSourceObject.Load(3, &m.inode)
+	stateSourceObject.Load(4, &m.t)
 }
 
-func (x *queue) StateTypeName() string {
+func (q *queue) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.queue"
 }
 
-func (x *queue) StateFields() []string {
+func (q *queue) StateFields() []string {
 	return []string{
 		"readBuf",
 		"waitBuf",
@@ -301,32 +301,32 @@ func (x *queue) StateFields() []string {
 	}
 }
 
-func (x *queue) beforeSave() {}
+func (q *queue) beforeSave() {}
 
-func (x *queue) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.readBuf)
-	m.Save(1, &x.waitBuf)
-	m.Save(2, &x.waitBufLen)
-	m.Save(3, &x.readable)
-	m.Save(4, &x.transformer)
+func (q *queue) StateSave(stateSinkObject state.Sink) {
+	q.beforeSave()
+	stateSinkObject.Save(0, &q.readBuf)
+	stateSinkObject.Save(1, &q.waitBuf)
+	stateSinkObject.Save(2, &q.waitBufLen)
+	stateSinkObject.Save(3, &q.readable)
+	stateSinkObject.Save(4, &q.transformer)
 }
 
-func (x *queue) afterLoad() {}
+func (q *queue) afterLoad() {}
 
-func (x *queue) StateLoad(m state.Source) {
-	m.Load(0, &x.readBuf)
-	m.Load(1, &x.waitBuf)
-	m.Load(2, &x.waitBufLen)
-	m.Load(3, &x.readable)
-	m.Load(4, &x.transformer)
+func (q *queue) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &q.readBuf)
+	stateSourceObject.Load(1, &q.waitBuf)
+	stateSourceObject.Load(2, &q.waitBufLen)
+	stateSourceObject.Load(3, &q.readable)
+	stateSourceObject.Load(4, &q.transformer)
 }
 
-func (x *replicaInode) StateTypeName() string {
+func (r *replicaInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.replicaInode"
 }
 
-func (x *replicaInode) StateFields() []string {
+func (r *replicaInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -340,40 +340,40 @@ func (x *replicaInode) StateFields() []string {
 	}
 }
 
-func (x *replicaInode) beforeSave() {}
+func (r *replicaInode) beforeSave() {}
 
-func (x *replicaInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeNotDirectory)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.locks)
-	m.Save(6, &x.dentry)
-	m.Save(7, &x.root)
-	m.Save(8, &x.t)
+func (r *replicaInode) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.implStatFS)
+	stateSinkObject.Save(1, &r.InodeAttrs)
+	stateSinkObject.Save(2, &r.InodeNoopRefCount)
+	stateSinkObject.Save(3, &r.InodeNotDirectory)
+	stateSinkObject.Save(4, &r.InodeNotSymlink)
+	stateSinkObject.Save(5, &r.locks)
+	stateSinkObject.Save(6, &r.dentry)
+	stateSinkObject.Save(7, &r.root)
+	stateSinkObject.Save(8, &r.t)
 }
 
-func (x *replicaInode) afterLoad() {}
+func (r *replicaInode) afterLoad() {}
 
-func (x *replicaInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeNotDirectory)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.locks)
-	m.Load(6, &x.dentry)
-	m.Load(7, &x.root)
-	m.Load(8, &x.t)
+func (r *replicaInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.implStatFS)
+	stateSourceObject.Load(1, &r.InodeAttrs)
+	stateSourceObject.Load(2, &r.InodeNoopRefCount)
+	stateSourceObject.Load(3, &r.InodeNotDirectory)
+	stateSourceObject.Load(4, &r.InodeNotSymlink)
+	stateSourceObject.Load(5, &r.locks)
+	stateSourceObject.Load(6, &r.dentry)
+	stateSourceObject.Load(7, &r.root)
+	stateSourceObject.Load(8, &r.t)
 }
 
-func (x *replicaFileDescription) StateTypeName() string {
+func (r *replicaFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.replicaFileDescription"
 }
 
-func (x *replicaFileDescription) StateFields() []string {
+func (r *replicaFileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -382,53 +382,53 @@ func (x *replicaFileDescription) StateFields() []string {
 	}
 }
 
-func (x *replicaFileDescription) beforeSave() {}
+func (r *replicaFileDescription) beforeSave() {}
 
-func (x *replicaFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
-	m.Save(3, &x.inode)
+func (r *replicaFileDescription) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.vfsfd)
+	stateSinkObject.Save(1, &r.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &r.LockFD)
+	stateSinkObject.Save(3, &r.inode)
 }
 
-func (x *replicaFileDescription) afterLoad() {}
+func (r *replicaFileDescription) afterLoad() {}
 
-func (x *replicaFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
-	m.Load(3, &x.inode)
+func (r *replicaFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.vfsfd)
+	stateSourceObject.Load(1, &r.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &r.LockFD)
+	stateSourceObject.Load(3, &r.inode)
 }
 
-func (x *rootInodeRefs) StateTypeName() string {
+func (r *rootInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.rootInodeRefs"
 }
 
-func (x *rootInodeRefs) StateFields() []string {
+func (r *rootInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *rootInodeRefs) beforeSave() {}
+func (r *rootInodeRefs) beforeSave() {}
 
-func (x *rootInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (r *rootInodeRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (x *rootInodeRefs) afterLoad() {}
+func (r *rootInodeRefs) afterLoad() {}
 
-func (x *rootInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (r *rootInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
-func (x *Terminal) StateTypeName() string {
+func (t *Terminal) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devpts.Terminal"
 }
 
-func (x *Terminal) StateFields() []string {
+func (t *Terminal) StateFields() []string {
 	return []string{
 		"n",
 		"ld",
@@ -437,23 +437,23 @@ func (x *Terminal) StateFields() []string {
 	}
 }
 
-func (x *Terminal) beforeSave() {}
+func (t *Terminal) beforeSave() {}
 
-func (x *Terminal) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.n)
-	m.Save(1, &x.ld)
-	m.Save(2, &x.masterKTTY)
-	m.Save(3, &x.replicaKTTY)
+func (t *Terminal) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.n)
+	stateSinkObject.Save(1, &t.ld)
+	stateSinkObject.Save(2, &t.masterKTTY)
+	stateSinkObject.Save(3, &t.replicaKTTY)
 }
 
-func (x *Terminal) afterLoad() {}
+func (t *Terminal) afterLoad() {}
 
-func (x *Terminal) StateLoad(m state.Source) {
-	m.Load(0, &x.n)
-	m.Load(1, &x.ld)
-	m.Load(2, &x.masterKTTY)
-	m.Load(3, &x.replicaKTTY)
+func (t *Terminal) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.n)
+	stateSourceObject.Load(1, &t.ld)
+	stateSourceObject.Load(2, &t.masterKTTY)
+	stateSourceObject.Load(3, &t.replicaKTTY)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go b/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go
index 1253bed4e..b9885df45 100644
--- a/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go
+++ b/pkg/sentry/fsimpl/devtmpfs/devtmpfs_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/devtmpfs.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{
 		"initErr",
 		"fs",
@@ -18,21 +18,21 @@ func (x *FilesystemType) StateFields() []string {
 	}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.initErr)
-	m.Save(1, &x.fs)
-	m.Save(2, &x.root)
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.initErr)
+	stateSinkObject.Save(1, &f.fs)
+	stateSinkObject.Save(2, &f.root)
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
-	m.Load(0, &x.initErr)
-	m.Load(1, &x.fs)
-	m.Load(2, &x.root)
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.initErr)
+	stateSourceObject.Load(1, &f.fs)
+	stateSourceObject.Load(2, &f.root)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go b/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go
index 0507be064..3de6bc3bb 100644
--- a/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go
+++ b/pkg/sentry/fsimpl/eventfd/eventfd_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *EventFileDescription) StateTypeName() string {
+func (e *EventFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/eventfd.EventFileDescription"
 }
 
-func (x *EventFileDescription) StateFields() []string {
+func (e *EventFileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -22,32 +22,32 @@ func (x *EventFileDescription) StateFields() []string {
 	}
 }
 
-func (x *EventFileDescription) beforeSave() {}
+func (e *EventFileDescription) beforeSave() {}
 
-func (x *EventFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	if !state.IsZeroValue(&x.queue) {
-		state.Failf("queue is %#v, expected zero", &x.queue)
+func (e *EventFileDescription) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	if !state.IsZeroValue(&e.queue) {
+		state.Failf("queue is %#v, expected zero", &e.queue)
 	}
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.NoLockFD)
-	m.Save(4, &x.val)
-	m.Save(5, &x.semMode)
-	m.Save(6, &x.hostfd)
+	stateSinkObject.Save(0, &e.vfsfd)
+	stateSinkObject.Save(1, &e.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &e.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &e.NoLockFD)
+	stateSinkObject.Save(4, &e.val)
+	stateSinkObject.Save(5, &e.semMode)
+	stateSinkObject.Save(6, &e.hostfd)
 }
 
-func (x *EventFileDescription) afterLoad() {}
+func (e *EventFileDescription) afterLoad() {}
 
-func (x *EventFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.NoLockFD)
-	m.Load(4, &x.val)
-	m.Load(5, &x.semMode)
-	m.Load(6, &x.hostfd)
+func (e *EventFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.vfsfd)
+	stateSourceObject.Load(1, &e.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &e.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &e.NoLockFD)
+	stateSourceObject.Load(4, &e.val)
+	stateSourceObject.Load(5, &e.semMode)
+	stateSourceObject.Load(6, &e.hostfd)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
index b127b2015..fc0da410c 100644
--- a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
+++ b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *connection) StateTypeName() string {
+func (c *connection) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.connection"
 }
 
-func (x *connection) StateFields() []string {
+func (c *connection) StateFields() []string {
 	return []string{
 		"fd",
 		"attributeVersion",
@@ -37,86 +37,86 @@ func (x *connection) StateFields() []string {
 	}
 }
 
-func (x *connection) beforeSave() {}
-
-func (x *connection) StateSave(m state.Sink) {
-	x.beforeSave()
-	var initializedChan bool = x.saveInitializedChan()
-	m.SaveValue(3, initializedChan)
-	m.Save(0, &x.fd)
-	m.Save(1, &x.attributeVersion)
-	m.Save(2, &x.initialized)
-	m.Save(4, &x.connected)
-	m.Save(5, &x.connInitError)
-	m.Save(6, &x.connInitSuccess)
-	m.Save(7, &x.aborted)
-	m.Save(8, &x.numWaiting)
-	m.Save(9, &x.asyncNum)
-	m.Save(10, &x.asyncCongestionThreshold)
-	m.Save(11, &x.asyncNumMax)
-	m.Save(12, &x.maxRead)
-	m.Save(13, &x.maxWrite)
-	m.Save(14, &x.maxPages)
-	m.Save(15, &x.minor)
-	m.Save(16, &x.atomicOTrunc)
-	m.Save(17, &x.asyncRead)
-	m.Save(18, &x.writebackCache)
-	m.Save(19, &x.bigWrites)
-	m.Save(20, &x.dontMask)
-	m.Save(21, &x.noOpen)
-}
-
-func (x *connection) afterLoad() {}
-
-func (x *connection) StateLoad(m state.Source) {
-	m.Load(0, &x.fd)
-	m.Load(1, &x.attributeVersion)
-	m.Load(2, &x.initialized)
-	m.Load(4, &x.connected)
-	m.Load(5, &x.connInitError)
-	m.Load(6, &x.connInitSuccess)
-	m.Load(7, &x.aborted)
-	m.Load(8, &x.numWaiting)
-	m.Load(9, &x.asyncNum)
-	m.Load(10, &x.asyncCongestionThreshold)
-	m.Load(11, &x.asyncNumMax)
-	m.Load(12, &x.maxRead)
-	m.Load(13, &x.maxWrite)
-	m.Load(14, &x.maxPages)
-	m.Load(15, &x.minor)
-	m.Load(16, &x.atomicOTrunc)
-	m.Load(17, &x.asyncRead)
-	m.Load(18, &x.writebackCache)
-	m.Load(19, &x.bigWrites)
-	m.Load(20, &x.dontMask)
-	m.Load(21, &x.noOpen)
-	m.LoadValue(3, new(bool), func(y interface{}) { x.loadInitializedChan(y.(bool)) })
-}
-
-func (x *fuseDevice) StateTypeName() string {
+func (c *connection) beforeSave() {}
+
+func (c *connection) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	var initializedChanValue bool = c.saveInitializedChan()
+	stateSinkObject.SaveValue(3, initializedChanValue)
+	stateSinkObject.Save(0, &c.fd)
+	stateSinkObject.Save(1, &c.attributeVersion)
+	stateSinkObject.Save(2, &c.initialized)
+	stateSinkObject.Save(4, &c.connected)
+	stateSinkObject.Save(5, &c.connInitError)
+	stateSinkObject.Save(6, &c.connInitSuccess)
+	stateSinkObject.Save(7, &c.aborted)
+	stateSinkObject.Save(8, &c.numWaiting)
+	stateSinkObject.Save(9, &c.asyncNum)
+	stateSinkObject.Save(10, &c.asyncCongestionThreshold)
+	stateSinkObject.Save(11, &c.asyncNumMax)
+	stateSinkObject.Save(12, &c.maxRead)
+	stateSinkObject.Save(13, &c.maxWrite)
+	stateSinkObject.Save(14, &c.maxPages)
+	stateSinkObject.Save(15, &c.minor)
+	stateSinkObject.Save(16, &c.atomicOTrunc)
+	stateSinkObject.Save(17, &c.asyncRead)
+	stateSinkObject.Save(18, &c.writebackCache)
+	stateSinkObject.Save(19, &c.bigWrites)
+	stateSinkObject.Save(20, &c.dontMask)
+	stateSinkObject.Save(21, &c.noOpen)
+}
+
+func (c *connection) afterLoad() {}
+
+func (c *connection) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.fd)
+	stateSourceObject.Load(1, &c.attributeVersion)
+	stateSourceObject.Load(2, &c.initialized)
+	stateSourceObject.Load(4, &c.connected)
+	stateSourceObject.Load(5, &c.connInitError)
+	stateSourceObject.Load(6, &c.connInitSuccess)
+	stateSourceObject.Load(7, &c.aborted)
+	stateSourceObject.Load(8, &c.numWaiting)
+	stateSourceObject.Load(9, &c.asyncNum)
+	stateSourceObject.Load(10, &c.asyncCongestionThreshold)
+	stateSourceObject.Load(11, &c.asyncNumMax)
+	stateSourceObject.Load(12, &c.maxRead)
+	stateSourceObject.Load(13, &c.maxWrite)
+	stateSourceObject.Load(14, &c.maxPages)
+	stateSourceObject.Load(15, &c.minor)
+	stateSourceObject.Load(16, &c.atomicOTrunc)
+	stateSourceObject.Load(17, &c.asyncRead)
+	stateSourceObject.Load(18, &c.writebackCache)
+	stateSourceObject.Load(19, &c.bigWrites)
+	stateSourceObject.Load(20, &c.dontMask)
+	stateSourceObject.Load(21, &c.noOpen)
+	stateSourceObject.LoadValue(3, new(bool), func(y interface{}) { c.loadInitializedChan(y.(bool)) })
+}
+
+func (f *fuseDevice) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.fuseDevice"
 }
 
-func (x *fuseDevice) StateFields() []string {
+func (f *fuseDevice) StateFields() []string {
 	return []string{}
 }
 
-func (x *fuseDevice) beforeSave() {}
+func (f *fuseDevice) beforeSave() {}
 
-func (x *fuseDevice) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *fuseDevice) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *fuseDevice) afterLoad() {}
+func (f *fuseDevice) afterLoad() {}
 
-func (x *fuseDevice) StateLoad(m state.Source) {
+func (f *fuseDevice) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *DeviceFD) StateTypeName() string {
+func (d *DeviceFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.DeviceFD"
 }
 
-func (x *DeviceFD) StateFields() []string {
+func (d *DeviceFD) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -135,70 +135,70 @@ func (x *DeviceFD) StateFields() []string {
 	}
 }
 
-func (x *DeviceFD) beforeSave() {}
-
-func (x *DeviceFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	var fullQueueCh int = x.saveFullQueueCh()
-	m.SaveValue(12, fullQueueCh)
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.NoLockFD)
-	m.Save(4, &x.nextOpID)
-	m.Save(5, &x.queue)
-	m.Save(6, &x.numActiveRequests)
-	m.Save(7, &x.completions)
-	m.Save(8, &x.writeCursor)
-	m.Save(9, &x.writeBuf)
-	m.Save(10, &x.writeCursorFR)
-	m.Save(11, &x.waitQueue)
-	m.Save(13, &x.fs)
-}
-
-func (x *DeviceFD) afterLoad() {}
-
-func (x *DeviceFD) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.NoLockFD)
-	m.Load(4, &x.nextOpID)
-	m.Load(5, &x.queue)
-	m.Load(6, &x.numActiveRequests)
-	m.Load(7, &x.completions)
-	m.Load(8, &x.writeCursor)
-	m.Load(9, &x.writeBuf)
-	m.Load(10, &x.writeCursorFR)
-	m.Load(11, &x.waitQueue)
-	m.Load(13, &x.fs)
-	m.LoadValue(12, new(int), func(y interface{}) { x.loadFullQueueCh(y.(int)) })
-}
-
-func (x *FilesystemType) StateTypeName() string {
+func (d *DeviceFD) beforeSave() {}
+
+func (d *DeviceFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	var fullQueueChValue int = d.saveFullQueueCh()
+	stateSinkObject.SaveValue(12, fullQueueChValue)
+	stateSinkObject.Save(0, &d.vfsfd)
+	stateSinkObject.Save(1, &d.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &d.NoLockFD)
+	stateSinkObject.Save(4, &d.nextOpID)
+	stateSinkObject.Save(5, &d.queue)
+	stateSinkObject.Save(6, &d.numActiveRequests)
+	stateSinkObject.Save(7, &d.completions)
+	stateSinkObject.Save(8, &d.writeCursor)
+	stateSinkObject.Save(9, &d.writeBuf)
+	stateSinkObject.Save(10, &d.writeCursorFR)
+	stateSinkObject.Save(11, &d.waitQueue)
+	stateSinkObject.Save(13, &d.fs)
+}
+
+func (d *DeviceFD) afterLoad() {}
+
+func (d *DeviceFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsfd)
+	stateSourceObject.Load(1, &d.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &d.NoLockFD)
+	stateSourceObject.Load(4, &d.nextOpID)
+	stateSourceObject.Load(5, &d.queue)
+	stateSourceObject.Load(6, &d.numActiveRequests)
+	stateSourceObject.Load(7, &d.completions)
+	stateSourceObject.Load(8, &d.writeCursor)
+	stateSourceObject.Load(9, &d.writeBuf)
+	stateSourceObject.Load(10, &d.writeCursorFR)
+	stateSourceObject.Load(11, &d.waitQueue)
+	stateSourceObject.Load(13, &d.fs)
+	stateSourceObject.LoadValue(12, new(int), func(y interface{}) { d.loadFullQueueCh(y.(int)) })
+}
+
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystemOptions) StateTypeName() string {
+func (f *filesystemOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.filesystemOptions"
 }
 
-func (x *filesystemOptions) StateFields() []string {
+func (f *filesystemOptions) StateFields() []string {
 	return []string{
 		"userID",
 		"groupID",
@@ -208,32 +208,32 @@ func (x *filesystemOptions) StateFields() []string {
 	}
 }
 
-func (x *filesystemOptions) beforeSave() {}
+func (f *filesystemOptions) beforeSave() {}
 
-func (x *filesystemOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.userID)
-	m.Save(1, &x.groupID)
-	m.Save(2, &x.rootMode)
-	m.Save(3, &x.maxActiveRequests)
-	m.Save(4, &x.maxRead)
+func (f *filesystemOptions) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.userID)
+	stateSinkObject.Save(1, &f.groupID)
+	stateSinkObject.Save(2, &f.rootMode)
+	stateSinkObject.Save(3, &f.maxActiveRequests)
+	stateSinkObject.Save(4, &f.maxRead)
 }
 
-func (x *filesystemOptions) afterLoad() {}
+func (f *filesystemOptions) afterLoad() {}
 
-func (x *filesystemOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.userID)
-	m.Load(1, &x.groupID)
-	m.Load(2, &x.rootMode)
-	m.Load(3, &x.maxActiveRequests)
-	m.Load(4, &x.maxRead)
+func (f *filesystemOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.userID)
+	stateSourceObject.Load(1, &f.groupID)
+	stateSourceObject.Load(2, &f.rootMode)
+	stateSourceObject.Load(3, &f.maxActiveRequests)
+	stateSourceObject.Load(4, &f.maxRead)
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
@@ -243,32 +243,32 @@ func (x *filesystem) StateFields() []string {
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
-	m.Save(2, &x.conn)
-	m.Save(3, &x.opts)
-	m.Save(4, &x.umounted)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
+	stateSinkObject.Save(2, &f.conn)
+	stateSinkObject.Save(3, &f.opts)
+	stateSinkObject.Save(4, &f.umounted)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
-	m.Load(2, &x.conn)
-	m.Load(3, &x.opts)
-	m.Load(4, &x.umounted)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
+	stateSourceObject.Load(2, &f.conn)
+	stateSourceObject.Load(3, &f.opts)
+	stateSourceObject.Load(4, &f.umounted)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"inodeRefs",
 		"InodeAttrs",
@@ -289,129 +289,129 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
-
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inodeRefs)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeDirectoryNoNewChildren)
-	m.Save(3, &x.InodeNoDynamicLookup)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.dentry)
-	m.Save(7, &x.fs)
-	m.Save(8, &x.metadataMu)
-	m.Save(9, &x.nodeID)
-	m.Save(10, &x.locks)
-	m.Save(11, &x.size)
-	m.Save(12, &x.attributeVersion)
-	m.Save(13, &x.attributeTime)
-	m.Save(14, &x.version)
-	m.Save(15, &x.link)
-}
-
-func (x *inode) afterLoad() {}
-
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.inodeRefs)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeDirectoryNoNewChildren)
-	m.Load(3, &x.InodeNoDynamicLookup)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.dentry)
-	m.Load(7, &x.fs)
-	m.Load(8, &x.metadataMu)
-	m.Load(9, &x.nodeID)
-	m.Load(10, &x.locks)
-	m.Load(11, &x.size)
-	m.Load(12, &x.attributeVersion)
-	m.Load(13, &x.attributeTime)
-	m.Load(14, &x.version)
-	m.Load(15, &x.link)
-}
-
-func (x *inodeRefs) StateTypeName() string {
+func (i *inode) beforeSave() {}
+
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.inodeRefs)
+	stateSinkObject.Save(1, &i.InodeAttrs)
+	stateSinkObject.Save(2, &i.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(3, &i.InodeNoDynamicLookup)
+	stateSinkObject.Save(4, &i.InodeNotSymlink)
+	stateSinkObject.Save(5, &i.OrderedChildren)
+	stateSinkObject.Save(6, &i.dentry)
+	stateSinkObject.Save(7, &i.fs)
+	stateSinkObject.Save(8, &i.metadataMu)
+	stateSinkObject.Save(9, &i.nodeID)
+	stateSinkObject.Save(10, &i.locks)
+	stateSinkObject.Save(11, &i.size)
+	stateSinkObject.Save(12, &i.attributeVersion)
+	stateSinkObject.Save(13, &i.attributeTime)
+	stateSinkObject.Save(14, &i.version)
+	stateSinkObject.Save(15, &i.link)
+}
+
+func (i *inode) afterLoad() {}
+
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.inodeRefs)
+	stateSourceObject.Load(1, &i.InodeAttrs)
+	stateSourceObject.Load(2, &i.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(3, &i.InodeNoDynamicLookup)
+	stateSourceObject.Load(4, &i.InodeNotSymlink)
+	stateSourceObject.Load(5, &i.OrderedChildren)
+	stateSourceObject.Load(6, &i.dentry)
+	stateSourceObject.Load(7, &i.fs)
+	stateSourceObject.Load(8, &i.metadataMu)
+	stateSourceObject.Load(9, &i.nodeID)
+	stateSourceObject.Load(10, &i.locks)
+	stateSourceObject.Load(11, &i.size)
+	stateSourceObject.Load(12, &i.attributeVersion)
+	stateSourceObject.Load(13, &i.attributeTime)
+	stateSourceObject.Load(14, &i.version)
+	stateSourceObject.Load(15, &i.link)
+}
+
+func (i *inodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.inodeRefs"
 }
 
-func (x *inodeRefs) StateFields() []string {
+func (i *inodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *inodeRefs) beforeSave() {}
+func (i *inodeRefs) beforeSave() {}
 
-func (x *inodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (i *inodeRefs) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.refCount)
 }
 
-func (x *inodeRefs) afterLoad() {}
+func (i *inodeRefs) afterLoad() {}
 
-func (x *inodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (i *inodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.refCount)
 }
 
-func (x *requestList) StateTypeName() string {
+func (r *requestList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestList"
 }
 
-func (x *requestList) StateFields() []string {
+func (r *requestList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *requestList) beforeSave() {}
+func (r *requestList) beforeSave() {}
 
-func (x *requestList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (r *requestList) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.head)
+	stateSinkObject.Save(1, &r.tail)
 }
 
-func (x *requestList) afterLoad() {}
+func (r *requestList) afterLoad() {}
 
-func (x *requestList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (r *requestList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.head)
+	stateSourceObject.Load(1, &r.tail)
 }
 
-func (x *requestEntry) StateTypeName() string {
+func (r *requestEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestEntry"
 }
 
-func (x *requestEntry) StateFields() []string {
+func (r *requestEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *requestEntry) beforeSave() {}
+func (r *requestEntry) beforeSave() {}
 
-func (x *requestEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (r *requestEntry) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.next)
+	stateSinkObject.Save(1, &r.prev)
 }
 
-func (x *requestEntry) afterLoad() {}
+func (r *requestEntry) afterLoad() {}
 
-func (x *requestEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (r *requestEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.next)
+	stateSourceObject.Load(1, &r.prev)
 }
 
-func (x *Request) StateTypeName() string {
+func (r *Request) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.Request"
 }
 
-func (x *Request) StateFields() []string {
+func (r *Request) StateFields() []string {
 	return []string{
 		"requestEntry",
 		"id",
@@ -423,36 +423,36 @@ func (x *Request) StateFields() []string {
 	}
 }
 
-func (x *Request) beforeSave() {}
+func (r *Request) beforeSave() {}
 
-func (x *Request) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.requestEntry)
-	m.Save(1, &x.id)
-	m.Save(2, &x.hdr)
-	m.Save(3, &x.data)
-	m.Save(4, &x.payload)
-	m.Save(5, &x.async)
-	m.Save(6, &x.noReply)
+func (r *Request) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.requestEntry)
+	stateSinkObject.Save(1, &r.id)
+	stateSinkObject.Save(2, &r.hdr)
+	stateSinkObject.Save(3, &r.data)
+	stateSinkObject.Save(4, &r.payload)
+	stateSinkObject.Save(5, &r.async)
+	stateSinkObject.Save(6, &r.noReply)
 }
 
-func (x *Request) afterLoad() {}
+func (r *Request) afterLoad() {}
 
-func (x *Request) StateLoad(m state.Source) {
-	m.Load(0, &x.requestEntry)
-	m.Load(1, &x.id)
-	m.Load(2, &x.hdr)
-	m.Load(3, &x.data)
-	m.Load(4, &x.payload)
-	m.Load(5, &x.async)
-	m.Load(6, &x.noReply)
+func (r *Request) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.requestEntry)
+	stateSourceObject.Load(1, &r.id)
+	stateSourceObject.Load(2, &r.hdr)
+	stateSourceObject.Load(3, &r.data)
+	stateSourceObject.Load(4, &r.payload)
+	stateSourceObject.Load(5, &r.async)
+	stateSourceObject.Load(6, &r.noReply)
 }
 
-func (x *futureResponse) StateTypeName() string {
+func (f *futureResponse) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.futureResponse"
 }
 
-func (x *futureResponse) StateFields() []string {
+func (f *futureResponse) StateFields() []string {
 	return []string{
 		"opcode",
 		"ch",
@@ -462,32 +462,32 @@ func (x *futureResponse) StateFields() []string {
 	}
 }
 
-func (x *futureResponse) beforeSave() {}
+func (f *futureResponse) beforeSave() {}
 
-func (x *futureResponse) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.opcode)
-	m.Save(1, &x.ch)
-	m.Save(2, &x.hdr)
-	m.Save(3, &x.data)
-	m.Save(4, &x.async)
+func (f *futureResponse) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.opcode)
+	stateSinkObject.Save(1, &f.ch)
+	stateSinkObject.Save(2, &f.hdr)
+	stateSinkObject.Save(3, &f.data)
+	stateSinkObject.Save(4, &f.async)
 }
 
-func (x *futureResponse) afterLoad() {}
+func (f *futureResponse) afterLoad() {}
 
-func (x *futureResponse) StateLoad(m state.Source) {
-	m.Load(0, &x.opcode)
-	m.Load(1, &x.ch)
-	m.Load(2, &x.hdr)
-	m.Load(3, &x.data)
-	m.Load(4, &x.async)
+func (f *futureResponse) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.opcode)
+	stateSourceObject.Load(1, &f.ch)
+	stateSourceObject.Load(2, &f.hdr)
+	stateSourceObject.Load(3, &f.data)
+	stateSourceObject.Load(4, &f.async)
 }
 
-func (x *Response) StateTypeName() string {
+func (r *Response) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.Response"
 }
 
-func (x *Response) StateFields() []string {
+func (r *Response) StateFields() []string {
 	return []string{
 		"opcode",
 		"hdr",
@@ -495,21 +495,21 @@ func (x *Response) StateFields() []string {
 	}
 }
 
-func (x *Response) beforeSave() {}
+func (r *Response) beforeSave() {}
 
-func (x *Response) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.opcode)
-	m.Save(1, &x.hdr)
-	m.Save(2, &x.data)
+func (r *Response) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.opcode)
+	stateSinkObject.Save(1, &r.hdr)
+	stateSinkObject.Save(2, &r.data)
 }
 
-func (x *Response) afterLoad() {}
+func (r *Response) afterLoad() {}
 
-func (x *Response) StateLoad(m state.Source) {
-	m.Load(0, &x.opcode)
-	m.Load(1, &x.hdr)
-	m.Load(2, &x.data)
+func (r *Response) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.opcode)
+	stateSourceObject.Load(1, &r.hdr)
+	stateSourceObject.Load(2, &r.data)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go b/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go
index 7831e1830..1316e29e5 100644
--- a/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go
+++ b/pkg/sentry/fsimpl/gofer/gofer_state_autogen.go
@@ -6,63 +6,63 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *dentryList) StateTypeName() string {
+func (d *dentryList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.dentryList"
 }
 
-func (x *dentryList) StateFields() []string {
+func (d *dentryList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *dentryList) beforeSave() {}
+func (d *dentryList) beforeSave() {}
 
-func (x *dentryList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (d *dentryList) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.head)
+	stateSinkObject.Save(1, &d.tail)
 }
 
-func (x *dentryList) afterLoad() {}
+func (d *dentryList) afterLoad() {}
 
-func (x *dentryList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (d *dentryList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.head)
+	stateSourceObject.Load(1, &d.tail)
 }
 
-func (x *dentryEntry) StateTypeName() string {
+func (d *dentryEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.dentryEntry"
 }
 
-func (x *dentryEntry) StateFields() []string {
+func (d *dentryEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *dentryEntry) beforeSave() {}
+func (d *dentryEntry) beforeSave() {}
 
-func (x *dentryEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (d *dentryEntry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.next)
+	stateSinkObject.Save(1, &d.prev)
 }
 
-func (x *dentryEntry) afterLoad() {}
+func (d *dentryEntry) afterLoad() {}
 
-func (x *dentryEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (d *dentryEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.next)
+	stateSourceObject.Load(1, &d.prev)
 }
 
-func (x *directoryFD) StateTypeName() string {
+func (d *directoryFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.directoryFD"
 }
 
-func (x *directoryFD) StateFields() []string {
+func (d *directoryFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"DirectoryFileDescriptionDefaultImpl",
@@ -71,49 +71,49 @@ func (x *directoryFD) StateFields() []string {
 	}
 }
 
-func (x *directoryFD) beforeSave() {}
+func (d *directoryFD) beforeSave() {}
 
-func (x *directoryFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Save(2, &x.off)
-	m.Save(3, &x.dirents)
+func (d *directoryFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.fileDescription)
+	stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &d.off)
+	stateSinkObject.Save(3, &d.dirents)
 }
 
-func (x *directoryFD) afterLoad() {}
+func (d *directoryFD) afterLoad() {}
 
-func (x *directoryFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Load(2, &x.off)
-	m.Load(3, &x.dirents)
+func (d *directoryFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.fileDescription)
+	stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &d.off)
+	stateSourceObject.Load(3, &d.dirents)
 }
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"vfsfs",
 		"mfp",
@@ -129,52 +129,52 @@ func (x *filesystem) StateFields() []string {
 	}
 }
 
-func (x *filesystem) beforeSave() {}
-
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfs)
-	m.Save(1, &x.mfp)
-	m.Save(2, &x.opts)
-	m.Save(3, &x.iopts)
-	m.Save(4, &x.clock)
-	m.Save(5, &x.devMinor)
-	m.Save(6, &x.cachedDentries)
-	m.Save(7, &x.cachedDentriesLen)
-	m.Save(8, &x.syncableDentries)
-	m.Save(9, &x.specialFileFDs)
-	m.Save(10, &x.syntheticSeq)
-}
-
-func (x *filesystem) afterLoad() {}
-
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfs)
-	m.Load(1, &x.mfp)
-	m.Load(2, &x.opts)
-	m.Load(3, &x.iopts)
-	m.Load(4, &x.clock)
-	m.Load(5, &x.devMinor)
-	m.Load(6, &x.cachedDentries)
-	m.Load(7, &x.cachedDentriesLen)
-	m.Load(8, &x.syncableDentries)
-	m.Load(9, &x.specialFileFDs)
-	m.Load(10, &x.syntheticSeq)
-}
-
-func (x *inodeNumber) StateTypeName() string {
+func (f *filesystem) beforeSave() {}
+
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfs)
+	stateSinkObject.Save(1, &f.mfp)
+	stateSinkObject.Save(2, &f.opts)
+	stateSinkObject.Save(3, &f.iopts)
+	stateSinkObject.Save(4, &f.clock)
+	stateSinkObject.Save(5, &f.devMinor)
+	stateSinkObject.Save(6, &f.cachedDentries)
+	stateSinkObject.Save(7, &f.cachedDentriesLen)
+	stateSinkObject.Save(8, &f.syncableDentries)
+	stateSinkObject.Save(9, &f.specialFileFDs)
+	stateSinkObject.Save(10, &f.syntheticSeq)
+}
+
+func (f *filesystem) afterLoad() {}
+
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfs)
+	stateSourceObject.Load(1, &f.mfp)
+	stateSourceObject.Load(2, &f.opts)
+	stateSourceObject.Load(3, &f.iopts)
+	stateSourceObject.Load(4, &f.clock)
+	stateSourceObject.Load(5, &f.devMinor)
+	stateSourceObject.Load(6, &f.cachedDentries)
+	stateSourceObject.Load(7, &f.cachedDentriesLen)
+	stateSourceObject.Load(8, &f.syncableDentries)
+	stateSourceObject.Load(9, &f.specialFileFDs)
+	stateSourceObject.Load(10, &f.syntheticSeq)
+}
+
+func (i *inodeNumber) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.inodeNumber"
 }
 
-func (x *inodeNumber) StateFields() []string {
+func (i *inodeNumber) StateFields() []string {
 	return nil
 }
 
-func (x *filesystemOptions) StateTypeName() string {
+func (f *filesystemOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.filesystemOptions"
 }
 
-func (x *filesystemOptions) StateFields() []string {
+func (f *filesystemOptions) StateFields() []string {
 	return []string{
 		"fd",
 		"aname",
@@ -191,80 +191,80 @@ func (x *filesystemOptions) StateFields() []string {
 	}
 }
 
-func (x *filesystemOptions) beforeSave() {}
-
-func (x *filesystemOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fd)
-	m.Save(1, &x.aname)
-	m.Save(2, &x.interop)
-	m.Save(3, &x.dfltuid)
-	m.Save(4, &x.dfltgid)
-	m.Save(5, &x.msize)
-	m.Save(6, &x.version)
-	m.Save(7, &x.maxCachedDentries)
-	m.Save(8, &x.forcePageCache)
-	m.Save(9, &x.limitHostFDTranslation)
-	m.Save(10, &x.overlayfsStaleRead)
-	m.Save(11, &x.regularFilesUseSpecialFileFD)
-}
-
-func (x *filesystemOptions) afterLoad() {}
-
-func (x *filesystemOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.fd)
-	m.Load(1, &x.aname)
-	m.Load(2, &x.interop)
-	m.Load(3, &x.dfltuid)
-	m.Load(4, &x.dfltgid)
-	m.Load(5, &x.msize)
-	m.Load(6, &x.version)
-	m.Load(7, &x.maxCachedDentries)
-	m.Load(8, &x.forcePageCache)
-	m.Load(9, &x.limitHostFDTranslation)
-	m.Load(10, &x.overlayfsStaleRead)
-	m.Load(11, &x.regularFilesUseSpecialFileFD)
-}
-
-func (x *InteropMode) StateTypeName() string {
+func (f *filesystemOptions) beforeSave() {}
+
+func (f *filesystemOptions) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.fd)
+	stateSinkObject.Save(1, &f.aname)
+	stateSinkObject.Save(2, &f.interop)
+	stateSinkObject.Save(3, &f.dfltuid)
+	stateSinkObject.Save(4, &f.dfltgid)
+	stateSinkObject.Save(5, &f.msize)
+	stateSinkObject.Save(6, &f.version)
+	stateSinkObject.Save(7, &f.maxCachedDentries)
+	stateSinkObject.Save(8, &f.forcePageCache)
+	stateSinkObject.Save(9, &f.limitHostFDTranslation)
+	stateSinkObject.Save(10, &f.overlayfsStaleRead)
+	stateSinkObject.Save(11, &f.regularFilesUseSpecialFileFD)
+}
+
+func (f *filesystemOptions) afterLoad() {}
+
+func (f *filesystemOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.fd)
+	stateSourceObject.Load(1, &f.aname)
+	stateSourceObject.Load(2, &f.interop)
+	stateSourceObject.Load(3, &f.dfltuid)
+	stateSourceObject.Load(4, &f.dfltgid)
+	stateSourceObject.Load(5, &f.msize)
+	stateSourceObject.Load(6, &f.version)
+	stateSourceObject.Load(7, &f.maxCachedDentries)
+	stateSourceObject.Load(8, &f.forcePageCache)
+	stateSourceObject.Load(9, &f.limitHostFDTranslation)
+	stateSourceObject.Load(10, &f.overlayfsStaleRead)
+	stateSourceObject.Load(11, &f.regularFilesUseSpecialFileFD)
+}
+
+func (i *InteropMode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.InteropMode"
 }
 
-func (x *InteropMode) StateFields() []string {
+func (i *InteropMode) StateFields() []string {
 	return nil
 }
 
-func (x *InternalFilesystemOptions) StateTypeName() string {
+func (i *InternalFilesystemOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.InternalFilesystemOptions"
 }
 
-func (x *InternalFilesystemOptions) StateFields() []string {
+func (i *InternalFilesystemOptions) StateFields() []string {
 	return []string{
 		"LeakConnection",
 		"OpenSocketsByConnecting",
 	}
 }
 
-func (x *InternalFilesystemOptions) beforeSave() {}
+func (i *InternalFilesystemOptions) beforeSave() {}
 
-func (x *InternalFilesystemOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.LeakConnection)
-	m.Save(1, &x.OpenSocketsByConnecting)
+func (i *InternalFilesystemOptions) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.LeakConnection)
+	stateSinkObject.Save(1, &i.OpenSocketsByConnecting)
 }
 
-func (x *InternalFilesystemOptions) afterLoad() {}
+func (i *InternalFilesystemOptions) afterLoad() {}
 
-func (x *InternalFilesystemOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.LeakConnection)
-	m.Load(1, &x.OpenSocketsByConnecting)
+func (i *InternalFilesystemOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.LeakConnection)
+	stateSourceObject.Load(1, &i.OpenSocketsByConnecting)
 }
 
-func (x *dentry) StateTypeName() string {
+func (d *dentry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.dentry"
 }
 
-func (x *dentry) StateFields() []string {
+func (d *dentry) StateFields() []string {
 	return []string{
 		"vfsd",
 		"refs",
@@ -304,92 +304,92 @@ func (x *dentry) StateFields() []string {
 	}
 }
 
-func (x *dentry) beforeSave() {}
-
-func (x *dentry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsd)
-	m.Save(1, &x.refs)
-	m.Save(2, &x.fs)
-	m.Save(3, &x.parent)
-	m.Save(4, &x.name)
-	m.Save(5, &x.deleted)
-	m.Save(6, &x.cached)
-	m.Save(7, &x.dentryEntry)
-	m.Save(8, &x.children)
-	m.Save(9, &x.syntheticChildren)
-	m.Save(10, &x.dirents)
-	m.Save(11, &x.ino)
-	m.Save(12, &x.mode)
-	m.Save(13, &x.uid)
-	m.Save(14, &x.gid)
-	m.Save(15, &x.blockSize)
-	m.Save(16, &x.atime)
-	m.Save(17, &x.mtime)
-	m.Save(18, &x.ctime)
-	m.Save(19, &x.btime)
-	m.Save(20, &x.size)
-	m.Save(21, &x.atimeDirty)
-	m.Save(22, &x.mtimeDirty)
-	m.Save(23, &x.nlink)
-	m.Save(24, &x.mappings)
-	m.Save(25, &x.hostFD)
-	m.Save(26, &x.cache)
-	m.Save(27, &x.dirty)
-	m.Save(28, &x.pf)
-	m.Save(29, &x.haveTarget)
-	m.Save(30, &x.target)
-	m.Save(31, &x.endpoint)
-	m.Save(32, &x.pipe)
-	m.Save(33, &x.locks)
-	m.Save(34, &x.watches)
-}
-
-func (x *dentry) afterLoad() {}
-
-func (x *dentry) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsd)
-	m.Load(1, &x.refs)
-	m.Load(2, &x.fs)
-	m.Load(3, &x.parent)
-	m.Load(4, &x.name)
-	m.Load(5, &x.deleted)
-	m.Load(6, &x.cached)
-	m.Load(7, &x.dentryEntry)
-	m.Load(8, &x.children)
-	m.Load(9, &x.syntheticChildren)
-	m.Load(10, &x.dirents)
-	m.Load(11, &x.ino)
-	m.Load(12, &x.mode)
-	m.Load(13, &x.uid)
-	m.Load(14, &x.gid)
-	m.Load(15, &x.blockSize)
-	m.Load(16, &x.atime)
-	m.Load(17, &x.mtime)
-	m.Load(18, &x.ctime)
-	m.Load(19, &x.btime)
-	m.Load(20, &x.size)
-	m.Load(21, &x.atimeDirty)
-	m.Load(22, &x.mtimeDirty)
-	m.Load(23, &x.nlink)
-	m.Load(24, &x.mappings)
-	m.Load(25, &x.hostFD)
-	m.Load(26, &x.cache)
-	m.Load(27, &x.dirty)
-	m.Load(28, &x.pf)
-	m.Load(29, &x.haveTarget)
-	m.Load(30, &x.target)
-	m.Load(31, &x.endpoint)
-	m.Load(32, &x.pipe)
-	m.Load(33, &x.locks)
-	m.Load(34, &x.watches)
-}
-
-func (x *fileDescription) StateTypeName() string {
+func (d *dentry) beforeSave() {}
+
+func (d *dentry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.vfsd)
+	stateSinkObject.Save(1, &d.refs)
+	stateSinkObject.Save(2, &d.fs)
+	stateSinkObject.Save(3, &d.parent)
+	stateSinkObject.Save(4, &d.name)
+	stateSinkObject.Save(5, &d.deleted)
+	stateSinkObject.Save(6, &d.cached)
+	stateSinkObject.Save(7, &d.dentryEntry)
+	stateSinkObject.Save(8, &d.children)
+	stateSinkObject.Save(9, &d.syntheticChildren)
+	stateSinkObject.Save(10, &d.dirents)
+	stateSinkObject.Save(11, &d.ino)
+	stateSinkObject.Save(12, &d.mode)
+	stateSinkObject.Save(13, &d.uid)
+	stateSinkObject.Save(14, &d.gid)
+	stateSinkObject.Save(15, &d.blockSize)
+	stateSinkObject.Save(16, &d.atime)
+	stateSinkObject.Save(17, &d.mtime)
+	stateSinkObject.Save(18, &d.ctime)
+	stateSinkObject.Save(19, &d.btime)
+	stateSinkObject.Save(20, &d.size)
+	stateSinkObject.Save(21, &d.atimeDirty)
+	stateSinkObject.Save(22, &d.mtimeDirty)
+	stateSinkObject.Save(23, &d.nlink)
+	stateSinkObject.Save(24, &d.mappings)
+	stateSinkObject.Save(25, &d.hostFD)
+	stateSinkObject.Save(26, &d.cache)
+	stateSinkObject.Save(27, &d.dirty)
+	stateSinkObject.Save(28, &d.pf)
+	stateSinkObject.Save(29, &d.haveTarget)
+	stateSinkObject.Save(30, &d.target)
+	stateSinkObject.Save(31, &d.endpoint)
+	stateSinkObject.Save(32, &d.pipe)
+	stateSinkObject.Save(33, &d.locks)
+	stateSinkObject.Save(34, &d.watches)
+}
+
+func (d *dentry) afterLoad() {}
+
+func (d *dentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsd)
+	stateSourceObject.Load(1, &d.refs)
+	stateSourceObject.Load(2, &d.fs)
+	stateSourceObject.Load(3, &d.parent)
+	stateSourceObject.Load(4, &d.name)
+	stateSourceObject.Load(5, &d.deleted)
+	stateSourceObject.Load(6, &d.cached)
+	stateSourceObject.Load(7, &d.dentryEntry)
+	stateSourceObject.Load(8, &d.children)
+	stateSourceObject.Load(9, &d.syntheticChildren)
+	stateSourceObject.Load(10, &d.dirents)
+	stateSourceObject.Load(11, &d.ino)
+	stateSourceObject.Load(12, &d.mode)
+	stateSourceObject.Load(13, &d.uid)
+	stateSourceObject.Load(14, &d.gid)
+	stateSourceObject.Load(15, &d.blockSize)
+	stateSourceObject.Load(16, &d.atime)
+	stateSourceObject.Load(17, &d.mtime)
+	stateSourceObject.Load(18, &d.ctime)
+	stateSourceObject.Load(19, &d.btime)
+	stateSourceObject.Load(20, &d.size)
+	stateSourceObject.Load(21, &d.atimeDirty)
+	stateSourceObject.Load(22, &d.mtimeDirty)
+	stateSourceObject.Load(23, &d.nlink)
+	stateSourceObject.Load(24, &d.mappings)
+	stateSourceObject.Load(25, &d.hostFD)
+	stateSourceObject.Load(26, &d.cache)
+	stateSourceObject.Load(27, &d.dirty)
+	stateSourceObject.Load(28, &d.pf)
+	stateSourceObject.Load(29, &d.haveTarget)
+	stateSourceObject.Load(30, &d.target)
+	stateSourceObject.Load(31, &d.endpoint)
+	stateSourceObject.Load(32, &d.pipe)
+	stateSourceObject.Load(33, &d.locks)
+	stateSourceObject.Load(34, &d.watches)
+}
+
+func (f *fileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.fileDescription"
 }
 
-func (x *fileDescription) StateFields() []string {
+func (f *fileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -397,54 +397,54 @@ func (x *fileDescription) StateFields() []string {
 	}
 }
 
-func (x *fileDescription) beforeSave() {}
+func (f *fileDescription) beforeSave() {}
 
-func (x *fileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
+func (f *fileDescription) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfd)
+	stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &f.LockFD)
 }
 
-func (x *fileDescription) afterLoad() {}
+func (f *fileDescription) afterLoad() {}
 
-func (x *fileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
+func (f *fileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfd)
+	stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &f.LockFD)
 }
 
-func (x *regularFileFD) StateTypeName() string {
+func (r *regularFileFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.regularFileFD"
 }
 
-func (x *regularFileFD) StateFields() []string {
+func (r *regularFileFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"off",
 	}
 }
 
-func (x *regularFileFD) beforeSave() {}
+func (r *regularFileFD) beforeSave() {}
 
-func (x *regularFileFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.off)
+func (r *regularFileFD) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.fileDescription)
+	stateSinkObject.Save(1, &r.off)
 }
 
-func (x *regularFileFD) afterLoad() {}
+func (r *regularFileFD) afterLoad() {}
 
-func (x *regularFileFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.off)
+func (r *regularFileFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.fileDescription)
+	stateSourceObject.Load(1, &r.off)
 }
 
-func (x *dentryPlatformFile) StateTypeName() string {
+func (d *dentryPlatformFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.dentryPlatformFile"
 }
 
-func (x *dentryPlatformFile) StateFields() []string {
+func (d *dentryPlatformFile) StateFields() []string {
 	return []string{
 		"dentry",
 		"fdRefs",
@@ -452,54 +452,54 @@ func (x *dentryPlatformFile) StateFields() []string {
 	}
 }
 
-func (x *dentryPlatformFile) beforeSave() {}
+func (d *dentryPlatformFile) beforeSave() {}
 
-func (x *dentryPlatformFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dentry)
-	m.Save(1, &x.fdRefs)
-	m.Save(2, &x.hostFileMapper)
+func (d *dentryPlatformFile) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.dentry)
+	stateSinkObject.Save(1, &d.fdRefs)
+	stateSinkObject.Save(2, &d.hostFileMapper)
 }
 
-func (x *dentryPlatformFile) afterLoad() {}
+func (d *dentryPlatformFile) afterLoad() {}
 
-func (x *dentryPlatformFile) StateLoad(m state.Source) {
-	m.Load(0, &x.dentry)
-	m.Load(1, &x.fdRefs)
-	m.Load(2, &x.hostFileMapper)
+func (d *dentryPlatformFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.dentry)
+	stateSourceObject.Load(1, &d.fdRefs)
+	stateSourceObject.Load(2, &d.hostFileMapper)
 }
 
-func (x *endpoint) StateTypeName() string {
+func (e *endpoint) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.endpoint"
 }
 
-func (x *endpoint) StateFields() []string {
+func (e *endpoint) StateFields() []string {
 	return []string{
 		"dentry",
 		"path",
 	}
 }
 
-func (x *endpoint) beforeSave() {}
+func (e *endpoint) beforeSave() {}
 
-func (x *endpoint) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dentry)
-	m.Save(1, &x.path)
+func (e *endpoint) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.dentry)
+	stateSinkObject.Save(1, &e.path)
 }
 
-func (x *endpoint) afterLoad() {}
+func (e *endpoint) afterLoad() {}
 
-func (x *endpoint) StateLoad(m state.Source) {
-	m.Load(0, &x.dentry)
-	m.Load(1, &x.path)
+func (e *endpoint) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.dentry)
+	stateSourceObject.Load(1, &e.path)
 }
 
-func (x *specialFileFD) StateTypeName() string {
+func (s *specialFileFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/gofer.specialFileFD"
 }
 
-func (x *specialFileFD) StateFields() []string {
+func (s *specialFileFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"isRegularFile",
@@ -510,27 +510,27 @@ func (x *specialFileFD) StateFields() []string {
 	}
 }
 
-func (x *specialFileFD) beforeSave() {}
+func (s *specialFileFD) beforeSave() {}
 
-func (x *specialFileFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.isRegularFile)
-	m.Save(2, &x.seekable)
-	m.Save(3, &x.haveQueue)
-	m.Save(4, &x.queue)
-	m.Save(5, &x.off)
+func (s *specialFileFD) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.fileDescription)
+	stateSinkObject.Save(1, &s.isRegularFile)
+	stateSinkObject.Save(2, &s.seekable)
+	stateSinkObject.Save(3, &s.haveQueue)
+	stateSinkObject.Save(4, &s.queue)
+	stateSinkObject.Save(5, &s.off)
 }
 
-func (x *specialFileFD) afterLoad() {}
+func (s *specialFileFD) afterLoad() {}
 
-func (x *specialFileFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.isRegularFile)
-	m.Load(2, &x.seekable)
-	m.Load(3, &x.haveQueue)
-	m.Load(4, &x.queue)
-	m.Load(5, &x.off)
+func (s *specialFileFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.fileDescription)
+	stateSourceObject.Load(1, &s.isRegularFile)
+	stateSourceObject.Load(2, &s.seekable)
+	stateSourceObject.Load(3, &s.haveQueue)
+	stateSourceObject.Load(4, &s.queue)
+	stateSourceObject.Load(5, &s.off)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/host/host_state_autogen.go b/pkg/sentry/fsimpl/host/host_state_autogen.go
index c97fa7212..76a2fdbdd 100644
--- a/pkg/sentry/fsimpl/host/host_state_autogen.go
+++ b/pkg/sentry/fsimpl/host/host_state_autogen.go
@@ -6,79 +6,79 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *ConnectedEndpointRefs) StateTypeName() string {
+func (c *ConnectedEndpointRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.ConnectedEndpointRefs"
 }
 
-func (x *ConnectedEndpointRefs) StateFields() []string {
+func (c *ConnectedEndpointRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *ConnectedEndpointRefs) beforeSave() {}
+func (c *ConnectedEndpointRefs) beforeSave() {}
 
-func (x *ConnectedEndpointRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (c *ConnectedEndpointRefs) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.refCount)
 }
 
-func (x *ConnectedEndpointRefs) afterLoad() {}
+func (c *ConnectedEndpointRefs) afterLoad() {}
 
-func (x *ConnectedEndpointRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (c *ConnectedEndpointRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.refCount)
 }
 
-func (x *filesystemType) StateTypeName() string {
+func (f *filesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.filesystemType"
 }
 
-func (x *filesystemType) StateFields() []string {
+func (f *filesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *filesystemType) beforeSave() {}
+func (f *filesystemType) beforeSave() {}
 
-func (x *filesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *filesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *filesystemType) afterLoad() {}
+func (f *filesystemType) afterLoad() {}
 
-func (x *filesystemType) StateLoad(m state.Source) {
+func (f *filesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"InodeNoStatFS",
 		"InodeNotDirectory",
@@ -97,50 +97,50 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
-
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeNoStatFS)
-	m.Save(1, &x.InodeNotDirectory)
-	m.Save(2, &x.InodeNotSymlink)
-	m.Save(3, &x.locks)
-	m.Save(4, &x.inodeRefs)
-	m.Save(5, &x.hostFD)
-	m.Save(6, &x.ino)
-	m.Save(7, &x.isTTY)
-	m.Save(8, &x.seekable)
-	m.Save(9, &x.wouldBlock)
-	m.Save(10, &x.queue)
-	m.Save(11, &x.canMap)
-	m.Save(12, &x.mappings)
-	m.Save(13, &x.pf)
-}
-
-func (x *inode) afterLoad() {}
-
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeNoStatFS)
-	m.Load(1, &x.InodeNotDirectory)
-	m.Load(2, &x.InodeNotSymlink)
-	m.Load(3, &x.locks)
-	m.Load(4, &x.inodeRefs)
-	m.Load(5, &x.hostFD)
-	m.Load(6, &x.ino)
-	m.Load(7, &x.isTTY)
-	m.Load(8, &x.seekable)
-	m.Load(9, &x.wouldBlock)
-	m.Load(10, &x.queue)
-	m.Load(11, &x.canMap)
-	m.Load(12, &x.mappings)
-	m.Load(13, &x.pf)
-}
-
-func (x *fileDescription) StateTypeName() string {
+func (i *inode) beforeSave() {}
+
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.InodeNoStatFS)
+	stateSinkObject.Save(1, &i.InodeNotDirectory)
+	stateSinkObject.Save(2, &i.InodeNotSymlink)
+	stateSinkObject.Save(3, &i.locks)
+	stateSinkObject.Save(4, &i.inodeRefs)
+	stateSinkObject.Save(5, &i.hostFD)
+	stateSinkObject.Save(6, &i.ino)
+	stateSinkObject.Save(7, &i.isTTY)
+	stateSinkObject.Save(8, &i.seekable)
+	stateSinkObject.Save(9, &i.wouldBlock)
+	stateSinkObject.Save(10, &i.queue)
+	stateSinkObject.Save(11, &i.canMap)
+	stateSinkObject.Save(12, &i.mappings)
+	stateSinkObject.Save(13, &i.pf)
+}
+
+func (i *inode) afterLoad() {}
+
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.InodeNoStatFS)
+	stateSourceObject.Load(1, &i.InodeNotDirectory)
+	stateSourceObject.Load(2, &i.InodeNotSymlink)
+	stateSourceObject.Load(3, &i.locks)
+	stateSourceObject.Load(4, &i.inodeRefs)
+	stateSourceObject.Load(5, &i.hostFD)
+	stateSourceObject.Load(6, &i.ino)
+	stateSourceObject.Load(7, &i.isTTY)
+	stateSourceObject.Load(8, &i.seekable)
+	stateSourceObject.Load(9, &i.wouldBlock)
+	stateSourceObject.Load(10, &i.queue)
+	stateSourceObject.Load(11, &i.canMap)
+	stateSourceObject.Load(12, &i.mappings)
+	stateSourceObject.Load(13, &i.pf)
+}
+
+func (f *fileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.fileDescription"
 }
 
-func (x *fileDescription) StateFields() []string {
+func (f *fileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -150,55 +150,55 @@ func (x *fileDescription) StateFields() []string {
 	}
 }
 
-func (x *fileDescription) beforeSave() {}
+func (f *fileDescription) beforeSave() {}
 
-func (x *fileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
-	m.Save(3, &x.inode)
-	m.Save(4, &x.offset)
+func (f *fileDescription) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfd)
+	stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &f.LockFD)
+	stateSinkObject.Save(3, &f.inode)
+	stateSinkObject.Save(4, &f.offset)
 }
 
-func (x *fileDescription) afterLoad() {}
+func (f *fileDescription) afterLoad() {}
 
-func (x *fileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
-	m.Load(3, &x.inode)
-	m.Load(4, &x.offset)
+func (f *fileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfd)
+	stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &f.LockFD)
+	stateSourceObject.Load(3, &f.inode)
+	stateSourceObject.Load(4, &f.offset)
 }
 
-func (x *inodeRefs) StateTypeName() string {
+func (i *inodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.inodeRefs"
 }
 
-func (x *inodeRefs) StateFields() []string {
+func (i *inodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *inodeRefs) beforeSave() {}
+func (i *inodeRefs) beforeSave() {}
 
-func (x *inodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (i *inodeRefs) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.refCount)
 }
 
-func (x *inodeRefs) afterLoad() {}
+func (i *inodeRefs) afterLoad() {}
 
-func (x *inodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (i *inodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.refCount)
 }
 
-func (x *inodePlatformFile) StateTypeName() string {
+func (i *inodePlatformFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.inodePlatformFile"
 }
 
-func (x *inodePlatformFile) StateFields() []string {
+func (i *inodePlatformFile) StateFields() []string {
 	return []string{
 		"inode",
 		"fdRefs",
@@ -206,28 +206,28 @@ func (x *inodePlatformFile) StateFields() []string {
 	}
 }
 
-func (x *inodePlatformFile) beforeSave() {}
+func (i *inodePlatformFile) beforeSave() {}
 
-func (x *inodePlatformFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.fdRefs)
-	m.Save(2, &x.fileMapper)
+func (i *inodePlatformFile) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.inode)
+	stateSinkObject.Save(1, &i.fdRefs)
+	stateSinkObject.Save(2, &i.fileMapper)
 }
 
-func (x *inodePlatformFile) afterLoad() {}
+func (i *inodePlatformFile) afterLoad() {}
 
-func (x *inodePlatformFile) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.fdRefs)
-	m.Load(2, &x.fileMapper)
+func (i *inodePlatformFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.inode)
+	stateSourceObject.Load(1, &i.fdRefs)
+	stateSourceObject.Load(2, &i.fileMapper)
 }
 
-func (x *ConnectedEndpoint) StateTypeName() string {
+func (c *ConnectedEndpoint) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.ConnectedEndpoint"
 }
 
-func (x *ConnectedEndpoint) StateFields() []string {
+func (c *ConnectedEndpoint) StateFields() []string {
 	return []string{
 		"ConnectedEndpointRefs",
 		"fd",
@@ -236,30 +236,30 @@ func (x *ConnectedEndpoint) StateFields() []string {
 	}
 }
 
-func (x *ConnectedEndpoint) beforeSave() {}
+func (c *ConnectedEndpoint) beforeSave() {}
 
-func (x *ConnectedEndpoint) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.ConnectedEndpointRefs)
-	m.Save(1, &x.fd)
-	m.Save(2, &x.addr)
-	m.Save(3, &x.stype)
+func (c *ConnectedEndpoint) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.ConnectedEndpointRefs)
+	stateSinkObject.Save(1, &c.fd)
+	stateSinkObject.Save(2, &c.addr)
+	stateSinkObject.Save(3, &c.stype)
 }
 
-func (x *ConnectedEndpoint) afterLoad() {}
+func (c *ConnectedEndpoint) afterLoad() {}
 
-func (x *ConnectedEndpoint) StateLoad(m state.Source) {
-	m.Load(0, &x.ConnectedEndpointRefs)
-	m.Load(1, &x.fd)
-	m.Load(2, &x.addr)
-	m.Load(3, &x.stype)
+func (c *ConnectedEndpoint) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.ConnectedEndpointRefs)
+	stateSourceObject.Load(1, &c.fd)
+	stateSourceObject.Load(2, &c.addr)
+	stateSourceObject.Load(3, &c.stype)
 }
 
-func (x *TTYFileDescription) StateTypeName() string {
+func (t *TTYFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/host.TTYFileDescription"
 }
 
-func (x *TTYFileDescription) StateFields() []string {
+func (t *TTYFileDescription) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"session",
@@ -268,23 +268,23 @@ func (x *TTYFileDescription) StateFields() []string {
 	}
 }
 
-func (x *TTYFileDescription) beforeSave() {}
+func (t *TTYFileDescription) beforeSave() {}
 
-func (x *TTYFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.session)
-	m.Save(2, &x.fgProcessGroup)
-	m.Save(3, &x.termios)
+func (t *TTYFileDescription) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.fileDescription)
+	stateSinkObject.Save(1, &t.session)
+	stateSinkObject.Save(2, &t.fgProcessGroup)
+	stateSinkObject.Save(3, &t.termios)
 }
 
-func (x *TTYFileDescription) afterLoad() {}
+func (t *TTYFileDescription) afterLoad() {}
 
-func (x *TTYFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.session)
-	m.Load(2, &x.fgProcessGroup)
-	m.Load(3, &x.termios)
+func (t *TTYFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.fileDescription)
+	stateSourceObject.Load(1, &t.session)
+	stateSourceObject.Load(2, &t.fgProcessGroup)
+	stateSourceObject.Load(3, &t.termios)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go b/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go
index f42662d2d..dc7a033ab 100644
--- a/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go
+++ b/pkg/sentry/fsimpl/kernfs/kernfs_state_autogen.go
@@ -6,34 +6,34 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *DentryRefs) StateTypeName() string {
+func (d *DentryRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.DentryRefs"
 }
 
-func (x *DentryRefs) StateFields() []string {
+func (d *DentryRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *DentryRefs) beforeSave() {}
+func (d *DentryRefs) beforeSave() {}
 
-func (x *DentryRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (d *DentryRefs) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.refCount)
 }
 
-func (x *DentryRefs) afterLoad() {}
+func (d *DentryRefs) afterLoad() {}
 
-func (x *DentryRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (d *DentryRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.refCount)
 }
 
-func (x *DynamicBytesFile) StateTypeName() string {
+func (d *DynamicBytesFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.DynamicBytesFile"
 }
 
-func (x *DynamicBytesFile) StateFields() []string {
+func (d *DynamicBytesFile) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeNoStatFS",
@@ -45,36 +45,36 @@ func (x *DynamicBytesFile) StateFields() []string {
 	}
 }
 
-func (x *DynamicBytesFile) beforeSave() {}
+func (d *DynamicBytesFile) beforeSave() {}
 
-func (x *DynamicBytesFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeNoStatFS)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeNotDirectory)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.locks)
-	m.Save(6, &x.data)
+func (d *DynamicBytesFile) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.InodeAttrs)
+	stateSinkObject.Save(1, &d.InodeNoStatFS)
+	stateSinkObject.Save(2, &d.InodeNoopRefCount)
+	stateSinkObject.Save(3, &d.InodeNotDirectory)
+	stateSinkObject.Save(4, &d.InodeNotSymlink)
+	stateSinkObject.Save(5, &d.locks)
+	stateSinkObject.Save(6, &d.data)
 }
 
-func (x *DynamicBytesFile) afterLoad() {}
+func (d *DynamicBytesFile) afterLoad() {}
 
-func (x *DynamicBytesFile) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeNoStatFS)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeNotDirectory)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.locks)
-	m.Load(6, &x.data)
+func (d *DynamicBytesFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.InodeAttrs)
+	stateSourceObject.Load(1, &d.InodeNoStatFS)
+	stateSourceObject.Load(2, &d.InodeNoopRefCount)
+	stateSourceObject.Load(3, &d.InodeNotDirectory)
+	stateSourceObject.Load(4, &d.InodeNotSymlink)
+	stateSourceObject.Load(5, &d.locks)
+	stateSourceObject.Load(6, &d.data)
 }
 
-func (x *DynamicBytesFD) StateTypeName() string {
+func (d *DynamicBytesFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.DynamicBytesFD"
 }
 
-func (x *DynamicBytesFD) StateFields() []string {
+func (d *DynamicBytesFD) StateFields() []string {
 	return []string{
 		"FileDescriptionDefaultImpl",
 		"DynamicBytesFileDescriptionImpl",
@@ -84,63 +84,63 @@ func (x *DynamicBytesFD) StateFields() []string {
 	}
 }
 
-func (x *DynamicBytesFD) beforeSave() {}
+func (d *DynamicBytesFD) beforeSave() {}
 
-func (x *DynamicBytesFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FileDescriptionDefaultImpl)
-	m.Save(1, &x.DynamicBytesFileDescriptionImpl)
-	m.Save(2, &x.LockFD)
-	m.Save(3, &x.vfsfd)
-	m.Save(4, &x.inode)
+func (d *DynamicBytesFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(1, &d.DynamicBytesFileDescriptionImpl)
+	stateSinkObject.Save(2, &d.LockFD)
+	stateSinkObject.Save(3, &d.vfsfd)
+	stateSinkObject.Save(4, &d.inode)
 }
 
-func (x *DynamicBytesFD) afterLoad() {}
+func (d *DynamicBytesFD) afterLoad() {}
 
-func (x *DynamicBytesFD) StateLoad(m state.Source) {
-	m.Load(0, &x.FileDescriptionDefaultImpl)
-	m.Load(1, &x.DynamicBytesFileDescriptionImpl)
-	m.Load(2, &x.LockFD)
-	m.Load(3, &x.vfsfd)
-	m.Load(4, &x.inode)
+func (d *DynamicBytesFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(1, &d.DynamicBytesFileDescriptionImpl)
+	stateSourceObject.Load(2, &d.LockFD)
+	stateSourceObject.Load(3, &d.vfsfd)
+	stateSourceObject.Load(4, &d.inode)
 }
 
-func (x *SeekEndConfig) StateTypeName() string {
+func (s *SeekEndConfig) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.SeekEndConfig"
 }
 
-func (x *SeekEndConfig) StateFields() []string {
+func (s *SeekEndConfig) StateFields() []string {
 	return nil
 }
 
-func (x *GenericDirectoryFDOptions) StateTypeName() string {
+func (g *GenericDirectoryFDOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.GenericDirectoryFDOptions"
 }
 
-func (x *GenericDirectoryFDOptions) StateFields() []string {
+func (g *GenericDirectoryFDOptions) StateFields() []string {
 	return []string{
 		"SeekEnd",
 	}
 }
 
-func (x *GenericDirectoryFDOptions) beforeSave() {}
+func (g *GenericDirectoryFDOptions) beforeSave() {}
 
-func (x *GenericDirectoryFDOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.SeekEnd)
+func (g *GenericDirectoryFDOptions) StateSave(stateSinkObject state.Sink) {
+	g.beforeSave()
+	stateSinkObject.Save(0, &g.SeekEnd)
 }
 
-func (x *GenericDirectoryFDOptions) afterLoad() {}
+func (g *GenericDirectoryFDOptions) afterLoad() {}
 
-func (x *GenericDirectoryFDOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.SeekEnd)
+func (g *GenericDirectoryFDOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &g.SeekEnd)
 }
 
-func (x *GenericDirectoryFD) StateTypeName() string {
+func (g *GenericDirectoryFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.GenericDirectoryFD"
 }
 
-func (x *GenericDirectoryFD) StateFields() []string {
+func (g *GenericDirectoryFD) StateFields() []string {
 	return []string{
 		"FileDescriptionDefaultImpl",
 		"DirectoryFileDescriptionDefaultImpl",
@@ -152,131 +152,131 @@ func (x *GenericDirectoryFD) StateFields() []string {
 	}
 }
 
-func (x *GenericDirectoryFD) beforeSave() {}
+func (g *GenericDirectoryFD) beforeSave() {}
 
-func (x *GenericDirectoryFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FileDescriptionDefaultImpl)
-	m.Save(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
-	m.Save(3, &x.seekEnd)
-	m.Save(4, &x.vfsfd)
-	m.Save(5, &x.children)
-	m.Save(6, &x.off)
+func (g *GenericDirectoryFD) StateSave(stateSinkObject state.Sink) {
+	g.beforeSave()
+	stateSinkObject.Save(0, &g.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(1, &g.DirectoryFileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &g.LockFD)
+	stateSinkObject.Save(3, &g.seekEnd)
+	stateSinkObject.Save(4, &g.vfsfd)
+	stateSinkObject.Save(5, &g.children)
+	stateSinkObject.Save(6, &g.off)
 }
 
-func (x *GenericDirectoryFD) afterLoad() {}
+func (g *GenericDirectoryFD) afterLoad() {}
 
-func (x *GenericDirectoryFD) StateLoad(m state.Source) {
-	m.Load(0, &x.FileDescriptionDefaultImpl)
-	m.Load(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
-	m.Load(3, &x.seekEnd)
-	m.Load(4, &x.vfsfd)
-	m.Load(5, &x.children)
-	m.Load(6, &x.off)
+func (g *GenericDirectoryFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &g.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(1, &g.DirectoryFileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &g.LockFD)
+	stateSourceObject.Load(3, &g.seekEnd)
+	stateSourceObject.Load(4, &g.vfsfd)
+	stateSourceObject.Load(5, &g.children)
+	stateSourceObject.Load(6, &g.off)
 }
 
-func (x *InodeNoopRefCount) StateTypeName() string {
+func (i *InodeNoopRefCount) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeNoopRefCount"
 }
 
-func (x *InodeNoopRefCount) StateFields() []string {
+func (i *InodeNoopRefCount) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeNoopRefCount) beforeSave() {}
+func (i *InodeNoopRefCount) beforeSave() {}
 
-func (x *InodeNoopRefCount) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeNoopRefCount) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeNoopRefCount) afterLoad() {}
+func (i *InodeNoopRefCount) afterLoad() {}
 
-func (x *InodeNoopRefCount) StateLoad(m state.Source) {
+func (i *InodeNoopRefCount) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeDirectoryNoNewChildren) StateTypeName() string {
+func (i *InodeDirectoryNoNewChildren) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeDirectoryNoNewChildren"
 }
 
-func (x *InodeDirectoryNoNewChildren) StateFields() []string {
+func (i *InodeDirectoryNoNewChildren) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeDirectoryNoNewChildren) beforeSave() {}
+func (i *InodeDirectoryNoNewChildren) beforeSave() {}
 
-func (x *InodeDirectoryNoNewChildren) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeDirectoryNoNewChildren) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeDirectoryNoNewChildren) afterLoad() {}
+func (i *InodeDirectoryNoNewChildren) afterLoad() {}
 
-func (x *InodeDirectoryNoNewChildren) StateLoad(m state.Source) {
+func (i *InodeDirectoryNoNewChildren) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeNotDirectory) StateTypeName() string {
+func (i *InodeNotDirectory) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeNotDirectory"
 }
 
-func (x *InodeNotDirectory) StateFields() []string {
+func (i *InodeNotDirectory) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeNotDirectory) beforeSave() {}
+func (i *InodeNotDirectory) beforeSave() {}
 
-func (x *InodeNotDirectory) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeNotDirectory) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeNotDirectory) afterLoad() {}
+func (i *InodeNotDirectory) afterLoad() {}
 
-func (x *InodeNotDirectory) StateLoad(m state.Source) {
+func (i *InodeNotDirectory) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeNoDynamicLookup) StateTypeName() string {
+func (i *InodeNoDynamicLookup) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeNoDynamicLookup"
 }
 
-func (x *InodeNoDynamicLookup) StateFields() []string {
+func (i *InodeNoDynamicLookup) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeNoDynamicLookup) beforeSave() {}
+func (i *InodeNoDynamicLookup) beforeSave() {}
 
-func (x *InodeNoDynamicLookup) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeNoDynamicLookup) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeNoDynamicLookup) afterLoad() {}
+func (i *InodeNoDynamicLookup) afterLoad() {}
 
-func (x *InodeNoDynamicLookup) StateLoad(m state.Source) {
+func (i *InodeNoDynamicLookup) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeNotSymlink) StateTypeName() string {
+func (i *InodeNotSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeNotSymlink"
 }
 
-func (x *InodeNotSymlink) StateFields() []string {
+func (i *InodeNotSymlink) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeNotSymlink) beforeSave() {}
+func (i *InodeNotSymlink) beforeSave() {}
 
-func (x *InodeNotSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeNotSymlink) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeNotSymlink) afterLoad() {}
+func (i *InodeNotSymlink) afterLoad() {}
 
-func (x *InodeNotSymlink) StateLoad(m state.Source) {
+func (i *InodeNotSymlink) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeAttrs) StateTypeName() string {
+func (i *InodeAttrs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeAttrs"
 }
 
-func (x *InodeAttrs) StateFields() []string {
+func (i *InodeAttrs) StateFields() []string {
 	return []string{
 		"devMajor",
 		"devMinor",
@@ -288,36 +288,36 @@ func (x *InodeAttrs) StateFields() []string {
 	}
 }
 
-func (x *InodeAttrs) beforeSave() {}
+func (i *InodeAttrs) beforeSave() {}
 
-func (x *InodeAttrs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.devMajor)
-	m.Save(1, &x.devMinor)
-	m.Save(2, &x.ino)
-	m.Save(3, &x.mode)
-	m.Save(4, &x.uid)
-	m.Save(5, &x.gid)
-	m.Save(6, &x.nlink)
+func (i *InodeAttrs) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.devMajor)
+	stateSinkObject.Save(1, &i.devMinor)
+	stateSinkObject.Save(2, &i.ino)
+	stateSinkObject.Save(3, &i.mode)
+	stateSinkObject.Save(4, &i.uid)
+	stateSinkObject.Save(5, &i.gid)
+	stateSinkObject.Save(6, &i.nlink)
 }
 
-func (x *InodeAttrs) afterLoad() {}
+func (i *InodeAttrs) afterLoad() {}
 
-func (x *InodeAttrs) StateLoad(m state.Source) {
-	m.Load(0, &x.devMajor)
-	m.Load(1, &x.devMinor)
-	m.Load(2, &x.ino)
-	m.Load(3, &x.mode)
-	m.Load(4, &x.uid)
-	m.Load(5, &x.gid)
-	m.Load(6, &x.nlink)
+func (i *InodeAttrs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.devMajor)
+	stateSourceObject.Load(1, &i.devMinor)
+	stateSourceObject.Load(2, &i.ino)
+	stateSourceObject.Load(3, &i.mode)
+	stateSourceObject.Load(4, &i.uid)
+	stateSourceObject.Load(5, &i.gid)
+	stateSourceObject.Load(6, &i.nlink)
 }
 
-func (x *slot) StateTypeName() string {
+func (s *slot) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.slot"
 }
 
-func (x *slot) StateFields() []string {
+func (s *slot) StateFields() []string {
 	return []string{
 		"Name",
 		"Dentry",
@@ -325,51 +325,51 @@ func (x *slot) StateFields() []string {
 	}
 }
 
-func (x *slot) beforeSave() {}
+func (s *slot) beforeSave() {}
 
-func (x *slot) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Name)
-	m.Save(1, &x.Dentry)
-	m.Save(2, &x.slotEntry)
+func (s *slot) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.Name)
+	stateSinkObject.Save(1, &s.Dentry)
+	stateSinkObject.Save(2, &s.slotEntry)
 }
 
-func (x *slot) afterLoad() {}
+func (s *slot) afterLoad() {}
 
-func (x *slot) StateLoad(m state.Source) {
-	m.Load(0, &x.Name)
-	m.Load(1, &x.Dentry)
-	m.Load(2, &x.slotEntry)
+func (s *slot) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.Name)
+	stateSourceObject.Load(1, &s.Dentry)
+	stateSourceObject.Load(2, &s.slotEntry)
 }
 
-func (x *OrderedChildrenOptions) StateTypeName() string {
+func (o *OrderedChildrenOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.OrderedChildrenOptions"
 }
 
-func (x *OrderedChildrenOptions) StateFields() []string {
+func (o *OrderedChildrenOptions) StateFields() []string {
 	return []string{
 		"Writable",
 	}
 }
 
-func (x *OrderedChildrenOptions) beforeSave() {}
+func (o *OrderedChildrenOptions) beforeSave() {}
 
-func (x *OrderedChildrenOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Writable)
+func (o *OrderedChildrenOptions) StateSave(stateSinkObject state.Sink) {
+	o.beforeSave()
+	stateSinkObject.Save(0, &o.Writable)
 }
 
-func (x *OrderedChildrenOptions) afterLoad() {}
+func (o *OrderedChildrenOptions) afterLoad() {}
 
-func (x *OrderedChildrenOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.Writable)
+func (o *OrderedChildrenOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &o.Writable)
 }
 
-func (x *OrderedChildren) StateTypeName() string {
+func (o *OrderedChildren) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.OrderedChildren"
 }
 
-func (x *OrderedChildren) StateFields() []string {
+func (o *OrderedChildren) StateFields() []string {
 	return []string{
 		"writable",
 		"order",
@@ -377,70 +377,70 @@ func (x *OrderedChildren) StateFields() []string {
 	}
 }
 
-func (x *OrderedChildren) beforeSave() {}
+func (o *OrderedChildren) beforeSave() {}
 
-func (x *OrderedChildren) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.writable)
-	m.Save(1, &x.order)
-	m.Save(2, &x.set)
+func (o *OrderedChildren) StateSave(stateSinkObject state.Sink) {
+	o.beforeSave()
+	stateSinkObject.Save(0, &o.writable)
+	stateSinkObject.Save(1, &o.order)
+	stateSinkObject.Save(2, &o.set)
 }
 
-func (x *OrderedChildren) afterLoad() {}
+func (o *OrderedChildren) afterLoad() {}
 
-func (x *OrderedChildren) StateLoad(m state.Source) {
-	m.Load(0, &x.writable)
-	m.Load(1, &x.order)
-	m.Load(2, &x.set)
+func (o *OrderedChildren) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &o.writable)
+	stateSourceObject.Load(1, &o.order)
+	stateSourceObject.Load(2, &o.set)
 }
 
-func (x *renameAcrossDifferentImplementationsError) StateTypeName() string {
+func (r *renameAcrossDifferentImplementationsError) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.renameAcrossDifferentImplementationsError"
 }
 
-func (x *renameAcrossDifferentImplementationsError) StateFields() []string {
+func (r *renameAcrossDifferentImplementationsError) StateFields() []string {
 	return []string{}
 }
 
-func (x *renameAcrossDifferentImplementationsError) beforeSave() {}
+func (r *renameAcrossDifferentImplementationsError) beforeSave() {}
 
-func (x *renameAcrossDifferentImplementationsError) StateSave(m state.Sink) {
-	x.beforeSave()
+func (r *renameAcrossDifferentImplementationsError) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
 }
 
-func (x *renameAcrossDifferentImplementationsError) afterLoad() {}
+func (r *renameAcrossDifferentImplementationsError) afterLoad() {}
 
-func (x *renameAcrossDifferentImplementationsError) StateLoad(m state.Source) {
+func (r *renameAcrossDifferentImplementationsError) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeSymlink) StateTypeName() string {
+func (i *InodeSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeSymlink"
 }
 
-func (x *InodeSymlink) StateFields() []string {
+func (i *InodeSymlink) StateFields() []string {
 	return []string{
 		"InodeNotDirectory",
 	}
 }
 
-func (x *InodeSymlink) beforeSave() {}
+func (i *InodeSymlink) beforeSave() {}
 
-func (x *InodeSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeNotDirectory)
+func (i *InodeSymlink) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.InodeNotDirectory)
 }
 
-func (x *InodeSymlink) afterLoad() {}
+func (i *InodeSymlink) afterLoad() {}
 
-func (x *InodeSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeNotDirectory)
+func (i *InodeSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.InodeNotDirectory)
 }
 
-func (x *StaticDirectory) StateTypeName() string {
+func (s *StaticDirectory) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.StaticDirectory"
 }
 
-func (x *StaticDirectory) StateFields() []string {
+func (s *StaticDirectory) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeDirectoryNoNewChildren",
@@ -454,78 +454,78 @@ func (x *StaticDirectory) StateFields() []string {
 	}
 }
 
-func (x *StaticDirectory) beforeSave() {}
+func (s *StaticDirectory) beforeSave() {}
 
-func (x *StaticDirectory) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeDirectoryNoNewChildren)
-	m.Save(2, &x.InodeNoDynamicLookup)
-	m.Save(3, &x.InodeNoStatFS)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.StaticDirectoryRefs)
-	m.Save(7, &x.locks)
-	m.Save(8, &x.fdOpts)
+func (s *StaticDirectory) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.InodeAttrs)
+	stateSinkObject.Save(1, &s.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(2, &s.InodeNoDynamicLookup)
+	stateSinkObject.Save(3, &s.InodeNoStatFS)
+	stateSinkObject.Save(4, &s.InodeNotSymlink)
+	stateSinkObject.Save(5, &s.OrderedChildren)
+	stateSinkObject.Save(6, &s.StaticDirectoryRefs)
+	stateSinkObject.Save(7, &s.locks)
+	stateSinkObject.Save(8, &s.fdOpts)
 }
 
-func (x *StaticDirectory) afterLoad() {}
+func (s *StaticDirectory) afterLoad() {}
 
-func (x *StaticDirectory) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeDirectoryNoNewChildren)
-	m.Load(2, &x.InodeNoDynamicLookup)
-	m.Load(3, &x.InodeNoStatFS)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.StaticDirectoryRefs)
-	m.Load(7, &x.locks)
-	m.Load(8, &x.fdOpts)
+func (s *StaticDirectory) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.InodeAttrs)
+	stateSourceObject.Load(1, &s.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(2, &s.InodeNoDynamicLookup)
+	stateSourceObject.Load(3, &s.InodeNoStatFS)
+	stateSourceObject.Load(4, &s.InodeNotSymlink)
+	stateSourceObject.Load(5, &s.OrderedChildren)
+	stateSourceObject.Load(6, &s.StaticDirectoryRefs)
+	stateSourceObject.Load(7, &s.locks)
+	stateSourceObject.Load(8, &s.fdOpts)
 }
 
-func (x *AlwaysValid) StateTypeName() string {
+func (a *AlwaysValid) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.AlwaysValid"
 }
 
-func (x *AlwaysValid) StateFields() []string {
+func (a *AlwaysValid) StateFields() []string {
 	return []string{}
 }
 
-func (x *AlwaysValid) beforeSave() {}
+func (a *AlwaysValid) beforeSave() {}
 
-func (x *AlwaysValid) StateSave(m state.Sink) {
-	x.beforeSave()
+func (a *AlwaysValid) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
 }
 
-func (x *AlwaysValid) afterLoad() {}
+func (a *AlwaysValid) afterLoad() {}
 
-func (x *AlwaysValid) StateLoad(m state.Source) {
+func (a *AlwaysValid) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *InodeNoStatFS) StateTypeName() string {
+func (i *InodeNoStatFS) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.InodeNoStatFS"
 }
 
-func (x *InodeNoStatFS) StateFields() []string {
+func (i *InodeNoStatFS) StateFields() []string {
 	return []string{}
 }
 
-func (x *InodeNoStatFS) beforeSave() {}
+func (i *InodeNoStatFS) beforeSave() {}
 
-func (x *InodeNoStatFS) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *InodeNoStatFS) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *InodeNoStatFS) afterLoad() {}
+func (i *InodeNoStatFS) afterLoad() {}
 
-func (x *InodeNoStatFS) StateLoad(m state.Source) {
+func (i *InodeNoStatFS) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *Filesystem) StateTypeName() string {
+func (f *Filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.Filesystem"
 }
 
-func (x *Filesystem) StateFields() []string {
+func (f *Filesystem) StateFields() []string {
 	return []string{
 		"vfsfs",
 		"droppedDentries",
@@ -533,28 +533,28 @@ func (x *Filesystem) StateFields() []string {
 	}
 }
 
-func (x *Filesystem) beforeSave() {}
+func (f *Filesystem) beforeSave() {}
 
-func (x *Filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfs)
-	m.Save(1, &x.droppedDentries)
-	m.Save(2, &x.nextInoMinusOne)
+func (f *Filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfs)
+	stateSinkObject.Save(1, &f.droppedDentries)
+	stateSinkObject.Save(2, &f.nextInoMinusOne)
 }
 
-func (x *Filesystem) afterLoad() {}
+func (f *Filesystem) afterLoad() {}
 
-func (x *Filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfs)
-	m.Load(1, &x.droppedDentries)
-	m.Load(2, &x.nextInoMinusOne)
+func (f *Filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfs)
+	stateSourceObject.Load(1, &f.droppedDentries)
+	stateSourceObject.Load(2, &f.nextInoMinusOne)
 }
 
-func (x *Dentry) StateTypeName() string {
+func (d *Dentry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.Dentry"
 }
 
-func (x *Dentry) StateFields() []string {
+func (d *Dentry) StateFields() []string {
 	return []string{
 		"DentryRefs",
 		"vfsd",
@@ -566,111 +566,111 @@ func (x *Dentry) StateFields() []string {
 	}
 }
 
-func (x *Dentry) beforeSave() {}
+func (d *Dentry) beforeSave() {}
 
-func (x *Dentry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DentryRefs)
-	m.Save(1, &x.vfsd)
-	m.Save(2, &x.flags)
-	m.Save(3, &x.parent)
-	m.Save(4, &x.name)
-	m.Save(5, &x.children)
-	m.Save(6, &x.inode)
+func (d *Dentry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.DentryRefs)
+	stateSinkObject.Save(1, &d.vfsd)
+	stateSinkObject.Save(2, &d.flags)
+	stateSinkObject.Save(3, &d.parent)
+	stateSinkObject.Save(4, &d.name)
+	stateSinkObject.Save(5, &d.children)
+	stateSinkObject.Save(6, &d.inode)
 }
 
-func (x *Dentry) afterLoad() {}
+func (d *Dentry) afterLoad() {}
 
-func (x *Dentry) StateLoad(m state.Source) {
-	m.Load(0, &x.DentryRefs)
-	m.Load(1, &x.vfsd)
-	m.Load(2, &x.flags)
-	m.Load(3, &x.parent)
-	m.Load(4, &x.name)
-	m.Load(5, &x.children)
-	m.Load(6, &x.inode)
+func (d *Dentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.DentryRefs)
+	stateSourceObject.Load(1, &d.vfsd)
+	stateSourceObject.Load(2, &d.flags)
+	stateSourceObject.Load(3, &d.parent)
+	stateSourceObject.Load(4, &d.name)
+	stateSourceObject.Load(5, &d.children)
+	stateSourceObject.Load(6, &d.inode)
 }
 
-func (x *slotList) StateTypeName() string {
+func (s *slotList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.slotList"
 }
 
-func (x *slotList) StateFields() []string {
+func (s *slotList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *slotList) beforeSave() {}
+func (s *slotList) beforeSave() {}
 
-func (x *slotList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (s *slotList) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.head)
+	stateSinkObject.Save(1, &s.tail)
 }
 
-func (x *slotList) afterLoad() {}
+func (s *slotList) afterLoad() {}
 
-func (x *slotList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (s *slotList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.head)
+	stateSourceObject.Load(1, &s.tail)
 }
 
-func (x *slotEntry) StateTypeName() string {
+func (s *slotEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.slotEntry"
 }
 
-func (x *slotEntry) StateFields() []string {
+func (s *slotEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *slotEntry) beforeSave() {}
+func (s *slotEntry) beforeSave() {}
 
-func (x *slotEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (s *slotEntry) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.next)
+	stateSinkObject.Save(1, &s.prev)
 }
 
-func (x *slotEntry) afterLoad() {}
+func (s *slotEntry) afterLoad() {}
 
-func (x *slotEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (s *slotEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.next)
+	stateSourceObject.Load(1, &s.prev)
 }
 
-func (x *StaticDirectoryRefs) StateTypeName() string {
+func (s *StaticDirectoryRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.StaticDirectoryRefs"
 }
 
-func (x *StaticDirectoryRefs) StateFields() []string {
+func (s *StaticDirectoryRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *StaticDirectoryRefs) beforeSave() {}
+func (s *StaticDirectoryRefs) beforeSave() {}
 
-func (x *StaticDirectoryRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (s *StaticDirectoryRefs) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.refCount)
 }
 
-func (x *StaticDirectoryRefs) afterLoad() {}
+func (s *StaticDirectoryRefs) afterLoad() {}
 
-func (x *StaticDirectoryRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (s *StaticDirectoryRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.refCount)
 }
 
-func (x *StaticSymlink) StateTypeName() string {
+func (s *StaticSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.StaticSymlink"
 }
 
-func (x *StaticSymlink) StateFields() []string {
+func (s *StaticSymlink) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeNoopRefCount",
@@ -680,32 +680,32 @@ func (x *StaticSymlink) StateFields() []string {
 	}
 }
 
-func (x *StaticSymlink) beforeSave() {}
+func (s *StaticSymlink) beforeSave() {}
 
-func (x *StaticSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeNoopRefCount)
-	m.Save(2, &x.InodeSymlink)
-	m.Save(3, &x.InodeNoStatFS)
-	m.Save(4, &x.target)
+func (s *StaticSymlink) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.InodeAttrs)
+	stateSinkObject.Save(1, &s.InodeNoopRefCount)
+	stateSinkObject.Save(2, &s.InodeSymlink)
+	stateSinkObject.Save(3, &s.InodeNoStatFS)
+	stateSinkObject.Save(4, &s.target)
 }
 
-func (x *StaticSymlink) afterLoad() {}
+func (s *StaticSymlink) afterLoad() {}
 
-func (x *StaticSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeNoopRefCount)
-	m.Load(2, &x.InodeSymlink)
-	m.Load(3, &x.InodeNoStatFS)
-	m.Load(4, &x.target)
+func (s *StaticSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.InodeAttrs)
+	stateSourceObject.Load(1, &s.InodeNoopRefCount)
+	stateSourceObject.Load(2, &s.InodeSymlink)
+	stateSourceObject.Load(3, &s.InodeNoStatFS)
+	stateSourceObject.Load(4, &s.target)
 }
 
-func (x *syntheticDirectory) StateTypeName() string {
+func (s *syntheticDirectory) StateTypeName() string {
 	return "pkg/sentry/fsimpl/kernfs.syntheticDirectory"
 }
 
-func (x *syntheticDirectory) StateFields() []string {
+func (s *syntheticDirectory) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeNoStatFS",
@@ -717,29 +717,29 @@ func (x *syntheticDirectory) StateFields() []string {
 	}
 }
 
-func (x *syntheticDirectory) beforeSave() {}
+func (s *syntheticDirectory) beforeSave() {}
 
-func (x *syntheticDirectory) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeNoStatFS)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeNoDynamicLookup)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.locks)
+func (s *syntheticDirectory) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.InodeAttrs)
+	stateSinkObject.Save(1, &s.InodeNoStatFS)
+	stateSinkObject.Save(2, &s.InodeNoopRefCount)
+	stateSinkObject.Save(3, &s.InodeNoDynamicLookup)
+	stateSinkObject.Save(4, &s.InodeNotSymlink)
+	stateSinkObject.Save(5, &s.OrderedChildren)
+	stateSinkObject.Save(6, &s.locks)
 }
 
-func (x *syntheticDirectory) afterLoad() {}
+func (s *syntheticDirectory) afterLoad() {}
 
-func (x *syntheticDirectory) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeNoStatFS)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeNoDynamicLookup)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.locks)
+func (s *syntheticDirectory) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.InodeAttrs)
+	stateSourceObject.Load(1, &s.InodeNoStatFS)
+	stateSourceObject.Load(2, &s.InodeNoopRefCount)
+	stateSourceObject.Load(3, &s.InodeNoDynamicLookup)
+	stateSourceObject.Load(4, &s.InodeNotSymlink)
+	stateSourceObject.Load(5, &s.OrderedChildren)
+	stateSourceObject.Load(6, &s.locks)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go b/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go
index d3e649672..bf2f3fb30 100644
--- a/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go
+++ b/pkg/sentry/fsimpl/overlay/overlay_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *directoryFD) StateTypeName() string {
+func (d *directoryFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.directoryFD"
 }
 
-func (x *directoryFD) StateFields() []string {
+func (d *directoryFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"DirectoryFileDescriptionDefaultImpl",
@@ -20,32 +20,32 @@ func (x *directoryFD) StateFields() []string {
 	}
 }
 
-func (x *directoryFD) beforeSave() {}
+func (d *directoryFD) beforeSave() {}
 
-func (x *directoryFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.off)
-	m.Save(4, &x.dirents)
+func (d *directoryFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.fileDescription)
+	stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &d.off)
+	stateSinkObject.Save(4, &d.dirents)
 }
 
-func (x *directoryFD) afterLoad() {}
+func (d *directoryFD) afterLoad() {}
 
-func (x *directoryFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.off)
-	m.Load(4, &x.dirents)
+func (d *directoryFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.fileDescription)
+	stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &d.off)
+	stateSourceObject.Load(4, &d.dirents)
 }
 
-func (x *nonDirectoryFD) StateTypeName() string {
+func (n *nonDirectoryFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.nonDirectoryFD"
 }
 
-func (x *nonDirectoryFD) StateFields() []string {
+func (n *nonDirectoryFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"copiedUp",
@@ -54,75 +54,75 @@ func (x *nonDirectoryFD) StateFields() []string {
 	}
 }
 
-func (x *nonDirectoryFD) beforeSave() {}
+func (n *nonDirectoryFD) beforeSave() {}
 
-func (x *nonDirectoryFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.copiedUp)
-	m.Save(2, &x.cachedFD)
-	m.Save(3, &x.cachedFlags)
+func (n *nonDirectoryFD) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.fileDescription)
+	stateSinkObject.Save(1, &n.copiedUp)
+	stateSinkObject.Save(2, &n.cachedFD)
+	stateSinkObject.Save(3, &n.cachedFlags)
 }
 
-func (x *nonDirectoryFD) afterLoad() {}
+func (n *nonDirectoryFD) afterLoad() {}
 
-func (x *nonDirectoryFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.copiedUp)
-	m.Load(2, &x.cachedFD)
-	m.Load(3, &x.cachedFlags)
+func (n *nonDirectoryFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.fileDescription)
+	stateSourceObject.Load(1, &n.copiedUp)
+	stateSourceObject.Load(2, &n.cachedFD)
+	stateSourceObject.Load(3, &n.cachedFlags)
 }
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *FilesystemOptions) StateTypeName() string {
+func (f *FilesystemOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.FilesystemOptions"
 }
 
-func (x *FilesystemOptions) StateFields() []string {
+func (f *FilesystemOptions) StateFields() []string {
 	return []string{
 		"UpperRoot",
 		"LowerRoots",
 	}
 }
 
-func (x *FilesystemOptions) beforeSave() {}
+func (f *FilesystemOptions) beforeSave() {}
 
-func (x *FilesystemOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.UpperRoot)
-	m.Save(1, &x.LowerRoots)
+func (f *FilesystemOptions) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.UpperRoot)
+	stateSinkObject.Save(1, &f.LowerRoots)
 }
 
-func (x *FilesystemOptions) afterLoad() {}
+func (f *FilesystemOptions) afterLoad() {}
 
-func (x *FilesystemOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.UpperRoot)
-	m.Load(1, &x.LowerRoots)
+func (f *FilesystemOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.UpperRoot)
+	stateSourceObject.Load(1, &f.LowerRoots)
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"vfsfs",
 		"opts",
@@ -133,34 +133,34 @@ func (x *filesystem) StateFields() []string {
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfs)
-	m.Save(1, &x.opts)
-	m.Save(2, &x.creds)
-	m.Save(3, &x.dirDevMinor)
-	m.Save(4, &x.lowerDevMinors)
-	m.Save(5, &x.lastDirIno)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfs)
+	stateSinkObject.Save(1, &f.opts)
+	stateSinkObject.Save(2, &f.creds)
+	stateSinkObject.Save(3, &f.dirDevMinor)
+	stateSinkObject.Save(4, &f.lowerDevMinors)
+	stateSinkObject.Save(5, &f.lastDirIno)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfs)
-	m.Load(1, &x.opts)
-	m.Load(2, &x.creds)
-	m.Load(3, &x.dirDevMinor)
-	m.Load(4, &x.lowerDevMinors)
-	m.Load(5, &x.lastDirIno)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfs)
+	stateSourceObject.Load(1, &f.opts)
+	stateSourceObject.Load(2, &f.creds)
+	stateSourceObject.Load(3, &f.dirDevMinor)
+	stateSourceObject.Load(4, &f.lowerDevMinors)
+	stateSourceObject.Load(5, &f.lastDirIno)
 }
 
-func (x *dentry) StateTypeName() string {
+func (d *dentry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.dentry"
 }
 
-func (x *dentry) StateFields() []string {
+func (d *dentry) StateFields() []string {
 	return []string{
 		"vfsd",
 		"refs",
@@ -189,70 +189,70 @@ func (x *dentry) StateFields() []string {
 	}
 }
 
-func (x *dentry) beforeSave() {}
-
-func (x *dentry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsd)
-	m.Save(1, &x.refs)
-	m.Save(2, &x.fs)
-	m.Save(3, &x.mode)
-	m.Save(4, &x.uid)
-	m.Save(5, &x.gid)
-	m.Save(6, &x.copiedUp)
-	m.Save(7, &x.parent)
-	m.Save(8, &x.name)
-	m.Save(9, &x.children)
-	m.Save(10, &x.dirents)
-	m.Save(11, &x.upperVD)
-	m.Save(12, &x.lowerVDs)
-	m.Save(13, &x.inlineLowerVDs)
-	m.Save(14, &x.devMajor)
-	m.Save(15, &x.devMinor)
-	m.Save(16, &x.ino)
-	m.Save(17, &x.mapsMu)
-	m.Save(18, &x.lowerMappings)
-	m.Save(19, &x.dataMu)
-	m.Save(20, &x.wrappedMappable)
-	m.Save(21, &x.isMappable)
-	m.Save(22, &x.locks)
-	m.Save(23, &x.watches)
+func (d *dentry) beforeSave() {}
+
+func (d *dentry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.vfsd)
+	stateSinkObject.Save(1, &d.refs)
+	stateSinkObject.Save(2, &d.fs)
+	stateSinkObject.Save(3, &d.mode)
+	stateSinkObject.Save(4, &d.uid)
+	stateSinkObject.Save(5, &d.gid)
+	stateSinkObject.Save(6, &d.copiedUp)
+	stateSinkObject.Save(7, &d.parent)
+	stateSinkObject.Save(8, &d.name)
+	stateSinkObject.Save(9, &d.children)
+	stateSinkObject.Save(10, &d.dirents)
+	stateSinkObject.Save(11, &d.upperVD)
+	stateSinkObject.Save(12, &d.lowerVDs)
+	stateSinkObject.Save(13, &d.inlineLowerVDs)
+	stateSinkObject.Save(14, &d.devMajor)
+	stateSinkObject.Save(15, &d.devMinor)
+	stateSinkObject.Save(16, &d.ino)
+	stateSinkObject.Save(17, &d.mapsMu)
+	stateSinkObject.Save(18, &d.lowerMappings)
+	stateSinkObject.Save(19, &d.dataMu)
+	stateSinkObject.Save(20, &d.wrappedMappable)
+	stateSinkObject.Save(21, &d.isMappable)
+	stateSinkObject.Save(22, &d.locks)
+	stateSinkObject.Save(23, &d.watches)
 }
 
-func (x *dentry) afterLoad() {}
-
-func (x *dentry) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsd)
-	m.Load(1, &x.refs)
-	m.Load(2, &x.fs)
-	m.Load(3, &x.mode)
-	m.Load(4, &x.uid)
-	m.Load(5, &x.gid)
-	m.Load(6, &x.copiedUp)
-	m.Load(7, &x.parent)
-	m.Load(8, &x.name)
-	m.Load(9, &x.children)
-	m.Load(10, &x.dirents)
-	m.Load(11, &x.upperVD)
-	m.Load(12, &x.lowerVDs)
-	m.Load(13, &x.inlineLowerVDs)
-	m.Load(14, &x.devMajor)
-	m.Load(15, &x.devMinor)
-	m.Load(16, &x.ino)
-	m.Load(17, &x.mapsMu)
-	m.Load(18, &x.lowerMappings)
-	m.Load(19, &x.dataMu)
-	m.Load(20, &x.wrappedMappable)
-	m.Load(21, &x.isMappable)
-	m.Load(22, &x.locks)
-	m.Load(23, &x.watches)
+func (d *dentry) afterLoad() {}
+
+func (d *dentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsd)
+	stateSourceObject.Load(1, &d.refs)
+	stateSourceObject.Load(2, &d.fs)
+	stateSourceObject.Load(3, &d.mode)
+	stateSourceObject.Load(4, &d.uid)
+	stateSourceObject.Load(5, &d.gid)
+	stateSourceObject.Load(6, &d.copiedUp)
+	stateSourceObject.Load(7, &d.parent)
+	stateSourceObject.Load(8, &d.name)
+	stateSourceObject.Load(9, &d.children)
+	stateSourceObject.Load(10, &d.dirents)
+	stateSourceObject.Load(11, &d.upperVD)
+	stateSourceObject.Load(12, &d.lowerVDs)
+	stateSourceObject.Load(13, &d.inlineLowerVDs)
+	stateSourceObject.Load(14, &d.devMajor)
+	stateSourceObject.Load(15, &d.devMinor)
+	stateSourceObject.Load(16, &d.ino)
+	stateSourceObject.Load(17, &d.mapsMu)
+	stateSourceObject.Load(18, &d.lowerMappings)
+	stateSourceObject.Load(19, &d.dataMu)
+	stateSourceObject.Load(20, &d.wrappedMappable)
+	stateSourceObject.Load(21, &d.isMappable)
+	stateSourceObject.Load(22, &d.locks)
+	stateSourceObject.Load(23, &d.watches)
 }
 
-func (x *fileDescription) StateTypeName() string {
+func (f *fileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/overlay.fileDescription"
 }
 
-func (x *fileDescription) StateFields() []string {
+func (f *fileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -260,21 +260,21 @@ func (x *fileDescription) StateFields() []string {
 	}
 }
 
-func (x *fileDescription) beforeSave() {}
+func (f *fileDescription) beforeSave() {}
 
-func (x *fileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
+func (f *fileDescription) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfd)
+	stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &f.LockFD)
 }
 
-func (x *fileDescription) afterLoad() {}
+func (f *fileDescription) afterLoad() {}
 
-func (x *fileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
+func (f *fileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfd)
+	stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &f.LockFD)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go b/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go
index bdb899396..384af5bf0 100644
--- a/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go
+++ b/pkg/sentry/fsimpl/pipefs/pipefs_state_autogen.go
@@ -6,56 +6,56 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *filesystemType) StateTypeName() string {
+func (f *filesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/pipefs.filesystemType"
 }
 
-func (x *filesystemType) StateFields() []string {
+func (f *filesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *filesystemType) beforeSave() {}
+func (f *filesystemType) beforeSave() {}
 
-func (x *filesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *filesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *filesystemType) afterLoad() {}
+func (f *filesystemType) afterLoad() {}
 
-func (x *filesystemType) StateLoad(m state.Source) {
+func (f *filesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/pipefs.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/pipefs.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"InodeNotDirectory",
 		"InodeNotSymlink",
@@ -69,33 +69,33 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
-
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeNotDirectory)
-	m.Save(1, &x.InodeNotSymlink)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.locks)
-	m.Save(4, &x.pipe)
-	m.Save(5, &x.ino)
-	m.Save(6, &x.uid)
-	m.Save(7, &x.gid)
-	m.Save(8, &x.ctime)
+func (i *inode) beforeSave() {}
+
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.InodeNotDirectory)
+	stateSinkObject.Save(1, &i.InodeNotSymlink)
+	stateSinkObject.Save(2, &i.InodeNoopRefCount)
+	stateSinkObject.Save(3, &i.locks)
+	stateSinkObject.Save(4, &i.pipe)
+	stateSinkObject.Save(5, &i.ino)
+	stateSinkObject.Save(6, &i.uid)
+	stateSinkObject.Save(7, &i.gid)
+	stateSinkObject.Save(8, &i.ctime)
 }
 
-func (x *inode) afterLoad() {}
-
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeNotDirectory)
-	m.Load(1, &x.InodeNotSymlink)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.locks)
-	m.Load(4, &x.pipe)
-	m.Load(5, &x.ino)
-	m.Load(6, &x.uid)
-	m.Load(7, &x.gid)
-	m.Load(8, &x.ctime)
+func (i *inode) afterLoad() {}
+
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.InodeNotDirectory)
+	stateSourceObject.Load(1, &i.InodeNotSymlink)
+	stateSourceObject.Load(2, &i.InodeNoopRefCount)
+	stateSourceObject.Load(3, &i.locks)
+	stateSourceObject.Load(4, &i.pipe)
+	stateSourceObject.Load(5, &i.ino)
+	stateSourceObject.Load(6, &i.uid)
+	stateSourceObject.Load(7, &i.gid)
+	stateSourceObject.Load(8, &i.ctime)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/proc/proc_state_autogen.go b/pkg/sentry/fsimpl/proc/proc_state_autogen.go
index 83100aa15..72fc112e2 100644
--- a/pkg/sentry/fsimpl/proc/proc_state_autogen.go
+++ b/pkg/sentry/fsimpl/proc/proc_state_autogen.go
@@ -6,170 +6,170 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *fdDirInodeRefs) StateTypeName() string {
+func (f *fdDirInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdDirInodeRefs"
 }
 
-func (x *fdDirInodeRefs) StateFields() []string {
+func (f *fdDirInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *fdDirInodeRefs) beforeSave() {}
+func (f *fdDirInodeRefs) beforeSave() {}
 
-func (x *fdDirInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (f *fdDirInodeRefs) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.refCount)
 }
 
-func (x *fdDirInodeRefs) afterLoad() {}
+func (f *fdDirInodeRefs) afterLoad() {}
 
-func (x *fdDirInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (f *fdDirInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.refCount)
 }
 
-func (x *fdInfoDirInodeRefs) StateTypeName() string {
+func (f *fdInfoDirInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdInfoDirInodeRefs"
 }
 
-func (x *fdInfoDirInodeRefs) StateFields() []string {
+func (f *fdInfoDirInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *fdInfoDirInodeRefs) beforeSave() {}
+func (f *fdInfoDirInodeRefs) beforeSave() {}
 
-func (x *fdInfoDirInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (f *fdInfoDirInodeRefs) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.refCount)
 }
 
-func (x *fdInfoDirInodeRefs) afterLoad() {}
+func (f *fdInfoDirInodeRefs) afterLoad() {}
 
-func (x *fdInfoDirInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (f *fdInfoDirInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.refCount)
 }
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *staticFile) StateTypeName() string {
+func (s *staticFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.staticFile"
 }
 
-func (x *staticFile) StateFields() []string {
+func (s *staticFile) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"StaticData",
 	}
 }
 
-func (x *staticFile) beforeSave() {}
+func (s *staticFile) beforeSave() {}
 
-func (x *staticFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.StaticData)
+func (s *staticFile) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.DynamicBytesFile)
+	stateSinkObject.Save(1, &s.StaticData)
 }
 
-func (x *staticFile) afterLoad() {}
+func (s *staticFile) afterLoad() {}
 
-func (x *staticFile) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.StaticData)
+func (s *staticFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.DynamicBytesFile)
+	stateSourceObject.Load(1, &s.StaticData)
 }
 
-func (x *InternalData) StateTypeName() string {
+func (i *InternalData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.InternalData"
 }
 
-func (x *InternalData) StateFields() []string {
+func (i *InternalData) StateFields() []string {
 	return []string{
 		"Cgroups",
 	}
 }
 
-func (x *InternalData) beforeSave() {}
+func (i *InternalData) beforeSave() {}
 
-func (x *InternalData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Cgroups)
+func (i *InternalData) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.Cgroups)
 }
 
-func (x *InternalData) afterLoad() {}
+func (i *InternalData) afterLoad() {}
 
-func (x *InternalData) StateLoad(m state.Source) {
-	m.Load(0, &x.Cgroups)
+func (i *InternalData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.Cgroups)
 }
 
-func (x *implStatFS) StateTypeName() string {
+func (i *implStatFS) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.implStatFS"
 }
 
-func (x *implStatFS) StateFields() []string {
+func (i *implStatFS) StateFields() []string {
 	return []string{}
 }
 
-func (x *implStatFS) beforeSave() {}
+func (i *implStatFS) beforeSave() {}
 
-func (x *implStatFS) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *implStatFS) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *implStatFS) afterLoad() {}
+func (i *implStatFS) afterLoad() {}
 
-func (x *implStatFS) StateLoad(m state.Source) {
+func (i *implStatFS) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *subtasksInode) StateTypeName() string {
+func (s *subtasksInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.subtasksInode"
 }
 
-func (x *subtasksInode) StateFields() []string {
+func (s *subtasksInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"AlwaysValid",
@@ -186,95 +186,95 @@ func (x *subtasksInode) StateFields() []string {
 	}
 }
 
-func (x *subtasksInode) beforeSave() {}
+func (s *subtasksInode) beforeSave() {}
 
-func (x *subtasksInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.AlwaysValid)
-	m.Save(2, &x.InodeAttrs)
-	m.Save(3, &x.InodeDirectoryNoNewChildren)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.subtasksInodeRefs)
-	m.Save(7, &x.locks)
-	m.Save(8, &x.fs)
-	m.Save(9, &x.task)
-	m.Save(10, &x.pidns)
-	m.Save(11, &x.cgroupControllers)
+func (s *subtasksInode) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.implStatFS)
+	stateSinkObject.Save(1, &s.AlwaysValid)
+	stateSinkObject.Save(2, &s.InodeAttrs)
+	stateSinkObject.Save(3, &s.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(4, &s.InodeNotSymlink)
+	stateSinkObject.Save(5, &s.OrderedChildren)
+	stateSinkObject.Save(6, &s.subtasksInodeRefs)
+	stateSinkObject.Save(7, &s.locks)
+	stateSinkObject.Save(8, &s.fs)
+	stateSinkObject.Save(9, &s.task)
+	stateSinkObject.Save(10, &s.pidns)
+	stateSinkObject.Save(11, &s.cgroupControllers)
 }
 
-func (x *subtasksInode) afterLoad() {}
+func (s *subtasksInode) afterLoad() {}
 
-func (x *subtasksInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.AlwaysValid)
-	m.Load(2, &x.InodeAttrs)
-	m.Load(3, &x.InodeDirectoryNoNewChildren)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.subtasksInodeRefs)
-	m.Load(7, &x.locks)
-	m.Load(8, &x.fs)
-	m.Load(9, &x.task)
-	m.Load(10, &x.pidns)
-	m.Load(11, &x.cgroupControllers)
+func (s *subtasksInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.implStatFS)
+	stateSourceObject.Load(1, &s.AlwaysValid)
+	stateSourceObject.Load(2, &s.InodeAttrs)
+	stateSourceObject.Load(3, &s.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(4, &s.InodeNotSymlink)
+	stateSourceObject.Load(5, &s.OrderedChildren)
+	stateSourceObject.Load(6, &s.subtasksInodeRefs)
+	stateSourceObject.Load(7, &s.locks)
+	stateSourceObject.Load(8, &s.fs)
+	stateSourceObject.Load(9, &s.task)
+	stateSourceObject.Load(10, &s.pidns)
+	stateSourceObject.Load(11, &s.cgroupControllers)
 }
 
-func (x *subtasksFD) StateTypeName() string {
+func (s *subtasksFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.subtasksFD"
 }
 
-func (x *subtasksFD) StateFields() []string {
+func (s *subtasksFD) StateFields() []string {
 	return []string{
 		"GenericDirectoryFD",
 		"task",
 	}
 }
 
-func (x *subtasksFD) beforeSave() {}
+func (s *subtasksFD) beforeSave() {}
 
-func (x *subtasksFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.GenericDirectoryFD)
-	m.Save(1, &x.task)
+func (s *subtasksFD) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.GenericDirectoryFD)
+	stateSinkObject.Save(1, &s.task)
 }
 
-func (x *subtasksFD) afterLoad() {}
+func (s *subtasksFD) afterLoad() {}
 
-func (x *subtasksFD) StateLoad(m state.Source) {
-	m.Load(0, &x.GenericDirectoryFD)
-	m.Load(1, &x.task)
+func (s *subtasksFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.GenericDirectoryFD)
+	stateSourceObject.Load(1, &s.task)
 }
 
-func (x *subtasksInodeRefs) StateTypeName() string {
+func (s *subtasksInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.subtasksInodeRefs"
 }
 
-func (x *subtasksInodeRefs) StateFields() []string {
+func (s *subtasksInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *subtasksInodeRefs) beforeSave() {}
+func (s *subtasksInodeRefs) beforeSave() {}
 
-func (x *subtasksInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (s *subtasksInodeRefs) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.refCount)
 }
 
-func (x *subtasksInodeRefs) afterLoad() {}
+func (s *subtasksInodeRefs) afterLoad() {}
 
-func (x *subtasksInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (s *subtasksInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.refCount)
 }
 
-func (x *taskInode) StateTypeName() string {
+func (t *taskInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.taskInode"
 }
 
-func (x *taskInode) StateFields() []string {
+func (t *taskInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -288,66 +288,66 @@ func (x *taskInode) StateFields() []string {
 	}
 }
 
-func (x *taskInode) beforeSave() {}
+func (t *taskInode) beforeSave() {}
 
-func (x *taskInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeDirectoryNoNewChildren)
-	m.Save(3, &x.InodeNoDynamicLookup)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.taskInodeRefs)
-	m.Save(7, &x.locks)
-	m.Save(8, &x.task)
+func (t *taskInode) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.implStatFS)
+	stateSinkObject.Save(1, &t.InodeAttrs)
+	stateSinkObject.Save(2, &t.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(3, &t.InodeNoDynamicLookup)
+	stateSinkObject.Save(4, &t.InodeNotSymlink)
+	stateSinkObject.Save(5, &t.OrderedChildren)
+	stateSinkObject.Save(6, &t.taskInodeRefs)
+	stateSinkObject.Save(7, &t.locks)
+	stateSinkObject.Save(8, &t.task)
 }
 
-func (x *taskInode) afterLoad() {}
+func (t *taskInode) afterLoad() {}
 
-func (x *taskInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeDirectoryNoNewChildren)
-	m.Load(3, &x.InodeNoDynamicLookup)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.taskInodeRefs)
-	m.Load(7, &x.locks)
-	m.Load(8, &x.task)
+func (t *taskInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.implStatFS)
+	stateSourceObject.Load(1, &t.InodeAttrs)
+	stateSourceObject.Load(2, &t.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(3, &t.InodeNoDynamicLookup)
+	stateSourceObject.Load(4, &t.InodeNotSymlink)
+	stateSourceObject.Load(5, &t.OrderedChildren)
+	stateSourceObject.Load(6, &t.taskInodeRefs)
+	stateSourceObject.Load(7, &t.locks)
+	stateSourceObject.Load(8, &t.task)
 }
 
-func (x *taskOwnedInode) StateTypeName() string {
+func (t *taskOwnedInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.taskOwnedInode"
 }
 
-func (x *taskOwnedInode) StateFields() []string {
+func (t *taskOwnedInode) StateFields() []string {
 	return []string{
 		"Inode",
 		"owner",
 	}
 }
 
-func (x *taskOwnedInode) beforeSave() {}
+func (t *taskOwnedInode) beforeSave() {}
 
-func (x *taskOwnedInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Inode)
-	m.Save(1, &x.owner)
+func (t *taskOwnedInode) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.Inode)
+	stateSinkObject.Save(1, &t.owner)
 }
 
-func (x *taskOwnedInode) afterLoad() {}
+func (t *taskOwnedInode) afterLoad() {}
 
-func (x *taskOwnedInode) StateLoad(m state.Source) {
-	m.Load(0, &x.Inode)
-	m.Load(1, &x.owner)
+func (t *taskOwnedInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.Inode)
+	stateSourceObject.Load(1, &t.owner)
 }
 
-func (x *fdDir) StateTypeName() string {
+func (f *fdDir) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdDir"
 }
 
-func (x *fdDir) StateFields() []string {
+func (f *fdDir) StateFields() []string {
 	return []string{
 		"locks",
 		"fs",
@@ -356,30 +356,30 @@ func (x *fdDir) StateFields() []string {
 	}
 }
 
-func (x *fdDir) beforeSave() {}
+func (f *fdDir) beforeSave() {}
 
-func (x *fdDir) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.locks)
-	m.Save(1, &x.fs)
-	m.Save(2, &x.task)
-	m.Save(3, &x.produceSymlink)
+func (f *fdDir) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.locks)
+	stateSinkObject.Save(1, &f.fs)
+	stateSinkObject.Save(2, &f.task)
+	stateSinkObject.Save(3, &f.produceSymlink)
 }
 
-func (x *fdDir) afterLoad() {}
+func (f *fdDir) afterLoad() {}
 
-func (x *fdDir) StateLoad(m state.Source) {
-	m.Load(0, &x.locks)
-	m.Load(1, &x.fs)
-	m.Load(2, &x.task)
-	m.Load(3, &x.produceSymlink)
+func (f *fdDir) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.locks)
+	stateSourceObject.Load(1, &f.fs)
+	stateSourceObject.Load(2, &f.task)
+	stateSourceObject.Load(3, &f.produceSymlink)
 }
 
-func (x *fdDirInode) StateTypeName() string {
+func (f *fdDirInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdDirInode"
 }
 
-func (x *fdDirInode) StateFields() []string {
+func (f *fdDirInode) StateFields() []string {
 	return []string{
 		"fdDir",
 		"fdDirInodeRefs",
@@ -392,38 +392,38 @@ func (x *fdDirInode) StateFields() []string {
 	}
 }
 
-func (x *fdDirInode) beforeSave() {}
+func (f *fdDirInode) beforeSave() {}
 
-func (x *fdDirInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fdDir)
-	m.Save(1, &x.fdDirInodeRefs)
-	m.Save(2, &x.implStatFS)
-	m.Save(3, &x.AlwaysValid)
-	m.Save(4, &x.InodeAttrs)
-	m.Save(5, &x.InodeDirectoryNoNewChildren)
-	m.Save(6, &x.InodeNotSymlink)
-	m.Save(7, &x.OrderedChildren)
+func (f *fdDirInode) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.fdDir)
+	stateSinkObject.Save(1, &f.fdDirInodeRefs)
+	stateSinkObject.Save(2, &f.implStatFS)
+	stateSinkObject.Save(3, &f.AlwaysValid)
+	stateSinkObject.Save(4, &f.InodeAttrs)
+	stateSinkObject.Save(5, &f.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(6, &f.InodeNotSymlink)
+	stateSinkObject.Save(7, &f.OrderedChildren)
 }
 
-func (x *fdDirInode) afterLoad() {}
+func (f *fdDirInode) afterLoad() {}
 
-func (x *fdDirInode) StateLoad(m state.Source) {
-	m.Load(0, &x.fdDir)
-	m.Load(1, &x.fdDirInodeRefs)
-	m.Load(2, &x.implStatFS)
-	m.Load(3, &x.AlwaysValid)
-	m.Load(4, &x.InodeAttrs)
-	m.Load(5, &x.InodeDirectoryNoNewChildren)
-	m.Load(6, &x.InodeNotSymlink)
-	m.Load(7, &x.OrderedChildren)
+func (f *fdDirInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.fdDir)
+	stateSourceObject.Load(1, &f.fdDirInodeRefs)
+	stateSourceObject.Load(2, &f.implStatFS)
+	stateSourceObject.Load(3, &f.AlwaysValid)
+	stateSourceObject.Load(4, &f.InodeAttrs)
+	stateSourceObject.Load(5, &f.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(6, &f.InodeNotSymlink)
+	stateSourceObject.Load(7, &f.OrderedChildren)
 }
 
-func (x *fdSymlink) StateTypeName() string {
+func (f *fdSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdSymlink"
 }
 
-func (x *fdSymlink) StateFields() []string {
+func (f *fdSymlink) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -434,34 +434,34 @@ func (x *fdSymlink) StateFields() []string {
 	}
 }
 
-func (x *fdSymlink) beforeSave() {}
+func (f *fdSymlink) beforeSave() {}
 
-func (x *fdSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeSymlink)
-	m.Save(4, &x.task)
-	m.Save(5, &x.fd)
+func (f *fdSymlink) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.implStatFS)
+	stateSinkObject.Save(1, &f.InodeAttrs)
+	stateSinkObject.Save(2, &f.InodeNoopRefCount)
+	stateSinkObject.Save(3, &f.InodeSymlink)
+	stateSinkObject.Save(4, &f.task)
+	stateSinkObject.Save(5, &f.fd)
 }
 
-func (x *fdSymlink) afterLoad() {}
+func (f *fdSymlink) afterLoad() {}
 
-func (x *fdSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeSymlink)
-	m.Load(4, &x.task)
-	m.Load(5, &x.fd)
+func (f *fdSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.implStatFS)
+	stateSourceObject.Load(1, &f.InodeAttrs)
+	stateSourceObject.Load(2, &f.InodeNoopRefCount)
+	stateSourceObject.Load(3, &f.InodeSymlink)
+	stateSourceObject.Load(4, &f.task)
+	stateSourceObject.Load(5, &f.fd)
 }
 
-func (x *fdInfoDirInode) StateTypeName() string {
+func (f *fdInfoDirInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdInfoDirInode"
 }
 
-func (x *fdInfoDirInode) StateFields() []string {
+func (f *fdInfoDirInode) StateFields() []string {
 	return []string{
 		"fdDir",
 		"fdInfoDirInodeRefs",
@@ -474,38 +474,38 @@ func (x *fdInfoDirInode) StateFields() []string {
 	}
 }
 
-func (x *fdInfoDirInode) beforeSave() {}
+func (f *fdInfoDirInode) beforeSave() {}
 
-func (x *fdInfoDirInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fdDir)
-	m.Save(1, &x.fdInfoDirInodeRefs)
-	m.Save(2, &x.implStatFS)
-	m.Save(3, &x.AlwaysValid)
-	m.Save(4, &x.InodeAttrs)
-	m.Save(5, &x.InodeDirectoryNoNewChildren)
-	m.Save(6, &x.InodeNotSymlink)
-	m.Save(7, &x.OrderedChildren)
+func (f *fdInfoDirInode) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.fdDir)
+	stateSinkObject.Save(1, &f.fdInfoDirInodeRefs)
+	stateSinkObject.Save(2, &f.implStatFS)
+	stateSinkObject.Save(3, &f.AlwaysValid)
+	stateSinkObject.Save(4, &f.InodeAttrs)
+	stateSinkObject.Save(5, &f.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(6, &f.InodeNotSymlink)
+	stateSinkObject.Save(7, &f.OrderedChildren)
 }
 
-func (x *fdInfoDirInode) afterLoad() {}
+func (f *fdInfoDirInode) afterLoad() {}
 
-func (x *fdInfoDirInode) StateLoad(m state.Source) {
-	m.Load(0, &x.fdDir)
-	m.Load(1, &x.fdInfoDirInodeRefs)
-	m.Load(2, &x.implStatFS)
-	m.Load(3, &x.AlwaysValid)
-	m.Load(4, &x.InodeAttrs)
-	m.Load(5, &x.InodeDirectoryNoNewChildren)
-	m.Load(6, &x.InodeNotSymlink)
-	m.Load(7, &x.OrderedChildren)
+func (f *fdInfoDirInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.fdDir)
+	stateSourceObject.Load(1, &f.fdInfoDirInodeRefs)
+	stateSourceObject.Load(2, &f.implStatFS)
+	stateSourceObject.Load(3, &f.AlwaysValid)
+	stateSourceObject.Load(4, &f.InodeAttrs)
+	stateSourceObject.Load(5, &f.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(6, &f.InodeNotSymlink)
+	stateSourceObject.Load(7, &f.OrderedChildren)
 }
 
-func (x *fdInfoData) StateTypeName() string {
+func (f *fdInfoData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.fdInfoData"
 }
 
-func (x *fdInfoData) StateFields() []string {
+func (f *fdInfoData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
@@ -513,54 +513,54 @@ func (x *fdInfoData) StateFields() []string {
 	}
 }
 
-func (x *fdInfoData) beforeSave() {}
+func (f *fdInfoData) beforeSave() {}
 
-func (x *fdInfoData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
-	m.Save(2, &x.fd)
+func (f *fdInfoData) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.DynamicBytesFile)
+	stateSinkObject.Save(1, &f.task)
+	stateSinkObject.Save(2, &f.fd)
 }
 
-func (x *fdInfoData) afterLoad() {}
+func (f *fdInfoData) afterLoad() {}
 
-func (x *fdInfoData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
-	m.Load(2, &x.fd)
+func (f *fdInfoData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.DynamicBytesFile)
+	stateSourceObject.Load(1, &f.task)
+	stateSourceObject.Load(2, &f.fd)
 }
 
-func (x *auxvData) StateTypeName() string {
+func (a *auxvData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.auxvData"
 }
 
-func (x *auxvData) StateFields() []string {
+func (a *auxvData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *auxvData) beforeSave() {}
+func (a *auxvData) beforeSave() {}
 
-func (x *auxvData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (a *auxvData) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	stateSinkObject.Save(0, &a.DynamicBytesFile)
+	stateSinkObject.Save(1, &a.task)
 }
 
-func (x *auxvData) afterLoad() {}
+func (a *auxvData) afterLoad() {}
 
-func (x *auxvData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (a *auxvData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &a.DynamicBytesFile)
+	stateSourceObject.Load(1, &a.task)
 }
 
-func (x *cmdlineData) StateTypeName() string {
+func (c *cmdlineData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.cmdlineData"
 }
 
-func (x *cmdlineData) StateFields() []string {
+func (c *cmdlineData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
@@ -568,80 +568,80 @@ func (x *cmdlineData) StateFields() []string {
 	}
 }
 
-func (x *cmdlineData) beforeSave() {}
+func (c *cmdlineData) beforeSave() {}
 
-func (x *cmdlineData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
-	m.Save(2, &x.arg)
+func (c *cmdlineData) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.DynamicBytesFile)
+	stateSinkObject.Save(1, &c.task)
+	stateSinkObject.Save(2, &c.arg)
 }
 
-func (x *cmdlineData) afterLoad() {}
+func (c *cmdlineData) afterLoad() {}
 
-func (x *cmdlineData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
-	m.Load(2, &x.arg)
+func (c *cmdlineData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.DynamicBytesFile)
+	stateSourceObject.Load(1, &c.task)
+	stateSourceObject.Load(2, &c.arg)
 }
 
-func (x *commInode) StateTypeName() string {
+func (c *commInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.commInode"
 }
 
-func (x *commInode) StateFields() []string {
+func (c *commInode) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *commInode) beforeSave() {}
+func (c *commInode) beforeSave() {}
 
-func (x *commInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (c *commInode) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.DynamicBytesFile)
+	stateSinkObject.Save(1, &c.task)
 }
 
-func (x *commInode) afterLoad() {}
+func (c *commInode) afterLoad() {}
 
-func (x *commInode) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (c *commInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.DynamicBytesFile)
+	stateSourceObject.Load(1, &c.task)
 }
 
-func (x *commData) StateTypeName() string {
+func (c *commData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.commData"
 }
 
-func (x *commData) StateFields() []string {
+func (c *commData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *commData) beforeSave() {}
+func (c *commData) beforeSave() {}
 
-func (x *commData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (c *commData) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.DynamicBytesFile)
+	stateSinkObject.Save(1, &c.task)
 }
 
-func (x *commData) afterLoad() {}
+func (c *commData) afterLoad() {}
 
-func (x *commData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (c *commData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.DynamicBytesFile)
+	stateSourceObject.Load(1, &c.task)
 }
 
-func (x *idMapData) StateTypeName() string {
+func (i *idMapData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.idMapData"
 }
 
-func (x *idMapData) StateFields() []string {
+func (i *idMapData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
@@ -649,80 +649,80 @@ func (x *idMapData) StateFields() []string {
 	}
 }
 
-func (x *idMapData) beforeSave() {}
+func (i *idMapData) beforeSave() {}
 
-func (x *idMapData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
-	m.Save(2, &x.gids)
+func (i *idMapData) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.DynamicBytesFile)
+	stateSinkObject.Save(1, &i.task)
+	stateSinkObject.Save(2, &i.gids)
 }
 
-func (x *idMapData) afterLoad() {}
+func (i *idMapData) afterLoad() {}
 
-func (x *idMapData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
-	m.Load(2, &x.gids)
+func (i *idMapData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.DynamicBytesFile)
+	stateSourceObject.Load(1, &i.task)
+	stateSourceObject.Load(2, &i.gids)
 }
 
-func (x *mapsData) StateTypeName() string {
+func (m *mapsData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.mapsData"
 }
 
-func (x *mapsData) StateFields() []string {
+func (m *mapsData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *mapsData) beforeSave() {}
+func (m *mapsData) beforeSave() {}
 
-func (x *mapsData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (m *mapsData) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.DynamicBytesFile)
+	stateSinkObject.Save(1, &m.task)
 }
 
-func (x *mapsData) afterLoad() {}
+func (m *mapsData) afterLoad() {}
 
-func (x *mapsData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (m *mapsData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.DynamicBytesFile)
+	stateSourceObject.Load(1, &m.task)
 }
 
-func (x *smapsData) StateTypeName() string {
+func (s *smapsData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.smapsData"
 }
 
-func (x *smapsData) StateFields() []string {
+func (s *smapsData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *smapsData) beforeSave() {}
+func (s *smapsData) beforeSave() {}
 
-func (x *smapsData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (s *smapsData) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.DynamicBytesFile)
+	stateSinkObject.Save(1, &s.task)
 }
 
-func (x *smapsData) afterLoad() {}
+func (s *smapsData) afterLoad() {}
 
-func (x *smapsData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (s *smapsData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.DynamicBytesFile)
+	stateSourceObject.Load(1, &s.task)
 }
 
-func (x *taskStatData) StateTypeName() string {
+func (t *taskStatData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.taskStatData"
 }
 
-func (x *taskStatData) StateFields() []string {
+func (t *taskStatData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
@@ -731,56 +731,56 @@ func (x *taskStatData) StateFields() []string {
 	}
 }
 
-func (x *taskStatData) beforeSave() {}
+func (t *taskStatData) beforeSave() {}
 
-func (x *taskStatData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
-	m.Save(2, &x.tgstats)
-	m.Save(3, &x.pidns)
+func (t *taskStatData) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.DynamicBytesFile)
+	stateSinkObject.Save(1, &t.task)
+	stateSinkObject.Save(2, &t.tgstats)
+	stateSinkObject.Save(3, &t.pidns)
 }
 
-func (x *taskStatData) afterLoad() {}
+func (t *taskStatData) afterLoad() {}
 
-func (x *taskStatData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
-	m.Load(2, &x.tgstats)
-	m.Load(3, &x.pidns)
+func (t *taskStatData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.DynamicBytesFile)
+	stateSourceObject.Load(1, &t.task)
+	stateSourceObject.Load(2, &t.tgstats)
+	stateSourceObject.Load(3, &t.pidns)
 }
 
-func (x *statmData) StateTypeName() string {
+func (s *statmData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.statmData"
 }
 
-func (x *statmData) StateFields() []string {
+func (s *statmData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *statmData) beforeSave() {}
+func (s *statmData) beforeSave() {}
 
-func (x *statmData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (s *statmData) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.DynamicBytesFile)
+	stateSinkObject.Save(1, &s.task)
 }
 
-func (x *statmData) afterLoad() {}
+func (s *statmData) afterLoad() {}
 
-func (x *statmData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (s *statmData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.DynamicBytesFile)
+	stateSourceObject.Load(1, &s.task)
 }
 
-func (x *statusData) StateTypeName() string {
+func (s *statusData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.statusData"
 }
 
-func (x *statusData) StateFields() []string {
+func (s *statusData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
@@ -788,80 +788,80 @@ func (x *statusData) StateFields() []string {
 	}
 }
 
-func (x *statusData) beforeSave() {}
+func (s *statusData) beforeSave() {}
 
-func (x *statusData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
-	m.Save(2, &x.pidns)
+func (s *statusData) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.DynamicBytesFile)
+	stateSinkObject.Save(1, &s.task)
+	stateSinkObject.Save(2, &s.pidns)
 }
 
-func (x *statusData) afterLoad() {}
+func (s *statusData) afterLoad() {}
 
-func (x *statusData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
-	m.Load(2, &x.pidns)
+func (s *statusData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.DynamicBytesFile)
+	stateSourceObject.Load(1, &s.task)
+	stateSourceObject.Load(2, &s.pidns)
 }
 
-func (x *ioData) StateTypeName() string {
+func (i *ioData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.ioData"
 }
 
-func (x *ioData) StateFields() []string {
+func (i *ioData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"ioUsage",
 	}
 }
 
-func (x *ioData) beforeSave() {}
+func (i *ioData) beforeSave() {}
 
-func (x *ioData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.ioUsage)
+func (i *ioData) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.DynamicBytesFile)
+	stateSinkObject.Save(1, &i.ioUsage)
 }
 
-func (x *ioData) afterLoad() {}
+func (i *ioData) afterLoad() {}
 
-func (x *ioData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.ioUsage)
+func (i *ioData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.DynamicBytesFile)
+	stateSourceObject.Load(1, &i.ioUsage)
 }
 
-func (x *oomScoreAdj) StateTypeName() string {
+func (o *oomScoreAdj) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.oomScoreAdj"
 }
 
-func (x *oomScoreAdj) StateFields() []string {
+func (o *oomScoreAdj) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *oomScoreAdj) beforeSave() {}
+func (o *oomScoreAdj) beforeSave() {}
 
-func (x *oomScoreAdj) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (o *oomScoreAdj) StateSave(stateSinkObject state.Sink) {
+	o.beforeSave()
+	stateSinkObject.Save(0, &o.DynamicBytesFile)
+	stateSinkObject.Save(1, &o.task)
 }
 
-func (x *oomScoreAdj) afterLoad() {}
+func (o *oomScoreAdj) afterLoad() {}
 
-func (x *oomScoreAdj) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (o *oomScoreAdj) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &o.DynamicBytesFile)
+	stateSourceObject.Load(1, &o.task)
 }
 
-func (x *exeSymlink) StateTypeName() string {
+func (e *exeSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.exeSymlink"
 }
 
-func (x *exeSymlink) StateFields() []string {
+func (e *exeSymlink) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -871,32 +871,32 @@ func (x *exeSymlink) StateFields() []string {
 	}
 }
 
-func (x *exeSymlink) beforeSave() {}
+func (e *exeSymlink) beforeSave() {}
 
-func (x *exeSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeSymlink)
-	m.Save(4, &x.task)
+func (e *exeSymlink) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.implStatFS)
+	stateSinkObject.Save(1, &e.InodeAttrs)
+	stateSinkObject.Save(2, &e.InodeNoopRefCount)
+	stateSinkObject.Save(3, &e.InodeSymlink)
+	stateSinkObject.Save(4, &e.task)
 }
 
-func (x *exeSymlink) afterLoad() {}
+func (e *exeSymlink) afterLoad() {}
 
-func (x *exeSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeSymlink)
-	m.Load(4, &x.task)
+func (e *exeSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.implStatFS)
+	stateSourceObject.Load(1, &e.InodeAttrs)
+	stateSourceObject.Load(2, &e.InodeNoopRefCount)
+	stateSourceObject.Load(3, &e.InodeSymlink)
+	stateSourceObject.Load(4, &e.task)
 }
 
-func (x *cwdSymlink) StateTypeName() string {
+func (c *cwdSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.cwdSymlink"
 }
 
-func (x *cwdSymlink) StateFields() []string {
+func (c *cwdSymlink) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -906,110 +906,110 @@ func (x *cwdSymlink) StateFields() []string {
 	}
 }
 
-func (x *cwdSymlink) beforeSave() {}
+func (c *cwdSymlink) beforeSave() {}
 
-func (x *cwdSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeSymlink)
-	m.Save(4, &x.task)
+func (c *cwdSymlink) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.implStatFS)
+	stateSinkObject.Save(1, &c.InodeAttrs)
+	stateSinkObject.Save(2, &c.InodeNoopRefCount)
+	stateSinkObject.Save(3, &c.InodeSymlink)
+	stateSinkObject.Save(4, &c.task)
 }
 
-func (x *cwdSymlink) afterLoad() {}
+func (c *cwdSymlink) afterLoad() {}
 
-func (x *cwdSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeSymlink)
-	m.Load(4, &x.task)
+func (c *cwdSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.implStatFS)
+	stateSourceObject.Load(1, &c.InodeAttrs)
+	stateSourceObject.Load(2, &c.InodeNoopRefCount)
+	stateSourceObject.Load(3, &c.InodeSymlink)
+	stateSourceObject.Load(4, &c.task)
 }
 
-func (x *mountInfoData) StateTypeName() string {
+func (m *mountInfoData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.mountInfoData"
 }
 
-func (x *mountInfoData) StateFields() []string {
+func (m *mountInfoData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *mountInfoData) beforeSave() {}
+func (m *mountInfoData) beforeSave() {}
 
-func (x *mountInfoData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (m *mountInfoData) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.DynamicBytesFile)
+	stateSinkObject.Save(1, &m.task)
 }
 
-func (x *mountInfoData) afterLoad() {}
+func (m *mountInfoData) afterLoad() {}
 
-func (x *mountInfoData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (m *mountInfoData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.DynamicBytesFile)
+	stateSourceObject.Load(1, &m.task)
 }
 
-func (x *mountsData) StateTypeName() string {
+func (m *mountsData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.mountsData"
 }
 
-func (x *mountsData) StateFields() []string {
+func (m *mountsData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"task",
 	}
 }
 
-func (x *mountsData) beforeSave() {}
+func (m *mountsData) beforeSave() {}
 
-func (x *mountsData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.task)
+func (m *mountsData) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.DynamicBytesFile)
+	stateSinkObject.Save(1, &m.task)
 }
 
-func (x *mountsData) afterLoad() {}
+func (m *mountsData) afterLoad() {}
 
-func (x *mountsData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.task)
+func (m *mountsData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.DynamicBytesFile)
+	stateSourceObject.Load(1, &m.task)
 }
 
-func (x *namespaceSymlink) StateTypeName() string {
+func (n *namespaceSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.namespaceSymlink"
 }
 
-func (x *namespaceSymlink) StateFields() []string {
+func (n *namespaceSymlink) StateFields() []string {
 	return []string{
 		"StaticSymlink",
 		"task",
 	}
 }
 
-func (x *namespaceSymlink) beforeSave() {}
+func (n *namespaceSymlink) beforeSave() {}
 
-func (x *namespaceSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.StaticSymlink)
-	m.Save(1, &x.task)
+func (n *namespaceSymlink) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.StaticSymlink)
+	stateSinkObject.Save(1, &n.task)
 }
 
-func (x *namespaceSymlink) afterLoad() {}
+func (n *namespaceSymlink) afterLoad() {}
 
-func (x *namespaceSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.StaticSymlink)
-	m.Load(1, &x.task)
+func (n *namespaceSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.StaticSymlink)
+	stateSourceObject.Load(1, &n.task)
 }
 
-func (x *namespaceInode) StateTypeName() string {
+func (n *namespaceInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.namespaceInode"
 }
 
-func (x *namespaceInode) StateFields() []string {
+func (n *namespaceInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -1020,34 +1020,34 @@ func (x *namespaceInode) StateFields() []string {
 	}
 }
 
-func (x *namespaceInode) beforeSave() {}
+func (n *namespaceInode) beforeSave() {}
 
-func (x *namespaceInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeNotDirectory)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.locks)
+func (n *namespaceInode) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.implStatFS)
+	stateSinkObject.Save(1, &n.InodeAttrs)
+	stateSinkObject.Save(2, &n.InodeNoopRefCount)
+	stateSinkObject.Save(3, &n.InodeNotDirectory)
+	stateSinkObject.Save(4, &n.InodeNotSymlink)
+	stateSinkObject.Save(5, &n.locks)
 }
 
-func (x *namespaceInode) afterLoad() {}
+func (n *namespaceInode) afterLoad() {}
 
-func (x *namespaceInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeNotDirectory)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.locks)
+func (n *namespaceInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.implStatFS)
+	stateSourceObject.Load(1, &n.InodeAttrs)
+	stateSourceObject.Load(2, &n.InodeNoopRefCount)
+	stateSourceObject.Load(3, &n.InodeNotDirectory)
+	stateSourceObject.Load(4, &n.InodeNotSymlink)
+	stateSourceObject.Load(5, &n.locks)
 }
 
-func (x *namespaceFD) StateTypeName() string {
+func (n *namespaceFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.namespaceFD"
 }
 
-func (x *namespaceFD) StateFields() []string {
+func (n *namespaceFD) StateFields() []string {
 	return []string{
 		"FileDescriptionDefaultImpl",
 		"LockFD",
@@ -1056,313 +1056,313 @@ func (x *namespaceFD) StateFields() []string {
 	}
 }
 
-func (x *namespaceFD) beforeSave() {}
+func (n *namespaceFD) beforeSave() {}
 
-func (x *namespaceFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FileDescriptionDefaultImpl)
-	m.Save(1, &x.LockFD)
-	m.Save(2, &x.vfsfd)
-	m.Save(3, &x.inode)
+func (n *namespaceFD) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(1, &n.LockFD)
+	stateSinkObject.Save(2, &n.vfsfd)
+	stateSinkObject.Save(3, &n.inode)
 }
 
-func (x *namespaceFD) afterLoad() {}
+func (n *namespaceFD) afterLoad() {}
 
-func (x *namespaceFD) StateLoad(m state.Source) {
-	m.Load(0, &x.FileDescriptionDefaultImpl)
-	m.Load(1, &x.LockFD)
-	m.Load(2, &x.vfsfd)
-	m.Load(3, &x.inode)
+func (n *namespaceFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(1, &n.LockFD)
+	stateSourceObject.Load(2, &n.vfsfd)
+	stateSourceObject.Load(3, &n.inode)
 }
 
-func (x *taskInodeRefs) StateTypeName() string {
+func (t *taskInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.taskInodeRefs"
 }
 
-func (x *taskInodeRefs) StateFields() []string {
+func (t *taskInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *taskInodeRefs) beforeSave() {}
+func (t *taskInodeRefs) beforeSave() {}
 
-func (x *taskInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (t *taskInodeRefs) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.refCount)
 }
 
-func (x *taskInodeRefs) afterLoad() {}
+func (t *taskInodeRefs) afterLoad() {}
 
-func (x *taskInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (t *taskInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.refCount)
 }
 
-func (x *ifinet6) StateTypeName() string {
+func (i *ifinet6) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.ifinet6"
 }
 
-func (x *ifinet6) StateFields() []string {
+func (i *ifinet6) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *ifinet6) beforeSave() {}
+func (i *ifinet6) beforeSave() {}
 
-func (x *ifinet6) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (i *ifinet6) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.DynamicBytesFile)
+	stateSinkObject.Save(1, &i.stack)
 }
 
-func (x *ifinet6) afterLoad() {}
+func (i *ifinet6) afterLoad() {}
 
-func (x *ifinet6) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.stack)
+func (i *ifinet6) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.DynamicBytesFile)
+	stateSourceObject.Load(1, &i.stack)
 }
 
-func (x *netDevData) StateTypeName() string {
+func (n *netDevData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netDevData"
 }
 
-func (x *netDevData) StateFields() []string {
+func (n *netDevData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *netDevData) beforeSave() {}
+func (n *netDevData) beforeSave() {}
 
-func (x *netDevData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (n *netDevData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.stack)
 }
 
-func (x *netDevData) afterLoad() {}
+func (n *netDevData) afterLoad() {}
 
-func (x *netDevData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.stack)
+func (n *netDevData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.stack)
 }
 
-func (x *netUnixData) StateTypeName() string {
+func (n *netUnixData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netUnixData"
 }
 
-func (x *netUnixData) StateFields() []string {
+func (n *netUnixData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"kernel",
 	}
 }
 
-func (x *netUnixData) beforeSave() {}
+func (n *netUnixData) beforeSave() {}
 
-func (x *netUnixData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.kernel)
+func (n *netUnixData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.kernel)
 }
 
-func (x *netUnixData) afterLoad() {}
+func (n *netUnixData) afterLoad() {}
 
-func (x *netUnixData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.kernel)
+func (n *netUnixData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.kernel)
 }
 
-func (x *netTCPData) StateTypeName() string {
+func (n *netTCPData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netTCPData"
 }
 
-func (x *netTCPData) StateFields() []string {
+func (n *netTCPData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"kernel",
 	}
 }
 
-func (x *netTCPData) beforeSave() {}
+func (n *netTCPData) beforeSave() {}
 
-func (x *netTCPData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.kernel)
+func (n *netTCPData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.kernel)
 }
 
-func (x *netTCPData) afterLoad() {}
+func (n *netTCPData) afterLoad() {}
 
-func (x *netTCPData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.kernel)
+func (n *netTCPData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.kernel)
 }
 
-func (x *netTCP6Data) StateTypeName() string {
+func (n *netTCP6Data) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netTCP6Data"
 }
 
-func (x *netTCP6Data) StateFields() []string {
+func (n *netTCP6Data) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"kernel",
 	}
 }
 
-func (x *netTCP6Data) beforeSave() {}
+func (n *netTCP6Data) beforeSave() {}
 
-func (x *netTCP6Data) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.kernel)
+func (n *netTCP6Data) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.kernel)
 }
 
-func (x *netTCP6Data) afterLoad() {}
+func (n *netTCP6Data) afterLoad() {}
 
-func (x *netTCP6Data) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.kernel)
+func (n *netTCP6Data) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.kernel)
 }
 
-func (x *netUDPData) StateTypeName() string {
+func (n *netUDPData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netUDPData"
 }
 
-func (x *netUDPData) StateFields() []string {
+func (n *netUDPData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"kernel",
 	}
 }
 
-func (x *netUDPData) beforeSave() {}
+func (n *netUDPData) beforeSave() {}
 
-func (x *netUDPData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.kernel)
+func (n *netUDPData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.kernel)
 }
 
-func (x *netUDPData) afterLoad() {}
+func (n *netUDPData) afterLoad() {}
 
-func (x *netUDPData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.kernel)
+func (n *netUDPData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.kernel)
 }
 
-func (x *netSnmpData) StateTypeName() string {
+func (n *netSnmpData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netSnmpData"
 }
 
-func (x *netSnmpData) StateFields() []string {
+func (n *netSnmpData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *netSnmpData) beforeSave() {}
+func (n *netSnmpData) beforeSave() {}
 
-func (x *netSnmpData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (n *netSnmpData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.stack)
 }
 
-func (x *netSnmpData) afterLoad() {}
+func (n *netSnmpData) afterLoad() {}
 
-func (x *netSnmpData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.stack)
+func (n *netSnmpData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.stack)
 }
 
-func (x *snmpLine) StateTypeName() string {
+func (s *snmpLine) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.snmpLine"
 }
 
-func (x *snmpLine) StateFields() []string {
+func (s *snmpLine) StateFields() []string {
 	return []string{
 		"prefix",
 		"header",
 	}
 }
 
-func (x *snmpLine) beforeSave() {}
+func (s *snmpLine) beforeSave() {}
 
-func (x *snmpLine) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.prefix)
-	m.Save(1, &x.header)
+func (s *snmpLine) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.prefix)
+	stateSinkObject.Save(1, &s.header)
 }
 
-func (x *snmpLine) afterLoad() {}
+func (s *snmpLine) afterLoad() {}
 
-func (x *snmpLine) StateLoad(m state.Source) {
-	m.Load(0, &x.prefix)
-	m.Load(1, &x.header)
+func (s *snmpLine) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.prefix)
+	stateSourceObject.Load(1, &s.header)
 }
 
-func (x *netRouteData) StateTypeName() string {
+func (n *netRouteData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netRouteData"
 }
 
-func (x *netRouteData) StateFields() []string {
+func (n *netRouteData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *netRouteData) beforeSave() {}
+func (n *netRouteData) beforeSave() {}
 
-func (x *netRouteData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (n *netRouteData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.stack)
 }
 
-func (x *netRouteData) afterLoad() {}
+func (n *netRouteData) afterLoad() {}
 
-func (x *netRouteData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.stack)
+func (n *netRouteData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.stack)
 }
 
-func (x *netStatData) StateTypeName() string {
+func (n *netStatData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.netStatData"
 }
 
-func (x *netStatData) StateFields() []string {
+func (n *netStatData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *netStatData) beforeSave() {}
+func (n *netStatData) beforeSave() {}
 
-func (x *netStatData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (n *netStatData) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.DynamicBytesFile)
+	stateSinkObject.Save(1, &n.stack)
 }
 
-func (x *netStatData) afterLoad() {}
+func (n *netStatData) afterLoad() {}
 
-func (x *netStatData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.stack)
+func (n *netStatData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.DynamicBytesFile)
+	stateSourceObject.Load(1, &n.stack)
 }
 
-func (x *tasksInode) StateTypeName() string {
+func (t *tasksInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tasksInode"
 }
 
-func (x *tasksInode) StateFields() []string {
+func (t *tasksInode) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"AlwaysValid",
@@ -1380,74 +1380,74 @@ func (x *tasksInode) StateFields() []string {
 	}
 }
 
-func (x *tasksInode) beforeSave() {}
-
-func (x *tasksInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.AlwaysValid)
-	m.Save(2, &x.InodeAttrs)
-	m.Save(3, &x.InodeDirectoryNoNewChildren)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.tasksInodeRefs)
-	m.Save(7, &x.locks)
-	m.Save(8, &x.fs)
-	m.Save(9, &x.pidns)
-	m.Save(10, &x.selfSymlink)
-	m.Save(11, &x.threadSelfSymlink)
-	m.Save(12, &x.cgroupControllers)
-}
-
-func (x *tasksInode) afterLoad() {}
-
-func (x *tasksInode) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.AlwaysValid)
-	m.Load(2, &x.InodeAttrs)
-	m.Load(3, &x.InodeDirectoryNoNewChildren)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.tasksInodeRefs)
-	m.Load(7, &x.locks)
-	m.Load(8, &x.fs)
-	m.Load(9, &x.pidns)
-	m.Load(10, &x.selfSymlink)
-	m.Load(11, &x.threadSelfSymlink)
-	m.Load(12, &x.cgroupControllers)
-}
-
-func (x *staticFileSetStat) StateTypeName() string {
+func (t *tasksInode) beforeSave() {}
+
+func (t *tasksInode) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.implStatFS)
+	stateSinkObject.Save(1, &t.AlwaysValid)
+	stateSinkObject.Save(2, &t.InodeAttrs)
+	stateSinkObject.Save(3, &t.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(4, &t.InodeNotSymlink)
+	stateSinkObject.Save(5, &t.OrderedChildren)
+	stateSinkObject.Save(6, &t.tasksInodeRefs)
+	stateSinkObject.Save(7, &t.locks)
+	stateSinkObject.Save(8, &t.fs)
+	stateSinkObject.Save(9, &t.pidns)
+	stateSinkObject.Save(10, &t.selfSymlink)
+	stateSinkObject.Save(11, &t.threadSelfSymlink)
+	stateSinkObject.Save(12, &t.cgroupControllers)
+}
+
+func (t *tasksInode) afterLoad() {}
+
+func (t *tasksInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.implStatFS)
+	stateSourceObject.Load(1, &t.AlwaysValid)
+	stateSourceObject.Load(2, &t.InodeAttrs)
+	stateSourceObject.Load(3, &t.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(4, &t.InodeNotSymlink)
+	stateSourceObject.Load(5, &t.OrderedChildren)
+	stateSourceObject.Load(6, &t.tasksInodeRefs)
+	stateSourceObject.Load(7, &t.locks)
+	stateSourceObject.Load(8, &t.fs)
+	stateSourceObject.Load(9, &t.pidns)
+	stateSourceObject.Load(10, &t.selfSymlink)
+	stateSourceObject.Load(11, &t.threadSelfSymlink)
+	stateSourceObject.Load(12, &t.cgroupControllers)
+}
+
+func (s *staticFileSetStat) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.staticFileSetStat"
 }
 
-func (x *staticFileSetStat) StateFields() []string {
+func (s *staticFileSetStat) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 		"StaticData",
 	}
 }
 
-func (x *staticFileSetStat) beforeSave() {}
+func (s *staticFileSetStat) beforeSave() {}
 
-func (x *staticFileSetStat) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
-	m.Save(1, &x.StaticData)
+func (s *staticFileSetStat) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.dynamicBytesFileSetAttr)
+	stateSinkObject.Save(1, &s.StaticData)
 }
 
-func (x *staticFileSetStat) afterLoad() {}
+func (s *staticFileSetStat) afterLoad() {}
 
-func (x *staticFileSetStat) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
-	m.Load(1, &x.StaticData)
+func (s *staticFileSetStat) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.dynamicBytesFileSetAttr)
+	stateSourceObject.Load(1, &s.StaticData)
 }
 
-func (x *selfSymlink) StateTypeName() string {
+func (s *selfSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.selfSymlink"
 }
 
-func (x *selfSymlink) StateFields() []string {
+func (s *selfSymlink) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -1457,32 +1457,32 @@ func (x *selfSymlink) StateFields() []string {
 	}
 }
 
-func (x *selfSymlink) beforeSave() {}
+func (s *selfSymlink) beforeSave() {}
 
-func (x *selfSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeSymlink)
-	m.Save(4, &x.pidns)
+func (s *selfSymlink) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.implStatFS)
+	stateSinkObject.Save(1, &s.InodeAttrs)
+	stateSinkObject.Save(2, &s.InodeNoopRefCount)
+	stateSinkObject.Save(3, &s.InodeSymlink)
+	stateSinkObject.Save(4, &s.pidns)
 }
 
-func (x *selfSymlink) afterLoad() {}
+func (s *selfSymlink) afterLoad() {}
 
-func (x *selfSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeSymlink)
-	m.Load(4, &x.pidns)
+func (s *selfSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.implStatFS)
+	stateSourceObject.Load(1, &s.InodeAttrs)
+	stateSourceObject.Load(2, &s.InodeNoopRefCount)
+	stateSourceObject.Load(3, &s.InodeSymlink)
+	stateSourceObject.Load(4, &s.pidns)
 }
 
-func (x *threadSelfSymlink) StateTypeName() string {
+func (t *threadSelfSymlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.threadSelfSymlink"
 }
 
-func (x *threadSelfSymlink) StateFields() []string {
+func (t *threadSelfSymlink) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"InodeAttrs",
@@ -1492,55 +1492,55 @@ func (x *threadSelfSymlink) StateFields() []string {
 	}
 }
 
-func (x *threadSelfSymlink) beforeSave() {}
+func (t *threadSelfSymlink) beforeSave() {}
 
-func (x *threadSelfSymlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoopRefCount)
-	m.Save(3, &x.InodeSymlink)
-	m.Save(4, &x.pidns)
+func (t *threadSelfSymlink) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.implStatFS)
+	stateSinkObject.Save(1, &t.InodeAttrs)
+	stateSinkObject.Save(2, &t.InodeNoopRefCount)
+	stateSinkObject.Save(3, &t.InodeSymlink)
+	stateSinkObject.Save(4, &t.pidns)
 }
 
-func (x *threadSelfSymlink) afterLoad() {}
+func (t *threadSelfSymlink) afterLoad() {}
 
-func (x *threadSelfSymlink) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoopRefCount)
-	m.Load(3, &x.InodeSymlink)
-	m.Load(4, &x.pidns)
+func (t *threadSelfSymlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.implStatFS)
+	stateSourceObject.Load(1, &t.InodeAttrs)
+	stateSourceObject.Load(2, &t.InodeNoopRefCount)
+	stateSourceObject.Load(3, &t.InodeSymlink)
+	stateSourceObject.Load(4, &t.pidns)
 }
 
-func (x *dynamicBytesFileSetAttr) StateTypeName() string {
+func (d *dynamicBytesFileSetAttr) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.dynamicBytesFileSetAttr"
 }
 
-func (x *dynamicBytesFileSetAttr) StateFields() []string {
+func (d *dynamicBytesFileSetAttr) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 	}
 }
 
-func (x *dynamicBytesFileSetAttr) beforeSave() {}
+func (d *dynamicBytesFileSetAttr) beforeSave() {}
 
-func (x *dynamicBytesFileSetAttr) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
+func (d *dynamicBytesFileSetAttr) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.DynamicBytesFile)
 }
 
-func (x *dynamicBytesFileSetAttr) afterLoad() {}
+func (d *dynamicBytesFileSetAttr) afterLoad() {}
 
-func (x *dynamicBytesFileSetAttr) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
+func (d *dynamicBytesFileSetAttr) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.DynamicBytesFile)
 }
 
-func (x *cpuStats) StateTypeName() string {
+func (c *cpuStats) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.cpuStats"
 }
 
-func (x *cpuStats) StateFields() []string {
+func (c *cpuStats) StateFields() []string {
 	return []string{
 		"user",
 		"nice",
@@ -1555,260 +1555,260 @@ func (x *cpuStats) StateFields() []string {
 	}
 }
 
-func (x *cpuStats) beforeSave() {}
+func (c *cpuStats) beforeSave() {}
 
-func (x *cpuStats) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.user)
-	m.Save(1, &x.nice)
-	m.Save(2, &x.system)
-	m.Save(3, &x.idle)
-	m.Save(4, &x.ioWait)
-	m.Save(5, &x.irq)
-	m.Save(6, &x.softirq)
-	m.Save(7, &x.steal)
-	m.Save(8, &x.guest)
-	m.Save(9, &x.guestNice)
+func (c *cpuStats) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.user)
+	stateSinkObject.Save(1, &c.nice)
+	stateSinkObject.Save(2, &c.system)
+	stateSinkObject.Save(3, &c.idle)
+	stateSinkObject.Save(4, &c.ioWait)
+	stateSinkObject.Save(5, &c.irq)
+	stateSinkObject.Save(6, &c.softirq)
+	stateSinkObject.Save(7, &c.steal)
+	stateSinkObject.Save(8, &c.guest)
+	stateSinkObject.Save(9, &c.guestNice)
 }
 
-func (x *cpuStats) afterLoad() {}
+func (c *cpuStats) afterLoad() {}
 
-func (x *cpuStats) StateLoad(m state.Source) {
-	m.Load(0, &x.user)
-	m.Load(1, &x.nice)
-	m.Load(2, &x.system)
-	m.Load(3, &x.idle)
-	m.Load(4, &x.ioWait)
-	m.Load(5, &x.irq)
-	m.Load(6, &x.softirq)
-	m.Load(7, &x.steal)
-	m.Load(8, &x.guest)
-	m.Load(9, &x.guestNice)
+func (c *cpuStats) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.user)
+	stateSourceObject.Load(1, &c.nice)
+	stateSourceObject.Load(2, &c.system)
+	stateSourceObject.Load(3, &c.idle)
+	stateSourceObject.Load(4, &c.ioWait)
+	stateSourceObject.Load(5, &c.irq)
+	stateSourceObject.Load(6, &c.softirq)
+	stateSourceObject.Load(7, &c.steal)
+	stateSourceObject.Load(8, &c.guest)
+	stateSourceObject.Load(9, &c.guestNice)
 }
 
-func (x *statData) StateTypeName() string {
+func (s *statData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.statData"
 }
 
-func (x *statData) StateFields() []string {
+func (s *statData) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 	}
 }
 
-func (x *statData) beforeSave() {}
+func (s *statData) beforeSave() {}
 
-func (x *statData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
+func (s *statData) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.dynamicBytesFileSetAttr)
 }
 
-func (x *statData) afterLoad() {}
+func (s *statData) afterLoad() {}
 
-func (x *statData) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
+func (s *statData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.dynamicBytesFileSetAttr)
 }
 
-func (x *loadavgData) StateTypeName() string {
+func (l *loadavgData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.loadavgData"
 }
 
-func (x *loadavgData) StateFields() []string {
+func (l *loadavgData) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 	}
 }
 
-func (x *loadavgData) beforeSave() {}
+func (l *loadavgData) beforeSave() {}
 
-func (x *loadavgData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
+func (l *loadavgData) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.dynamicBytesFileSetAttr)
 }
 
-func (x *loadavgData) afterLoad() {}
+func (l *loadavgData) afterLoad() {}
 
-func (x *loadavgData) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
+func (l *loadavgData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.dynamicBytesFileSetAttr)
 }
 
-func (x *meminfoData) StateTypeName() string {
+func (m *meminfoData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.meminfoData"
 }
 
-func (x *meminfoData) StateFields() []string {
+func (m *meminfoData) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 	}
 }
 
-func (x *meminfoData) beforeSave() {}
+func (m *meminfoData) beforeSave() {}
 
-func (x *meminfoData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
+func (m *meminfoData) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.dynamicBytesFileSetAttr)
 }
 
-func (x *meminfoData) afterLoad() {}
+func (m *meminfoData) afterLoad() {}
 
-func (x *meminfoData) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
+func (m *meminfoData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.dynamicBytesFileSetAttr)
 }
 
-func (x *uptimeData) StateTypeName() string {
+func (u *uptimeData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.uptimeData"
 }
 
-func (x *uptimeData) StateFields() []string {
+func (u *uptimeData) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 	}
 }
 
-func (x *uptimeData) beforeSave() {}
+func (u *uptimeData) beforeSave() {}
 
-func (x *uptimeData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
+func (u *uptimeData) StateSave(stateSinkObject state.Sink) {
+	u.beforeSave()
+	stateSinkObject.Save(0, &u.dynamicBytesFileSetAttr)
 }
 
-func (x *uptimeData) afterLoad() {}
+func (u *uptimeData) afterLoad() {}
 
-func (x *uptimeData) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
+func (u *uptimeData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &u.dynamicBytesFileSetAttr)
 }
 
-func (x *versionData) StateTypeName() string {
+func (v *versionData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.versionData"
 }
 
-func (x *versionData) StateFields() []string {
+func (v *versionData) StateFields() []string {
 	return []string{
 		"dynamicBytesFileSetAttr",
 	}
 }
 
-func (x *versionData) beforeSave() {}
+func (v *versionData) beforeSave() {}
 
-func (x *versionData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dynamicBytesFileSetAttr)
+func (v *versionData) StateSave(stateSinkObject state.Sink) {
+	v.beforeSave()
+	stateSinkObject.Save(0, &v.dynamicBytesFileSetAttr)
 }
 
-func (x *versionData) afterLoad() {}
+func (v *versionData) afterLoad() {}
 
-func (x *versionData) StateLoad(m state.Source) {
-	m.Load(0, &x.dynamicBytesFileSetAttr)
+func (v *versionData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &v.dynamicBytesFileSetAttr)
 }
 
-func (x *filesystemsData) StateTypeName() string {
+func (f *filesystemsData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.filesystemsData"
 }
 
-func (x *filesystemsData) StateFields() []string {
+func (f *filesystemsData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 	}
 }
 
-func (x *filesystemsData) beforeSave() {}
+func (f *filesystemsData) beforeSave() {}
 
-func (x *filesystemsData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
+func (f *filesystemsData) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.DynamicBytesFile)
 }
 
-func (x *filesystemsData) afterLoad() {}
+func (f *filesystemsData) afterLoad() {}
 
-func (x *filesystemsData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
+func (f *filesystemsData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.DynamicBytesFile)
 }
 
-func (x *tasksInodeRefs) StateTypeName() string {
+func (t *tasksInodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tasksInodeRefs"
 }
 
-func (x *tasksInodeRefs) StateFields() []string {
+func (t *tasksInodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *tasksInodeRefs) beforeSave() {}
+func (t *tasksInodeRefs) beforeSave() {}
 
-func (x *tasksInodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (t *tasksInodeRefs) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.refCount)
 }
 
-func (x *tasksInodeRefs) afterLoad() {}
+func (t *tasksInodeRefs) afterLoad() {}
 
-func (x *tasksInodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (t *tasksInodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.refCount)
 }
 
-func (x *tcpMemDir) StateTypeName() string {
+func (t *tcpMemDir) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tcpMemDir"
 }
 
-func (x *tcpMemDir) StateFields() []string {
+func (t *tcpMemDir) StateFields() []string {
 	return nil
 }
 
-func (x *mmapMinAddrData) StateTypeName() string {
+func (m *mmapMinAddrData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.mmapMinAddrData"
 }
 
-func (x *mmapMinAddrData) StateFields() []string {
+func (m *mmapMinAddrData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"k",
 	}
 }
 
-func (x *mmapMinAddrData) beforeSave() {}
+func (m *mmapMinAddrData) beforeSave() {}
 
-func (x *mmapMinAddrData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.k)
+func (m *mmapMinAddrData) StateSave(stateSinkObject state.Sink) {
+	m.beforeSave()
+	stateSinkObject.Save(0, &m.DynamicBytesFile)
+	stateSinkObject.Save(1, &m.k)
 }
 
-func (x *mmapMinAddrData) afterLoad() {}
+func (m *mmapMinAddrData) afterLoad() {}
 
-func (x *mmapMinAddrData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.k)
+func (m *mmapMinAddrData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &m.DynamicBytesFile)
+	stateSourceObject.Load(1, &m.k)
 }
 
-func (x *hostnameData) StateTypeName() string {
+func (h *hostnameData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.hostnameData"
 }
 
-func (x *hostnameData) StateFields() []string {
+func (h *hostnameData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 	}
 }
 
-func (x *hostnameData) beforeSave() {}
+func (h *hostnameData) beforeSave() {}
 
-func (x *hostnameData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
+func (h *hostnameData) StateSave(stateSinkObject state.Sink) {
+	h.beforeSave()
+	stateSinkObject.Save(0, &h.DynamicBytesFile)
 }
 
-func (x *hostnameData) afterLoad() {}
+func (h *hostnameData) afterLoad() {}
 
-func (x *hostnameData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
+func (h *hostnameData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &h.DynamicBytesFile)
 }
 
-func (x *tcpSackData) StateTypeName() string {
+func (t *tcpSackData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tcpSackData"
 }
 
-func (x *tcpSackData) StateFields() []string {
+func (t *tcpSackData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
@@ -1816,54 +1816,54 @@ func (x *tcpSackData) StateFields() []string {
 	}
 }
 
-func (x *tcpSackData) beforeSave() {}
+func (t *tcpSackData) beforeSave() {}
 
-func (x *tcpSackData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
-	m.Save(2, &x.enabled)
+func (t *tcpSackData) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.DynamicBytesFile)
+	stateSinkObject.Save(1, &t.stack)
+	stateSinkObject.Save(2, &t.enabled)
 }
 
-func (x *tcpSackData) afterLoad() {}
+func (t *tcpSackData) afterLoad() {}
 
-func (x *tcpSackData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.LoadWait(1, &x.stack)
-	m.Load(2, &x.enabled)
+func (t *tcpSackData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.DynamicBytesFile)
+	stateSourceObject.LoadWait(1, &t.stack)
+	stateSourceObject.Load(2, &t.enabled)
 }
 
-func (x *tcpRecoveryData) StateTypeName() string {
+func (t *tcpRecoveryData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tcpRecoveryData"
 }
 
-func (x *tcpRecoveryData) StateFields() []string {
+func (t *tcpRecoveryData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
 	}
 }
 
-func (x *tcpRecoveryData) beforeSave() {}
+func (t *tcpRecoveryData) beforeSave() {}
 
-func (x *tcpRecoveryData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
+func (t *tcpRecoveryData) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.DynamicBytesFile)
+	stateSinkObject.Save(1, &t.stack)
 }
 
-func (x *tcpRecoveryData) afterLoad() {}
+func (t *tcpRecoveryData) afterLoad() {}
 
-func (x *tcpRecoveryData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.LoadWait(1, &x.stack)
+func (t *tcpRecoveryData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.DynamicBytesFile)
+	stateSourceObject.LoadWait(1, &t.stack)
 }
 
-func (x *tcpMemData) StateTypeName() string {
+func (t *tcpMemData) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.tcpMemData"
 }
 
-func (x *tcpMemData) StateFields() []string {
+func (t *tcpMemData) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"dir",
@@ -1871,28 +1871,28 @@ func (x *tcpMemData) StateFields() []string {
 	}
 }
 
-func (x *tcpMemData) beforeSave() {}
+func (t *tcpMemData) beforeSave() {}
 
-func (x *tcpMemData) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.dir)
-	m.Save(2, &x.stack)
+func (t *tcpMemData) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.DynamicBytesFile)
+	stateSinkObject.Save(1, &t.dir)
+	stateSinkObject.Save(2, &t.stack)
 }
 
-func (x *tcpMemData) afterLoad() {}
+func (t *tcpMemData) afterLoad() {}
 
-func (x *tcpMemData) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.Load(1, &x.dir)
-	m.LoadWait(2, &x.stack)
+func (t *tcpMemData) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.DynamicBytesFile)
+	stateSourceObject.Load(1, &t.dir)
+	stateSourceObject.LoadWait(2, &t.stack)
 }
 
-func (x *ipForwarding) StateTypeName() string {
+func (i *ipForwarding) StateTypeName() string {
 	return "pkg/sentry/fsimpl/proc.ipForwarding"
 }
 
-func (x *ipForwarding) StateFields() []string {
+func (i *ipForwarding) StateFields() []string {
 	return []string{
 		"DynamicBytesFile",
 		"stack",
@@ -1900,21 +1900,21 @@ func (x *ipForwarding) StateFields() []string {
 	}
 }
 
-func (x *ipForwarding) beforeSave() {}
+func (i *ipForwarding) beforeSave() {}
 
-func (x *ipForwarding) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.DynamicBytesFile)
-	m.Save(1, &x.stack)
-	m.Save(2, &x.enabled)
+func (i *ipForwarding) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.DynamicBytesFile)
+	stateSinkObject.Save(1, &i.stack)
+	stateSinkObject.Save(2, &i.enabled)
 }
 
-func (x *ipForwarding) afterLoad() {}
+func (i *ipForwarding) afterLoad() {}
 
-func (x *ipForwarding) StateLoad(m state.Source) {
-	m.Load(0, &x.DynamicBytesFile)
-	m.LoadWait(1, &x.stack)
-	m.Load(2, &x.enabled)
+func (i *ipForwarding) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.DynamicBytesFile)
+	stateSourceObject.LoadWait(1, &i.stack)
+	stateSourceObject.Load(2, &i.enabled)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go b/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go
index acd2ff5b4..4a1496528 100644
--- a/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go
+++ b/pkg/sentry/fsimpl/signalfd/signalfd_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *SignalFileDescription) StateTypeName() string {
+func (s *SignalFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/signalfd.SignalFileDescription"
 }
 
-func (x *SignalFileDescription) StateFields() []string {
+func (s *SignalFileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -21,27 +21,27 @@ func (x *SignalFileDescription) StateFields() []string {
 	}
 }
 
-func (x *SignalFileDescription) beforeSave() {}
+func (s *SignalFileDescription) beforeSave() {}
 
-func (x *SignalFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.NoLockFD)
-	m.Save(4, &x.target)
-	m.Save(5, &x.mask)
+func (s *SignalFileDescription) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.vfsfd)
+	stateSinkObject.Save(1, &s.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &s.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &s.NoLockFD)
+	stateSinkObject.Save(4, &s.target)
+	stateSinkObject.Save(5, &s.mask)
 }
 
-func (x *SignalFileDescription) afterLoad() {}
+func (s *SignalFileDescription) afterLoad() {}
 
-func (x *SignalFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.NoLockFD)
-	m.Load(4, &x.target)
-	m.Load(5, &x.mask)
+func (s *SignalFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.vfsfd)
+	stateSourceObject.Load(1, &s.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &s.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &s.NoLockFD)
+	stateSourceObject.Load(4, &s.target)
+	stateSourceObject.Load(5, &s.mask)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go b/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go
index bbc868a48..38bbf9eb5 100644
--- a/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go
+++ b/pkg/sentry/fsimpl/sockfs/sockfs_state_autogen.go
@@ -6,56 +6,56 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *filesystemType) StateTypeName() string {
+func (f *filesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sockfs.filesystemType"
 }
 
-func (x *filesystemType) StateFields() []string {
+func (f *filesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *filesystemType) beforeSave() {}
+func (f *filesystemType) beforeSave() {}
 
-func (x *filesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *filesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *filesystemType) afterLoad() {}
+func (f *filesystemType) afterLoad() {}
 
-func (x *filesystemType) StateLoad(m state.Source) {
+func (f *filesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sockfs.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sockfs.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeNoopRefCount",
@@ -64,23 +64,23 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
+func (i *inode) beforeSave() {}
 
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeNoopRefCount)
-	m.Save(2, &x.InodeNotDirectory)
-	m.Save(3, &x.InodeNotSymlink)
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.InodeAttrs)
+	stateSinkObject.Save(1, &i.InodeNoopRefCount)
+	stateSinkObject.Save(2, &i.InodeNotDirectory)
+	stateSinkObject.Save(3, &i.InodeNotSymlink)
 }
 
-func (x *inode) afterLoad() {}
+func (i *inode) afterLoad() {}
 
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeNoopRefCount)
-	m.Load(2, &x.InodeNotDirectory)
-	m.Load(3, &x.InodeNotSymlink)
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.InodeAttrs)
+	stateSourceObject.Load(1, &i.InodeNoopRefCount)
+	stateSourceObject.Load(2, &i.InodeNotDirectory)
+	stateSourceObject.Load(3, &i.InodeNotSymlink)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/sys/sys_state_autogen.go b/pkg/sentry/fsimpl/sys/sys_state_autogen.go
index 14d4efce9..6ba7397ba 100644
--- a/pkg/sentry/fsimpl/sys/sys_state_autogen.go
+++ b/pkg/sentry/fsimpl/sys/sys_state_autogen.go
@@ -6,34 +6,34 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *dirRefs) StateTypeName() string {
+func (d *dirRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.dirRefs"
 }
 
-func (x *dirRefs) StateFields() []string {
+func (d *dirRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *dirRefs) beforeSave() {}
+func (d *dirRefs) beforeSave() {}
 
-func (x *dirRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (d *dirRefs) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.refCount)
 }
 
-func (x *dirRefs) afterLoad() {}
+func (d *dirRefs) afterLoad() {}
 
-func (x *dirRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (d *dirRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.refCount)
 }
 
-func (x *kcovInode) StateTypeName() string {
+func (k *kcovInode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.kcovInode"
 }
 
-func (x *kcovInode) StateFields() []string {
+func (k *kcovInode) StateFields() []string {
 	return []string{
 		"InodeAttrs",
 		"InodeNoopRefCount",
@@ -43,32 +43,32 @@ func (x *kcovInode) StateFields() []string {
 	}
 }
 
-func (x *kcovInode) beforeSave() {}
+func (k *kcovInode) beforeSave() {}
 
-func (x *kcovInode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.InodeAttrs)
-	m.Save(1, &x.InodeNoopRefCount)
-	m.Save(2, &x.InodeNotDirectory)
-	m.Save(3, &x.InodeNotSymlink)
-	m.Save(4, &x.implStatFS)
+func (k *kcovInode) StateSave(stateSinkObject state.Sink) {
+	k.beforeSave()
+	stateSinkObject.Save(0, &k.InodeAttrs)
+	stateSinkObject.Save(1, &k.InodeNoopRefCount)
+	stateSinkObject.Save(2, &k.InodeNotDirectory)
+	stateSinkObject.Save(3, &k.InodeNotSymlink)
+	stateSinkObject.Save(4, &k.implStatFS)
 }
 
-func (x *kcovInode) afterLoad() {}
+func (k *kcovInode) afterLoad() {}
 
-func (x *kcovInode) StateLoad(m state.Source) {
-	m.Load(0, &x.InodeAttrs)
-	m.Load(1, &x.InodeNoopRefCount)
-	m.Load(2, &x.InodeNotDirectory)
-	m.Load(3, &x.InodeNotSymlink)
-	m.Load(4, &x.implStatFS)
+func (k *kcovInode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &k.InodeAttrs)
+	stateSourceObject.Load(1, &k.InodeNoopRefCount)
+	stateSourceObject.Load(2, &k.InodeNotDirectory)
+	stateSourceObject.Load(3, &k.InodeNotSymlink)
+	stateSourceObject.Load(4, &k.implStatFS)
 }
 
-func (x *kcovFD) StateTypeName() string {
+func (k *kcovFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.kcovFD"
 }
 
-func (x *kcovFD) StateFields() []string {
+func (k *kcovFD) StateFields() []string {
 	return []string{
 		"FileDescriptionDefaultImpl",
 		"NoLockFD",
@@ -78,77 +78,77 @@ func (x *kcovFD) StateFields() []string {
 	}
 }
 
-func (x *kcovFD) beforeSave() {}
+func (k *kcovFD) beforeSave() {}
 
-func (x *kcovFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.FileDescriptionDefaultImpl)
-	m.Save(1, &x.NoLockFD)
-	m.Save(2, &x.vfsfd)
-	m.Save(3, &x.inode)
-	m.Save(4, &x.kcov)
+func (k *kcovFD) StateSave(stateSinkObject state.Sink) {
+	k.beforeSave()
+	stateSinkObject.Save(0, &k.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(1, &k.NoLockFD)
+	stateSinkObject.Save(2, &k.vfsfd)
+	stateSinkObject.Save(3, &k.inode)
+	stateSinkObject.Save(4, &k.kcov)
 }
 
-func (x *kcovFD) afterLoad() {}
+func (k *kcovFD) afterLoad() {}
 
-func (x *kcovFD) StateLoad(m state.Source) {
-	m.Load(0, &x.FileDescriptionDefaultImpl)
-	m.Load(1, &x.NoLockFD)
-	m.Load(2, &x.vfsfd)
-	m.Load(3, &x.inode)
-	m.Load(4, &x.kcov)
+func (k *kcovFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &k.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(1, &k.NoLockFD)
+	stateSourceObject.Load(2, &k.vfsfd)
+	stateSourceObject.Load(3, &k.inode)
+	stateSourceObject.Load(4, &k.kcov)
 }
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
 }
 
-func (x *dir) StateTypeName() string {
+func (d *dir) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.dir"
 }
 
-func (x *dir) StateFields() []string {
+func (d *dir) StateFields() []string {
 	return []string{
 		"dirRefs",
 		"InodeAttrs",
@@ -161,38 +161,38 @@ func (x *dir) StateFields() []string {
 	}
 }
 
-func (x *dir) beforeSave() {}
+func (d *dir) beforeSave() {}
 
-func (x *dir) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dirRefs)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeNoDynamicLookup)
-	m.Save(3, &x.InodeNotSymlink)
-	m.Save(4, &x.InodeDirectoryNoNewChildren)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.locks)
-	m.Save(7, &x.dentry)
+func (d *dir) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.dirRefs)
+	stateSinkObject.Save(1, &d.InodeAttrs)
+	stateSinkObject.Save(2, &d.InodeNoDynamicLookup)
+	stateSinkObject.Save(3, &d.InodeNotSymlink)
+	stateSinkObject.Save(4, &d.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(5, &d.OrderedChildren)
+	stateSinkObject.Save(6, &d.locks)
+	stateSinkObject.Save(7, &d.dentry)
 }
 
-func (x *dir) afterLoad() {}
+func (d *dir) afterLoad() {}
 
-func (x *dir) StateLoad(m state.Source) {
-	m.Load(0, &x.dirRefs)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeNoDynamicLookup)
-	m.Load(3, &x.InodeNotSymlink)
-	m.Load(4, &x.InodeDirectoryNoNewChildren)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.locks)
-	m.Load(7, &x.dentry)
+func (d *dir) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.dirRefs)
+	stateSourceObject.Load(1, &d.InodeAttrs)
+	stateSourceObject.Load(2, &d.InodeNoDynamicLookup)
+	stateSourceObject.Load(3, &d.InodeNotSymlink)
+	stateSourceObject.Load(4, &d.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(5, &d.OrderedChildren)
+	stateSourceObject.Load(6, &d.locks)
+	stateSourceObject.Load(7, &d.dentry)
 }
 
-func (x *cpuFile) StateTypeName() string {
+func (c *cpuFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.cpuFile"
 }
 
-func (x *cpuFile) StateFields() []string {
+func (c *cpuFile) StateFields() []string {
 	return []string{
 		"implStatFS",
 		"DynamicBytesFile",
@@ -200,40 +200,40 @@ func (x *cpuFile) StateFields() []string {
 	}
 }
 
-func (x *cpuFile) beforeSave() {}
+func (c *cpuFile) beforeSave() {}
 
-func (x *cpuFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.implStatFS)
-	m.Save(1, &x.DynamicBytesFile)
-	m.Save(2, &x.maxCores)
+func (c *cpuFile) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	stateSinkObject.Save(0, &c.implStatFS)
+	stateSinkObject.Save(1, &c.DynamicBytesFile)
+	stateSinkObject.Save(2, &c.maxCores)
 }
 
-func (x *cpuFile) afterLoad() {}
+func (c *cpuFile) afterLoad() {}
 
-func (x *cpuFile) StateLoad(m state.Source) {
-	m.Load(0, &x.implStatFS)
-	m.Load(1, &x.DynamicBytesFile)
-	m.Load(2, &x.maxCores)
+func (c *cpuFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.implStatFS)
+	stateSourceObject.Load(1, &c.DynamicBytesFile)
+	stateSourceObject.Load(2, &c.maxCores)
 }
 
-func (x *implStatFS) StateTypeName() string {
+func (i *implStatFS) StateTypeName() string {
 	return "pkg/sentry/fsimpl/sys.implStatFS"
 }
 
-func (x *implStatFS) StateFields() []string {
+func (i *implStatFS) StateFields() []string {
 	return []string{}
 }
 
-func (x *implStatFS) beforeSave() {}
+func (i *implStatFS) beforeSave() {}
 
-func (x *implStatFS) StateSave(m state.Sink) {
-	x.beforeSave()
+func (i *implStatFS) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
 }
 
-func (x *implStatFS) afterLoad() {}
+func (i *implStatFS) afterLoad() {}
 
-func (x *implStatFS) StateLoad(m state.Source) {
+func (i *implStatFS) StateLoad(stateSourceObject state.Source) {
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go b/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go
index 722153ff8..0bfca83b9 100644
--- a/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go
+++ b/pkg/sentry/fsimpl/timerfd/timerfd_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *TimerFileDescription) StateTypeName() string {
+func (t *TimerFileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/timerfd.TimerFileDescription"
 }
 
-func (x *TimerFileDescription) StateFields() []string {
+func (t *TimerFileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -22,29 +22,29 @@ func (x *TimerFileDescription) StateFields() []string {
 	}
 }
 
-func (x *TimerFileDescription) beforeSave() {}
-
-func (x *TimerFileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.NoLockFD)
-	m.Save(4, &x.events)
-	m.Save(5, &x.timer)
-	m.Save(6, &x.val)
+func (t *TimerFileDescription) beforeSave() {}
+
+func (t *TimerFileDescription) StateSave(stateSinkObject state.Sink) {
+	t.beforeSave()
+	stateSinkObject.Save(0, &t.vfsfd)
+	stateSinkObject.Save(1, &t.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &t.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &t.NoLockFD)
+	stateSinkObject.Save(4, &t.events)
+	stateSinkObject.Save(5, &t.timer)
+	stateSinkObject.Save(6, &t.val)
 }
 
-func (x *TimerFileDescription) afterLoad() {}
+func (t *TimerFileDescription) afterLoad() {}
 
-func (x *TimerFileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.NoLockFD)
-	m.Load(4, &x.events)
-	m.Load(5, &x.timer)
-	m.Load(6, &x.val)
+func (t *TimerFileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &t.vfsfd)
+	stateSourceObject.Load(1, &t.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &t.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &t.NoLockFD)
+	stateSourceObject.Load(4, &t.events)
+	stateSourceObject.Load(5, &t.timer)
+	stateSourceObject.Load(6, &t.val)
 }
 
 func init() {
diff --git a/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go b/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go
index 4252b95e6..8fa28e3da 100644
--- a/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go
+++ b/pkg/sentry/fsimpl/tmpfs/tmpfs_state_autogen.go
@@ -6,63 +6,63 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *dentryList) StateTypeName() string {
+func (d *dentryList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.dentryList"
 }
 
-func (x *dentryList) StateFields() []string {
+func (d *dentryList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *dentryList) beforeSave() {}
+func (d *dentryList) beforeSave() {}
 
-func (x *dentryList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (d *dentryList) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.head)
+	stateSinkObject.Save(1, &d.tail)
 }
 
-func (x *dentryList) afterLoad() {}
+func (d *dentryList) afterLoad() {}
 
-func (x *dentryList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (d *dentryList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.head)
+	stateSourceObject.Load(1, &d.tail)
 }
 
-func (x *dentryEntry) StateTypeName() string {
+func (d *dentryEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.dentryEntry"
 }
 
-func (x *dentryEntry) StateFields() []string {
+func (d *dentryEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *dentryEntry) beforeSave() {}
+func (d *dentryEntry) beforeSave() {}
 
-func (x *dentryEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (d *dentryEntry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.next)
+	stateSinkObject.Save(1, &d.prev)
 }
 
-func (x *dentryEntry) afterLoad() {}
+func (d *dentryEntry) afterLoad() {}
 
-func (x *dentryEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (d *dentryEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.next)
+	stateSourceObject.Load(1, &d.prev)
 }
 
-func (x *deviceFile) StateTypeName() string {
+func (d *deviceFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.deviceFile"
 }
 
-func (x *deviceFile) StateFields() []string {
+func (d *deviceFile) StateFields() []string {
 	return []string{
 		"inode",
 		"kind",
@@ -71,30 +71,30 @@ func (x *deviceFile) StateFields() []string {
 	}
 }
 
-func (x *deviceFile) beforeSave() {}
+func (d *deviceFile) beforeSave() {}
 
-func (x *deviceFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.kind)
-	m.Save(2, &x.major)
-	m.Save(3, &x.minor)
+func (d *deviceFile) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.inode)
+	stateSinkObject.Save(1, &d.kind)
+	stateSinkObject.Save(2, &d.major)
+	stateSinkObject.Save(3, &d.minor)
 }
 
-func (x *deviceFile) afterLoad() {}
+func (d *deviceFile) afterLoad() {}
 
-func (x *deviceFile) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.kind)
-	m.Load(2, &x.major)
-	m.Load(3, &x.minor)
+func (d *deviceFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.inode)
+	stateSourceObject.Load(1, &d.kind)
+	stateSourceObject.Load(2, &d.major)
+	stateSourceObject.Load(3, &d.minor)
 }
 
-func (x *directory) StateTypeName() string {
+func (d *directory) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.directory"
 }
 
-func (x *directory) StateFields() []string {
+func (d *directory) StateFields() []string {
 	return []string{
 		"dentry",
 		"inode",
@@ -104,32 +104,32 @@ func (x *directory) StateFields() []string {
 	}
 }
 
-func (x *directory) beforeSave() {}
+func (d *directory) beforeSave() {}
 
-func (x *directory) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.dentry)
-	m.Save(1, &x.inode)
-	m.Save(2, &x.childMap)
-	m.Save(3, &x.numChildren)
-	m.Save(4, &x.childList)
+func (d *directory) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.dentry)
+	stateSinkObject.Save(1, &d.inode)
+	stateSinkObject.Save(2, &d.childMap)
+	stateSinkObject.Save(3, &d.numChildren)
+	stateSinkObject.Save(4, &d.childList)
 }
 
-func (x *directory) afterLoad() {}
+func (d *directory) afterLoad() {}
 
-func (x *directory) StateLoad(m state.Source) {
-	m.Load(0, &x.dentry)
-	m.Load(1, &x.inode)
-	m.Load(2, &x.childMap)
-	m.Load(3, &x.numChildren)
-	m.Load(4, &x.childList)
+func (d *directory) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.dentry)
+	stateSourceObject.Load(1, &d.inode)
+	stateSourceObject.Load(2, &d.childMap)
+	stateSourceObject.Load(3, &d.numChildren)
+	stateSourceObject.Load(4, &d.childList)
 }
 
-func (x *directoryFD) StateTypeName() string {
+func (d *directoryFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.directoryFD"
 }
 
-func (x *directoryFD) StateFields() []string {
+func (d *directoryFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"DirectoryFileDescriptionDefaultImpl",
@@ -138,79 +138,79 @@ func (x *directoryFD) StateFields() []string {
 	}
 }
 
-func (x *directoryFD) beforeSave() {}
+func (d *directoryFD) beforeSave() {}
 
-func (x *directoryFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Save(2, &x.iter)
-	m.Save(3, &x.off)
+func (d *directoryFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.fileDescription)
+	stateSinkObject.Save(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &d.iter)
+	stateSinkObject.Save(3, &d.off)
 }
 
-func (x *directoryFD) afterLoad() {}
+func (d *directoryFD) afterLoad() {}
 
-func (x *directoryFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.DirectoryFileDescriptionDefaultImpl)
-	m.Load(2, &x.iter)
-	m.Load(3, &x.off)
+func (d *directoryFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.fileDescription)
+	stateSourceObject.Load(1, &d.DirectoryFileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &d.iter)
+	stateSourceObject.Load(3, &d.off)
 }
 
-func (x *inodeRefs) StateTypeName() string {
+func (i *inodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.inodeRefs"
 }
 
-func (x *inodeRefs) StateFields() []string {
+func (i *inodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *inodeRefs) beforeSave() {}
+func (i *inodeRefs) beforeSave() {}
 
-func (x *inodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (i *inodeRefs) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.refCount)
 }
 
-func (x *inodeRefs) afterLoad() {}
+func (i *inodeRefs) afterLoad() {}
 
-func (x *inodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (i *inodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.refCount)
 }
 
-func (x *namedPipe) StateTypeName() string {
+func (n *namedPipe) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.namedPipe"
 }
 
-func (x *namedPipe) StateFields() []string {
+func (n *namedPipe) StateFields() []string {
 	return []string{
 		"inode",
 		"pipe",
 	}
 }
 
-func (x *namedPipe) beforeSave() {}
+func (n *namedPipe) beforeSave() {}
 
-func (x *namedPipe) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.pipe)
+func (n *namedPipe) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.inode)
+	stateSinkObject.Save(1, &n.pipe)
 }
 
-func (x *namedPipe) afterLoad() {}
+func (n *namedPipe) afterLoad() {}
 
-func (x *namedPipe) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.pipe)
+func (n *namedPipe) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.inode)
+	stateSourceObject.Load(1, &n.pipe)
 }
 
-func (x *regularFile) StateTypeName() string {
+func (r *regularFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.regularFile"
 }
 
-func (x *regularFile) StateFields() []string {
+func (r *regularFile) StateFields() []string {
 	return []string{
 		"inode",
 		"memFile",
@@ -223,135 +223,135 @@ func (x *regularFile) StateFields() []string {
 	}
 }
 
-func (x *regularFile) beforeSave() {}
+func (r *regularFile) beforeSave() {}
 
-func (x *regularFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.memFile)
-	m.Save(2, &x.memoryUsageKind)
-	m.Save(3, &x.mappings)
-	m.Save(4, &x.writableMappingPages)
-	m.Save(5, &x.data)
-	m.Save(6, &x.seals)
-	m.Save(7, &x.size)
+func (r *regularFile) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.inode)
+	stateSinkObject.Save(1, &r.memFile)
+	stateSinkObject.Save(2, &r.memoryUsageKind)
+	stateSinkObject.Save(3, &r.mappings)
+	stateSinkObject.Save(4, &r.writableMappingPages)
+	stateSinkObject.Save(5, &r.data)
+	stateSinkObject.Save(6, &r.seals)
+	stateSinkObject.Save(7, &r.size)
 }
 
-func (x *regularFile) afterLoad() {}
+func (r *regularFile) afterLoad() {}
 
-func (x *regularFile) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.memFile)
-	m.Load(2, &x.memoryUsageKind)
-	m.Load(3, &x.mappings)
-	m.Load(4, &x.writableMappingPages)
-	m.Load(5, &x.data)
-	m.Load(6, &x.seals)
-	m.Load(7, &x.size)
+func (r *regularFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.inode)
+	stateSourceObject.Load(1, &r.memFile)
+	stateSourceObject.Load(2, &r.memoryUsageKind)
+	stateSourceObject.Load(3, &r.mappings)
+	stateSourceObject.Load(4, &r.writableMappingPages)
+	stateSourceObject.Load(5, &r.data)
+	stateSourceObject.Load(6, &r.seals)
+	stateSourceObject.Load(7, &r.size)
 }
 
-func (x *regularFileFD) StateTypeName() string {
+func (r *regularFileFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.regularFileFD"
 }
 
-func (x *regularFileFD) StateFields() []string {
+func (r *regularFileFD) StateFields() []string {
 	return []string{
 		"fileDescription",
 		"off",
 	}
 }
 
-func (x *regularFileFD) beforeSave() {}
+func (r *regularFileFD) beforeSave() {}
 
-func (x *regularFileFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fileDescription)
-	m.Save(1, &x.off)
+func (r *regularFileFD) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.fileDescription)
+	stateSinkObject.Save(1, &r.off)
 }
 
-func (x *regularFileFD) afterLoad() {}
+func (r *regularFileFD) afterLoad() {}
 
-func (x *regularFileFD) StateLoad(m state.Source) {
-	m.Load(0, &x.fileDescription)
-	m.Load(1, &x.off)
+func (r *regularFileFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.fileDescription)
+	stateSourceObject.Load(1, &r.off)
 }
 
-func (x *socketFile) StateTypeName() string {
+func (s *socketFile) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.socketFile"
 }
 
-func (x *socketFile) StateFields() []string {
+func (s *socketFile) StateFields() []string {
 	return []string{
 		"inode",
 		"ep",
 	}
 }
 
-func (x *socketFile) beforeSave() {}
+func (s *socketFile) beforeSave() {}
 
-func (x *socketFile) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.ep)
+func (s *socketFile) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.inode)
+	stateSinkObject.Save(1, &s.ep)
 }
 
-func (x *socketFile) afterLoad() {}
+func (s *socketFile) afterLoad() {}
 
-func (x *socketFile) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.ep)
+func (s *socketFile) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.inode)
+	stateSourceObject.Load(1, &s.ep)
 }
 
-func (x *symlink) StateTypeName() string {
+func (s *symlink) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.symlink"
 }
 
-func (x *symlink) StateFields() []string {
+func (s *symlink) StateFields() []string {
 	return []string{
 		"inode",
 		"target",
 	}
 }
 
-func (x *symlink) beforeSave() {}
+func (s *symlink) beforeSave() {}
 
-func (x *symlink) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inode)
-	m.Save(1, &x.target)
+func (s *symlink) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.inode)
+	stateSinkObject.Save(1, &s.target)
 }
 
-func (x *symlink) afterLoad() {}
+func (s *symlink) afterLoad() {}
 
-func (x *symlink) StateLoad(m state.Source) {
-	m.Load(0, &x.inode)
-	m.Load(1, &x.target)
+func (s *symlink) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.inode)
+	stateSourceObject.Load(1, &s.target)
 }
 
-func (x *FilesystemType) StateTypeName() string {
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"vfsfs",
 		"memFile",
@@ -361,32 +361,32 @@ func (x *filesystem) StateFields() []string {
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfs)
-	m.Save(1, &x.memFile)
-	m.Save(2, &x.clock)
-	m.Save(3, &x.devMinor)
-	m.Save(4, &x.nextInoMinusOne)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfs)
+	stateSinkObject.Save(1, &f.memFile)
+	stateSinkObject.Save(2, &f.clock)
+	stateSinkObject.Save(3, &f.devMinor)
+	stateSinkObject.Save(4, &f.nextInoMinusOne)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfs)
-	m.Load(1, &x.memFile)
-	m.Load(2, &x.clock)
-	m.Load(3, &x.devMinor)
-	m.Load(4, &x.nextInoMinusOne)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfs)
+	stateSourceObject.Load(1, &f.memFile)
+	stateSourceObject.Load(2, &f.clock)
+	stateSourceObject.Load(3, &f.devMinor)
+	stateSourceObject.Load(4, &f.nextInoMinusOne)
 }
 
-func (x *FilesystemOpts) StateTypeName() string {
+func (f *FilesystemOpts) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.FilesystemOpts"
 }
 
-func (x *FilesystemOpts) StateFields() []string {
+func (f *FilesystemOpts) StateFields() []string {
 	return []string{
 		"RootFileType",
 		"RootSymlinkTarget",
@@ -394,28 +394,28 @@ func (x *FilesystemOpts) StateFields() []string {
 	}
 }
 
-func (x *FilesystemOpts) beforeSave() {}
+func (f *FilesystemOpts) beforeSave() {}
 
-func (x *FilesystemOpts) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.RootFileType)
-	m.Save(1, &x.RootSymlinkTarget)
-	m.Save(2, &x.FilesystemType)
+func (f *FilesystemOpts) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.RootFileType)
+	stateSinkObject.Save(1, &f.RootSymlinkTarget)
+	stateSinkObject.Save(2, &f.FilesystemType)
 }
 
-func (x *FilesystemOpts) afterLoad() {}
+func (f *FilesystemOpts) afterLoad() {}
 
-func (x *FilesystemOpts) StateLoad(m state.Source) {
-	m.Load(0, &x.RootFileType)
-	m.Load(1, &x.RootSymlinkTarget)
-	m.Load(2, &x.FilesystemType)
+func (f *FilesystemOpts) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.RootFileType)
+	stateSourceObject.Load(1, &f.RootSymlinkTarget)
+	stateSourceObject.Load(2, &f.FilesystemType)
 }
 
-func (x *dentry) StateTypeName() string {
+func (d *dentry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.dentry"
 }
 
-func (x *dentry) StateFields() []string {
+func (d *dentry) StateFields() []string {
 	return []string{
 		"vfsd",
 		"parent",
@@ -425,32 +425,32 @@ func (x *dentry) StateFields() []string {
 	}
 }
 
-func (x *dentry) beforeSave() {}
+func (d *dentry) beforeSave() {}
 
-func (x *dentry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsd)
-	m.Save(1, &x.parent)
-	m.Save(2, &x.name)
-	m.Save(3, &x.dentryEntry)
-	m.Save(4, &x.inode)
+func (d *dentry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.vfsd)
+	stateSinkObject.Save(1, &d.parent)
+	stateSinkObject.Save(2, &d.name)
+	stateSinkObject.Save(3, &d.dentryEntry)
+	stateSinkObject.Save(4, &d.inode)
 }
 
-func (x *dentry) afterLoad() {}
+func (d *dentry) afterLoad() {}
 
-func (x *dentry) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsd)
-	m.Load(1, &x.parent)
-	m.Load(2, &x.name)
-	m.Load(3, &x.dentryEntry)
-	m.Load(4, &x.inode)
+func (d *dentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsd)
+	stateSourceObject.Load(1, &d.parent)
+	stateSourceObject.Load(2, &d.name)
+	stateSourceObject.Load(3, &d.dentryEntry)
+	stateSourceObject.Load(4, &d.inode)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"fs",
 		"refs",
@@ -469,50 +469,50 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
-
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.fs)
-	m.Save(1, &x.refs)
-	m.Save(2, &x.xattrs)
-	m.Save(3, &x.mode)
-	m.Save(4, &x.nlink)
-	m.Save(5, &x.uid)
-	m.Save(6, &x.gid)
-	m.Save(7, &x.ino)
-	m.Save(8, &x.atime)
-	m.Save(9, &x.ctime)
-	m.Save(10, &x.mtime)
-	m.Save(11, &x.locks)
-	m.Save(12, &x.watches)
-	m.Save(13, &x.impl)
-}
-
-func (x *inode) afterLoad() {}
-
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.fs)
-	m.Load(1, &x.refs)
-	m.Load(2, &x.xattrs)
-	m.Load(3, &x.mode)
-	m.Load(4, &x.nlink)
-	m.Load(5, &x.uid)
-	m.Load(6, &x.gid)
-	m.Load(7, &x.ino)
-	m.Load(8, &x.atime)
-	m.Load(9, &x.ctime)
-	m.Load(10, &x.mtime)
-	m.Load(11, &x.locks)
-	m.Load(12, &x.watches)
-	m.Load(13, &x.impl)
-}
-
-func (x *fileDescription) StateTypeName() string {
+func (i *inode) beforeSave() {}
+
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.fs)
+	stateSinkObject.Save(1, &i.refs)
+	stateSinkObject.Save(2, &i.xattrs)
+	stateSinkObject.Save(3, &i.mode)
+	stateSinkObject.Save(4, &i.nlink)
+	stateSinkObject.Save(5, &i.uid)
+	stateSinkObject.Save(6, &i.gid)
+	stateSinkObject.Save(7, &i.ino)
+	stateSinkObject.Save(8, &i.atime)
+	stateSinkObject.Save(9, &i.ctime)
+	stateSinkObject.Save(10, &i.mtime)
+	stateSinkObject.Save(11, &i.locks)
+	stateSinkObject.Save(12, &i.watches)
+	stateSinkObject.Save(13, &i.impl)
+}
+
+func (i *inode) afterLoad() {}
+
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.fs)
+	stateSourceObject.Load(1, &i.refs)
+	stateSourceObject.Load(2, &i.xattrs)
+	stateSourceObject.Load(3, &i.mode)
+	stateSourceObject.Load(4, &i.nlink)
+	stateSourceObject.Load(5, &i.uid)
+	stateSourceObject.Load(6, &i.gid)
+	stateSourceObject.Load(7, &i.ino)
+	stateSourceObject.Load(8, &i.atime)
+	stateSourceObject.Load(9, &i.ctime)
+	stateSourceObject.Load(10, &i.mtime)
+	stateSourceObject.Load(11, &i.locks)
+	stateSourceObject.Load(12, &i.watches)
+	stateSourceObject.Load(13, &i.impl)
+}
+
+func (f *fileDescription) StateTypeName() string {
 	return "pkg/sentry/fsimpl/tmpfs.fileDescription"
 }
 
-func (x *fileDescription) StateFields() []string {
+func (f *fileDescription) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -520,21 +520,21 @@ func (x *fileDescription) StateFields() []string {
 	}
 }
 
-func (x *fileDescription) beforeSave() {}
+func (f *fileDescription) beforeSave() {}
 
-func (x *fileDescription) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.LockFD)
+func (f *fileDescription) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.vfsfd)
+	stateSinkObject.Save(1, &f.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &f.LockFD)
 }
 
-func (x *fileDescription) afterLoad() {}
+func (f *fileDescription) afterLoad() {}
 
-func (x *fileDescription) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.LockFD)
+func (f *fileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.vfsfd)
+	stateSourceObject.Load(1, &f.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &f.LockFD)
 }
 
 func init() {