Merge release-20200928.0-66-ga55bd73d4 (automated)

1 files changed, 275 insertions, 275 deletions

diff --git a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
index b127b2015..fc0da410c 100644
--- a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
+++ b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
@@ -6,11 +6,11 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
-func (x *connection) StateTypeName() string {
+func (c *connection) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.connection"
 }
 
-func (x *connection) StateFields() []string {
+func (c *connection) StateFields() []string {
 	return []string{
 		"fd",
 		"attributeVersion",
@@ -37,86 +37,86 @@ func (x *connection) StateFields() []string {
 	}
 }
 
-func (x *connection) beforeSave() {}
-
-func (x *connection) StateSave(m state.Sink) {
-	x.beforeSave()
-	var initializedChan bool = x.saveInitializedChan()
-	m.SaveValue(3, initializedChan)
-	m.Save(0, &x.fd)
-	m.Save(1, &x.attributeVersion)
-	m.Save(2, &x.initialized)
-	m.Save(4, &x.connected)
-	m.Save(5, &x.connInitError)
-	m.Save(6, &x.connInitSuccess)
-	m.Save(7, &x.aborted)
-	m.Save(8, &x.numWaiting)
-	m.Save(9, &x.asyncNum)
-	m.Save(10, &x.asyncCongestionThreshold)
-	m.Save(11, &x.asyncNumMax)
-	m.Save(12, &x.maxRead)
-	m.Save(13, &x.maxWrite)
-	m.Save(14, &x.maxPages)
-	m.Save(15, &x.minor)
-	m.Save(16, &x.atomicOTrunc)
-	m.Save(17, &x.asyncRead)
-	m.Save(18, &x.writebackCache)
-	m.Save(19, &x.bigWrites)
-	m.Save(20, &x.dontMask)
-	m.Save(21, &x.noOpen)
-}
-
-func (x *connection) afterLoad() {}
-
-func (x *connection) StateLoad(m state.Source) {
-	m.Load(0, &x.fd)
-	m.Load(1, &x.attributeVersion)
-	m.Load(2, &x.initialized)
-	m.Load(4, &x.connected)
-	m.Load(5, &x.connInitError)
-	m.Load(6, &x.connInitSuccess)
-	m.Load(7, &x.aborted)
-	m.Load(8, &x.numWaiting)
-	m.Load(9, &x.asyncNum)
-	m.Load(10, &x.asyncCongestionThreshold)
-	m.Load(11, &x.asyncNumMax)
-	m.Load(12, &x.maxRead)
-	m.Load(13, &x.maxWrite)
-	m.Load(14, &x.maxPages)
-	m.Load(15, &x.minor)
-	m.Load(16, &x.atomicOTrunc)
-	m.Load(17, &x.asyncRead)
-	m.Load(18, &x.writebackCache)
-	m.Load(19, &x.bigWrites)
-	m.Load(20, &x.dontMask)
-	m.Load(21, &x.noOpen)
-	m.LoadValue(3, new(bool), func(y interface{}) { x.loadInitializedChan(y.(bool)) })
-}
-
-func (x *fuseDevice) StateTypeName() string {
+func (c *connection) beforeSave() {}
+
+func (c *connection) StateSave(stateSinkObject state.Sink) {
+	c.beforeSave()
+	var initializedChanValue bool = c.saveInitializedChan()
+	stateSinkObject.SaveValue(3, initializedChanValue)
+	stateSinkObject.Save(0, &c.fd)
+	stateSinkObject.Save(1, &c.attributeVersion)
+	stateSinkObject.Save(2, &c.initialized)
+	stateSinkObject.Save(4, &c.connected)
+	stateSinkObject.Save(5, &c.connInitError)
+	stateSinkObject.Save(6, &c.connInitSuccess)
+	stateSinkObject.Save(7, &c.aborted)
+	stateSinkObject.Save(8, &c.numWaiting)
+	stateSinkObject.Save(9, &c.asyncNum)
+	stateSinkObject.Save(10, &c.asyncCongestionThreshold)
+	stateSinkObject.Save(11, &c.asyncNumMax)
+	stateSinkObject.Save(12, &c.maxRead)
+	stateSinkObject.Save(13, &c.maxWrite)
+	stateSinkObject.Save(14, &c.maxPages)
+	stateSinkObject.Save(15, &c.minor)
+	stateSinkObject.Save(16, &c.atomicOTrunc)
+	stateSinkObject.Save(17, &c.asyncRead)
+	stateSinkObject.Save(18, &c.writebackCache)
+	stateSinkObject.Save(19, &c.bigWrites)
+	stateSinkObject.Save(20, &c.dontMask)
+	stateSinkObject.Save(21, &c.noOpen)
+}
+
+func (c *connection) afterLoad() {}
+
+func (c *connection) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &c.fd)
+	stateSourceObject.Load(1, &c.attributeVersion)
+	stateSourceObject.Load(2, &c.initialized)
+	stateSourceObject.Load(4, &c.connected)
+	stateSourceObject.Load(5, &c.connInitError)
+	stateSourceObject.Load(6, &c.connInitSuccess)
+	stateSourceObject.Load(7, &c.aborted)
+	stateSourceObject.Load(8, &c.numWaiting)
+	stateSourceObject.Load(9, &c.asyncNum)
+	stateSourceObject.Load(10, &c.asyncCongestionThreshold)
+	stateSourceObject.Load(11, &c.asyncNumMax)
+	stateSourceObject.Load(12, &c.maxRead)
+	stateSourceObject.Load(13, &c.maxWrite)
+	stateSourceObject.Load(14, &c.maxPages)
+	stateSourceObject.Load(15, &c.minor)
+	stateSourceObject.Load(16, &c.atomicOTrunc)
+	stateSourceObject.Load(17, &c.asyncRead)
+	stateSourceObject.Load(18, &c.writebackCache)
+	stateSourceObject.Load(19, &c.bigWrites)
+	stateSourceObject.Load(20, &c.dontMask)
+	stateSourceObject.Load(21, &c.noOpen)
+	stateSourceObject.LoadValue(3, new(bool), func(y interface{}) { c.loadInitializedChan(y.(bool)) })
+}
+
+func (f *fuseDevice) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.fuseDevice"
 }
 
-func (x *fuseDevice) StateFields() []string {
+func (f *fuseDevice) StateFields() []string {
 	return []string{}
 }
 
-func (x *fuseDevice) beforeSave() {}
+func (f *fuseDevice) beforeSave() {}
 
-func (x *fuseDevice) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *fuseDevice) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *fuseDevice) afterLoad() {}
+func (f *fuseDevice) afterLoad() {}
 
-func (x *fuseDevice) StateLoad(m state.Source) {
+func (f *fuseDevice) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *DeviceFD) StateTypeName() string {
+func (d *DeviceFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.DeviceFD"
 }
 
-func (x *DeviceFD) StateFields() []string {
+func (d *DeviceFD) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -135,70 +135,70 @@ func (x *DeviceFD) StateFields() []string {
 	}
 }
 
-func (x *DeviceFD) beforeSave() {}
-
-func (x *DeviceFD) StateSave(m state.Sink) {
-	x.beforeSave()
-	var fullQueueCh int = x.saveFullQueueCh()
-	m.SaveValue(12, fullQueueCh)
-	m.Save(0, &x.vfsfd)
-	m.Save(1, &x.FileDescriptionDefaultImpl)
-	m.Save(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Save(3, &x.NoLockFD)
-	m.Save(4, &x.nextOpID)
-	m.Save(5, &x.queue)
-	m.Save(6, &x.numActiveRequests)
-	m.Save(7, &x.completions)
-	m.Save(8, &x.writeCursor)
-	m.Save(9, &x.writeBuf)
-	m.Save(10, &x.writeCursorFR)
-	m.Save(11, &x.waitQueue)
-	m.Save(13, &x.fs)
-}
-
-func (x *DeviceFD) afterLoad() {}
-
-func (x *DeviceFD) StateLoad(m state.Source) {
-	m.Load(0, &x.vfsfd)
-	m.Load(1, &x.FileDescriptionDefaultImpl)
-	m.Load(2, &x.DentryMetadataFileDescriptionImpl)
-	m.Load(3, &x.NoLockFD)
-	m.Load(4, &x.nextOpID)
-	m.Load(5, &x.queue)
-	m.Load(6, &x.numActiveRequests)
-	m.Load(7, &x.completions)
-	m.Load(8, &x.writeCursor)
-	m.Load(9, &x.writeBuf)
-	m.Load(10, &x.writeCursorFR)
-	m.Load(11, &x.waitQueue)
-	m.Load(13, &x.fs)
-	m.LoadValue(12, new(int), func(y interface{}) { x.loadFullQueueCh(y.(int)) })
-}
-
-func (x *FilesystemType) StateTypeName() string {
+func (d *DeviceFD) beforeSave() {}
+
+func (d *DeviceFD) StateSave(stateSinkObject state.Sink) {
+	d.beforeSave()
+	var fullQueueChValue int = d.saveFullQueueCh()
+	stateSinkObject.SaveValue(12, fullQueueChValue)
+	stateSinkObject.Save(0, &d.vfsfd)
+	stateSinkObject.Save(1, &d.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &d.NoLockFD)
+	stateSinkObject.Save(4, &d.nextOpID)
+	stateSinkObject.Save(5, &d.queue)
+	stateSinkObject.Save(6, &d.numActiveRequests)
+	stateSinkObject.Save(7, &d.completions)
+	stateSinkObject.Save(8, &d.writeCursor)
+	stateSinkObject.Save(9, &d.writeBuf)
+	stateSinkObject.Save(10, &d.writeCursorFR)
+	stateSinkObject.Save(11, &d.waitQueue)
+	stateSinkObject.Save(13, &d.fs)
+}
+
+func (d *DeviceFD) afterLoad() {}
+
+func (d *DeviceFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &d.vfsfd)
+	stateSourceObject.Load(1, &d.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &d.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &d.NoLockFD)
+	stateSourceObject.Load(4, &d.nextOpID)
+	stateSourceObject.Load(5, &d.queue)
+	stateSourceObject.Load(6, &d.numActiveRequests)
+	stateSourceObject.Load(7, &d.completions)
+	stateSourceObject.Load(8, &d.writeCursor)
+	stateSourceObject.Load(9, &d.writeBuf)
+	stateSourceObject.Load(10, &d.writeCursorFR)
+	stateSourceObject.Load(11, &d.waitQueue)
+	stateSourceObject.Load(13, &d.fs)
+	stateSourceObject.LoadValue(12, new(int), func(y interface{}) { d.loadFullQueueCh(y.(int)) })
+}
+
+func (f *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.FilesystemType"
 }
 
-func (x *FilesystemType) StateFields() []string {
+func (f *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (x *FilesystemType) beforeSave() {}
+func (f *FilesystemType) beforeSave() {}
 
-func (x *FilesystemType) StateSave(m state.Sink) {
-	x.beforeSave()
+func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
 }
 
-func (x *FilesystemType) afterLoad() {}
+func (f *FilesystemType) afterLoad() {}
 
-func (x *FilesystemType) StateLoad(m state.Source) {
+func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
-func (x *filesystemOptions) StateTypeName() string {
+func (f *filesystemOptions) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.filesystemOptions"
 }
 
-func (x *filesystemOptions) StateFields() []string {
+func (f *filesystemOptions) StateFields() []string {
 	return []string{
 		"userID",
 		"groupID",
@@ -208,32 +208,32 @@ func (x *filesystemOptions) StateFields() []string {
 	}
 }
 
-func (x *filesystemOptions) beforeSave() {}
+func (f *filesystemOptions) beforeSave() {}
 
-func (x *filesystemOptions) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.userID)
-	m.Save(1, &x.groupID)
-	m.Save(2, &x.rootMode)
-	m.Save(3, &x.maxActiveRequests)
-	m.Save(4, &x.maxRead)
+func (f *filesystemOptions) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.userID)
+	stateSinkObject.Save(1, &f.groupID)
+	stateSinkObject.Save(2, &f.rootMode)
+	stateSinkObject.Save(3, &f.maxActiveRequests)
+	stateSinkObject.Save(4, &f.maxRead)
 }
 
-func (x *filesystemOptions) afterLoad() {}
+func (f *filesystemOptions) afterLoad() {}
 
-func (x *filesystemOptions) StateLoad(m state.Source) {
-	m.Load(0, &x.userID)
-	m.Load(1, &x.groupID)
-	m.Load(2, &x.rootMode)
-	m.Load(3, &x.maxActiveRequests)
-	m.Load(4, &x.maxRead)
+func (f *filesystemOptions) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.userID)
+	stateSourceObject.Load(1, &f.groupID)
+	stateSourceObject.Load(2, &f.rootMode)
+	stateSourceObject.Load(3, &f.maxActiveRequests)
+	stateSourceObject.Load(4, &f.maxRead)
 }
 
-func (x *filesystem) StateTypeName() string {
+func (f *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.filesystem"
 }
 
-func (x *filesystem) StateFields() []string {
+func (f *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
@@ -243,32 +243,32 @@ func (x *filesystem) StateFields() []string {
 	}
 }
 
-func (x *filesystem) beforeSave() {}
+func (f *filesystem) beforeSave() {}
 
-func (x *filesystem) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.Filesystem)
-	m.Save(1, &x.devMinor)
-	m.Save(2, &x.conn)
-	m.Save(3, &x.opts)
-	m.Save(4, &x.umounted)
+func (f *filesystem) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.Filesystem)
+	stateSinkObject.Save(1, &f.devMinor)
+	stateSinkObject.Save(2, &f.conn)
+	stateSinkObject.Save(3, &f.opts)
+	stateSinkObject.Save(4, &f.umounted)
 }
 
-func (x *filesystem) afterLoad() {}
+func (f *filesystem) afterLoad() {}
 
-func (x *filesystem) StateLoad(m state.Source) {
-	m.Load(0, &x.Filesystem)
-	m.Load(1, &x.devMinor)
-	m.Load(2, &x.conn)
-	m.Load(3, &x.opts)
-	m.Load(4, &x.umounted)
+func (f *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.Filesystem)
+	stateSourceObject.Load(1, &f.devMinor)
+	stateSourceObject.Load(2, &f.conn)
+	stateSourceObject.Load(3, &f.opts)
+	stateSourceObject.Load(4, &f.umounted)
 }
 
-func (x *inode) StateTypeName() string {
+func (i *inode) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.inode"
 }
 
-func (x *inode) StateFields() []string {
+func (i *inode) StateFields() []string {
 	return []string{
 		"inodeRefs",
 		"InodeAttrs",
@@ -289,129 +289,129 @@ func (x *inode) StateFields() []string {
 	}
 }
 
-func (x *inode) beforeSave() {}
-
-func (x *inode) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.inodeRefs)
-	m.Save(1, &x.InodeAttrs)
-	m.Save(2, &x.InodeDirectoryNoNewChildren)
-	m.Save(3, &x.InodeNoDynamicLookup)
-	m.Save(4, &x.InodeNotSymlink)
-	m.Save(5, &x.OrderedChildren)
-	m.Save(6, &x.dentry)
-	m.Save(7, &x.fs)
-	m.Save(8, &x.metadataMu)
-	m.Save(9, &x.nodeID)
-	m.Save(10, &x.locks)
-	m.Save(11, &x.size)
-	m.Save(12, &x.attributeVersion)
-	m.Save(13, &x.attributeTime)
-	m.Save(14, &x.version)
-	m.Save(15, &x.link)
-}
-
-func (x *inode) afterLoad() {}
-
-func (x *inode) StateLoad(m state.Source) {
-	m.Load(0, &x.inodeRefs)
-	m.Load(1, &x.InodeAttrs)
-	m.Load(2, &x.InodeDirectoryNoNewChildren)
-	m.Load(3, &x.InodeNoDynamicLookup)
-	m.Load(4, &x.InodeNotSymlink)
-	m.Load(5, &x.OrderedChildren)
-	m.Load(6, &x.dentry)
-	m.Load(7, &x.fs)
-	m.Load(8, &x.metadataMu)
-	m.Load(9, &x.nodeID)
-	m.Load(10, &x.locks)
-	m.Load(11, &x.size)
-	m.Load(12, &x.attributeVersion)
-	m.Load(13, &x.attributeTime)
-	m.Load(14, &x.version)
-	m.Load(15, &x.link)
-}
-
-func (x *inodeRefs) StateTypeName() string {
+func (i *inode) beforeSave() {}
+
+func (i *inode) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.inodeRefs)
+	stateSinkObject.Save(1, &i.InodeAttrs)
+	stateSinkObject.Save(2, &i.InodeDirectoryNoNewChildren)
+	stateSinkObject.Save(3, &i.InodeNoDynamicLookup)
+	stateSinkObject.Save(4, &i.InodeNotSymlink)
+	stateSinkObject.Save(5, &i.OrderedChildren)
+	stateSinkObject.Save(6, &i.dentry)
+	stateSinkObject.Save(7, &i.fs)
+	stateSinkObject.Save(8, &i.metadataMu)
+	stateSinkObject.Save(9, &i.nodeID)
+	stateSinkObject.Save(10, &i.locks)
+	stateSinkObject.Save(11, &i.size)
+	stateSinkObject.Save(12, &i.attributeVersion)
+	stateSinkObject.Save(13, &i.attributeTime)
+	stateSinkObject.Save(14, &i.version)
+	stateSinkObject.Save(15, &i.link)
+}
+
+func (i *inode) afterLoad() {}
+
+func (i *inode) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.inodeRefs)
+	stateSourceObject.Load(1, &i.InodeAttrs)
+	stateSourceObject.Load(2, &i.InodeDirectoryNoNewChildren)
+	stateSourceObject.Load(3, &i.InodeNoDynamicLookup)
+	stateSourceObject.Load(4, &i.InodeNotSymlink)
+	stateSourceObject.Load(5, &i.OrderedChildren)
+	stateSourceObject.Load(6, &i.dentry)
+	stateSourceObject.Load(7, &i.fs)
+	stateSourceObject.Load(8, &i.metadataMu)
+	stateSourceObject.Load(9, &i.nodeID)
+	stateSourceObject.Load(10, &i.locks)
+	stateSourceObject.Load(11, &i.size)
+	stateSourceObject.Load(12, &i.attributeVersion)
+	stateSourceObject.Load(13, &i.attributeTime)
+	stateSourceObject.Load(14, &i.version)
+	stateSourceObject.Load(15, &i.link)
+}
+
+func (i *inodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.inodeRefs"
 }
 
-func (x *inodeRefs) StateFields() []string {
+func (i *inodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (x *inodeRefs) beforeSave() {}
+func (i *inodeRefs) beforeSave() {}
 
-func (x *inodeRefs) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.refCount)
+func (i *inodeRefs) StateSave(stateSinkObject state.Sink) {
+	i.beforeSave()
+	stateSinkObject.Save(0, &i.refCount)
 }
 
-func (x *inodeRefs) afterLoad() {}
+func (i *inodeRefs) afterLoad() {}
 
-func (x *inodeRefs) StateLoad(m state.Source) {
-	m.Load(0, &x.refCount)
+func (i *inodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &i.refCount)
 }
 
-func (x *requestList) StateTypeName() string {
+func (r *requestList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestList"
 }
 
-func (x *requestList) StateFields() []string {
+func (r *requestList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (x *requestList) beforeSave() {}
+func (r *requestList) beforeSave() {}
 
-func (x *requestList) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.head)
-	m.Save(1, &x.tail)
+func (r *requestList) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.head)
+	stateSinkObject.Save(1, &r.tail)
 }
 
-func (x *requestList) afterLoad() {}
+func (r *requestList) afterLoad() {}
 
-func (x *requestList) StateLoad(m state.Source) {
-	m.Load(0, &x.head)
-	m.Load(1, &x.tail)
+func (r *requestList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.head)
+	stateSourceObject.Load(1, &r.tail)
 }
 
-func (x *requestEntry) StateTypeName() string {
+func (r *requestEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestEntry"
 }
 
-func (x *requestEntry) StateFields() []string {
+func (r *requestEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (x *requestEntry) beforeSave() {}
+func (r *requestEntry) beforeSave() {}
 
-func (x *requestEntry) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.next)
-	m.Save(1, &x.prev)
+func (r *requestEntry) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.next)
+	stateSinkObject.Save(1, &r.prev)
 }
 
-func (x *requestEntry) afterLoad() {}
+func (r *requestEntry) afterLoad() {}
 
-func (x *requestEntry) StateLoad(m state.Source) {
-	m.Load(0, &x.next)
-	m.Load(1, &x.prev)
+func (r *requestEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.next)
+	stateSourceObject.Load(1, &r.prev)
 }
 
-func (x *Request) StateTypeName() string {
+func (r *Request) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.Request"
 }
 
-func (x *Request) StateFields() []string {
+func (r *Request) StateFields() []string {
 	return []string{
 		"requestEntry",
 		"id",
@@ -423,36 +423,36 @@ func (x *Request) StateFields() []string {
 	}
 }
 
-func (x *Request) beforeSave() {}
+func (r *Request) beforeSave() {}
 
-func (x *Request) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.requestEntry)
-	m.Save(1, &x.id)
-	m.Save(2, &x.hdr)
-	m.Save(3, &x.data)
-	m.Save(4, &x.payload)
-	m.Save(5, &x.async)
-	m.Save(6, &x.noReply)
+func (r *Request) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.requestEntry)
+	stateSinkObject.Save(1, &r.id)
+	stateSinkObject.Save(2, &r.hdr)
+	stateSinkObject.Save(3, &r.data)
+	stateSinkObject.Save(4, &r.payload)
+	stateSinkObject.Save(5, &r.async)
+	stateSinkObject.Save(6, &r.noReply)
 }
 
-func (x *Request) afterLoad() {}
+func (r *Request) afterLoad() {}
 
-func (x *Request) StateLoad(m state.Source) {
-	m.Load(0, &x.requestEntry)
-	m.Load(1, &x.id)
-	m.Load(2, &x.hdr)
-	m.Load(3, &x.data)
-	m.Load(4, &x.payload)
-	m.Load(5, &x.async)
-	m.Load(6, &x.noReply)
+func (r *Request) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.requestEntry)
+	stateSourceObject.Load(1, &r.id)
+	stateSourceObject.Load(2, &r.hdr)
+	stateSourceObject.Load(3, &r.data)
+	stateSourceObject.Load(4, &r.payload)
+	stateSourceObject.Load(5, &r.async)
+	stateSourceObject.Load(6, &r.noReply)
 }
 
-func (x *futureResponse) StateTypeName() string {
+func (f *futureResponse) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.futureResponse"
 }
 
-func (x *futureResponse) StateFields() []string {
+func (f *futureResponse) StateFields() []string {
 	return []string{
 		"opcode",
 		"ch",
@@ -462,32 +462,32 @@ func (x *futureResponse) StateFields() []string {
 	}
 }
 
-func (x *futureResponse) beforeSave() {}
+func (f *futureResponse) beforeSave() {}
 
-func (x *futureResponse) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.opcode)
-	m.Save(1, &x.ch)
-	m.Save(2, &x.hdr)
-	m.Save(3, &x.data)
-	m.Save(4, &x.async)
+func (f *futureResponse) StateSave(stateSinkObject state.Sink) {
+	f.beforeSave()
+	stateSinkObject.Save(0, &f.opcode)
+	stateSinkObject.Save(1, &f.ch)
+	stateSinkObject.Save(2, &f.hdr)
+	stateSinkObject.Save(3, &f.data)
+	stateSinkObject.Save(4, &f.async)
 }
 
-func (x *futureResponse) afterLoad() {}
+func (f *futureResponse) afterLoad() {}
 
-func (x *futureResponse) StateLoad(m state.Source) {
-	m.Load(0, &x.opcode)
-	m.Load(1, &x.ch)
-	m.Load(2, &x.hdr)
-	m.Load(3, &x.data)
-	m.Load(4, &x.async)
+func (f *futureResponse) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &f.opcode)
+	stateSourceObject.Load(1, &f.ch)
+	stateSourceObject.Load(2, &f.hdr)
+	stateSourceObject.Load(3, &f.data)
+	stateSourceObject.Load(4, &f.async)
 }
 
-func (x *Response) StateTypeName() string {
+func (r *Response) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.Response"
 }
 
-func (x *Response) StateFields() []string {
+func (r *Response) StateFields() []string {
 	return []string{
 		"opcode",
 		"hdr",
@@ -495,21 +495,21 @@ func (x *Response) StateFields() []string {
 	}
 }
 
-func (x *Response) beforeSave() {}
+func (r *Response) beforeSave() {}
 
-func (x *Response) StateSave(m state.Sink) {
-	x.beforeSave()
-	m.Save(0, &x.opcode)
-	m.Save(1, &x.hdr)
-	m.Save(2, &x.data)
+func (r *Response) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.opcode)
+	stateSinkObject.Save(1, &r.hdr)
+	stateSinkObject.Save(2, &r.data)
 }
 
-func (x *Response) afterLoad() {}
+func (r *Response) afterLoad() {}
 
-func (x *Response) StateLoad(m state.Source) {
-	m.Load(0, &x.opcode)
-	m.Load(1, &x.hdr)
-	m.Load(2, &x.data)
+func (r *Response) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.opcode)
+	stateSourceObject.Load(1, &r.hdr)
+	stateSourceObject.Load(2, &r.data)
 }
 
 func init() {