Merge release-20200928.0-78-g743327817 (automated)

10 files changed, 618 insertions, 618 deletions

diff --git a/pkg/sentry/kernel/auth/auth_state_autogen.go b/pkg/sentry/kernel/auth/auth_state_autogen.go
index 7381b79ea..b844c1fdc 100644
--- a/pkg/sentry/kernel/auth/auth_state_autogen.go
+++ b/pkg/sentry/kernel/auth/auth_state_autogen.go
@@ -94,61 +94,61 @@ func (i *IDMapEntry) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &i.Length)
 }
 
-func (i *idMapRange) StateTypeName() string {
+func (r *idMapRange) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapRange"
 }
 
-func (i *idMapRange) StateFields() []string {
+func (r *idMapRange) StateFields() []string {
 	return []string{
 		"Start",
 		"End",
 	}
 }
 
-func (i *idMapRange) beforeSave() {}
+func (r *idMapRange) beforeSave() {}
 
-func (i *idMapRange) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	stateSinkObject.Save(0, &i.Start)
-	stateSinkObject.Save(1, &i.End)
+func (r *idMapRange) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.Start)
+	stateSinkObject.Save(1, &r.End)
 }
 
-func (i *idMapRange) afterLoad() {}
+func (r *idMapRange) afterLoad() {}
 
-func (i *idMapRange) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &i.Start)
-	stateSourceObject.Load(1, &i.End)
+func (r *idMapRange) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.Start)
+	stateSourceObject.Load(1, &r.End)
 }
 
-func (i *idMapSet) StateTypeName() string {
+func (s *idMapSet) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapSet"
 }
 
-func (i *idMapSet) StateFields() []string {
+func (s *idMapSet) StateFields() []string {
 	return []string{
 		"root",
 	}
 }
 
-func (i *idMapSet) beforeSave() {}
+func (s *idMapSet) beforeSave() {}
 
-func (i *idMapSet) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	var rootValue *idMapSegmentDataSlices = i.saveRoot()
+func (s *idMapSet) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	var rootValue *idMapSegmentDataSlices = s.saveRoot()
 	stateSinkObject.SaveValue(0, rootValue)
 }
 
-func (i *idMapSet) afterLoad() {}
+func (s *idMapSet) afterLoad() {}
 
-func (i *idMapSet) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { i.loadRoot(y.(*idMapSegmentDataSlices)) })
+func (s *idMapSet) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { s.loadRoot(y.(*idMapSegmentDataSlices)) })
 }
 
-func (i *idMapnode) StateTypeName() string {
+func (n *idMapnode) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.idMapnode"
 }
 
-func (i *idMapnode) StateFields() []string {
+func (n *idMapnode) StateFields() []string {
 	return []string{
 		"nrSegments",
 		"parent",
@@ -161,31 +161,31 @@ func (i *idMapnode) StateFields() []string {
 	}
 }
 
-func (i *idMapnode) beforeSave() {}
-
-func (i *idMapnode) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	stateSinkObject.Save(0, &i.nrSegments)
-	stateSinkObject.Save(1, &i.parent)
-	stateSinkObject.Save(2, &i.parentIndex)
-	stateSinkObject.Save(3, &i.hasChildren)
-	stateSinkObject.Save(4, &i.maxGap)
-	stateSinkObject.Save(5, &i.keys)
-	stateSinkObject.Save(6, &i.values)
-	stateSinkObject.Save(7, &i.children)
+func (n *idMapnode) beforeSave() {}
+
+func (n *idMapnode) StateSave(stateSinkObject state.Sink) {
+	n.beforeSave()
+	stateSinkObject.Save(0, &n.nrSegments)
+	stateSinkObject.Save(1, &n.parent)
+	stateSinkObject.Save(2, &n.parentIndex)
+	stateSinkObject.Save(3, &n.hasChildren)
+	stateSinkObject.Save(4, &n.maxGap)
+	stateSinkObject.Save(5, &n.keys)
+	stateSinkObject.Save(6, &n.values)
+	stateSinkObject.Save(7, &n.children)
 }
 
-func (i *idMapnode) afterLoad() {}
-
-func (i *idMapnode) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &i.nrSegments)
-	stateSourceObject.Load(1, &i.parent)
-	stateSourceObject.Load(2, &i.parentIndex)
-	stateSourceObject.Load(3, &i.hasChildren)
-	stateSourceObject.Load(4, &i.maxGap)
-	stateSourceObject.Load(5, &i.keys)
-	stateSourceObject.Load(6, &i.values)
-	stateSourceObject.Load(7, &i.children)
+func (n *idMapnode) afterLoad() {}
+
+func (n *idMapnode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &n.nrSegments)
+	stateSourceObject.Load(1, &n.parent)
+	stateSourceObject.Load(2, &n.parentIndex)
+	stateSourceObject.Load(3, &n.hasChildren)
+	stateSourceObject.Load(4, &n.maxGap)
+	stateSourceObject.Load(5, &n.keys)
+	stateSourceObject.Load(6, &n.values)
+	stateSourceObject.Load(7, &n.children)
 }
 
 func (i *idMapSegmentDataSlices) StateTypeName() string {
@@ -217,11 +217,11 @@ func (i *idMapSegmentDataSlices) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &i.Values)
 }
 
-func (u *UserNamespace) StateTypeName() string {
+func (ns *UserNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.UserNamespace"
 }
 
-func (u *UserNamespace) StateFields() []string {
+func (ns *UserNamespace) StateFields() []string {
 	return []string{
 		"parent",
 		"owner",
@@ -232,27 +232,27 @@ func (u *UserNamespace) StateFields() []string {
 	}
 }
 
-func (u *UserNamespace) beforeSave() {}
+func (ns *UserNamespace) beforeSave() {}
 
-func (u *UserNamespace) StateSave(stateSinkObject state.Sink) {
-	u.beforeSave()
-	stateSinkObject.Save(0, &u.parent)
-	stateSinkObject.Save(1, &u.owner)
-	stateSinkObject.Save(2, &u.uidMapFromParent)
-	stateSinkObject.Save(3, &u.uidMapToParent)
-	stateSinkObject.Save(4, &u.gidMapFromParent)
-	stateSinkObject.Save(5, &u.gidMapToParent)
+func (ns *UserNamespace) StateSave(stateSinkObject state.Sink) {
+	ns.beforeSave()
+	stateSinkObject.Save(0, &ns.parent)
+	stateSinkObject.Save(1, &ns.owner)
+	stateSinkObject.Save(2, &ns.uidMapFromParent)
+	stateSinkObject.Save(3, &ns.uidMapToParent)
+	stateSinkObject.Save(4, &ns.gidMapFromParent)
+	stateSinkObject.Save(5, &ns.gidMapToParent)
 }
 
-func (u *UserNamespace) afterLoad() {}
+func (ns *UserNamespace) afterLoad() {}
 
-func (u *UserNamespace) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &u.parent)
-	stateSourceObject.Load(1, &u.owner)
-	stateSourceObject.Load(2, &u.uidMapFromParent)
-	stateSourceObject.Load(3, &u.uidMapToParent)
-	stateSourceObject.Load(4, &u.gidMapFromParent)
-	stateSourceObject.Load(5, &u.gidMapToParent)
+func (ns *UserNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &ns.parent)
+	stateSourceObject.Load(1, &ns.owner)
+	stateSourceObject.Load(2, &ns.uidMapFromParent)
+	stateSourceObject.Load(3, &ns.uidMapToParent)
+	stateSourceObject.Load(4, &ns.gidMapFromParent)
+	stateSourceObject.Load(5, &ns.gidMapToParent)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go b/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
index 4002e0cb2..7b4e62296 100644
--- a/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
+++ b/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
@@ -6,28 +6,28 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (a *AtomicPtrCredentials) StateTypeName() string {
+func (p *AtomicPtrCredentials) StateTypeName() string {
 	return "pkg/sentry/kernel/auth.AtomicPtrCredentials"
 }
 
-func (a *AtomicPtrCredentials) StateFields() []string {
+func (p *AtomicPtrCredentials) StateFields() []string {
 	return []string{
 		"ptr",
 	}
 }
 
-func (a *AtomicPtrCredentials) beforeSave() {}
+func (p *AtomicPtrCredentials) beforeSave() {}
 
-func (a *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) {
-	a.beforeSave()
-	var ptrValue *Credentials = a.savePtr()
+func (p *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	var ptrValue *Credentials = p.savePtr()
 	stateSinkObject.SaveValue(0, ptrValue)
 }
 
-func (a *AtomicPtrCredentials) afterLoad() {}
+func (p *AtomicPtrCredentials) afterLoad() {}
 
-func (a *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { a.loadPtr(y.(*Credentials)) })
+func (p *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { p.loadPtr(y.(*Credentials)) })
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/epoll/epoll_state_autogen.go b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
index cdeadd3e1..ba00fe082 100644
--- a/pkg/sentry/kernel/epoll/epoll_state_autogen.go
+++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
@@ -121,56 +121,56 @@ func (e *EventPoll) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.AfterLoad(e.afterLoad)
 }
 
-func (p *pollEntryList) StateTypeName() string {
+func (l *pollEntryList) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.pollEntryList"
 }
 
-func (p *pollEntryList) StateFields() []string {
+func (l *pollEntryList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (p *pollEntryList) beforeSave() {}
+func (l *pollEntryList) beforeSave() {}
 
-func (p *pollEntryList) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.head)
-	stateSinkObject.Save(1, &p.tail)
+func (l *pollEntryList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (p *pollEntryList) afterLoad() {}
+func (l *pollEntryList) afterLoad() {}
 
-func (p *pollEntryList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.head)
-	stateSourceObject.Load(1, &p.tail)
+func (l *pollEntryList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (p *pollEntryEntry) StateTypeName() string {
+func (e *pollEntryEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/epoll.pollEntryEntry"
 }
 
-func (p *pollEntryEntry) StateFields() []string {
+func (e *pollEntryEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (p *pollEntryEntry) beforeSave() {}
+func (e *pollEntryEntry) beforeSave() {}
 
-func (p *pollEntryEntry) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.next)
-	stateSinkObject.Save(1, &p.prev)
+func (e *pollEntryEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (p *pollEntryEntry) afterLoad() {}
+func (e *pollEntryEntry) afterLoad() {}
 
-func (p *pollEntryEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.next)
-	stateSourceObject.Load(1, &p.prev)
+func (e *pollEntryEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/fasync/fasync_state_autogen.go b/pkg/sentry/kernel/fasync/fasync_state_autogen.go
index e4a0b5695..ac5f4bb54 100644
--- a/pkg/sentry/kernel/fasync/fasync_state_autogen.go
+++ b/pkg/sentry/kernel/fasync/fasync_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (f *FileAsync) StateTypeName() string {
+func (a *FileAsync) StateTypeName() string {
 	return "pkg/sentry/kernel/fasync.FileAsync"
 }
 
-func (f *FileAsync) StateFields() []string {
+func (a *FileAsync) StateFields() []string {
 	return []string{
 		"e",
 		"requester",
@@ -21,27 +21,27 @@ func (f *FileAsync) StateFields() []string {
 	}
 }
 
-func (f *FileAsync) beforeSave() {}
+func (a *FileAsync) beforeSave() {}
 
-func (f *FileAsync) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.e)
-	stateSinkObject.Save(1, &f.requester)
-	stateSinkObject.Save(2, &f.registered)
-	stateSinkObject.Save(3, &f.recipientPG)
-	stateSinkObject.Save(4, &f.recipientTG)
-	stateSinkObject.Save(5, &f.recipientT)
+func (a *FileAsync) StateSave(stateSinkObject state.Sink) {
+	a.beforeSave()
+	stateSinkObject.Save(0, &a.e)
+	stateSinkObject.Save(1, &a.requester)
+	stateSinkObject.Save(2, &a.registered)
+	stateSinkObject.Save(3, &a.recipientPG)
+	stateSinkObject.Save(4, &a.recipientTG)
+	stateSinkObject.Save(5, &a.recipientT)
 }
 
-func (f *FileAsync) afterLoad() {}
+func (a *FileAsync) afterLoad() {}
 
-func (f *FileAsync) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.e)
-	stateSourceObject.Load(1, &f.requester)
-	stateSourceObject.Load(2, &f.registered)
-	stateSourceObject.Load(3, &f.recipientPG)
-	stateSourceObject.Load(4, &f.recipientTG)
-	stateSourceObject.Load(5, &f.recipientT)
+func (a *FileAsync) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &a.e)
+	stateSourceObject.Load(1, &a.requester)
+	stateSourceObject.Load(2, &a.registered)
+	stateSourceObject.Load(3, &a.recipientPG)
+	stateSourceObject.Load(4, &a.recipientTG)
+	stateSourceObject.Load(5, &a.recipientT)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/futex/futex_state_autogen.go b/pkg/sentry/kernel/futex/futex_state_autogen.go
index f36f5ccfc..f31e571f4 100644
--- a/pkg/sentry/kernel/futex/futex_state_autogen.go
+++ b/pkg/sentry/kernel/futex/futex_state_autogen.go
@@ -54,56 +54,56 @@ func (m *Manager) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &m.sharedBucket)
 }
 
-func (w *waiterList) StateTypeName() string {
+func (l *waiterList) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.waiterList"
 }
 
-func (w *waiterList) StateFields() []string {
+func (l *waiterList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (w *waiterList) beforeSave() {}
+func (l *waiterList) beforeSave() {}
 
-func (w *waiterList) StateSave(stateSinkObject state.Sink) {
-	w.beforeSave()
-	stateSinkObject.Save(0, &w.head)
-	stateSinkObject.Save(1, &w.tail)
+func (l *waiterList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (w *waiterList) afterLoad() {}
+func (l *waiterList) afterLoad() {}
 
-func (w *waiterList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &w.head)
-	stateSourceObject.Load(1, &w.tail)
+func (l *waiterList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (w *waiterEntry) StateTypeName() string {
+func (e *waiterEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.waiterEntry"
 }
 
-func (w *waiterEntry) StateFields() []string {
+func (e *waiterEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (w *waiterEntry) beforeSave() {}
+func (e *waiterEntry) beforeSave() {}
 
-func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
-	w.beforeSave()
-	stateSinkObject.Save(0, &w.next)
-	stateSinkObject.Save(1, &w.prev)
+func (e *waiterEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (w *waiterEntry) afterLoad() {}
+func (e *waiterEntry) afterLoad() {}
 
-func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &w.next)
-	stateSourceObject.Load(1, &w.prev)
+func (e *waiterEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go b/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
index 6a9953ffa..19e23104f 100644
--- a/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
+++ b/pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go
@@ -6,28 +6,28 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (a *AtomicPtrBucket) StateTypeName() string {
+func (p *AtomicPtrBucket) StateTypeName() string {
 	return "pkg/sentry/kernel/futex.AtomicPtrBucket"
 }
 
-func (a *AtomicPtrBucket) StateFields() []string {
+func (p *AtomicPtrBucket) StateFields() []string {
 	return []string{
 		"ptr",
 	}
 }
 
-func (a *AtomicPtrBucket) beforeSave() {}
+func (p *AtomicPtrBucket) beforeSave() {}
 
-func (a *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) {
-	a.beforeSave()
-	var ptrValue *bucket = a.savePtr()
+func (p *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) {
+	p.beforeSave()
+	var ptrValue *bucket = p.savePtr()
 	stateSinkObject.SaveValue(0, ptrValue)
 }
 
-func (a *AtomicPtrBucket) afterLoad() {}
+func (p *AtomicPtrBucket) afterLoad() {}
 
-func (a *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { a.loadPtr(y.(*bucket)) })
+func (p *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { p.loadPtr(y.(*bucket)) })
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/kernel_state_autogen.go b/pkg/sentry/kernel/kernel_state_autogen.go
index 101c137de..d8ff396b7 100644
--- a/pkg/sentry/kernel/kernel_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_state_autogen.go
@@ -152,27 +152,27 @@ func (f *FDTable) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { f.loadDescriptorTable(y.(map[int32]descriptor)) })
 }
 
-func (f *FDTableRefs) StateTypeName() string {
+func (r *FDTableRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.FDTableRefs"
 }
 
-func (f *FDTableRefs) StateFields() []string {
+func (r *FDTableRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (f *FDTableRefs) beforeSave() {}
+func (r *FDTableRefs) beforeSave() {}
 
-func (f *FDTableRefs) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.refCount)
+func (r *FDTableRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (f *FDTableRefs) afterLoad() {}
+func (r *FDTableRefs) afterLoad() {}
 
-func (f *FDTableRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.refCount)
+func (r *FDTableRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (f *FSContext) StateTypeName() string {
@@ -213,27 +213,27 @@ func (f *FSContext) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(5, &f.umask)
 }
 
-func (f *FSContextRefs) StateTypeName() string {
+func (r *FSContextRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.FSContextRefs"
 }
 
-func (f *FSContextRefs) StateFields() []string {
+func (r *FSContextRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (f *FSContextRefs) beforeSave() {}
+func (r *FSContextRefs) beforeSave() {}
 
-func (f *FSContextRefs) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.refCount)
+func (r *FSContextRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (f *FSContextRefs) afterLoad() {}
+func (r *FSContextRefs) afterLoad() {}
 
-func (f *FSContextRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.refCount)
+func (r *FSContextRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (i *IPCNamespace) StateTypeName() string {
@@ -535,56 +535,56 @@ func (p *pendingSignal) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &p.timer)
 }
 
-func (p *pendingSignalList) StateTypeName() string {
+func (l *pendingSignalList) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignalList"
 }
 
-func (p *pendingSignalList) StateFields() []string {
+func (l *pendingSignalList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (p *pendingSignalList) beforeSave() {}
+func (l *pendingSignalList) beforeSave() {}
 
-func (p *pendingSignalList) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.head)
-	stateSinkObject.Save(1, &p.tail)
+func (l *pendingSignalList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (p *pendingSignalList) afterLoad() {}
+func (l *pendingSignalList) afterLoad() {}
 
-func (p *pendingSignalList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.head)
-	stateSourceObject.Load(1, &p.tail)
+func (l *pendingSignalList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (p *pendingSignalEntry) StateTypeName() string {
+func (e *pendingSignalEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.pendingSignalEntry"
 }
 
-func (p *pendingSignalEntry) StateFields() []string {
+func (e *pendingSignalEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (p *pendingSignalEntry) beforeSave() {}
+func (e *pendingSignalEntry) beforeSave() {}
 
-func (p *pendingSignalEntry) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.next)
-	stateSinkObject.Save(1, &p.prev)
+func (e *pendingSignalEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (p *pendingSignalEntry) afterLoad() {}
+func (e *pendingSignalEntry) afterLoad() {}
 
-func (p *pendingSignalEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.next)
-	stateSourceObject.Load(1, &p.prev)
+func (e *pendingSignalEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func (s *savedPendingSignal) StateTypeName() string {
@@ -613,11 +613,11 @@ func (s *savedPendingSignal) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &s.timer)
 }
 
-func (i *IntervalTimer) StateTypeName() string {
+func (it *IntervalTimer) StateTypeName() string {
 	return "pkg/sentry/kernel.IntervalTimer"
 }
 
-func (i *IntervalTimer) StateFields() []string {
+func (it *IntervalTimer) StateFields() []string {
 	return []string{
 		"timer",
 		"target",
@@ -632,110 +632,110 @@ func (i *IntervalTimer) StateFields() []string {
 	}
 }
 
-func (i *IntervalTimer) beforeSave() {}
+func (it *IntervalTimer) beforeSave() {}
 
-func (i *IntervalTimer) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	stateSinkObject.Save(0, &i.timer)
-	stateSinkObject.Save(1, &i.target)
-	stateSinkObject.Save(2, &i.signo)
-	stateSinkObject.Save(3, &i.id)
-	stateSinkObject.Save(4, &i.sigval)
-	stateSinkObject.Save(5, &i.group)
-	stateSinkObject.Save(6, &i.sigpending)
-	stateSinkObject.Save(7, &i.sigorphan)
-	stateSinkObject.Save(8, &i.overrunCur)
-	stateSinkObject.Save(9, &i.overrunLast)
-}
-
-func (i *IntervalTimer) afterLoad() {}
-
-func (i *IntervalTimer) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &i.timer)
-	stateSourceObject.Load(1, &i.target)
-	stateSourceObject.Load(2, &i.signo)
-	stateSourceObject.Load(3, &i.id)
-	stateSourceObject.Load(4, &i.sigval)
-	stateSourceObject.Load(5, &i.group)
-	stateSourceObject.Load(6, &i.sigpending)
-	stateSourceObject.Load(7, &i.sigorphan)
-	stateSourceObject.Load(8, &i.overrunCur)
-	stateSourceObject.Load(9, &i.overrunLast)
-}
-
-func (p *processGroupList) StateTypeName() string {
+func (it *IntervalTimer) StateSave(stateSinkObject state.Sink) {
+	it.beforeSave()
+	stateSinkObject.Save(0, &it.timer)
+	stateSinkObject.Save(1, &it.target)
+	stateSinkObject.Save(2, &it.signo)
+	stateSinkObject.Save(3, &it.id)
+	stateSinkObject.Save(4, &it.sigval)
+	stateSinkObject.Save(5, &it.group)
+	stateSinkObject.Save(6, &it.sigpending)
+	stateSinkObject.Save(7, &it.sigorphan)
+	stateSinkObject.Save(8, &it.overrunCur)
+	stateSinkObject.Save(9, &it.overrunLast)
+}
+
+func (it *IntervalTimer) afterLoad() {}
+
+func (it *IntervalTimer) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &it.timer)
+	stateSourceObject.Load(1, &it.target)
+	stateSourceObject.Load(2, &it.signo)
+	stateSourceObject.Load(3, &it.id)
+	stateSourceObject.Load(4, &it.sigval)
+	stateSourceObject.Load(5, &it.group)
+	stateSourceObject.Load(6, &it.sigpending)
+	stateSourceObject.Load(7, &it.sigorphan)
+	stateSourceObject.Load(8, &it.overrunCur)
+	stateSourceObject.Load(9, &it.overrunLast)
+}
+
+func (l *processGroupList) StateTypeName() string {
 	return "pkg/sentry/kernel.processGroupList"
 }
 
-func (p *processGroupList) StateFields() []string {
+func (l *processGroupList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (p *processGroupList) beforeSave() {}
+func (l *processGroupList) beforeSave() {}
 
-func (p *processGroupList) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.head)
-	stateSinkObject.Save(1, &p.tail)
+func (l *processGroupList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (p *processGroupList) afterLoad() {}
+func (l *processGroupList) afterLoad() {}
 
-func (p *processGroupList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.head)
-	stateSourceObject.Load(1, &p.tail)
+func (l *processGroupList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (p *processGroupEntry) StateTypeName() string {
+func (e *processGroupEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.processGroupEntry"
 }
 
-func (p *processGroupEntry) StateFields() []string {
+func (e *processGroupEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (p *processGroupEntry) beforeSave() {}
+func (e *processGroupEntry) beforeSave() {}
 
-func (p *processGroupEntry) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.next)
-	stateSinkObject.Save(1, &p.prev)
+func (e *processGroupEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (p *processGroupEntry) afterLoad() {}
+func (e *processGroupEntry) afterLoad() {}
 
-func (p *processGroupEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.next)
-	stateSourceObject.Load(1, &p.prev)
+func (e *processGroupEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
-func (p *ProcessGroupRefs) StateTypeName() string {
+func (r *ProcessGroupRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.ProcessGroupRefs"
 }
 
-func (p *ProcessGroupRefs) StateFields() []string {
+func (r *ProcessGroupRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (p *ProcessGroupRefs) beforeSave() {}
+func (r *ProcessGroupRefs) beforeSave() {}
 
-func (p *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.refCount)
+func (r *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (p *ProcessGroupRefs) afterLoad() {}
+func (r *ProcessGroupRefs) afterLoad() {}
 
-func (p *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.refCount)
+func (r *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (p *ptraceOptions) StateTypeName() string {
@@ -785,30 +785,30 @@ func (p *ptraceOptions) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(8, &p.TraceVforkDone)
 }
 
-func (p *ptraceStop) StateTypeName() string {
+func (s *ptraceStop) StateTypeName() string {
 	return "pkg/sentry/kernel.ptraceStop"
 }
 
-func (p *ptraceStop) StateFields() []string {
+func (s *ptraceStop) StateFields() []string {
 	return []string{
 		"frozen",
 		"listen",
 	}
 }
 
-func (p *ptraceStop) beforeSave() {}
+func (s *ptraceStop) beforeSave() {}
 
-func (p *ptraceStop) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.frozen)
-	stateSinkObject.Save(1, &p.listen)
+func (s *ptraceStop) StateSave(stateSinkObject state.Sink) {
+	s.beforeSave()
+	stateSinkObject.Save(0, &s.frozen)
+	stateSinkObject.Save(1, &s.listen)
 }
 
-func (p *ptraceStop) afterLoad() {}
+func (s *ptraceStop) afterLoad() {}
 
-func (p *ptraceStop) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.frozen)
-	stateSourceObject.Load(1, &p.listen)
+func (s *ptraceStop) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &s.frozen)
+	stateSourceObject.Load(1, &s.listen)
 }
 
 func (o *OldRSeqCriticalRegion) StateTypeName() string {
@@ -837,79 +837,79 @@ func (o *OldRSeqCriticalRegion) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &o.Restart)
 }
 
-func (s *sessionList) StateTypeName() string {
+func (l *sessionList) StateTypeName() string {
 	return "pkg/sentry/kernel.sessionList"
 }
 
-func (s *sessionList) StateFields() []string {
+func (l *sessionList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (s *sessionList) beforeSave() {}
+func (l *sessionList) beforeSave() {}
 
-func (s *sessionList) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.head)
-	stateSinkObject.Save(1, &s.tail)
+func (l *sessionList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (s *sessionList) afterLoad() {}
+func (l *sessionList) afterLoad() {}
 
-func (s *sessionList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.head)
-	stateSourceObject.Load(1, &s.tail)
+func (l *sessionList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (s *sessionEntry) StateTypeName() string {
+func (e *sessionEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.sessionEntry"
 }
 
-func (s *sessionEntry) StateFields() []string {
+func (e *sessionEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (s *sessionEntry) beforeSave() {}
+func (e *sessionEntry) beforeSave() {}
 
-func (s *sessionEntry) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.next)
-	stateSinkObject.Save(1, &s.prev)
+func (e *sessionEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (s *sessionEntry) afterLoad() {}
+func (e *sessionEntry) afterLoad() {}
 
-func (s *sessionEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.next)
-	stateSourceObject.Load(1, &s.prev)
+func (e *sessionEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
-func (s *SessionRefs) StateTypeName() string {
+func (r *SessionRefs) StateTypeName() string {
 	return "pkg/sentry/kernel.SessionRefs"
 }
 
-func (s *SessionRefs) StateFields() []string {
+func (r *SessionRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (s *SessionRefs) beforeSave() {}
+func (r *SessionRefs) beforeSave() {}
 
-func (s *SessionRefs) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.refCount)
+func (r *SessionRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (s *SessionRefs) afterLoad() {}
+func (r *SessionRefs) afterLoad() {}
 
-func (s *SessionRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.refCount)
+func (r *SessionRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (s *Session) StateTypeName() string {
@@ -950,11 +950,11 @@ func (s *Session) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(5, &s.sessionEntry)
 }
 
-func (p *ProcessGroup) StateTypeName() string {
+func (pg *ProcessGroup) StateTypeName() string {
 	return "pkg/sentry/kernel.ProcessGroup"
 }
 
-func (p *ProcessGroup) StateFields() []string {
+func (pg *ProcessGroup) StateFields() []string {
 	return []string{
 		"refs",
 		"originator",
@@ -965,102 +965,102 @@ func (p *ProcessGroup) StateFields() []string {
 	}
 }
 
-func (p *ProcessGroup) beforeSave() {}
+func (pg *ProcessGroup) beforeSave() {}
 
-func (p *ProcessGroup) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.refs)
-	stateSinkObject.Save(1, &p.originator)
-	stateSinkObject.Save(2, &p.id)
-	stateSinkObject.Save(3, &p.session)
-	stateSinkObject.Save(4, &p.ancestors)
-	stateSinkObject.Save(5, &p.processGroupEntry)
+func (pg *ProcessGroup) StateSave(stateSinkObject state.Sink) {
+	pg.beforeSave()
+	stateSinkObject.Save(0, &pg.refs)
+	stateSinkObject.Save(1, &pg.originator)
+	stateSinkObject.Save(2, &pg.id)
+	stateSinkObject.Save(3, &pg.session)
+	stateSinkObject.Save(4, &pg.ancestors)
+	stateSinkObject.Save(5, &pg.processGroupEntry)
 }
 
-func (p *ProcessGroup) afterLoad() {}
+func (pg *ProcessGroup) afterLoad() {}
 
-func (p *ProcessGroup) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.refs)
-	stateSourceObject.Load(1, &p.originator)
-	stateSourceObject.Load(2, &p.id)
-	stateSourceObject.Load(3, &p.session)
-	stateSourceObject.Load(4, &p.ancestors)
-	stateSourceObject.Load(5, &p.processGroupEntry)
+func (pg *ProcessGroup) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &pg.refs)
+	stateSourceObject.Load(1, &pg.originator)
+	stateSourceObject.Load(2, &pg.id)
+	stateSourceObject.Load(3, &pg.session)
+	stateSourceObject.Load(4, &pg.ancestors)
+	stateSourceObject.Load(5, &pg.processGroupEntry)
 }
 
-func (s *SignalHandlers) StateTypeName() string {
+func (sh *SignalHandlers) StateTypeName() string {
 	return "pkg/sentry/kernel.SignalHandlers"
 }
 
-func (s *SignalHandlers) StateFields() []string {
+func (sh *SignalHandlers) StateFields() []string {
 	return []string{
 		"actions",
 	}
 }
 
-func (s *SignalHandlers) beforeSave() {}
+func (sh *SignalHandlers) beforeSave() {}
 
-func (s *SignalHandlers) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.actions)
+func (sh *SignalHandlers) StateSave(stateSinkObject state.Sink) {
+	sh.beforeSave()
+	stateSinkObject.Save(0, &sh.actions)
 }
 
-func (s *SignalHandlers) afterLoad() {}
+func (sh *SignalHandlers) afterLoad() {}
 
-func (s *SignalHandlers) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.actions)
+func (sh *SignalHandlers) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &sh.actions)
 }
 
-func (s *socketList) StateTypeName() string {
+func (l *socketList) StateTypeName() string {
 	return "pkg/sentry/kernel.socketList"
 }
 
-func (s *socketList) StateFields() []string {
+func (l *socketList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (s *socketList) beforeSave() {}
+func (l *socketList) beforeSave() {}
 
-func (s *socketList) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.head)
-	stateSinkObject.Save(1, &s.tail)
+func (l *socketList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (s *socketList) afterLoad() {}
+func (l *socketList) afterLoad() {}
 
-func (s *socketList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.head)
-	stateSourceObject.Load(1, &s.tail)
+func (l *socketList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (s *socketEntry) StateTypeName() string {
+func (e *socketEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.socketEntry"
 }
 
-func (s *socketEntry) StateFields() []string {
+func (e *socketEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (s *socketEntry) beforeSave() {}
+func (e *socketEntry) beforeSave() {}
 
-func (s *socketEntry) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.next)
-	stateSinkObject.Save(1, &s.prev)
+func (e *socketEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (s *socketEntry) afterLoad() {}
+func (e *socketEntry) afterLoad() {}
 
-func (s *socketEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.next)
-	stateSourceObject.Load(1, &s.prev)
+func (e *socketEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func (s *syscallTableInfo) StateTypeName() string {
@@ -1390,11 +1390,11 @@ func (v *vforkStop) afterLoad() {}
 func (v *vforkStop) StateLoad(stateSourceObject state.Source) {
 }
 
-func (t *TaskContext) StateTypeName() string {
+func (tc *TaskContext) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskContext"
 }
 
-func (t *TaskContext) StateFields() []string {
+func (tc *TaskContext) StateFields() []string {
 	return []string{
 		"Name",
 		"Arch",
@@ -1404,26 +1404,26 @@ func (t *TaskContext) StateFields() []string {
 	}
 }
 
-func (t *TaskContext) beforeSave() {}
+func (tc *TaskContext) beforeSave() {}
 
-func (t *TaskContext) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	var stValue syscallTableInfo = t.saveSt()
+func (tc *TaskContext) StateSave(stateSinkObject state.Sink) {
+	tc.beforeSave()
+	var stValue syscallTableInfo = tc.saveSt()
 	stateSinkObject.SaveValue(4, stValue)
-	stateSinkObject.Save(0, &t.Name)
-	stateSinkObject.Save(1, &t.Arch)
-	stateSinkObject.Save(2, &t.MemoryManager)
-	stateSinkObject.Save(3, &t.fu)
+	stateSinkObject.Save(0, &tc.Name)
+	stateSinkObject.Save(1, &tc.Arch)
+	stateSinkObject.Save(2, &tc.MemoryManager)
+	stateSinkObject.Save(3, &tc.fu)
 }
 
-func (t *TaskContext) afterLoad() {}
+func (tc *TaskContext) afterLoad() {}
 
-func (t *TaskContext) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.Name)
-	stateSourceObject.Load(1, &t.Arch)
-	stateSourceObject.Load(2, &t.MemoryManager)
-	stateSourceObject.Load(3, &t.fu)
-	stateSourceObject.LoadValue(4, new(syscallTableInfo), func(y interface{}) { t.loadSt(y.(syscallTableInfo)) })
+func (tc *TaskContext) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &tc.Name)
+	stateSourceObject.Load(1, &tc.Arch)
+	stateSourceObject.Load(2, &tc.MemoryManager)
+	stateSourceObject.Load(3, &tc.fu)
+	stateSourceObject.LoadValue(4, new(syscallTableInfo), func(y interface{}) { tc.loadSt(y.(syscallTableInfo)) })
 }
 
 func (e *execStop) StateTypeName() string {
@@ -1468,30 +1468,30 @@ func (r *runSyscallAfterExecStop) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &r.tc)
 }
 
-func (e *ExitStatus) StateTypeName() string {
+func (es *ExitStatus) StateTypeName() string {
 	return "pkg/sentry/kernel.ExitStatus"
 }
 
-func (e *ExitStatus) StateFields() []string {
+func (es *ExitStatus) StateFields() []string {
 	return []string{
 		"Code",
 		"Signo",
 	}
 }
 
-func (e *ExitStatus) beforeSave() {}
+func (es *ExitStatus) beforeSave() {}
 
-func (e *ExitStatus) StateSave(stateSinkObject state.Sink) {
-	e.beforeSave()
-	stateSinkObject.Save(0, &e.Code)
-	stateSinkObject.Save(1, &e.Signo)
+func (es *ExitStatus) StateSave(stateSinkObject state.Sink) {
+	es.beforeSave()
+	stateSinkObject.Save(0, &es.Code)
+	stateSinkObject.Save(1, &es.Signo)
 }
 
-func (e *ExitStatus) afterLoad() {}
+func (es *ExitStatus) afterLoad() {}
 
-func (e *ExitStatus) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.Code)
-	stateSourceObject.Load(1, &e.Signo)
+func (es *ExitStatus) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &es.Code)
+	stateSourceObject.Load(1, &es.Signo)
 }
 
 func (r *runExit) StateTypeName() string {
@@ -1551,82 +1551,82 @@ func (r *runExitNotify) afterLoad() {}
 func (r *runExitNotify) StateLoad(stateSourceObject state.Source) {
 }
 
-func (t *taskList) StateTypeName() string {
+func (l *taskList) StateTypeName() string {
 	return "pkg/sentry/kernel.taskList"
 }
 
-func (t *taskList) StateFields() []string {
+func (l *taskList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (t *taskList) beforeSave() {}
+func (l *taskList) beforeSave() {}
 
-func (t *taskList) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.head)
-	stateSinkObject.Save(1, &t.tail)
+func (l *taskList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (t *taskList) afterLoad() {}
+func (l *taskList) afterLoad() {}
 
-func (t *taskList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.head)
-	stateSourceObject.Load(1, &t.tail)
+func (l *taskList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (t *taskEntry) StateTypeName() string {
+func (e *taskEntry) StateTypeName() string {
 	return "pkg/sentry/kernel.taskEntry"
 }
 
-func (t *taskEntry) StateFields() []string {
+func (e *taskEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (t *taskEntry) beforeSave() {}
+func (e *taskEntry) beforeSave() {}
 
-func (t *taskEntry) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.next)
-	stateSinkObject.Save(1, &t.prev)
+func (e *taskEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (t *taskEntry) afterLoad() {}
+func (e *taskEntry) afterLoad() {}
 
-func (t *taskEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.next)
-	stateSourceObject.Load(1, &t.prev)
+func (e *taskEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
-func (r *runApp) StateTypeName() string {
+func (app *runApp) StateTypeName() string {
 	return "pkg/sentry/kernel.runApp"
 }
 
-func (r *runApp) StateFields() []string {
+func (app *runApp) StateFields() []string {
 	return []string{}
 }
 
-func (r *runApp) beforeSave() {}
+func (app *runApp) beforeSave() {}
 
-func (r *runApp) StateSave(stateSinkObject state.Sink) {
-	r.beforeSave()
+func (app *runApp) StateSave(stateSinkObject state.Sink) {
+	app.beforeSave()
 }
 
-func (r *runApp) afterLoad() {}
+func (app *runApp) afterLoad() {}
 
-func (r *runApp) StateLoad(stateSourceObject state.Source) {
+func (app *runApp) StateLoad(stateSourceObject state.Source) {
 }
 
-func (t *TaskGoroutineSchedInfo) StateTypeName() string {
+func (ts *TaskGoroutineSchedInfo) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskGoroutineSchedInfo"
 }
 
-func (t *TaskGoroutineSchedInfo) StateFields() []string {
+func (ts *TaskGoroutineSchedInfo) StateFields() []string {
 	return []string{
 		"Timestamp",
 		"State",
@@ -1635,75 +1635,75 @@ func (t *TaskGoroutineSchedInfo) StateFields() []string {
 	}
 }
 
-func (t *TaskGoroutineSchedInfo) beforeSave() {}
+func (ts *TaskGoroutineSchedInfo) beforeSave() {}
 
-func (t *TaskGoroutineSchedInfo) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.Timestamp)
-	stateSinkObject.Save(1, &t.State)
-	stateSinkObject.Save(2, &t.UserTicks)
-	stateSinkObject.Save(3, &t.SysTicks)
+func (ts *TaskGoroutineSchedInfo) StateSave(stateSinkObject state.Sink) {
+	ts.beforeSave()
+	stateSinkObject.Save(0, &ts.Timestamp)
+	stateSinkObject.Save(1, &ts.State)
+	stateSinkObject.Save(2, &ts.UserTicks)
+	stateSinkObject.Save(3, &ts.SysTicks)
 }
 
-func (t *TaskGoroutineSchedInfo) afterLoad() {}
+func (ts *TaskGoroutineSchedInfo) afterLoad() {}
 
-func (t *TaskGoroutineSchedInfo) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.Timestamp)
-	stateSourceObject.Load(1, &t.State)
-	stateSourceObject.Load(2, &t.UserTicks)
-	stateSourceObject.Load(3, &t.SysTicks)
+func (ts *TaskGoroutineSchedInfo) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &ts.Timestamp)
+	stateSourceObject.Load(1, &ts.State)
+	stateSourceObject.Load(2, &ts.UserTicks)
+	stateSourceObject.Load(3, &ts.SysTicks)
 }
 
-func (t *taskClock) StateTypeName() string {
+func (tc *taskClock) StateTypeName() string {
 	return "pkg/sentry/kernel.taskClock"
 }
 
-func (t *taskClock) StateFields() []string {
+func (tc *taskClock) StateFields() []string {
 	return []string{
 		"t",
 		"includeSys",
 	}
 }
 
-func (t *taskClock) beforeSave() {}
+func (tc *taskClock) beforeSave() {}
 
-func (t *taskClock) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.t)
-	stateSinkObject.Save(1, &t.includeSys)
+func (tc *taskClock) StateSave(stateSinkObject state.Sink) {
+	tc.beforeSave()
+	stateSinkObject.Save(0, &tc.t)
+	stateSinkObject.Save(1, &tc.includeSys)
 }
 
-func (t *taskClock) afterLoad() {}
+func (tc *taskClock) afterLoad() {}
 
-func (t *taskClock) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.t)
-	stateSourceObject.Load(1, &t.includeSys)
+func (tc *taskClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &tc.t)
+	stateSourceObject.Load(1, &tc.includeSys)
 }
 
-func (t *tgClock) StateTypeName() string {
+func (tgc *tgClock) StateTypeName() string {
 	return "pkg/sentry/kernel.tgClock"
 }
 
-func (t *tgClock) StateFields() []string {
+func (tgc *tgClock) StateFields() []string {
 	return []string{
 		"tg",
 		"includeSys",
 	}
 }
 
-func (t *tgClock) beforeSave() {}
+func (tgc *tgClock) beforeSave() {}
 
-func (t *tgClock) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.tg)
-	stateSinkObject.Save(1, &t.includeSys)
+func (tgc *tgClock) StateSave(stateSinkObject state.Sink) {
+	tgc.beforeSave()
+	stateSinkObject.Save(0, &tgc.tg)
+	stateSinkObject.Save(1, &tgc.includeSys)
 }
 
-func (t *tgClock) afterLoad() {}
+func (tgc *tgClock) afterLoad() {}
 
-func (t *tgClock) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.tg)
-	stateSourceObject.Load(1, &t.includeSys)
+func (tgc *tgClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &tgc.tg)
+	stateSourceObject.Load(1, &tgc.includeSys)
 }
 
 func (g *groupStop) StateTypeName() string {
@@ -1839,11 +1839,11 @@ func (r *runSyscallExit) afterLoad() {}
 func (r *runSyscallExit) StateLoad(stateSourceObject state.Source) {
 }
 
-func (t *ThreadGroup) StateTypeName() string {
+func (tg *ThreadGroup) StateTypeName() string {
 	return "pkg/sentry/kernel.ThreadGroup"
 }
 
-func (t *ThreadGroup) StateFields() []string {
+func (tg *ThreadGroup) StateFields() []string {
 	return []string{
 		"threadGroupNode",
 		"signalHandlers",
@@ -1881,138 +1881,138 @@ func (t *ThreadGroup) StateFields() []string {
 	}
 }
 
-func (t *ThreadGroup) beforeSave() {}
+func (tg *ThreadGroup) beforeSave() {}
 
-func (t *ThreadGroup) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	var oldRSeqCriticalValue *OldRSeqCriticalRegion = t.saveOldRSeqCritical()
+func (tg *ThreadGroup) StateSave(stateSinkObject state.Sink) {
+	tg.beforeSave()
+	var oldRSeqCriticalValue *OldRSeqCriticalRegion = tg.saveOldRSeqCritical()
 	stateSinkObject.SaveValue(29, oldRSeqCriticalValue)
-	stateSinkObject.Save(0, &t.threadGroupNode)
-	stateSinkObject.Save(1, &t.signalHandlers)
-	stateSinkObject.Save(2, &t.pendingSignals)
-	stateSinkObject.Save(3, &t.groupStopDequeued)
-	stateSinkObject.Save(4, &t.groupStopSignal)
-	stateSinkObject.Save(5, &t.groupStopPendingCount)
-	stateSinkObject.Save(6, &t.groupStopComplete)
-	stateSinkObject.Save(7, &t.groupStopWaitable)
-	stateSinkObject.Save(8, &t.groupContNotify)
-	stateSinkObject.Save(9, &t.groupContInterrupted)
-	stateSinkObject.Save(10, &t.groupContWaitable)
-	stateSinkObject.Save(11, &t.exiting)
-	stateSinkObject.Save(12, &t.exitStatus)
-	stateSinkObject.Save(13, &t.terminationSignal)
-	stateSinkObject.Save(14, &t.itimerRealTimer)
-	stateSinkObject.Save(15, &t.itimerVirtSetting)
-	stateSinkObject.Save(16, &t.itimerProfSetting)
-	stateSinkObject.Save(17, &t.rlimitCPUSoftSetting)
-	stateSinkObject.Save(18, &t.cpuTimersEnabled)
-	stateSinkObject.Save(19, &t.timers)
-	stateSinkObject.Save(20, &t.nextTimerID)
-	stateSinkObject.Save(21, &t.exitedCPUStats)
-	stateSinkObject.Save(22, &t.childCPUStats)
-	stateSinkObject.Save(23, &t.ioUsage)
-	stateSinkObject.Save(24, &t.maxRSS)
-	stateSinkObject.Save(25, &t.childMaxRSS)
-	stateSinkObject.Save(26, &t.limits)
-	stateSinkObject.Save(27, &t.processGroup)
-	stateSinkObject.Save(28, &t.execed)
-	stateSinkObject.Save(30, &t.mounts)
-	stateSinkObject.Save(31, &t.tty)
-	stateSinkObject.Save(32, &t.oomScoreAdj)
-}
-
-func (t *ThreadGroup) afterLoad() {}
-
-func (t *ThreadGroup) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.threadGroupNode)
-	stateSourceObject.Load(1, &t.signalHandlers)
-	stateSourceObject.Load(2, &t.pendingSignals)
-	stateSourceObject.Load(3, &t.groupStopDequeued)
-	stateSourceObject.Load(4, &t.groupStopSignal)
-	stateSourceObject.Load(5, &t.groupStopPendingCount)
-	stateSourceObject.Load(6, &t.groupStopComplete)
-	stateSourceObject.Load(7, &t.groupStopWaitable)
-	stateSourceObject.Load(8, &t.groupContNotify)
-	stateSourceObject.Load(9, &t.groupContInterrupted)
-	stateSourceObject.Load(10, &t.groupContWaitable)
-	stateSourceObject.Load(11, &t.exiting)
-	stateSourceObject.Load(12, &t.exitStatus)
-	stateSourceObject.Load(13, &t.terminationSignal)
-	stateSourceObject.Load(14, &t.itimerRealTimer)
-	stateSourceObject.Load(15, &t.itimerVirtSetting)
-	stateSourceObject.Load(16, &t.itimerProfSetting)
-	stateSourceObject.Load(17, &t.rlimitCPUSoftSetting)
-	stateSourceObject.Load(18, &t.cpuTimersEnabled)
-	stateSourceObject.Load(19, &t.timers)
-	stateSourceObject.Load(20, &t.nextTimerID)
-	stateSourceObject.Load(21, &t.exitedCPUStats)
-	stateSourceObject.Load(22, &t.childCPUStats)
-	stateSourceObject.Load(23, &t.ioUsage)
-	stateSourceObject.Load(24, &t.maxRSS)
-	stateSourceObject.Load(25, &t.childMaxRSS)
-	stateSourceObject.Load(26, &t.limits)
-	stateSourceObject.Load(27, &t.processGroup)
-	stateSourceObject.Load(28, &t.execed)
-	stateSourceObject.Load(30, &t.mounts)
-	stateSourceObject.Load(31, &t.tty)
-	stateSourceObject.Load(32, &t.oomScoreAdj)
-	stateSourceObject.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { t.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
-}
-
-func (i *itimerRealListener) StateTypeName() string {
+	stateSinkObject.Save(0, &tg.threadGroupNode)
+	stateSinkObject.Save(1, &tg.signalHandlers)
+	stateSinkObject.Save(2, &tg.pendingSignals)
+	stateSinkObject.Save(3, &tg.groupStopDequeued)
+	stateSinkObject.Save(4, &tg.groupStopSignal)
+	stateSinkObject.Save(5, &tg.groupStopPendingCount)
+	stateSinkObject.Save(6, &tg.groupStopComplete)
+	stateSinkObject.Save(7, &tg.groupStopWaitable)
+	stateSinkObject.Save(8, &tg.groupContNotify)
+	stateSinkObject.Save(9, &tg.groupContInterrupted)
+	stateSinkObject.Save(10, &tg.groupContWaitable)
+	stateSinkObject.Save(11, &tg.exiting)
+	stateSinkObject.Save(12, &tg.exitStatus)
+	stateSinkObject.Save(13, &tg.terminationSignal)
+	stateSinkObject.Save(14, &tg.itimerRealTimer)
+	stateSinkObject.Save(15, &tg.itimerVirtSetting)
+	stateSinkObject.Save(16, &tg.itimerProfSetting)
+	stateSinkObject.Save(17, &tg.rlimitCPUSoftSetting)
+	stateSinkObject.Save(18, &tg.cpuTimersEnabled)
+	stateSinkObject.Save(19, &tg.timers)
+	stateSinkObject.Save(20, &tg.nextTimerID)
+	stateSinkObject.Save(21, &tg.exitedCPUStats)
+	stateSinkObject.Save(22, &tg.childCPUStats)
+	stateSinkObject.Save(23, &tg.ioUsage)
+	stateSinkObject.Save(24, &tg.maxRSS)
+	stateSinkObject.Save(25, &tg.childMaxRSS)
+	stateSinkObject.Save(26, &tg.limits)
+	stateSinkObject.Save(27, &tg.processGroup)
+	stateSinkObject.Save(28, &tg.execed)
+	stateSinkObject.Save(30, &tg.mounts)
+	stateSinkObject.Save(31, &tg.tty)
+	stateSinkObject.Save(32, &tg.oomScoreAdj)
+}
+
+func (tg *ThreadGroup) afterLoad() {}
+
+func (tg *ThreadGroup) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &tg.threadGroupNode)
+	stateSourceObject.Load(1, &tg.signalHandlers)
+	stateSourceObject.Load(2, &tg.pendingSignals)
+	stateSourceObject.Load(3, &tg.groupStopDequeued)
+	stateSourceObject.Load(4, &tg.groupStopSignal)
+	stateSourceObject.Load(5, &tg.groupStopPendingCount)
+	stateSourceObject.Load(6, &tg.groupStopComplete)
+	stateSourceObject.Load(7, &tg.groupStopWaitable)
+	stateSourceObject.Load(8, &tg.groupContNotify)
+	stateSourceObject.Load(9, &tg.groupContInterrupted)
+	stateSourceObject.Load(10, &tg.groupContWaitable)
+	stateSourceObject.Load(11, &tg.exiting)
+	stateSourceObject.Load(12, &tg.exitStatus)
+	stateSourceObject.Load(13, &tg.terminationSignal)
+	stateSourceObject.Load(14, &tg.itimerRealTimer)
+	stateSourceObject.Load(15, &tg.itimerVirtSetting)
+	stateSourceObject.Load(16, &tg.itimerProfSetting)
+	stateSourceObject.Load(17, &tg.rlimitCPUSoftSetting)
+	stateSourceObject.Load(18, &tg.cpuTimersEnabled)
+	stateSourceObject.Load(19, &tg.timers)
+	stateSourceObject.Load(20, &tg.nextTimerID)
+	stateSourceObject.Load(21, &tg.exitedCPUStats)
+	stateSourceObject.Load(22, &tg.childCPUStats)
+	stateSourceObject.Load(23, &tg.ioUsage)
+	stateSourceObject.Load(24, &tg.maxRSS)
+	stateSourceObject.Load(25, &tg.childMaxRSS)
+	stateSourceObject.Load(26, &tg.limits)
+	stateSourceObject.Load(27, &tg.processGroup)
+	stateSourceObject.Load(28, &tg.execed)
+	stateSourceObject.Load(30, &tg.mounts)
+	stateSourceObject.Load(31, &tg.tty)
+	stateSourceObject.Load(32, &tg.oomScoreAdj)
+	stateSourceObject.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { tg.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
+}
+
+func (l *itimerRealListener) StateTypeName() string {
 	return "pkg/sentry/kernel.itimerRealListener"
 }
 
-func (i *itimerRealListener) StateFields() []string {
+func (l *itimerRealListener) StateFields() []string {
 	return []string{
 		"tg",
 	}
 }
 
-func (i *itimerRealListener) beforeSave() {}
+func (l *itimerRealListener) beforeSave() {}
 
-func (i *itimerRealListener) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	stateSinkObject.Save(0, &i.tg)
+func (l *itimerRealListener) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.tg)
 }
 
-func (i *itimerRealListener) afterLoad() {}
+func (l *itimerRealListener) afterLoad() {}
 
-func (i *itimerRealListener) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &i.tg)
+func (l *itimerRealListener) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.tg)
 }
 
-func (t *TaskSet) StateTypeName() string {
+func (ts *TaskSet) StateTypeName() string {
 	return "pkg/sentry/kernel.TaskSet"
 }
 
-func (t *TaskSet) StateFields() []string {
+func (ts *TaskSet) StateFields() []string {
 	return []string{
 		"Root",
 		"sessions",
 	}
 }
 
-func (t *TaskSet) beforeSave() {}
+func (ts *TaskSet) beforeSave() {}
 
-func (t *TaskSet) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.Root)
-	stateSinkObject.Save(1, &t.sessions)
+func (ts *TaskSet) StateSave(stateSinkObject state.Sink) {
+	ts.beforeSave()
+	stateSinkObject.Save(0, &ts.Root)
+	stateSinkObject.Save(1, &ts.sessions)
 }
 
-func (t *TaskSet) afterLoad() {}
+func (ts *TaskSet) afterLoad() {}
 
-func (t *TaskSet) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.Root)
-	stateSourceObject.Load(1, &t.sessions)
+func (ts *TaskSet) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &ts.Root)
+	stateSourceObject.Load(1, &ts.sessions)
 }
 
-func (p *PIDNamespace) StateTypeName() string {
+func (ns *PIDNamespace) StateTypeName() string {
 	return "pkg/sentry/kernel.PIDNamespace"
 }
 
-func (p *PIDNamespace) StateFields() []string {
+func (ns *PIDNamespace) StateFields() []string {
 	return []string{
 		"owner",
 		"parent",
@@ -2029,39 +2029,39 @@ func (p *PIDNamespace) StateFields() []string {
 	}
 }
 
-func (p *PIDNamespace) beforeSave() {}
-
-func (p *PIDNamespace) StateSave(stateSinkObject state.Sink) {
-	p.beforeSave()
-	stateSinkObject.Save(0, &p.owner)
-	stateSinkObject.Save(1, &p.parent)
-	stateSinkObject.Save(2, &p.userns)
-	stateSinkObject.Save(3, &p.last)
-	stateSinkObject.Save(4, &p.tasks)
-	stateSinkObject.Save(5, &p.tids)
-	stateSinkObject.Save(6, &p.tgids)
-	stateSinkObject.Save(7, &p.sessions)
-	stateSinkObject.Save(8, &p.sids)
-	stateSinkObject.Save(9, &p.processGroups)
-	stateSinkObject.Save(10, &p.pgids)
-	stateSinkObject.Save(11, &p.exiting)
-}
-
-func (p *PIDNamespace) afterLoad() {}
-
-func (p *PIDNamespace) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &p.owner)
-	stateSourceObject.Load(1, &p.parent)
-	stateSourceObject.Load(2, &p.userns)
-	stateSourceObject.Load(3, &p.last)
-	stateSourceObject.Load(4, &p.tasks)
-	stateSourceObject.Load(5, &p.tids)
-	stateSourceObject.Load(6, &p.tgids)
-	stateSourceObject.Load(7, &p.sessions)
-	stateSourceObject.Load(8, &p.sids)
-	stateSourceObject.Load(9, &p.processGroups)
-	stateSourceObject.Load(10, &p.pgids)
-	stateSourceObject.Load(11, &p.exiting)
+func (ns *PIDNamespace) beforeSave() {}
+
+func (ns *PIDNamespace) StateSave(stateSinkObject state.Sink) {
+	ns.beforeSave()
+	stateSinkObject.Save(0, &ns.owner)
+	stateSinkObject.Save(1, &ns.parent)
+	stateSinkObject.Save(2, &ns.userns)
+	stateSinkObject.Save(3, &ns.last)
+	stateSinkObject.Save(4, &ns.tasks)
+	stateSinkObject.Save(5, &ns.tids)
+	stateSinkObject.Save(6, &ns.tgids)
+	stateSinkObject.Save(7, &ns.sessions)
+	stateSinkObject.Save(8, &ns.sids)
+	stateSinkObject.Save(9, &ns.processGroups)
+	stateSinkObject.Save(10, &ns.pgids)
+	stateSinkObject.Save(11, &ns.exiting)
+}
+
+func (ns *PIDNamespace) afterLoad() {}
+
+func (ns *PIDNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &ns.owner)
+	stateSourceObject.Load(1, &ns.parent)
+	stateSourceObject.Load(2, &ns.userns)
+	stateSourceObject.Load(3, &ns.last)
+	stateSourceObject.Load(4, &ns.tasks)
+	stateSourceObject.Load(5, &ns.tids)
+	stateSourceObject.Load(6, &ns.tgids)
+	stateSourceObject.Load(7, &ns.sessions)
+	stateSourceObject.Load(8, &ns.sids)
+	stateSourceObject.Load(9, &ns.processGroups)
+	stateSourceObject.Load(10, &ns.pgids)
+	stateSourceObject.Load(11, &ns.exiting)
 }
 
 func (t *threadGroupNode) StateTypeName() string {
@@ -2169,30 +2169,30 @@ func (t *Timekeeper) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.AfterLoad(t.afterLoad)
 }
 
-func (t *timekeeperClock) StateTypeName() string {
+func (tc *timekeeperClock) StateTypeName() string {
 	return "pkg/sentry/kernel.timekeeperClock"
 }
 
-func (t *timekeeperClock) StateFields() []string {
+func (tc *timekeeperClock) StateFields() []string {
 	return []string{
 		"tk",
 		"c",
 	}
 }
 
-func (t *timekeeperClock) beforeSave() {}
+func (tc *timekeeperClock) beforeSave() {}
 
-func (t *timekeeperClock) StateSave(stateSinkObject state.Sink) {
-	t.beforeSave()
-	stateSinkObject.Save(0, &t.tk)
-	stateSinkObject.Save(1, &t.c)
+func (tc *timekeeperClock) StateSave(stateSinkObject state.Sink) {
+	tc.beforeSave()
+	stateSinkObject.Save(0, &tc.tk)
+	stateSinkObject.Save(1, &tc.c)
 }
 
-func (t *timekeeperClock) afterLoad() {}
+func (tc *timekeeperClock) afterLoad() {}
 
-func (t *timekeeperClock) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &t.tk)
-	stateSourceObject.Load(1, &t.c)
+func (tc *timekeeperClock) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &tc.tk)
+	stateSourceObject.Load(1, &tc.c)
 }
 
 func (t *TTY) StateTypeName() string {
diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
index 031ea2cc2..9188cef94 100644
--- a/pkg/sentry/kernel/pipe/pipe_state_autogen.go
+++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
@@ -96,27 +96,27 @@ func (r *Reader) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &r.ReaderWriter)
 }
 
-func (r *ReaderWriter) StateTypeName() string {
+func (rw *ReaderWriter) StateTypeName() string {
 	return "pkg/sentry/kernel/pipe.ReaderWriter"
 }
 
-func (r *ReaderWriter) StateFields() []string {
+func (rw *ReaderWriter) StateFields() []string {
 	return []string{
 		"Pipe",
 	}
 }
 
-func (r *ReaderWriter) beforeSave() {}
+func (rw *ReaderWriter) beforeSave() {}
 
-func (r *ReaderWriter) StateSave(stateSinkObject state.Sink) {
-	r.beforeSave()
-	stateSinkObject.Save(0, &r.Pipe)
+func (rw *ReaderWriter) StateSave(stateSinkObject state.Sink) {
+	rw.beforeSave()
+	stateSinkObject.Save(0, &rw.Pipe)
 }
 
-func (r *ReaderWriter) afterLoad() {}
+func (rw *ReaderWriter) afterLoad() {}
 
-func (r *ReaderWriter) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &r.Pipe)
+func (rw *ReaderWriter) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &rw.Pipe)
 }
 
 func (w *Writer) StateTypeName() string {
diff --git a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
index 80358c6e3..aed6cfa29 100644
--- a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
+++ b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
@@ -143,56 +143,56 @@ func (w *waiter) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &w.ch)
 }
 
-func (w *waiterList) StateTypeName() string {
+func (l *waiterList) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.waiterList"
 }
 
-func (w *waiterList) StateFields() []string {
+func (l *waiterList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (w *waiterList) beforeSave() {}
+func (l *waiterList) beforeSave() {}
 
-func (w *waiterList) StateSave(stateSinkObject state.Sink) {
-	w.beforeSave()
-	stateSinkObject.Save(0, &w.head)
-	stateSinkObject.Save(1, &w.tail)
+func (l *waiterList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (w *waiterList) afterLoad() {}
+func (l *waiterList) afterLoad() {}
 
-func (w *waiterList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &w.head)
-	stateSourceObject.Load(1, &w.tail)
+func (l *waiterList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (w *waiterEntry) StateTypeName() string {
+func (e *waiterEntry) StateTypeName() string {
 	return "pkg/sentry/kernel/semaphore.waiterEntry"
 }
 
-func (w *waiterEntry) StateFields() []string {
+func (e *waiterEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (w *waiterEntry) beforeSave() {}
+func (e *waiterEntry) beforeSave() {}
 
-func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
-	w.beforeSave()
-	stateSinkObject.Save(0, &w.next)
-	stateSinkObject.Save(1, &w.prev)
+func (e *waiterEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (w *waiterEntry) afterLoad() {}
+func (e *waiterEntry) afterLoad() {}
 
-func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &w.next)
-	stateSourceObject.Load(1, &w.prev)
+func (e *waiterEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func init() {
diff --git a/pkg/sentry/kernel/shm/shm_state_autogen.go b/pkg/sentry/kernel/shm/shm_state_autogen.go
index 846cbc2d5..8202c37d6 100644
--- a/pkg/sentry/kernel/shm/shm_state_autogen.go
+++ b/pkg/sentry/kernel/shm/shm_state_autogen.go
@@ -112,27 +112,27 @@ func (s *Shm) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(16, &s.pendingDestruction)
 }
 
-func (s *ShmRefs) StateTypeName() string {
+func (r *ShmRefs) StateTypeName() string {
 	return "pkg/sentry/kernel/shm.ShmRefs"
 }
 
-func (s *ShmRefs) StateFields() []string {
+func (r *ShmRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (s *ShmRefs) beforeSave() {}
+func (r *ShmRefs) beforeSave() {}
 
-func (s *ShmRefs) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.refCount)
+func (r *ShmRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (s *ShmRefs) afterLoad() {}
+func (r *ShmRefs) afterLoad() {}
 
-func (s *ShmRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.refCount)
+func (r *ShmRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func init() {