Merge release-20200928.0-78-g743327817 (automated)

1 files changed, 149 insertions, 149 deletions

diff --git a/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go b/pkg/sentry/fsimpl/fuse/fuse_state_autogen.go
index fc0da410c..3c189317f 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 (c *connection) StateTypeName() string {
+func (conn *connection) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.connection"
 }
 
-func (c *connection) StateFields() []string {
+func (conn *connection) StateFields() []string {
 	return []string{
 		"fd",
 		"attributeVersion",
@@ -37,60 +37,60 @@ func (c *connection) StateFields() []string {
 	}
 }
 
-func (c *connection) beforeSave() {}
+func (conn *connection) beforeSave() {}
 
-func (c *connection) StateSave(stateSinkObject state.Sink) {
-	c.beforeSave()
-	var initializedChanValue bool = c.saveInitializedChan()
+func (conn *connection) StateSave(stateSinkObject state.Sink) {
+	conn.beforeSave()
+	var initializedChanValue bool = conn.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)) })
+	stateSinkObject.Save(0, &conn.fd)
+	stateSinkObject.Save(1, &conn.attributeVersion)
+	stateSinkObject.Save(2, &conn.initialized)
+	stateSinkObject.Save(4, &conn.connected)
+	stateSinkObject.Save(5, &conn.connInitError)
+	stateSinkObject.Save(6, &conn.connInitSuccess)
+	stateSinkObject.Save(7, &conn.aborted)
+	stateSinkObject.Save(8, &conn.numWaiting)
+	stateSinkObject.Save(9, &conn.asyncNum)
+	stateSinkObject.Save(10, &conn.asyncCongestionThreshold)
+	stateSinkObject.Save(11, &conn.asyncNumMax)
+	stateSinkObject.Save(12, &conn.maxRead)
+	stateSinkObject.Save(13, &conn.maxWrite)
+	stateSinkObject.Save(14, &conn.maxPages)
+	stateSinkObject.Save(15, &conn.minor)
+	stateSinkObject.Save(16, &conn.atomicOTrunc)
+	stateSinkObject.Save(17, &conn.asyncRead)
+	stateSinkObject.Save(18, &conn.writebackCache)
+	stateSinkObject.Save(19, &conn.bigWrites)
+	stateSinkObject.Save(20, &conn.dontMask)
+	stateSinkObject.Save(21, &conn.noOpen)
+}
+
+func (conn *connection) afterLoad() {}
+
+func (conn *connection) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &conn.fd)
+	stateSourceObject.Load(1, &conn.attributeVersion)
+	stateSourceObject.Load(2, &conn.initialized)
+	stateSourceObject.Load(4, &conn.connected)
+	stateSourceObject.Load(5, &conn.connInitError)
+	stateSourceObject.Load(6, &conn.connInitSuccess)
+	stateSourceObject.Load(7, &conn.aborted)
+	stateSourceObject.Load(8, &conn.numWaiting)
+	stateSourceObject.Load(9, &conn.asyncNum)
+	stateSourceObject.Load(10, &conn.asyncCongestionThreshold)
+	stateSourceObject.Load(11, &conn.asyncNumMax)
+	stateSourceObject.Load(12, &conn.maxRead)
+	stateSourceObject.Load(13, &conn.maxWrite)
+	stateSourceObject.Load(14, &conn.maxPages)
+	stateSourceObject.Load(15, &conn.minor)
+	stateSourceObject.Load(16, &conn.atomicOTrunc)
+	stateSourceObject.Load(17, &conn.asyncRead)
+	stateSourceObject.Load(18, &conn.writebackCache)
+	stateSourceObject.Load(19, &conn.bigWrites)
+	stateSourceObject.Load(20, &conn.dontMask)
+	stateSourceObject.Load(21, &conn.noOpen)
+	stateSourceObject.LoadValue(3, new(bool), func(y interface{}) { conn.loadInitializedChan(y.(bool)) })
 }
 
 func (f *fuseDevice) StateTypeName() string {
@@ -112,11 +112,11 @@ func (f *fuseDevice) afterLoad() {}
 func (f *fuseDevice) StateLoad(stateSourceObject state.Source) {
 }
 
-func (d *DeviceFD) StateTypeName() string {
+func (fd *DeviceFD) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.DeviceFD"
 }
 
-func (d *DeviceFD) StateFields() []string {
+func (fd *DeviceFD) StateFields() []string {
 	return []string{
 		"vfsfd",
 		"FileDescriptionDefaultImpl",
@@ -135,63 +135,63 @@ func (d *DeviceFD) StateFields() []string {
 	}
 }
 
-func (d *DeviceFD) beforeSave() {}
+func (fd *DeviceFD) beforeSave() {}
 
-func (d *DeviceFD) StateSave(stateSinkObject state.Sink) {
-	d.beforeSave()
-	var fullQueueChValue int = d.saveFullQueueCh()
+func (fd *DeviceFD) StateSave(stateSinkObject state.Sink) {
+	fd.beforeSave()
+	var fullQueueChValue int = fd.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 {
+	stateSinkObject.Save(0, &fd.vfsfd)
+	stateSinkObject.Save(1, &fd.FileDescriptionDefaultImpl)
+	stateSinkObject.Save(2, &fd.DentryMetadataFileDescriptionImpl)
+	stateSinkObject.Save(3, &fd.NoLockFD)
+	stateSinkObject.Save(4, &fd.nextOpID)
+	stateSinkObject.Save(5, &fd.queue)
+	stateSinkObject.Save(6, &fd.numActiveRequests)
+	stateSinkObject.Save(7, &fd.completions)
+	stateSinkObject.Save(8, &fd.writeCursor)
+	stateSinkObject.Save(9, &fd.writeBuf)
+	stateSinkObject.Save(10, &fd.writeCursorFR)
+	stateSinkObject.Save(11, &fd.waitQueue)
+	stateSinkObject.Save(13, &fd.fs)
+}
+
+func (fd *DeviceFD) afterLoad() {}
+
+func (fd *DeviceFD) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fd.vfsfd)
+	stateSourceObject.Load(1, &fd.FileDescriptionDefaultImpl)
+	stateSourceObject.Load(2, &fd.DentryMetadataFileDescriptionImpl)
+	stateSourceObject.Load(3, &fd.NoLockFD)
+	stateSourceObject.Load(4, &fd.nextOpID)
+	stateSourceObject.Load(5, &fd.queue)
+	stateSourceObject.Load(6, &fd.numActiveRequests)
+	stateSourceObject.Load(7, &fd.completions)
+	stateSourceObject.Load(8, &fd.writeCursor)
+	stateSourceObject.Load(9, &fd.writeBuf)
+	stateSourceObject.Load(10, &fd.writeCursorFR)
+	stateSourceObject.Load(11, &fd.waitQueue)
+	stateSourceObject.Load(13, &fd.fs)
+	stateSourceObject.LoadValue(12, new(int), func(y interface{}) { fd.loadFullQueueCh(y.(int)) })
+}
+
+func (fsType *FilesystemType) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.FilesystemType"
 }
 
-func (f *FilesystemType) StateFields() []string {
+func (fsType *FilesystemType) StateFields() []string {
 	return []string{}
 }
 
-func (f *FilesystemType) beforeSave() {}
+func (fsType *FilesystemType) beforeSave() {}
 
-func (f *FilesystemType) StateSave(stateSinkObject state.Sink) {
-	f.beforeSave()
+func (fsType *FilesystemType) StateSave(stateSinkObject state.Sink) {
+	fsType.beforeSave()
 }
 
-func (f *FilesystemType) afterLoad() {}
+func (fsType *FilesystemType) afterLoad() {}
 
-func (f *FilesystemType) StateLoad(stateSourceObject state.Source) {
+func (fsType *FilesystemType) StateLoad(stateSourceObject state.Source) {
 }
 
 func (f *filesystemOptions) StateTypeName() string {
@@ -229,11 +229,11 @@ func (f *filesystemOptions) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(4, &f.maxRead)
 }
 
-func (f *filesystem) StateTypeName() string {
+func (fs *filesystem) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.filesystem"
 }
 
-func (f *filesystem) StateFields() []string {
+func (fs *filesystem) StateFields() []string {
 	return []string{
 		"Filesystem",
 		"devMinor",
@@ -243,25 +243,25 @@ 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.Filesystem)
-	stateSinkObject.Save(1, &f.devMinor)
-	stateSinkObject.Save(2, &f.conn)
-	stateSinkObject.Save(3, &f.opts)
-	stateSinkObject.Save(4, &f.umounted)
+func (fs *filesystem) StateSave(stateSinkObject state.Sink) {
+	fs.beforeSave()
+	stateSinkObject.Save(0, &fs.Filesystem)
+	stateSinkObject.Save(1, &fs.devMinor)
+	stateSinkObject.Save(2, &fs.conn)
+	stateSinkObject.Save(3, &fs.opts)
+	stateSinkObject.Save(4, &fs.umounted)
 }
 
-func (f *filesystem) afterLoad() {}
+func (fs *filesystem) afterLoad() {}
 
-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 (fs *filesystem) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &fs.Filesystem)
+	stateSourceObject.Load(1, &fs.devMinor)
+	stateSourceObject.Load(2, &fs.conn)
+	stateSourceObject.Load(3, &fs.opts)
+	stateSourceObject.Load(4, &fs.umounted)
 }
 
 func (i *inode) StateTypeName() string {
@@ -332,79 +332,79 @@ func (i *inode) StateLoad(stateSourceObject state.Source) {
 	stateSourceObject.Load(15, &i.link)
 }
 
-func (i *inodeRefs) StateTypeName() string {
+func (r *inodeRefs) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.inodeRefs"
 }
 
-func (i *inodeRefs) StateFields() []string {
+func (r *inodeRefs) StateFields() []string {
 	return []string{
 		"refCount",
 	}
 }
 
-func (i *inodeRefs) beforeSave() {}
+func (r *inodeRefs) beforeSave() {}
 
-func (i *inodeRefs) StateSave(stateSinkObject state.Sink) {
-	i.beforeSave()
-	stateSinkObject.Save(0, &i.refCount)
+func (r *inodeRefs) StateSave(stateSinkObject state.Sink) {
+	r.beforeSave()
+	stateSinkObject.Save(0, &r.refCount)
 }
 
-func (i *inodeRefs) afterLoad() {}
+func (r *inodeRefs) afterLoad() {}
 
-func (i *inodeRefs) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &i.refCount)
+func (r *inodeRefs) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &r.refCount)
 }
 
-func (r *requestList) StateTypeName() string {
+func (l *requestList) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestList"
 }
 
-func (r *requestList) StateFields() []string {
+func (l *requestList) StateFields() []string {
 	return []string{
 		"head",
 		"tail",
 	}
 }
 
-func (r *requestList) beforeSave() {}
+func (l *requestList) beforeSave() {}
 
-func (r *requestList) StateSave(stateSinkObject state.Sink) {
-	r.beforeSave()
-	stateSinkObject.Save(0, &r.head)
-	stateSinkObject.Save(1, &r.tail)
+func (l *requestList) StateSave(stateSinkObject state.Sink) {
+	l.beforeSave()
+	stateSinkObject.Save(0, &l.head)
+	stateSinkObject.Save(1, &l.tail)
 }
 
-func (r *requestList) afterLoad() {}
+func (l *requestList) afterLoad() {}
 
-func (r *requestList) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &r.head)
-	stateSourceObject.Load(1, &r.tail)
+func (l *requestList) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &l.head)
+	stateSourceObject.Load(1, &l.tail)
 }
 
-func (r *requestEntry) StateTypeName() string {
+func (e *requestEntry) StateTypeName() string {
 	return "pkg/sentry/fsimpl/fuse.requestEntry"
 }
 
-func (r *requestEntry) StateFields() []string {
+func (e *requestEntry) StateFields() []string {
 	return []string{
 		"next",
 		"prev",
 	}
 }
 
-func (r *requestEntry) beforeSave() {}
+func (e *requestEntry) beforeSave() {}
 
-func (r *requestEntry) StateSave(stateSinkObject state.Sink) {
-	r.beforeSave()
-	stateSinkObject.Save(0, &r.next)
-	stateSinkObject.Save(1, &r.prev)
+func (e *requestEntry) StateSave(stateSinkObject state.Sink) {
+	e.beforeSave()
+	stateSinkObject.Save(0, &e.next)
+	stateSinkObject.Save(1, &e.prev)
 }
 
-func (r *requestEntry) afterLoad() {}
+func (e *requestEntry) afterLoad() {}
 
-func (r *requestEntry) StateLoad(stateSourceObject state.Source) {
-	stateSourceObject.Load(0, &r.next)
-	stateSourceObject.Load(1, &r.prev)
+func (e *requestEntry) StateLoad(stateSourceObject state.Source) {
+	stateSourceObject.Load(0, &e.next)
+	stateSourceObject.Load(1, &e.prev)
 }
 
 func (r *Request) StateTypeName() string {