Merge release-20200608.0-119-g364ac92ba (automated)

1 files changed, 276 insertions, 105 deletions

diff --git a/pkg/sentry/fs/tty/tty_state_autogen.go b/pkg/sentry/fs/tty/tty_state_autogen.go
index 25d601072..e82ca45a3 100644
--- a/pkg/sentry/fs/tty/tty_state_autogen.go
+++ b/pkg/sentry/fs/tty/tty_state_autogen.go
@@ -6,205 +6,376 @@ import (
 	"gvisor.dev/gvisor/pkg/state"
 )
 
+func (x *dirInodeOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.dirInodeOperations"
+}
+
+func (x *dirInodeOperations) StateFields() []string {
+	return []string{
+		"InodeSimpleAttributes",
+		"msrc",
+		"master",
+		"slaves",
+		"dentryMap",
+		"next",
+	}
+}
+
 func (x *dirInodeOperations) beforeSave() {}
-func (x *dirInodeOperations) save(m state.Map) {
+
+func (x *dirInodeOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("InodeSimpleAttributes", &x.InodeSimpleAttributes)
-	m.Save("msrc", &x.msrc)
-	m.Save("master", &x.master)
-	m.Save("slaves", &x.slaves)
-	m.Save("dentryMap", &x.dentryMap)
-	m.Save("next", &x.next)
+	m.Save(0, &x.InodeSimpleAttributes)
+	m.Save(1, &x.msrc)
+	m.Save(2, &x.master)
+	m.Save(3, &x.slaves)
+	m.Save(4, &x.dentryMap)
+	m.Save(5, &x.next)
 }
 
 func (x *dirInodeOperations) afterLoad() {}
-func (x *dirInodeOperations) load(m state.Map) {
-	m.Load("InodeSimpleAttributes", &x.InodeSimpleAttributes)
-	m.Load("msrc", &x.msrc)
-	m.Load("master", &x.master)
-	m.Load("slaves", &x.slaves)
-	m.Load("dentryMap", &x.dentryMap)
-	m.Load("next", &x.next)
+
+func (x *dirInodeOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.InodeSimpleAttributes)
+	m.Load(1, &x.msrc)
+	m.Load(2, &x.master)
+	m.Load(3, &x.slaves)
+	m.Load(4, &x.dentryMap)
+	m.Load(5, &x.next)
+}
+
+func (x *dirFileOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.dirFileOperations"
+}
+
+func (x *dirFileOperations) StateFields() []string {
+	return []string{
+		"di",
+		"dirCursor",
+	}
 }
 
 func (x *dirFileOperations) beforeSave() {}
-func (x *dirFileOperations) save(m state.Map) {
+
+func (x *dirFileOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("di", &x.di)
-	m.Save("dirCursor", &x.dirCursor)
+	m.Save(0, &x.di)
+	m.Save(1, &x.dirCursor)
 }
 
 func (x *dirFileOperations) afterLoad() {}
-func (x *dirFileOperations) load(m state.Map) {
-	m.Load("di", &x.di)
-	m.Load("dirCursor", &x.dirCursor)
+
+func (x *dirFileOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.di)
+	m.Load(1, &x.dirCursor)
+}
+
+func (x *filesystem) StateTypeName() string {
+	return "pkg/sentry/fs/tty.filesystem"
+}
+
+func (x *filesystem) StateFields() []string {
+	return []string{}
 }
 
 func (x *filesystem) beforeSave() {}
-func (x *filesystem) save(m state.Map) {
+
+func (x *filesystem) StateSave(m state.Sink) {
 	x.beforeSave()
 }
 
 func (x *filesystem) afterLoad() {}
-func (x *filesystem) load(m state.Map) {
+
+func (x *filesystem) StateLoad(m state.Source) {
+}
+
+func (x *superOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.superOperations"
+}
+
+func (x *superOperations) StateFields() []string {
+	return []string{}
 }
 
 func (x *superOperations) beforeSave() {}
-func (x *superOperations) save(m state.Map) {
+
+func (x *superOperations) StateSave(m state.Sink) {
 	x.beforeSave()
 }
 
 func (x *superOperations) afterLoad() {}
-func (x *superOperations) load(m state.Map) {
+
+func (x *superOperations) StateLoad(m state.Source) {
+}
+
+func (x *lineDiscipline) StateTypeName() string {
+	return "pkg/sentry/fs/tty.lineDiscipline"
+}
+
+func (x *lineDiscipline) StateFields() []string {
+	return []string{
+		"size",
+		"inQueue",
+		"outQueue",
+		"termios",
+		"column",
+	}
 }
 
 func (x *lineDiscipline) beforeSave() {}
-func (x *lineDiscipline) save(m state.Map) {
+
+func (x *lineDiscipline) StateSave(m state.Sink) {
 	x.beforeSave()
 	if !state.IsZeroValue(&x.masterWaiter) {
-		m.Failf("masterWaiter is %#v, expected zero", &x.masterWaiter)
+		state.Failf("masterWaiter is %#v, expected zero", &x.masterWaiter)
 	}
 	if !state.IsZeroValue(&x.slaveWaiter) {
-		m.Failf("slaveWaiter is %#v, expected zero", &x.slaveWaiter)
+		state.Failf("slaveWaiter is %#v, expected zero", &x.slaveWaiter)
 	}
-	m.Save("size", &x.size)
-	m.Save("inQueue", &x.inQueue)
-	m.Save("outQueue", &x.outQueue)
-	m.Save("termios", &x.termios)
-	m.Save("column", &x.column)
+	m.Save(0, &x.size)
+	m.Save(1, &x.inQueue)
+	m.Save(2, &x.outQueue)
+	m.Save(3, &x.termios)
+	m.Save(4, &x.column)
 }
 
 func (x *lineDiscipline) afterLoad() {}
-func (x *lineDiscipline) load(m state.Map) {
-	m.Load("size", &x.size)
-	m.Load("inQueue", &x.inQueue)
-	m.Load("outQueue", &x.outQueue)
-	m.Load("termios", &x.termios)
-	m.Load("column", &x.column)
+
+func (x *lineDiscipline) StateLoad(m state.Source) {
+	m.Load(0, &x.size)
+	m.Load(1, &x.inQueue)
+	m.Load(2, &x.outQueue)
+	m.Load(3, &x.termios)
+	m.Load(4, &x.column)
+}
+
+func (x *outputQueueTransformer) StateTypeName() string {
+	return "pkg/sentry/fs/tty.outputQueueTransformer"
+}
+
+func (x *outputQueueTransformer) StateFields() []string {
+	return []string{}
 }
 
 func (x *outputQueueTransformer) beforeSave() {}
-func (x *outputQueueTransformer) save(m state.Map) {
+
+func (x *outputQueueTransformer) StateSave(m state.Sink) {
 	x.beforeSave()
 }
 
 func (x *outputQueueTransformer) afterLoad() {}
-func (x *outputQueueTransformer) load(m state.Map) {
+
+func (x *outputQueueTransformer) StateLoad(m state.Source) {
+}
+
+func (x *inputQueueTransformer) StateTypeName() string {
+	return "pkg/sentry/fs/tty.inputQueueTransformer"
+}
+
+func (x *inputQueueTransformer) StateFields() []string {
+	return []string{}
 }
 
 func (x *inputQueueTransformer) beforeSave() {}
-func (x *inputQueueTransformer) save(m state.Map) {
+
+func (x *inputQueueTransformer) StateSave(m state.Sink) {
 	x.beforeSave()
 }
 
 func (x *inputQueueTransformer) afterLoad() {}
-func (x *inputQueueTransformer) load(m state.Map) {
+
+func (x *inputQueueTransformer) StateLoad(m state.Source) {
+}
+
+func (x *masterInodeOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.masterInodeOperations"
+}
+
+func (x *masterInodeOperations) StateFields() []string {
+	return []string{
+		"SimpleFileInode",
+		"d",
+	}
 }
 
 func (x *masterInodeOperations) beforeSave() {}
-func (x *masterInodeOperations) save(m state.Map) {
+
+func (x *masterInodeOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("SimpleFileInode", &x.SimpleFileInode)
-	m.Save("d", &x.d)
+	m.Save(0, &x.SimpleFileInode)
+	m.Save(1, &x.d)
 }
 
 func (x *masterInodeOperations) afterLoad() {}
-func (x *masterInodeOperations) load(m state.Map) {
-	m.Load("SimpleFileInode", &x.SimpleFileInode)
-	m.Load("d", &x.d)
+
+func (x *masterInodeOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.SimpleFileInode)
+	m.Load(1, &x.d)
+}
+
+func (x *masterFileOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.masterFileOperations"
+}
+
+func (x *masterFileOperations) StateFields() []string {
+	return []string{
+		"d",
+		"t",
+	}
 }
 
 func (x *masterFileOperations) beforeSave() {}
-func (x *masterFileOperations) save(m state.Map) {
+
+func (x *masterFileOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("d", &x.d)
-	m.Save("t", &x.t)
+	m.Save(0, &x.d)
+	m.Save(1, &x.t)
 }
 
 func (x *masterFileOperations) afterLoad() {}
-func (x *masterFileOperations) load(m state.Map) {
-	m.Load("d", &x.d)
-	m.Load("t", &x.t)
+
+func (x *masterFileOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.d)
+	m.Load(1, &x.t)
+}
+
+func (x *queue) StateTypeName() string {
+	return "pkg/sentry/fs/tty.queue"
+}
+
+func (x *queue) StateFields() []string {
+	return []string{
+		"readBuf",
+		"waitBuf",
+		"waitBufLen",
+		"readable",
+		"transformer",
+	}
 }
 
 func (x *queue) beforeSave() {}
-func (x *queue) save(m state.Map) {
+
+func (x *queue) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("readBuf", &x.readBuf)
-	m.Save("waitBuf", &x.waitBuf)
-	m.Save("waitBufLen", &x.waitBufLen)
-	m.Save("readable", &x.readable)
-	m.Save("transformer", &x.transformer)
+	m.Save(0, &x.readBuf)
+	m.Save(1, &x.waitBuf)
+	m.Save(2, &x.waitBufLen)
+	m.Save(3, &x.readable)
+	m.Save(4, &x.transformer)
 }
 
 func (x *queue) afterLoad() {}
-func (x *queue) load(m state.Map) {
-	m.Load("readBuf", &x.readBuf)
-	m.Load("waitBuf", &x.waitBuf)
-	m.Load("waitBufLen", &x.waitBufLen)
-	m.Load("readable", &x.readable)
-	m.Load("transformer", &x.transformer)
+
+func (x *queue) StateLoad(m state.Source) {
+	m.Load(0, &x.readBuf)
+	m.Load(1, &x.waitBuf)
+	m.Load(2, &x.waitBufLen)
+	m.Load(3, &x.readable)
+	m.Load(4, &x.transformer)
+}
+
+func (x *slaveInodeOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.slaveInodeOperations"
+}
+
+func (x *slaveInodeOperations) StateFields() []string {
+	return []string{
+		"SimpleFileInode",
+		"d",
+		"t",
+	}
 }
 
 func (x *slaveInodeOperations) beforeSave() {}
-func (x *slaveInodeOperations) save(m state.Map) {
+
+func (x *slaveInodeOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("SimpleFileInode", &x.SimpleFileInode)
-	m.Save("d", &x.d)
-	m.Save("t", &x.t)
+	m.Save(0, &x.SimpleFileInode)
+	m.Save(1, &x.d)
+	m.Save(2, &x.t)
 }
 
 func (x *slaveInodeOperations) afterLoad() {}
-func (x *slaveInodeOperations) load(m state.Map) {
-	m.Load("SimpleFileInode", &x.SimpleFileInode)
-	m.Load("d", &x.d)
-	m.Load("t", &x.t)
+
+func (x *slaveInodeOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.SimpleFileInode)
+	m.Load(1, &x.d)
+	m.Load(2, &x.t)
+}
+
+func (x *slaveFileOperations) StateTypeName() string {
+	return "pkg/sentry/fs/tty.slaveFileOperations"
+}
+
+func (x *slaveFileOperations) StateFields() []string {
+	return []string{
+		"si",
+	}
 }
 
 func (x *slaveFileOperations) beforeSave() {}
-func (x *slaveFileOperations) save(m state.Map) {
+
+func (x *slaveFileOperations) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("si", &x.si)
+	m.Save(0, &x.si)
 }
 
 func (x *slaveFileOperations) afterLoad() {}
-func (x *slaveFileOperations) load(m state.Map) {
-	m.Load("si", &x.si)
+
+func (x *slaveFileOperations) StateLoad(m state.Source) {
+	m.Load(0, &x.si)
+}
+
+func (x *Terminal) StateTypeName() string {
+	return "pkg/sentry/fs/tty.Terminal"
+}
+
+func (x *Terminal) StateFields() []string {
+	return []string{
+		"AtomicRefCount",
+		"n",
+		"d",
+		"ld",
+		"masterKTTY",
+		"slaveKTTY",
+	}
 }
 
 func (x *Terminal) beforeSave() {}
-func (x *Terminal) save(m state.Map) {
+
+func (x *Terminal) StateSave(m state.Sink) {
 	x.beforeSave()
-	m.Save("AtomicRefCount", &x.AtomicRefCount)
-	m.Save("n", &x.n)
-	m.Save("d", &x.d)
-	m.Save("ld", &x.ld)
-	m.Save("masterKTTY", &x.masterKTTY)
-	m.Save("slaveKTTY", &x.slaveKTTY)
+	m.Save(0, &x.AtomicRefCount)
+	m.Save(1, &x.n)
+	m.Save(2, &x.d)
+	m.Save(3, &x.ld)
+	m.Save(4, &x.masterKTTY)
+	m.Save(5, &x.slaveKTTY)
 }
 
 func (x *Terminal) afterLoad() {}
-func (x *Terminal) load(m state.Map) {
-	m.Load("AtomicRefCount", &x.AtomicRefCount)
-	m.Load("n", &x.n)
-	m.Load("d", &x.d)
-	m.Load("ld", &x.ld)
-	m.Load("masterKTTY", &x.masterKTTY)
-	m.Load("slaveKTTY", &x.slaveKTTY)
+
+func (x *Terminal) StateLoad(m state.Source) {
+	m.Load(0, &x.AtomicRefCount)
+	m.Load(1, &x.n)
+	m.Load(2, &x.d)
+	m.Load(3, &x.ld)
+	m.Load(4, &x.masterKTTY)
+	m.Load(5, &x.slaveKTTY)
 }
 
 func init() {
-	state.Register("pkg/sentry/fs/tty.dirInodeOperations", (*dirInodeOperations)(nil), state.Fns{Save: (*dirInodeOperations).save, Load: (*dirInodeOperations).load})
-	state.Register("pkg/sentry/fs/tty.dirFileOperations", (*dirFileOperations)(nil), state.Fns{Save: (*dirFileOperations).save, Load: (*dirFileOperations).load})
-	state.Register("pkg/sentry/fs/tty.filesystem", (*filesystem)(nil), state.Fns{Save: (*filesystem).save, Load: (*filesystem).load})
-	state.Register("pkg/sentry/fs/tty.superOperations", (*superOperations)(nil), state.Fns{Save: (*superOperations).save, Load: (*superOperations).load})
-	state.Register("pkg/sentry/fs/tty.lineDiscipline", (*lineDiscipline)(nil), state.Fns{Save: (*lineDiscipline).save, Load: (*lineDiscipline).load})
-	state.Register("pkg/sentry/fs/tty.outputQueueTransformer", (*outputQueueTransformer)(nil), state.Fns{Save: (*outputQueueTransformer).save, Load: (*outputQueueTransformer).load})
-	state.Register("pkg/sentry/fs/tty.inputQueueTransformer", (*inputQueueTransformer)(nil), state.Fns{Save: (*inputQueueTransformer).save, Load: (*inputQueueTransformer).load})
-	state.Register("pkg/sentry/fs/tty.masterInodeOperations", (*masterInodeOperations)(nil), state.Fns{Save: (*masterInodeOperations).save, Load: (*masterInodeOperations).load})
-	state.Register("pkg/sentry/fs/tty.masterFileOperations", (*masterFileOperations)(nil), state.Fns{Save: (*masterFileOperations).save, Load: (*masterFileOperations).load})
-	state.Register("pkg/sentry/fs/tty.queue", (*queue)(nil), state.Fns{Save: (*queue).save, Load: (*queue).load})
-	state.Register("pkg/sentry/fs/tty.slaveInodeOperations", (*slaveInodeOperations)(nil), state.Fns{Save: (*slaveInodeOperations).save, Load: (*slaveInodeOperations).load})
-	state.Register("pkg/sentry/fs/tty.slaveFileOperations", (*slaveFileOperations)(nil), state.Fns{Save: (*slaveFileOperations).save, Load: (*slaveFileOperations).load})
-	state.Register("pkg/sentry/fs/tty.Terminal", (*Terminal)(nil), state.Fns{Save: (*Terminal).save, Load: (*Terminal).load})
+	state.Register((*dirInodeOperations)(nil))
+	state.Register((*dirFileOperations)(nil))
+	state.Register((*filesystem)(nil))
+	state.Register((*superOperations)(nil))
+	state.Register((*lineDiscipline)(nil))
+	state.Register((*outputQueueTransformer)(nil))
+	state.Register((*inputQueueTransformer)(nil))
+	state.Register((*masterInodeOperations)(nil))
+	state.Register((*masterFileOperations)(nil))
+	state.Register((*queue)(nil))
+	state.Register((*slaveInodeOperations)(nil))
+	state.Register((*slaveFileOperations)(nil))
+	state.Register((*Terminal)(nil))
 }