Merge release-20200928.0-78-g743327817 (automated)

3 files changed, 347 insertions, 347 deletions

diff --git a/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go b/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go
index 28a4ae569..eafeac473 100644
--- a/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go
+++ b/pkg/sentry/vfs/memxattr/memxattr_state_autogen.go
@@ -6,27 +6,27 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (s *SimpleExtendedAttributes) StateTypeName() string {
+func (x *SimpleExtendedAttributes) StateTypeName() string {
 	return "pkg/sentry/vfs/memxattr.SimpleExtendedAttributes"
 }
 
-func (s *SimpleExtendedAttributes) StateFields() []string {
+func (x *SimpleExtendedAttributes) StateFields() []string {
 	return []string{
 		"xattrs",
 	}
 }
 
-func (s *SimpleExtendedAttributes) beforeSave() {}
+func (x *SimpleExtendedAttributes) beforeSave() {}
 
-func (s *SimpleExtendedAttributes) StateSave(stateSinkObject state.Sink) {
-	s.beforeSave()
-	stateSinkObject.Save(0, &s.xattrs)
+func (x *SimpleExtendedAttributes) StateSave(stateSinkObject state.Sink) {
+	x.beforeSave()
+	stateSinkObject.Save(0, &x.xattrs)
 }
 
-func (s *SimpleExtendedAttributes) afterLoad() {}
+func (x *SimpleExtendedAttributes) afterLoad() {}
 
-func (s *SimpleExtendedAttributes) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &s.xattrs)
+func (x *SimpleExtendedAttributes) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &x.xattrs)
 }
 
 func init() {
diff --git a/pkg/sentry/vfs/vfs_state_autogen.go b/pkg/sentry/vfs/vfs_state_autogen.go
index 2dff75293..d78221080 100644
--- a/pkg/sentry/vfs/vfs_state_autogen.go
+++ b/pkg/sentry/vfs/vfs_state_autogen.go
@@ -25,56 +25,56 @@ func (a *anonFilesystemType) afterLoad() {}
 func (a *anonFilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (a *anonFilesystem) StateTypeName() string {
+func (fs *anonFilesystem) StateTypeName() string {
 	return "pkg/sentry/vfs.anonFilesystem"
 }
 
-func (a *anonFilesystem) StateFields() []string {
+func (fs *anonFilesystem) StateFields() []string {
 	return []string{
 		"vfsfs",
 		"devMinor",
 	}
 }
 
-func (a *anonFilesystem) beforeSave() {}
+func (fs *anonFilesystem) beforeSave() {}
 
-func (a *anonFilesystem) StateSave(stateSinkObject state.Sink) {
-	a.beforeSave()
-	stateSinkObject.Save(0, &a.vfsfs)
-	stateSinkObject.Save(1, &a.devMinor)
+func (fs *anonFilesystem) StateSave(stateSinkObject state.Sink) {
+	fs.beforeSave()
+	stateSinkObject.Save(0, &fs.vfsfs)
+	stateSinkObject.Save(1, &fs.devMinor)
 }
 
-func (a *anonFilesystem) afterLoad() {}
+func (fs *anonFilesystem) afterLoad() {}
 
-func (a *anonFilesystem) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &a.vfsfs)
-	stateSourceObject.Load(1, &a.devMinor)
+func (fs *anonFilesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fs.vfsfs)
+	stateSourceObject.Load(1, &fs.devMinor)
 }
 
-func (a *anonDentry) StateTypeName() string {
+func (d *anonDentry) StateTypeName() string {
 	return "pkg/sentry/vfs.anonDentry"
 }
 
-func (a *anonDentry) StateFields() []string {
+func (d *anonDentry) StateFields() []string {
 	return []string{
 		"vfsd",
 		"name",
 	}
 }
 
-func (a *anonDentry) beforeSave() {}
+func (d *anonDentry) beforeSave() {}
 
-func (a *anonDentry) StateSave(stateSinkObject state.Sink) {
-	a.beforeSave()
-	stateSinkObject.Save(0, &a.vfsd)
-	stateSinkObject.Save(1, &a.name)
+func (d *anonDentry) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	stateSinkObject.Save(0, &d.vfsd)
+	stateSinkObject.Save(1, &d.name)
 }
 
-func (a *anonDentry) afterLoad() {}
+func (d *anonDentry) afterLoad() {}
 
-func (a *anonDentry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &a.vfsd)
-	stateSourceObject.Load(1, &a.name)
+func (d *anonDentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsd)
+	stateSourceObject.Load(1, &d.name)
 }
 
 func (d *Dentry) StateTypeName() string {
@@ -106,11 +106,11 @@ func (d *Dentry) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(2, &d.impl)
 }
 
-func (d *DeviceKind) StateTypeName() string {
+func (kind *DeviceKind) StateTypeName() string {
 	return "pkg/sentry/vfs.DeviceKind"
 }
 
-func (d *DeviceKind) StateFields() []string {
+func (kind *DeviceKind) StateFields() []string {
 	return nil
 }
 
@@ -192,11 +192,11 @@ func (r *RegisterDeviceOptions) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &r.GroupName)
 }
 
-func (e *EpollInstance) StateTypeName() string {
+func (ep *EpollInstance) StateTypeName() string {
 	return "pkg/sentry/vfs.EpollInstance"
 }
 
-func (e *EpollInstance) StateFields() []string {
+func (ep *EpollInstance) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -208,29 +208,29 @@ func (e *EpollInstance) StateFields() []string {
 	}
 }
 
-func (e *EpollInstance) beforeSave() {}
+func (ep *EpollInstance) beforeSave() {}
 
-func (e *EpollInstance) StateSave(stateSinkObject state.Sink) {
-	e.beforeSave()
-	stateSinkObject.Save(0, &e.vfsfd)
-	stateSinkObject.Save(1, &e.FileDescriptionDefaultImpl)
-	stateSinkObject.Save(2, &e.DentryMetadataFileDescriptionImpl)
-	stateSinkObject.Save(3, &e.NoLockFD)
-	stateSinkObject.Save(4, &e.q)
-	stateSinkObject.Save(5, &e.interest)
-	stateSinkObject.Save(6, &e.ready)
+func (ep *EpollInstance) StateSave(stateSinkObject state.Sink) {
+	ep.beforeSave()
+	stateSinkObject.Save(0, &ep.vfsfd)
+	stateSinkObject.Save(1, &ep.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &ep.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &ep.NoLockFD)
+	stateSinkObject.Save(4, &ep.q)
+	stateSinkObject.Save(5, &ep.interest)
+	stateSinkObject.Save(6, &ep.ready)
 }
 
-func (e *EpollInstance) afterLoad() {}
+func (ep *EpollInstance) afterLoad() {}
 
-func (e *EpollInstance) 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.q)
-	stateSourceObject.Load(5, &e.interest)
-	stateSourceObject.Load(6, &e.ready)
+func (ep *EpollInstance) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &ep.vfsfd)
+	stateSourceObject.Load(1, &ep.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &ep.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &ep.NoLockFD)
+	stateSourceObject.Load(4, &ep.q)
+	stateSourceObject.Load(5, &ep.interest)
+	stateSourceObject.Load(6, &ep.ready)
 }
 
 func (e *epollInterestKey) StateTypeName() string {
@@ -259,11 +259,11 @@ func (e *epollInterestKey) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &e.num)
 }
 
-func (e *epollInterest) StateTypeName() string {
+func (epi *epollInterest) StateTypeName() string {
 	return "pkg/sentry/vfs.epollInterest"
 }
 
-func (e *epollInterest) StateFields() []string {
+func (epi *epollInterest) StateFields() []string {
 	return []string{
 		"epoll",
 		"key",
@@ -275,55 +275,55 @@ func (e *epollInterest) StateFields() []string {
 	}
 }
 
-func (e *epollInterest) beforeSave() {}
+func (epi *epollInterest) beforeSave() {}
 
-func (e *epollInterest) StateSave(stateSinkObject state.Sink) {
-	e.beforeSave()
-	stateSinkObject.Save(0, &e.epoll)
-	stateSinkObject.Save(1, &e.key)
-	stateSinkObject.Save(2, &e.waiter)
-	stateSinkObject.Save(3, &e.mask)
-	stateSinkObject.Save(4, &e.ready)
-	stateSinkObject.Save(5, &e.epollInterestEntry)
-	stateSinkObject.Save(6, &e.userData)
+func (epi *epollInterest) StateSave(stateSinkObject state.Sink) {
+	epi.beforeSave()
+	stateSinkObject.Save(0, &epi.epoll)
+	stateSinkObject.Save(1, &epi.key)
+	stateSinkObject.Save(2, &epi.waiter)
+	stateSinkObject.Save(3, &epi.mask)
+	stateSinkObject.Save(4, &epi.ready)
+	stateSinkObject.Save(5, &epi.epollInterestEntry)
+	stateSinkObject.Save(6, &epi.userData)
 }
 
-func (e *epollInterest) afterLoad() {}
+func (epi *epollInterest) afterLoad() {}
 
-func (e *epollInterest) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.epoll)
-	stateSourceObject.Load(1, &e.key)
-	stateSourceObject.Load(2, &e.waiter)
-	stateSourceObject.Load(3, &e.mask)
-	stateSourceObject.Load(4, &e.ready)
-	stateSourceObject.Load(5, &e.epollInterestEntry)
-	stateSourceObject.Load(6, &e.userData)
+func (epi *epollInterest) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &epi.epoll)
+	stateSourceObject.Load(1, &epi.key)
+	stateSourceObject.Load(2, &epi.waiter)
+	stateSourceObject.Load(3, &epi.mask)
+	stateSourceObject.Load(4, &epi.ready)
+	stateSourceObject.Load(5, &epi.epollInterestEntry)
+	stateSourceObject.Load(6, &epi.userData)
 }
 
-func (e *epollInterestList) StateTypeName() string {
+func (l *epollInterestList) StateTypeName() string {
 	return "pkg/sentry/vfs.epollInterestList"
 }
 
-func (e *epollInterestList) StateFields() []string {
+func (l *epollInterestList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (e *epollInterestList) beforeSave() {}
+func (l *epollInterestList) beforeSave() {}
 
-func (e *epollInterestList) StateSave(stateSinkObject state.Sink) {
-	e.beforeSave()
-	stateSinkObject.Save(0, &e.head)
-	stateSinkObject.Save(1, &e.tail)
+func (l *epollInterestList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (e *epollInterestList) afterLoad() {}
+func (l *epollInterestList) afterLoad() {}
 
-func (e *epollInterestList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.head)
-	stateSourceObject.Load(1, &e.tail)
+func (l *epollInterestList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
 func (e *epollInterestEntry) StateTypeName() string {
@@ -352,30 +352,30 @@ func (e *epollInterestEntry) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &e.prev)
 }
 
-func (e *eventList) StateTypeName() string {
+func (l *eventList) StateTypeName() string {
 	return "pkg/sentry/vfs.eventList"
 }
 
-func (e *eventList) StateFields() []string {
+func (l *eventList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (e *eventList) beforeSave() {}
+func (l *eventList) beforeSave() {}
 
-func (e *eventList) StateSave(stateSinkObject state.Sink) {
-	e.beforeSave()
-	stateSinkObject.Save(0, &e.head)
-	stateSinkObject.Save(1, &e.tail)
+func (l *eventList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (e *eventList) afterLoad() {}
+func (l *eventList) afterLoad() {}
 
-func (e *eventList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &e.head)
-	stateSourceObject.Load(1, &e.tail)
+func (l *eventList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
 func (e *eventEntry) StateTypeName() string {
@@ -404,11 +404,11 @@ func (e *eventEntry) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &e.prev)
 }
 
-func (f *FileDescription) StateTypeName() string {
+func (fd *FileDescription) StateTypeName() string {
 	return "pkg/sentry/vfs.FileDescription"
 }
 
-func (f *FileDescription) StateFields() []string {
+func (fd *FileDescription) StateFields() []string {
 	return []string{
 		"FileDescriptionRefs",
 		"statusFlags",
@@ -423,35 +423,35 @@ func (f *FileDescription) StateFields() []string {
 	}
 }
 
-func (f *FileDescription) beforeSave() {}
+func (fd *FileDescription) beforeSave() {}
 
-func (f *FileDescription) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.FileDescriptionRefs)
-	stateSinkObject.Save(1, &f.statusFlags)
-	stateSinkObject.Save(2, &f.asyncHandler)
-	stateSinkObject.Save(3, &f.epolls)
-	stateSinkObject.Save(4, &f.vd)
-	stateSinkObject.Save(5, &f.opts)
-	stateSinkObject.Save(6, &f.readable)
-	stateSinkObject.Save(7, &f.writable)
-	stateSinkObject.Save(8, &f.usedLockBSD)
-	stateSinkObject.Save(9, &f.impl)
-}
-
-func (f *FileDescription) afterLoad() {}
-
-func (f *FileDescription) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.FileDescriptionRefs)
-	stateSourceObject.Load(1, &f.statusFlags)
-	stateSourceObject.Load(2, &f.asyncHandler)
-	stateSourceObject.Load(3, &f.epolls)
-	stateSourceObject.Load(4, &f.vd)
-	stateSourceObject.Load(5, &f.opts)
-	stateSourceObject.Load(6, &f.readable)
-	stateSourceObject.Load(7, &f.writable)
-	stateSourceObject.Load(8, &f.usedLockBSD)
-	stateSourceObject.Load(9, &f.impl)
+func (fd *FileDescription) StateSave(stateSinkObject state.Sink) {
+	fd.beforeSave()
+	stateSinkObject.Save(0, &fd.FileDescriptionRefs)
+	stateSinkObject.Save(1, &fd.statusFlags)
+	stateSinkObject.Save(2, &fd.asyncHandler)
+	stateSinkObject.Save(3, &fd.epolls)
+	stateSinkObject.Save(4, &fd.vd)
+	stateSinkObject.Save(5, &fd.opts)
+	stateSinkObject.Save(6, &fd.readable)
+	stateSinkObject.Save(7, &fd.writable)
+	stateSinkObject.Save(8, &fd.usedLockBSD)
+	stateSinkObject.Save(9, &fd.impl)
+}
+
+func (fd *FileDescription) afterLoad() {}
+
+func (fd *FileDescription) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fd.FileDescriptionRefs)
+	stateSourceObject.Load(1, &fd.statusFlags)
+	stateSourceObject.Load(2, &fd.asyncHandler)
+	stateSourceObject.Load(3, &fd.epolls)
+	stateSourceObject.Load(4, &fd.vd)
+	stateSourceObject.Load(5, &fd.opts)
+	stateSourceObject.Load(6, &fd.readable)
+	stateSourceObject.Load(7, &fd.writable)
+	stateSourceObject.Load(8, &fd.usedLockBSD)
+	stateSourceObject.Load(9, &fd.impl)
 }
 
 func (f *FileDescriptionOptions) StateTypeName() string {
@@ -598,11 +598,11 @@ func (s *StaticData) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(0, &s.Data)
 }
 
-func (d *DynamicBytesFileDescriptionImpl) StateTypeName() string {
+func (fd *DynamicBytesFileDescriptionImpl) StateTypeName() string {
 	return "pkg/sentry/vfs.DynamicBytesFileDescriptionImpl"
 }
 
-func (d *DynamicBytesFileDescriptionImpl) StateFields() []string {
+func (fd *DynamicBytesFileDescriptionImpl) StateFields() []string {
 	return []string{
 		"data",
 		"buf",
@@ -611,47 +611,47 @@ func (d *DynamicBytesFileDescriptionImpl) StateFields() []string {
 	}
 }
 
-func (d *DynamicBytesFileDescriptionImpl) beforeSave() {}
+func (fd *DynamicBytesFileDescriptionImpl) beforeSave() {}
 
-func (d *DynamicBytesFileDescriptionImpl) StateSave(stateSinkObject state.Sink) {
-	d.beforeSave()
-	var bufValue []byte = d.saveBuf()
+func (fd *DynamicBytesFileDescriptionImpl) StateSave(stateSinkObject state.Sink) {
+	fd.beforeSave()
+	var bufValue []byte = fd.saveBuf()
 	stateSinkObject.SaveValue(1, bufValue)
-	stateSinkObject.Save(0, &d.data)
-	stateSinkObject.Save(2, &d.off)
-	stateSinkObject.Save(3, &d.lastRead)
+	stateSinkObject.Save(0, &fd.data)
+	stateSinkObject.Save(2, &fd.off)
+	stateSinkObject.Save(3, &fd.lastRead)
 }
 
-func (d *DynamicBytesFileDescriptionImpl) afterLoad() {}
+func (fd *DynamicBytesFileDescriptionImpl) afterLoad() {}
 
-func (d *DynamicBytesFileDescriptionImpl) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &d.data)
-	stateSourceObject.Load(2, &d.off)
-	stateSourceObject.Load(3, &d.lastRead)
-	stateSourceObject.LoadValue(1, new([]byte), func(y interface{}) { d.loadBuf(y.([]byte)) })
+func (fd *DynamicBytesFileDescriptionImpl) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fd.data)
+	stateSourceObject.Load(2, &fd.off)
+	stateSourceObject.Load(3, &fd.lastRead)
+	stateSourceObject.LoadValue(1, new([]byte), func(y interface{}) { fd.loadBuf(y.([]byte)) })
 }
 
-func (l *LockFD) StateTypeName() string {
+func (fd *LockFD) StateTypeName() string {
 	return "pkg/sentry/vfs.LockFD"
 }
 
-func (l *LockFD) StateFields() []string {
+func (fd *LockFD) StateFields() []string {
 	return []string{
 		"locks",
 	}
 }
 
-func (l *LockFD) beforeSave() {}
+func (fd *LockFD) beforeSave() {}
 
-func (l *LockFD) StateSave(stateSinkObject state.Sink) {
-	l.beforeSave()
-	stateSinkObject.Save(0, &l.locks)
+func (fd *LockFD) StateSave(stateSinkObject state.Sink) {
+	fd.beforeSave()
+	stateSinkObject.Save(0, &fd.locks)
 }
 
-func (l *LockFD) afterLoad() {}
+func (fd *LockFD) afterLoad() {}
 
-func (l *LockFD) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &l.locks)
+func (fd *LockFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fd.locks)
 }
 
 func (n *NoLockFD) StateTypeName() string {
@@ -673,34 +673,34 @@ func (n *NoLockFD) afterLoad() {}
 func (n *NoLockFD) StateLoad(stateSourceObject state.Source) {
 }
 
-func (f *FileDescriptionRefs) StateTypeName() string {
+func (r *FileDescriptionRefs) StateTypeName() string {
 	return "pkg/sentry/vfs.FileDescriptionRefs"
 }
 
-func (f *FileDescriptionRefs) StateFields() []string {
+func (r *FileDescriptionRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (f *FileDescriptionRefs) beforeSave() {}
+func (r *FileDescriptionRefs) beforeSave() {}
 
-func (f *FileDescriptionRefs) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.refCount)
+func (r *FileDescriptionRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (f *FileDescriptionRefs) afterLoad() {}
+func (r *FileDescriptionRefs) afterLoad() {}
 
-func (f *FileDescriptionRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.refCount)
+func (r *FileDescriptionRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
-func (f *Filesystem) StateTypeName() string {
+func (fs *Filesystem) StateTypeName() string {
 	return "pkg/sentry/vfs.Filesystem"
 }
 
-func (f *Filesystem) StateFields() []string {
+func (fs *Filesystem) StateFields() []string {
 	return []string{
 		"FilesystemRefs",
 		"vfs",
@@ -709,23 +709,23 @@ func (f *Filesystem) StateFields() []string {
 	}
 }
 
-func (f *Filesystem) beforeSave() {}
+func (fs *Filesystem) beforeSave() {}
 
-func (f *Filesystem) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.FilesystemRefs)
-	stateSinkObject.Save(1, &f.vfs)
-	stateSinkObject.Save(2, &f.fsType)
-	stateSinkObject.Save(3, &f.impl)
+func (fs *Filesystem) StateSave(stateSinkObject state.Sink) {
+	fs.beforeSave()
+	stateSinkObject.Save(0, &fs.FilesystemRefs)
+	stateSinkObject.Save(1, &fs.vfs)
+	stateSinkObject.Save(2, &fs.fsType)
+	stateSinkObject.Save(3, &fs.impl)
 }
 
-func (f *Filesystem) afterLoad() {}
+func (fs *Filesystem) afterLoad() {}
 
-func (f *Filesystem) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.FilesystemRefs)
-	stateSourceObject.Load(1, &f.vfs)
-	stateSourceObject.Load(2, &f.fsType)
-	stateSourceObject.Load(3, &f.impl)
+func (fs *Filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fs.FilesystemRefs)
+	stateSourceObject.Load(1, &fs.vfs)
+	stateSourceObject.Load(2, &fs.fsType)
+	stateSourceObject.Load(3, &fs.impl)
 }
 
 func (p *PrependPathAtVFSRootError) StateTypeName() string {
@@ -785,27 +785,27 @@ func (p *PrependPathSyntheticError) afterLoad() {}
 func (p *PrependPathSyntheticError) StateLoad(stateSourceObject state.Source) {
 }
 
-func (f *FilesystemRefs) StateTypeName() string {
+func (r *FilesystemRefs) StateTypeName() string {
 	return "pkg/sentry/vfs.FilesystemRefs"
 }
 
-func (f *FilesystemRefs) StateFields() []string {
+func (r *FilesystemRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (f *FilesystemRefs) beforeSave() {}
+func (r *FilesystemRefs) beforeSave() {}
 
-func (f *FilesystemRefs) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.refCount)
+func (r *FilesystemRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (f *FilesystemRefs) afterLoad() {}
+func (r *FilesystemRefs) afterLoad() {}
 
-func (f *FilesystemRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.refCount)
+func (r *FilesystemRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (r *registeredFilesystemType) StateTypeName() string {
@@ -1014,37 +1014,37 @@ func (e *Event) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(5, &e.name)
 }
 
-func (f *FileLocks) StateTypeName() string {
+func (fl *FileLocks) StateTypeName() string {
 	return "pkg/sentry/vfs.FileLocks"
 }
 
-func (f *FileLocks) StateFields() []string {
+func (fl *FileLocks) StateFields() []string {
 	return []string{
 		"bsd",
 		"posix",
 	}
 }
 
-func (f *FileLocks) beforeSave() {}
+func (fl *FileLocks) beforeSave() {}
 
-func (f *FileLocks) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
-	stateSinkObject.Save(0, &f.bsd)
-	stateSinkObject.Save(1, &f.posix)
+func (fl *FileLocks) StateSave(stateSinkObject state.Sink) {
+	fl.beforeSave()
+	stateSinkObject.Save(0, &fl.bsd)
+	stateSinkObject.Save(1, &fl.posix)
 }
 
-func (f *FileLocks) afterLoad() {}
+func (fl *FileLocks) afterLoad() {}
 
-func (f *FileLocks) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &f.bsd)
-	stateSourceObject.Load(1, &f.posix)
+func (fl *FileLocks) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fl.bsd)
+	stateSourceObject.Load(1, &fl.posix)
 }
 
-func (m *Mount) StateTypeName() string {
+func (mnt *Mount) StateTypeName() string {
 	return "pkg/sentry/vfs.Mount"
 }
 
-func (m *Mount) StateFields() []string {
+func (mnt *Mount) StateFields() []string {
 	return []string{
 		"vfs",
 		"fs",
@@ -1060,45 +1060,45 @@ func (m *Mount) StateFields() []string {
 	}
 }
 
-func (m *Mount) beforeSave() {}
+func (mnt *Mount) beforeSave() {}
 
-func (m *Mount) StateSave(stateSinkObject state.Sink) {
-	m.beforeSave()
-	var keyValue VirtualDentry = m.saveKey()
+func (mnt *Mount) StateSave(stateSinkObject state.Sink) {
+	mnt.beforeSave()
+	var keyValue VirtualDentry = mnt.saveKey()
 	stateSinkObject.SaveValue(5, keyValue)
-	stateSinkObject.Save(0, &m.vfs)
-	stateSinkObject.Save(1, &m.fs)
-	stateSinkObject.Save(2, &m.root)
-	stateSinkObject.Save(3, &m.ID)
-	stateSinkObject.Save(4, &m.Flags)
-	stateSinkObject.Save(6, &m.ns)
-	stateSinkObject.Save(7, &m.refs)
-	stateSinkObject.Save(8, &m.children)
-	stateSinkObject.Save(9, &m.umounted)
-	stateSinkObject.Save(10, &m.writers)
-}
-
-func (m *Mount) afterLoad() {}
-
-func (m *Mount) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &m.vfs)
-	stateSourceObject.Load(1, &m.fs)
-	stateSourceObject.Load(2, &m.root)
-	stateSourceObject.Load(3, &m.ID)
-	stateSourceObject.Load(4, &m.Flags)
-	stateSourceObject.Load(6, &m.ns)
-	stateSourceObject.Load(7, &m.refs)
-	stateSourceObject.Load(8, &m.children)
-	stateSourceObject.Load(9, &m.umounted)
-	stateSourceObject.Load(10, &m.writers)
-	stateSourceObject.LoadValue(5, new(VirtualDentry), func(y interface{}) { m.loadKey(y.(VirtualDentry)) })
-}
-
-func (m *MountNamespace) StateTypeName() string {
+	stateSinkObject.Save(0, &mnt.vfs)
+	stateSinkObject.Save(1, &mnt.fs)
+	stateSinkObject.Save(2, &mnt.root)
+	stateSinkObject.Save(3, &mnt.ID)
+	stateSinkObject.Save(4, &mnt.Flags)
+	stateSinkObject.Save(6, &mnt.ns)
+	stateSinkObject.Save(7, &mnt.refs)
+	stateSinkObject.Save(8, &mnt.children)
+	stateSinkObject.Save(9, &mnt.umounted)
+	stateSinkObject.Save(10, &mnt.writers)
+}
+
+func (mnt *Mount) afterLoad() {}
+
+func (mnt *Mount) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &mnt.vfs)
+	stateSourceObject.Load(1, &mnt.fs)
+	stateSourceObject.Load(2, &mnt.root)
+	stateSourceObject.Load(3, &mnt.ID)
+	stateSourceObject.Load(4, &mnt.Flags)
+	stateSourceObject.Load(6, &mnt.ns)
+	stateSourceObject.Load(7, &mnt.refs)
+	stateSourceObject.Load(8, &mnt.children)
+	stateSourceObject.Load(9, &mnt.umounted)
+	stateSourceObject.Load(10, &mnt.writers)
+	stateSourceObject.LoadValue(5, new(VirtualDentry), func(y interface{}) { mnt.loadKey(y.(VirtualDentry)) })
+}
+
+func (mntns *MountNamespace) StateTypeName() string {
 	return "pkg/sentry/vfs.MountNamespace"
 }
 
-func (m *MountNamespace) StateFields() []string {
+func (mntns *MountNamespace) StateFields() []string {
 	return []string{
 		"MountNamespaceRefs",
 		"Owner",
@@ -1107,23 +1107,23 @@ func (m *MountNamespace) StateFields() []string {
 	}
 }
 
-func (m *MountNamespace) beforeSave() {}
+func (mntns *MountNamespace) beforeSave() {}
 
-func (m *MountNamespace) StateSave(stateSinkObject state.Sink) {
-	m.beforeSave()
-	stateSinkObject.Save(0, &m.MountNamespaceRefs)
-	stateSinkObject.Save(1, &m.Owner)
-	stateSinkObject.Save(2, &m.root)
-	stateSinkObject.Save(3, &m.mountpoints)
+func (mntns *MountNamespace) StateSave(stateSinkObject state.Sink) {
+	mntns.beforeSave()
+	stateSinkObject.Save(0, &mntns.MountNamespaceRefs)
+	stateSinkObject.Save(1, &mntns.Owner)
+	stateSinkObject.Save(2, &mntns.root)
+	stateSinkObject.Save(3, &mntns.mountpoints)
 }
 
-func (m *MountNamespace) afterLoad() {}
+func (mntns *MountNamespace) afterLoad() {}
 
-func (m *MountNamespace) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &m.MountNamespaceRefs)
-	stateSourceObject.Load(1, &m.Owner)
-	stateSourceObject.Load(2, &m.root)
-	stateSourceObject.Load(3, &m.mountpoints)
+func (mntns *MountNamespace) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &mntns.MountNamespaceRefs)
+	stateSourceObject.Load(1, &mntns.Owner)
+	stateSourceObject.Load(2, &mntns.root)
+	stateSourceObject.Load(3, &mntns.mountpoints)
 }
 
 func (u *umountRecursiveOptions) StateTypeName() string {
@@ -1152,27 +1152,27 @@ func (u *umountRecursiveOptions) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(1, &u.disconnectHierarchy)
 }
 
-func (m *MountNamespaceRefs) StateTypeName() string {
+func (r *MountNamespaceRefs) StateTypeName() string {
 	return "pkg/sentry/vfs.MountNamespaceRefs"
 }
 
-func (m *MountNamespaceRefs) StateFields() []string {
+func (r *MountNamespaceRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (m *MountNamespaceRefs) beforeSave() {}
+func (r *MountNamespaceRefs) beforeSave() {}
 
-func (m *MountNamespaceRefs) StateSave(stateSinkObject state.Sink) {
-	m.beforeSave()
-	stateSinkObject.Save(0, &m.refCount)
+func (r *MountNamespaceRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (m *MountNamespaceRefs) afterLoad() {}
+func (r *MountNamespaceRefs) afterLoad() {}
 
-func (m *MountNamespaceRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &m.refCount)
+func (r *MountNamespaceRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
 func (g *GetDentryOptions) StateTypeName() string {
@@ -1582,11 +1582,11 @@ func (a *AccessTypes) StateFields() []string {
 	return nil
 }
 
-func (r *ResolvingPath) StateTypeName() string {
+func (rp *ResolvingPath) StateTypeName() string {
 	return "pkg/sentry/vfs.ResolvingPath"
 }
 
-func (r *ResolvingPath) StateFields() []string {
+func (rp *ResolvingPath) StateFields() []string {
 	return []string{
 		"vfs",
 		"root",
@@ -1609,51 +1609,51 @@ func (r *ResolvingPath) StateFields() []string {
 	}
 }
 
-func (r *ResolvingPath) beforeSave() {}
-
-func (r *ResolvingPath) StateSave(stateSinkObject state.Sink) {
-	r.beforeSave()
-	stateSinkObject.Save(0, &r.vfs)
-	stateSinkObject.Save(1, &r.root)
-	stateSinkObject.Save(2, &r.mount)
-	stateSinkObject.Save(3, &r.start)
-	stateSinkObject.Save(4, &r.pit)
-	stateSinkObject.Save(5, &r.flags)
-	stateSinkObject.Save(6, &r.mustBeDir)
-	stateSinkObject.Save(7, &r.mustBeDirOrig)
-	stateSinkObject.Save(8, &r.symlinks)
-	stateSinkObject.Save(9, &r.symlinksOrig)
-	stateSinkObject.Save(10, &r.curPart)
-	stateSinkObject.Save(11, &r.numOrigParts)
-	stateSinkObject.Save(12, &r.creds)
-	stateSinkObject.Save(13, &r.nextMount)
-	stateSinkObject.Save(14, &r.nextStart)
-	stateSinkObject.Save(15, &r.absSymlinkTarget)
-	stateSinkObject.Save(16, &r.parts)
-	stateSinkObject.Save(17, &r.origParts)
-}
-
-func (r *ResolvingPath) afterLoad() {}
-
-func (r *ResolvingPath) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &r.vfs)
-	stateSourceObject.Load(1, &r.root)
-	stateSourceObject.Load(2, &r.mount)
-	stateSourceObject.Load(3, &r.start)
-	stateSourceObject.Load(4, &r.pit)
-	stateSourceObject.Load(5, &r.flags)
-	stateSourceObject.Load(6, &r.mustBeDir)
-	stateSourceObject.Load(7, &r.mustBeDirOrig)
-	stateSourceObject.Load(8, &r.symlinks)
-	stateSourceObject.Load(9, &r.symlinksOrig)
-	stateSourceObject.Load(10, &r.curPart)
-	stateSourceObject.Load(11, &r.numOrigParts)
-	stateSourceObject.Load(12, &r.creds)
-	stateSourceObject.Load(13, &r.nextMount)
-	stateSourceObject.Load(14, &r.nextStart)
-	stateSourceObject.Load(15, &r.absSymlinkTarget)
-	stateSourceObject.Load(16, &r.parts)
-	stateSourceObject.Load(17, &r.origParts)
+func (rp *ResolvingPath) beforeSave() {}
+
+func (rp *ResolvingPath) StateSave(stateSinkObject state.Sink) {
+	rp.beforeSave()
+	stateSinkObject.Save(0, &rp.vfs)
+	stateSinkObject.Save(1, &rp.root)
+	stateSinkObject.Save(2, &rp.mount)
+	stateSinkObject.Save(3, &rp.start)
+	stateSinkObject.Save(4, &rp.pit)
+	stateSinkObject.Save(5, &rp.flags)
+	stateSinkObject.Save(6, &rp.mustBeDir)
+	stateSinkObject.Save(7, &rp.mustBeDirOrig)
+	stateSinkObject.Save(8, &rp.symlinks)
+	stateSinkObject.Save(9, &rp.symlinksOrig)
+	stateSinkObject.Save(10, &rp.curPart)
+	stateSinkObject.Save(11, &rp.numOrigParts)
+	stateSinkObject.Save(12, &rp.creds)
+	stateSinkObject.Save(13, &rp.nextMount)
+	stateSinkObject.Save(14, &rp.nextStart)
+	stateSinkObject.Save(15, &rp.absSymlinkTarget)
+	stateSinkObject.Save(16, &rp.parts)
+	stateSinkObject.Save(17, &rp.origParts)
+}
+
+func (rp *ResolvingPath) afterLoad() {}
+
+func (rp *ResolvingPath) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &rp.vfs)
+	stateSourceObject.Load(1, &rp.root)
+	stateSourceObject.Load(2, &rp.mount)
+	stateSourceObject.Load(3, &rp.start)
+	stateSourceObject.Load(4, &rp.pit)
+	stateSourceObject.Load(5, &rp.flags)
+	stateSourceObject.Load(6, &rp.mustBeDir)
+	stateSourceObject.Load(7, &rp.mustBeDirOrig)
+	stateSourceObject.Load(8, &rp.symlinks)
+	stateSourceObject.Load(9, &rp.symlinksOrig)
+	stateSourceObject.Load(10, &rp.curPart)
+	stateSourceObject.Load(11, &rp.numOrigParts)
+	stateSourceObject.Load(12, &rp.creds)
+	stateSourceObject.Load(13, &rp.nextMount)
+	stateSourceObject.Load(14, &rp.nextStart)
+	stateSourceObject.Load(15, &rp.absSymlinkTarget)
+	stateSourceObject.Load(16, &rp.parts)
+	stateSourceObject.Load(17, &rp.origParts)
 }
 
 func (r *resolveMountRootOrJumpError) StateTypeName() string {
@@ -1713,11 +1713,11 @@ func (r *resolveAbsSymlinkError) afterLoad() {}
 func (r *resolveAbsSymlinkError) StateLoad(stateSourceObject state.Source) {
 }
 
-func (v *VirtualFilesystem) StateTypeName() string {
+func (vfs *VirtualFilesystem) StateTypeName() string {
 	return "pkg/sentry/vfs.VirtualFilesystem"
 }
 
-func (v *VirtualFilesystem) StateFields() []string {
+func (vfs *VirtualFilesystem) StateFields() []string {
 	return []string{
 		"mounts",
 		"mountpoints",
@@ -1731,33 +1731,33 @@ func (v *VirtualFilesystem) StateFields() []string {
 	}
 }
 
-func (v *VirtualFilesystem) beforeSave() {}
+func (vfs *VirtualFilesystem) beforeSave() {}
 
-func (v *VirtualFilesystem) StateSave(stateSinkObject state.Sink) {
-	v.beforeSave()
-	stateSinkObject.Save(0, &v.mounts)
-	stateSinkObject.Save(1, &v.mountpoints)
-	stateSinkObject.Save(2, &v.lastMountID)
-	stateSinkObject.Save(3, &v.anonMount)
-	stateSinkObject.Save(4, &v.devices)
-	stateSinkObject.Save(5, &v.anonBlockDevMinorNext)
-	stateSinkObject.Save(6, &v.anonBlockDevMinor)
-	stateSinkObject.Save(7, &v.fsTypes)
-	stateSinkObject.Save(8, &v.filesystems)
+func (vfs *VirtualFilesystem) StateSave(stateSinkObject state.Sink) {
+	vfs.beforeSave()
+	stateSinkObject.Save(0, &vfs.mounts)
+	stateSinkObject.Save(1, &vfs.mountpoints)
+	stateSinkObject.Save(2, &vfs.lastMountID)
+	stateSinkObject.Save(3, &vfs.anonMount)
+	stateSinkObject.Save(4, &vfs.devices)
+	stateSinkObject.Save(5, &vfs.anonBlockDevMinorNext)
+	stateSinkObject.Save(6, &vfs.anonBlockDevMinor)
+	stateSinkObject.Save(7, &vfs.fsTypes)
+	stateSinkObject.Save(8, &vfs.filesystems)
 }
 
-func (v *VirtualFilesystem) afterLoad() {}
+func (vfs *VirtualFilesystem) afterLoad() {}
 
-func (v *VirtualFilesystem) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &v.mounts)
-	stateSourceObject.Load(1, &v.mountpoints)
-	stateSourceObject.Load(2, &v.lastMountID)
-	stateSourceObject.Load(3, &v.anonMount)
-	stateSourceObject.Load(4, &v.devices)
-	stateSourceObject.Load(5, &v.anonBlockDevMinorNext)
-	stateSourceObject.Load(6, &v.anonBlockDevMinor)
-	stateSourceObject.Load(7, &v.fsTypes)
-	stateSourceObject.Load(8, &v.filesystems)
+func (vfs *VirtualFilesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &vfs.mounts)
+	stateSourceObject.Load(1, &vfs.mountpoints)
+	stateSourceObject.Load(2, &vfs.lastMountID)
+	stateSourceObject.Load(3, &vfs.anonMount)
+	stateSourceObject.Load(4, &vfs.devices)
+	stateSourceObject.Load(5, &vfs.anonBlockDevMinorNext)
+	stateSourceObject.Load(6, &vfs.anonBlockDevMinor)
+	stateSourceObject.Load(7, &vfs.fsTypes)
+	stateSourceObject.Load(8, &vfs.filesystems)
 }
 
 func (p *PathOperation) StateTypeName() string {
@@ -1792,30 +1792,30 @@ func (p *PathOperation) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(3, &p.FollowFinalSymlink)
 }
 
-func (v *VirtualDentry) StateTypeName() string {
+func (vd *VirtualDentry) StateTypeName() string {
 	return "pkg/sentry/vfs.VirtualDentry"
 }
 
-func (v *VirtualDentry) StateFields() []string {
+func (vd *VirtualDentry) StateFields() []string {
 	return []string{
 		"mount",
 		"dentry",
 	}
 }
 
-func (v *VirtualDentry) beforeSave() {}
+func (vd *VirtualDentry) beforeSave() {}
 
-func (v *VirtualDentry) StateSave(stateSinkObject state.Sink) {
-	v.beforeSave()
-	stateSinkObject.Save(0, &v.mount)
-	stateSinkObject.Save(1, &v.dentry)
+func (vd *VirtualDentry) StateSave(stateSinkObject state.Sink) {
+	vd.beforeSave()
+	stateSinkObject.Save(0, &vd.mount)
+	stateSinkObject.Save(1, &vd.dentry)
 }
 
-func (v *VirtualDentry) afterLoad() {}
+func (vd *VirtualDentry) afterLoad() {}
 
-func (v *VirtualDentry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &v.mount)
-	stateSourceObject.Load(1, &v.dentry)
+func (vd *VirtualDentry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &vd.mount)
+	stateSourceObject.Load(1, &vd.dentry)
 }
 
 func init() {
diff --git a/pkg/sentry/vfs/vfs_unsafe_state_autogen.go b/pkg/sentry/vfs/vfs_unsafe_state_autogen.go
index 1dedacc1f..d23733ee7 100644
--- a/pkg/sentry/vfs/vfs_unsafe_state_autogen.go
+++ b/pkg/sentry/vfs/vfs_unsafe_state_autogen.go
@@ -9,30 +9,30 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (m *mountTable) StateTypeName() string {
+func (mt *mountTable) StateTypeName() string {
 	return "pkg/sentry/vfs.mountTable"
 }
 
-func (m *mountTable) StateFields() []string {
+func (mt *mountTable) StateFields() []string {
 	return []string{
 		"seed",
 		"size",
 	}
 }
 
-func (m *mountTable) beforeSave() {}
+func (mt *mountTable) beforeSave() {}
 
-func (m *mountTable) StateSave(stateSinkObject state.Sink) {
-	m.beforeSave()
-	stateSinkObject.Save(0, &m.seed)
-	stateSinkObject.Save(1, &m.size)
+func (mt *mountTable) StateSave(stateSinkObject state.Sink) {
+	mt.beforeSave()
+	stateSinkObject.Save(0, &mt.seed)
+	stateSinkObject.Save(1, &mt.size)
 }
 
-func (m *mountTable) afterLoad() {}
+func (mt *mountTable) afterLoad() {}
 
-func (m *mountTable) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &m.seed)
-	stateSourceObject.Load(1, &m.size)
+func (mt *mountTable) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &mt.seed)
+	stateSourceObject.Load(1, &mt.size)
 }
 
 func init() {