summaryrefslogtreecommitdiffhomepage
path: root/pkg/sentry/kernel
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/sentry/kernel')
-rw-r--r--pkg/sentry/kernel/auth/auth_state_autogen.go252
-rw-r--r--pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go20
-rw-r--r--pkg/sentry/kernel/epoll/epoll_state_autogen.go162
-rw-r--r--pkg/sentry/kernel/eventfd/eventfd_state_autogen.go30
-rw-r--r--pkg/sentry/kernel/fasync/fasync_state_autogen.go38
-rw-r--r--pkg/sentry/kernel/futex/futex_state_autogen.go84
-rw-r--r--pkg/sentry/kernel/futex/futex_unsafe_state_autogen.go20
-rw-r--r--pkg/sentry/kernel/kernel_opts_state_autogen.go14
-rw-r--r--pkg/sentry/kernel/kernel_state_autogen.go2214
-rw-r--r--pkg/sentry/kernel/pipe/pipe_state_autogen.go118
-rw-r--r--pkg/sentry/kernel/semaphore/semaphore_state_autogen.go176
-rw-r--r--pkg/sentry/kernel/shm/shm_state_autogen.go138
-rw-r--r--pkg/sentry/kernel/signalfd/signalfd_state_autogen.go22
-rw-r--r--pkg/sentry/kernel/time/time_state_autogen.go74
14 files changed, 1681 insertions, 1681 deletions
diff --git a/pkg/sentry/kernel/auth/auth_state_autogen.go b/pkg/sentry/kernel/auth/auth_state_autogen.go
index 7a710d06d..7381b79ea 100644
--- a/pkg/sentry/kernel/auth/auth_state_autogen.go
+++ b/pkg/sentry/kernel/auth/auth_state_autogen.go
@@ -6,11 +6,11 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *Credentials) StateTypeName() string {
+func (c *Credentials) StateTypeName() string {
return "pkg/sentry/kernel/auth.Credentials"
}
-func (x *Credentials) StateFields() []string {
+func (c *Credentials) StateFields() []string {
return []string{
"RealKUID",
"EffectiveKUID",
@@ -28,48 +28,48 @@ func (x *Credentials) StateFields() []string {
}
}
-func (x *Credentials) beforeSave() {}
-
-func (x *Credentials) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.RealKUID)
- m.Save(1, &x.EffectiveKUID)
- m.Save(2, &x.SavedKUID)
- m.Save(3, &x.RealKGID)
- m.Save(4, &x.EffectiveKGID)
- m.Save(5, &x.SavedKGID)
- m.Save(6, &x.ExtraKGIDs)
- m.Save(7, &x.PermittedCaps)
- m.Save(8, &x.InheritableCaps)
- m.Save(9, &x.EffectiveCaps)
- m.Save(10, &x.BoundingCaps)
- m.Save(11, &x.KeepCaps)
- m.Save(12, &x.UserNamespace)
+func (c *Credentials) beforeSave() {}
+
+func (c *Credentials) StateSave(stateSinkObject state.Sink) {
+ c.beforeSave()
+ stateSinkObject.Save(0, &c.RealKUID)
+ stateSinkObject.Save(1, &c.EffectiveKUID)
+ stateSinkObject.Save(2, &c.SavedKUID)
+ stateSinkObject.Save(3, &c.RealKGID)
+ stateSinkObject.Save(4, &c.EffectiveKGID)
+ stateSinkObject.Save(5, &c.SavedKGID)
+ stateSinkObject.Save(6, &c.ExtraKGIDs)
+ stateSinkObject.Save(7, &c.PermittedCaps)
+ stateSinkObject.Save(8, &c.InheritableCaps)
+ stateSinkObject.Save(9, &c.EffectiveCaps)
+ stateSinkObject.Save(10, &c.BoundingCaps)
+ stateSinkObject.Save(11, &c.KeepCaps)
+ stateSinkObject.Save(12, &c.UserNamespace)
}
-func (x *Credentials) afterLoad() {}
-
-func (x *Credentials) StateLoad(m state.Source) {
- m.Load(0, &x.RealKUID)
- m.Load(1, &x.EffectiveKUID)
- m.Load(2, &x.SavedKUID)
- m.Load(3, &x.RealKGID)
- m.Load(4, &x.EffectiveKGID)
- m.Load(5, &x.SavedKGID)
- m.Load(6, &x.ExtraKGIDs)
- m.Load(7, &x.PermittedCaps)
- m.Load(8, &x.InheritableCaps)
- m.Load(9, &x.EffectiveCaps)
- m.Load(10, &x.BoundingCaps)
- m.Load(11, &x.KeepCaps)
- m.Load(12, &x.UserNamespace)
+func (c *Credentials) afterLoad() {}
+
+func (c *Credentials) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &c.RealKUID)
+ stateSourceObject.Load(1, &c.EffectiveKUID)
+ stateSourceObject.Load(2, &c.SavedKUID)
+ stateSourceObject.Load(3, &c.RealKGID)
+ stateSourceObject.Load(4, &c.EffectiveKGID)
+ stateSourceObject.Load(5, &c.SavedKGID)
+ stateSourceObject.Load(6, &c.ExtraKGIDs)
+ stateSourceObject.Load(7, &c.PermittedCaps)
+ stateSourceObject.Load(8, &c.InheritableCaps)
+ stateSourceObject.Load(9, &c.EffectiveCaps)
+ stateSourceObject.Load(10, &c.BoundingCaps)
+ stateSourceObject.Load(11, &c.KeepCaps)
+ stateSourceObject.Load(12, &c.UserNamespace)
}
-func (x *IDMapEntry) StateTypeName() string {
+func (i *IDMapEntry) StateTypeName() string {
return "pkg/sentry/kernel/auth.IDMapEntry"
}
-func (x *IDMapEntry) StateFields() []string {
+func (i *IDMapEntry) StateFields() []string {
return []string{
"FirstID",
"FirstParentID",
@@ -77,78 +77,78 @@ func (x *IDMapEntry) StateFields() []string {
}
}
-func (x *IDMapEntry) beforeSave() {}
+func (i *IDMapEntry) beforeSave() {}
-func (x *IDMapEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.FirstID)
- m.Save(1, &x.FirstParentID)
- m.Save(2, &x.Length)
+func (i *IDMapEntry) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.FirstID)
+ stateSinkObject.Save(1, &i.FirstParentID)
+ stateSinkObject.Save(2, &i.Length)
}
-func (x *IDMapEntry) afterLoad() {}
+func (i *IDMapEntry) afterLoad() {}
-func (x *IDMapEntry) StateLoad(m state.Source) {
- m.Load(0, &x.FirstID)
- m.Load(1, &x.FirstParentID)
- m.Load(2, &x.Length)
+func (i *IDMapEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.FirstID)
+ stateSourceObject.Load(1, &i.FirstParentID)
+ stateSourceObject.Load(2, &i.Length)
}
-func (x *idMapRange) StateTypeName() string {
+func (i *idMapRange) StateTypeName() string {
return "pkg/sentry/kernel/auth.idMapRange"
}
-func (x *idMapRange) StateFields() []string {
+func (i *idMapRange) StateFields() []string {
return []string{
"Start",
"End",
}
}
-func (x *idMapRange) beforeSave() {}
+func (i *idMapRange) beforeSave() {}
-func (x *idMapRange) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Start)
- m.Save(1, &x.End)
+func (i *idMapRange) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.Start)
+ stateSinkObject.Save(1, &i.End)
}
-func (x *idMapRange) afterLoad() {}
+func (i *idMapRange) afterLoad() {}
-func (x *idMapRange) StateLoad(m state.Source) {
- m.Load(0, &x.Start)
- m.Load(1, &x.End)
+func (i *idMapRange) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.Start)
+ stateSourceObject.Load(1, &i.End)
}
-func (x *idMapSet) StateTypeName() string {
+func (i *idMapSet) StateTypeName() string {
return "pkg/sentry/kernel/auth.idMapSet"
}
-func (x *idMapSet) StateFields() []string {
+func (i *idMapSet) StateFields() []string {
return []string{
"root",
}
}
-func (x *idMapSet) beforeSave() {}
+func (i *idMapSet) beforeSave() {}
-func (x *idMapSet) StateSave(m state.Sink) {
- x.beforeSave()
- var root *idMapSegmentDataSlices = x.saveRoot()
- m.SaveValue(0, root)
+func (i *idMapSet) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ var rootValue *idMapSegmentDataSlices = i.saveRoot()
+ stateSinkObject.SaveValue(0, rootValue)
}
-func (x *idMapSet) afterLoad() {}
+func (i *idMapSet) afterLoad() {}
-func (x *idMapSet) StateLoad(m state.Source) {
- m.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { x.loadRoot(y.(*idMapSegmentDataSlices)) })
+func (i *idMapSet) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadValue(0, new(*idMapSegmentDataSlices), func(y interface{}) { i.loadRoot(y.(*idMapSegmentDataSlices)) })
}
-func (x *idMapnode) StateTypeName() string {
+func (i *idMapnode) StateTypeName() string {
return "pkg/sentry/kernel/auth.idMapnode"
}
-func (x *idMapnode) StateFields() []string {
+func (i *idMapnode) StateFields() []string {
return []string{
"nrSegments",
"parent",
@@ -161,38 +161,38 @@ func (x *idMapnode) StateFields() []string {
}
}
-func (x *idMapnode) beforeSave() {}
-
-func (x *idMapnode) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.nrSegments)
- m.Save(1, &x.parent)
- m.Save(2, &x.parentIndex)
- m.Save(3, &x.hasChildren)
- m.Save(4, &x.maxGap)
- m.Save(5, &x.keys)
- m.Save(6, &x.values)
- m.Save(7, &x.children)
+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 (x *idMapnode) afterLoad() {}
-
-func (x *idMapnode) StateLoad(m state.Source) {
- m.Load(0, &x.nrSegments)
- m.Load(1, &x.parent)
- m.Load(2, &x.parentIndex)
- m.Load(3, &x.hasChildren)
- m.Load(4, &x.maxGap)
- m.Load(5, &x.keys)
- m.Load(6, &x.values)
- m.Load(7, &x.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 (x *idMapSegmentDataSlices) StateTypeName() string {
+func (i *idMapSegmentDataSlices) StateTypeName() string {
return "pkg/sentry/kernel/auth.idMapSegmentDataSlices"
}
-func (x *idMapSegmentDataSlices) StateFields() []string {
+func (i *idMapSegmentDataSlices) StateFields() []string {
return []string{
"Start",
"End",
@@ -200,28 +200,28 @@ func (x *idMapSegmentDataSlices) StateFields() []string {
}
}
-func (x *idMapSegmentDataSlices) beforeSave() {}
+func (i *idMapSegmentDataSlices) beforeSave() {}
-func (x *idMapSegmentDataSlices) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Start)
- m.Save(1, &x.End)
- m.Save(2, &x.Values)
+func (i *idMapSegmentDataSlices) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.Start)
+ stateSinkObject.Save(1, &i.End)
+ stateSinkObject.Save(2, &i.Values)
}
-func (x *idMapSegmentDataSlices) afterLoad() {}
+func (i *idMapSegmentDataSlices) afterLoad() {}
-func (x *idMapSegmentDataSlices) StateLoad(m state.Source) {
- m.Load(0, &x.Start)
- m.Load(1, &x.End)
- m.Load(2, &x.Values)
+func (i *idMapSegmentDataSlices) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.Start)
+ stateSourceObject.Load(1, &i.End)
+ stateSourceObject.Load(2, &i.Values)
}
-func (x *UserNamespace) StateTypeName() string {
+func (u *UserNamespace) StateTypeName() string {
return "pkg/sentry/kernel/auth.UserNamespace"
}
-func (x *UserNamespace) StateFields() []string {
+func (u *UserNamespace) StateFields() []string {
return []string{
"parent",
"owner",
@@ -232,27 +232,27 @@ func (x *UserNamespace) StateFields() []string {
}
}
-func (x *UserNamespace) beforeSave() {}
+func (u *UserNamespace) beforeSave() {}
-func (x *UserNamespace) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.parent)
- m.Save(1, &x.owner)
- m.Save(2, &x.uidMapFromParent)
- m.Save(3, &x.uidMapToParent)
- m.Save(4, &x.gidMapFromParent)
- m.Save(5, &x.gidMapToParent)
+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 (x *UserNamespace) afterLoad() {}
+func (u *UserNamespace) afterLoad() {}
-func (x *UserNamespace) StateLoad(m state.Source) {
- m.Load(0, &x.parent)
- m.Load(1, &x.owner)
- m.Load(2, &x.uidMapFromParent)
- m.Load(3, &x.uidMapToParent)
- m.Load(4, &x.gidMapFromParent)
- m.Load(5, &x.gidMapToParent)
+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 init() {
diff --git a/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go b/pkg/sentry/kernel/auth/auth_unsafe_state_autogen.go
index 0a3507dd5..4002e0cb2 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 (x *AtomicPtrCredentials) StateTypeName() string {
+func (a *AtomicPtrCredentials) StateTypeName() string {
return "pkg/sentry/kernel/auth.AtomicPtrCredentials"
}
-func (x *AtomicPtrCredentials) StateFields() []string {
+func (a *AtomicPtrCredentials) StateFields() []string {
return []string{
"ptr",
}
}
-func (x *AtomicPtrCredentials) beforeSave() {}
+func (a *AtomicPtrCredentials) beforeSave() {}
-func (x *AtomicPtrCredentials) StateSave(m state.Sink) {
- x.beforeSave()
- var ptr *Credentials = x.savePtr()
- m.SaveValue(0, ptr)
+func (a *AtomicPtrCredentials) StateSave(stateSinkObject state.Sink) {
+ a.beforeSave()
+ var ptrValue *Credentials = a.savePtr()
+ stateSinkObject.SaveValue(0, ptrValue)
}
-func (x *AtomicPtrCredentials) afterLoad() {}
+func (a *AtomicPtrCredentials) afterLoad() {}
-func (x *AtomicPtrCredentials) StateLoad(m state.Source) {
- m.LoadValue(0, new(*Credentials), func(y interface{}) { x.loadPtr(y.(*Credentials)) })
+func (a *AtomicPtrCredentials) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadValue(0, new(*Credentials), func(y interface{}) { a.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 3b9d76751..cdeadd3e1 100644
--- a/pkg/sentry/kernel/epoll/epoll_state_autogen.go
+++ b/pkg/sentry/kernel/epoll/epoll_state_autogen.go
@@ -6,37 +6,37 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *FileIdentifier) StateTypeName() string {
+func (f *FileIdentifier) StateTypeName() string {
return "pkg/sentry/kernel/epoll.FileIdentifier"
}
-func (x *FileIdentifier) StateFields() []string {
+func (f *FileIdentifier) StateFields() []string {
return []string{
"File",
"Fd",
}
}
-func (x *FileIdentifier) beforeSave() {}
+func (f *FileIdentifier) beforeSave() {}
-func (x *FileIdentifier) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.File)
- m.Save(1, &x.Fd)
+func (f *FileIdentifier) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.File)
+ stateSinkObject.Save(1, &f.Fd)
}
-func (x *FileIdentifier) afterLoad() {}
+func (f *FileIdentifier) afterLoad() {}
-func (x *FileIdentifier) StateLoad(m state.Source) {
- m.LoadWait(0, &x.File)
- m.Load(1, &x.Fd)
+func (f *FileIdentifier) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadWait(0, &f.File)
+ stateSourceObject.Load(1, &f.Fd)
}
-func (x *pollEntry) StateTypeName() string {
+func (p *pollEntry) StateTypeName() string {
return "pkg/sentry/kernel/epoll.pollEntry"
}
-func (x *pollEntry) StateFields() []string {
+func (p *pollEntry) StateFields() []string {
return []string{
"pollEntryEntry",
"id",
@@ -47,33 +47,33 @@ func (x *pollEntry) StateFields() []string {
}
}
-func (x *pollEntry) beforeSave() {}
+func (p *pollEntry) beforeSave() {}
-func (x *pollEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.pollEntryEntry)
- m.Save(1, &x.id)
- m.Save(2, &x.userData)
- m.Save(3, &x.mask)
- m.Save(4, &x.flags)
- m.Save(5, &x.epoll)
+func (p *pollEntry) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.pollEntryEntry)
+ stateSinkObject.Save(1, &p.id)
+ stateSinkObject.Save(2, &p.userData)
+ stateSinkObject.Save(3, &p.mask)
+ stateSinkObject.Save(4, &p.flags)
+ stateSinkObject.Save(5, &p.epoll)
}
-func (x *pollEntry) StateLoad(m state.Source) {
- m.Load(0, &x.pollEntryEntry)
- m.LoadWait(1, &x.id)
- m.Load(2, &x.userData)
- m.Load(3, &x.mask)
- m.Load(4, &x.flags)
- m.Load(5, &x.epoll)
- m.AfterLoad(x.afterLoad)
+func (p *pollEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.pollEntryEntry)
+ stateSourceObject.LoadWait(1, &p.id)
+ stateSourceObject.Load(2, &p.userData)
+ stateSourceObject.Load(3, &p.mask)
+ stateSourceObject.Load(4, &p.flags)
+ stateSourceObject.Load(5, &p.epoll)
+ stateSourceObject.AfterLoad(p.afterLoad)
}
-func (x *EventPoll) StateTypeName() string {
+func (e *EventPoll) StateTypeName() string {
return "pkg/sentry/kernel/epoll.EventPoll"
}
-func (x *EventPoll) StateFields() []string {
+func (e *EventPoll) StateFields() []string {
return []string{
"files",
"readyList",
@@ -82,95 +82,95 @@ func (x *EventPoll) StateFields() []string {
}
}
-func (x *EventPoll) beforeSave() {}
+func (e *EventPoll) beforeSave() {}
-func (x *EventPoll) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.FilePipeSeek) {
- state.Failf("FilePipeSeek is %#v, expected zero", &x.FilePipeSeek)
+func (e *EventPoll) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ if !state.IsZeroValue(&e.FilePipeSeek) {
+ state.Failf("FilePipeSeek is %#v, expected zero", &e.FilePipeSeek)
}
- if !state.IsZeroValue(&x.FileNotDirReaddir) {
- state.Failf("FileNotDirReaddir is %#v, expected zero", &x.FileNotDirReaddir)
+ if !state.IsZeroValue(&e.FileNotDirReaddir) {
+ state.Failf("FileNotDirReaddir is %#v, expected zero", &e.FileNotDirReaddir)
}
- if !state.IsZeroValue(&x.FileNoFsync) {
- state.Failf("FileNoFsync is %#v, expected zero", &x.FileNoFsync)
+ if !state.IsZeroValue(&e.FileNoFsync) {
+ state.Failf("FileNoFsync is %#v, expected zero", &e.FileNoFsync)
}
- if !state.IsZeroValue(&x.FileNoopFlush) {
- state.Failf("FileNoopFlush is %#v, expected zero", &x.FileNoopFlush)
+ if !state.IsZeroValue(&e.FileNoopFlush) {
+ state.Failf("FileNoopFlush is %#v, expected zero", &e.FileNoopFlush)
}
- if !state.IsZeroValue(&x.FileNoIoctl) {
- state.Failf("FileNoIoctl is %#v, expected zero", &x.FileNoIoctl)
+ if !state.IsZeroValue(&e.FileNoIoctl) {
+ state.Failf("FileNoIoctl is %#v, expected zero", &e.FileNoIoctl)
}
- if !state.IsZeroValue(&x.FileNoMMap) {
- state.Failf("FileNoMMap is %#v, expected zero", &x.FileNoMMap)
+ if !state.IsZeroValue(&e.FileNoMMap) {
+ state.Failf("FileNoMMap is %#v, expected zero", &e.FileNoMMap)
}
- if !state.IsZeroValue(&x.Queue) {
- state.Failf("Queue is %#v, expected zero", &x.Queue)
+ if !state.IsZeroValue(&e.Queue) {
+ state.Failf("Queue is %#v, expected zero", &e.Queue)
}
- m.Save(0, &x.files)
- m.Save(1, &x.readyList)
- m.Save(2, &x.waitingList)
- m.Save(3, &x.disabledList)
+ stateSinkObject.Save(0, &e.files)
+ stateSinkObject.Save(1, &e.readyList)
+ stateSinkObject.Save(2, &e.waitingList)
+ stateSinkObject.Save(3, &e.disabledList)
}
-func (x *EventPoll) StateLoad(m state.Source) {
- m.Load(0, &x.files)
- m.Load(1, &x.readyList)
- m.Load(2, &x.waitingList)
- m.Load(3, &x.disabledList)
- m.AfterLoad(x.afterLoad)
+func (e *EventPoll) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.files)
+ stateSourceObject.Load(1, &e.readyList)
+ stateSourceObject.Load(2, &e.waitingList)
+ stateSourceObject.Load(3, &e.disabledList)
+ stateSourceObject.AfterLoad(e.afterLoad)
}
-func (x *pollEntryList) StateTypeName() string {
+func (p *pollEntryList) StateTypeName() string {
return "pkg/sentry/kernel/epoll.pollEntryList"
}
-func (x *pollEntryList) StateFields() []string {
+func (p *pollEntryList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *pollEntryList) beforeSave() {}
+func (p *pollEntryList) beforeSave() {}
-func (x *pollEntryList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (p *pollEntryList) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.head)
+ stateSinkObject.Save(1, &p.tail)
}
-func (x *pollEntryList) afterLoad() {}
+func (p *pollEntryList) afterLoad() {}
-func (x *pollEntryList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (p *pollEntryList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.head)
+ stateSourceObject.Load(1, &p.tail)
}
-func (x *pollEntryEntry) StateTypeName() string {
+func (p *pollEntryEntry) StateTypeName() string {
return "pkg/sentry/kernel/epoll.pollEntryEntry"
}
-func (x *pollEntryEntry) StateFields() []string {
+func (p *pollEntryEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *pollEntryEntry) beforeSave() {}
+func (p *pollEntryEntry) beforeSave() {}
-func (x *pollEntryEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (p *pollEntryEntry) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.next)
+ stateSinkObject.Save(1, &p.prev)
}
-func (x *pollEntryEntry) afterLoad() {}
+func (p *pollEntryEntry) afterLoad() {}
-func (x *pollEntryEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (p *pollEntryEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.next)
+ stateSourceObject.Load(1, &p.prev)
}
func init() {
diff --git a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
index 72a285daa..336262eed 100644
--- a/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
+++ b/pkg/sentry/kernel/eventfd/eventfd_state_autogen.go
@@ -6,11 +6,11 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *EventOperations) StateTypeName() string {
+func (e *EventOperations) StateTypeName() string {
return "pkg/sentry/kernel/eventfd.EventOperations"
}
-func (x *EventOperations) StateFields() []string {
+func (e *EventOperations) StateFields() []string {
return []string{
"val",
"semMode",
@@ -18,24 +18,24 @@ func (x *EventOperations) StateFields() []string {
}
}
-func (x *EventOperations) beforeSave() {}
+func (e *EventOperations) beforeSave() {}
-func (x *EventOperations) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.wq) {
- state.Failf("wq is %#v, expected zero", &x.wq)
+func (e *EventOperations) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ if !state.IsZeroValue(&e.wq) {
+ state.Failf("wq is %#v, expected zero", &e.wq)
}
- m.Save(0, &x.val)
- m.Save(1, &x.semMode)
- m.Save(2, &x.hostfd)
+ stateSinkObject.Save(0, &e.val)
+ stateSinkObject.Save(1, &e.semMode)
+ stateSinkObject.Save(2, &e.hostfd)
}
-func (x *EventOperations) afterLoad() {}
+func (e *EventOperations) afterLoad() {}
-func (x *EventOperations) StateLoad(m state.Source) {
- m.Load(0, &x.val)
- m.Load(1, &x.semMode)
- m.Load(2, &x.hostfd)
+func (e *EventOperations) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.val)
+ stateSourceObject.Load(1, &e.semMode)
+ stateSourceObject.Load(2, &e.hostfd)
}
func init() {
diff --git a/pkg/sentry/kernel/fasync/fasync_state_autogen.go b/pkg/sentry/kernel/fasync/fasync_state_autogen.go
index 8da4a1b44..e4a0b5695 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 (x *FileAsync) StateTypeName() string {
+func (f *FileAsync) StateTypeName() string {
return "pkg/sentry/kernel/fasync.FileAsync"
}
-func (x *FileAsync) StateFields() []string {
+func (f *FileAsync) StateFields() []string {
return []string{
"e",
"requester",
@@ -21,27 +21,27 @@ func (x *FileAsync) StateFields() []string {
}
}
-func (x *FileAsync) beforeSave() {}
+func (f *FileAsync) beforeSave() {}
-func (x *FileAsync) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.e)
- m.Save(1, &x.requester)
- m.Save(2, &x.registered)
- m.Save(3, &x.recipientPG)
- m.Save(4, &x.recipientTG)
- m.Save(5, &x.recipientT)
+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 (x *FileAsync) afterLoad() {}
+func (f *FileAsync) afterLoad() {}
-func (x *FileAsync) StateLoad(m state.Source) {
- m.Load(0, &x.e)
- m.Load(1, &x.requester)
- m.Load(2, &x.registered)
- m.Load(3, &x.recipientPG)
- m.Load(4, &x.recipientTG)
- m.Load(5, &x.recipientT)
+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 init() {
diff --git a/pkg/sentry/kernel/futex/futex_state_autogen.go b/pkg/sentry/kernel/futex/futex_state_autogen.go
index 13e9a97d0..f36f5ccfc 100644
--- a/pkg/sentry/kernel/futex/futex_state_autogen.go
+++ b/pkg/sentry/kernel/futex/futex_state_autogen.go
@@ -6,104 +6,104 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *bucket) StateTypeName() string {
+func (b *bucket) StateTypeName() string {
return "pkg/sentry/kernel/futex.bucket"
}
-func (x *bucket) StateFields() []string {
+func (b *bucket) StateFields() []string {
return []string{}
}
-func (x *bucket) beforeSave() {}
+func (b *bucket) beforeSave() {}
-func (x *bucket) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.waiters) {
- state.Failf("waiters is %#v, expected zero", &x.waiters)
+func (b *bucket) StateSave(stateSinkObject state.Sink) {
+ b.beforeSave()
+ if !state.IsZeroValue(&b.waiters) {
+ state.Failf("waiters is %#v, expected zero", &b.waiters)
}
}
-func (x *bucket) afterLoad() {}
+func (b *bucket) afterLoad() {}
-func (x *bucket) StateLoad(m state.Source) {
+func (b *bucket) StateLoad(stateSourceObject state.Source) {
}
-func (x *Manager) StateTypeName() string {
+func (m *Manager) StateTypeName() string {
return "pkg/sentry/kernel/futex.Manager"
}
-func (x *Manager) StateFields() []string {
+func (m *Manager) StateFields() []string {
return []string{
"sharedBucket",
}
}
-func (x *Manager) beforeSave() {}
+func (m *Manager) beforeSave() {}
-func (x *Manager) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.privateBuckets) {
- state.Failf("privateBuckets is %#v, expected zero", &x.privateBuckets)
+func (m *Manager) StateSave(stateSinkObject state.Sink) {
+ m.beforeSave()
+ if !state.IsZeroValue(&m.privateBuckets) {
+ state.Failf("privateBuckets is %#v, expected zero", &m.privateBuckets)
}
- m.Save(0, &x.sharedBucket)
+ stateSinkObject.Save(0, &m.sharedBucket)
}
-func (x *Manager) afterLoad() {}
+func (m *Manager) afterLoad() {}
-func (x *Manager) StateLoad(m state.Source) {
- m.Load(0, &x.sharedBucket)
+func (m *Manager) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &m.sharedBucket)
}
-func (x *waiterList) StateTypeName() string {
+func (w *waiterList) StateTypeName() string {
return "pkg/sentry/kernel/futex.waiterList"
}
-func (x *waiterList) StateFields() []string {
+func (w *waiterList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *waiterList) beforeSave() {}
+func (w *waiterList) beforeSave() {}
-func (x *waiterList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (w *waiterList) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.head)
+ stateSinkObject.Save(1, &w.tail)
}
-func (x *waiterList) afterLoad() {}
+func (w *waiterList) afterLoad() {}
-func (x *waiterList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (w *waiterList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.head)
+ stateSourceObject.Load(1, &w.tail)
}
-func (x *waiterEntry) StateTypeName() string {
+func (w *waiterEntry) StateTypeName() string {
return "pkg/sentry/kernel/futex.waiterEntry"
}
-func (x *waiterEntry) StateFields() []string {
+func (w *waiterEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *waiterEntry) beforeSave() {}
+func (w *waiterEntry) beforeSave() {}
-func (x *waiterEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.next)
+ stateSinkObject.Save(1, &w.prev)
}
-func (x *waiterEntry) afterLoad() {}
+func (w *waiterEntry) afterLoad() {}
-func (x *waiterEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.next)
+ stateSourceObject.Load(1, &w.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 244cdb502..6a9953ffa 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 (x *AtomicPtrBucket) StateTypeName() string {
+func (a *AtomicPtrBucket) StateTypeName() string {
return "pkg/sentry/kernel/futex.AtomicPtrBucket"
}
-func (x *AtomicPtrBucket) StateFields() []string {
+func (a *AtomicPtrBucket) StateFields() []string {
return []string{
"ptr",
}
}
-func (x *AtomicPtrBucket) beforeSave() {}
+func (a *AtomicPtrBucket) beforeSave() {}
-func (x *AtomicPtrBucket) StateSave(m state.Sink) {
- x.beforeSave()
- var ptr *bucket = x.savePtr()
- m.SaveValue(0, ptr)
+func (a *AtomicPtrBucket) StateSave(stateSinkObject state.Sink) {
+ a.beforeSave()
+ var ptrValue *bucket = a.savePtr()
+ stateSinkObject.SaveValue(0, ptrValue)
}
-func (x *AtomicPtrBucket) afterLoad() {}
+func (a *AtomicPtrBucket) afterLoad() {}
-func (x *AtomicPtrBucket) StateLoad(m state.Source) {
- m.LoadValue(0, new(*bucket), func(y interface{}) { x.loadPtr(y.(*bucket)) })
+func (a *AtomicPtrBucket) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadValue(0, new(*bucket), func(y interface{}) { a.loadPtr(y.(*bucket)) })
}
func init() {
diff --git a/pkg/sentry/kernel/kernel_opts_state_autogen.go b/pkg/sentry/kernel/kernel_opts_state_autogen.go
index a01604159..7780c995f 100644
--- a/pkg/sentry/kernel/kernel_opts_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_opts_state_autogen.go
@@ -6,23 +6,23 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *SpecialOpts) StateTypeName() string {
+func (s *SpecialOpts) StateTypeName() string {
return "pkg/sentry/kernel.SpecialOpts"
}
-func (x *SpecialOpts) StateFields() []string {
+func (s *SpecialOpts) StateFields() []string {
return []string{}
}
-func (x *SpecialOpts) beforeSave() {}
+func (s *SpecialOpts) beforeSave() {}
-func (x *SpecialOpts) StateSave(m state.Sink) {
- x.beforeSave()
+func (s *SpecialOpts) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
}
-func (x *SpecialOpts) afterLoad() {}
+func (s *SpecialOpts) afterLoad() {}
-func (x *SpecialOpts) StateLoad(m state.Source) {
+func (s *SpecialOpts) StateLoad(stateSourceObject state.Source) {
}
func init() {
diff --git a/pkg/sentry/kernel/kernel_state_autogen.go b/pkg/sentry/kernel/kernel_state_autogen.go
index 7ff5e1eb9..101c137de 100644
--- a/pkg/sentry/kernel/kernel_state_autogen.go
+++ b/pkg/sentry/kernel/kernel_state_autogen.go
@@ -9,11 +9,11 @@ import (
"gvisor.dev/gvisor/pkg/tcpip"
)
-func (x *abstractEndpoint) StateTypeName() string {
+func (a *abstractEndpoint) StateTypeName() string {
return "pkg/sentry/kernel.abstractEndpoint"
}
-func (x *abstractEndpoint) StateFields() []string {
+func (a *abstractEndpoint) StateFields() []string {
return []string{
"ep",
"socket",
@@ -22,76 +22,76 @@ func (x *abstractEndpoint) StateFields() []string {
}
}
-func (x *abstractEndpoint) beforeSave() {}
+func (a *abstractEndpoint) beforeSave() {}
-func (x *abstractEndpoint) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ep)
- m.Save(1, &x.socket)
- m.Save(2, &x.name)
- m.Save(3, &x.ns)
+func (a *abstractEndpoint) StateSave(stateSinkObject state.Sink) {
+ a.beforeSave()
+ stateSinkObject.Save(0, &a.ep)
+ stateSinkObject.Save(1, &a.socket)
+ stateSinkObject.Save(2, &a.name)
+ stateSinkObject.Save(3, &a.ns)
}
-func (x *abstractEndpoint) afterLoad() {}
+func (a *abstractEndpoint) afterLoad() {}
-func (x *abstractEndpoint) StateLoad(m state.Source) {
- m.Load(0, &x.ep)
- m.Load(1, &x.socket)
- m.Load(2, &x.name)
- m.Load(3, &x.ns)
+func (a *abstractEndpoint) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &a.ep)
+ stateSourceObject.Load(1, &a.socket)
+ stateSourceObject.Load(2, &a.name)
+ stateSourceObject.Load(3, &a.ns)
}
-func (x *AbstractSocketNamespace) StateTypeName() string {
+func (a *AbstractSocketNamespace) StateTypeName() string {
return "pkg/sentry/kernel.AbstractSocketNamespace"
}
-func (x *AbstractSocketNamespace) StateFields() []string {
+func (a *AbstractSocketNamespace) StateFields() []string {
return []string{
"endpoints",
}
}
-func (x *AbstractSocketNamespace) beforeSave() {}
+func (a *AbstractSocketNamespace) beforeSave() {}
-func (x *AbstractSocketNamespace) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.endpoints)
+func (a *AbstractSocketNamespace) StateSave(stateSinkObject state.Sink) {
+ a.beforeSave()
+ stateSinkObject.Save(0, &a.endpoints)
}
-func (x *AbstractSocketNamespace) afterLoad() {}
+func (a *AbstractSocketNamespace) afterLoad() {}
-func (x *AbstractSocketNamespace) StateLoad(m state.Source) {
- m.Load(0, &x.endpoints)
+func (a *AbstractSocketNamespace) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &a.endpoints)
}
-func (x *FDFlags) StateTypeName() string {
+func (f *FDFlags) StateTypeName() string {
return "pkg/sentry/kernel.FDFlags"
}
-func (x *FDFlags) StateFields() []string {
+func (f *FDFlags) StateFields() []string {
return []string{
"CloseOnExec",
}
}
-func (x *FDFlags) beforeSave() {}
+func (f *FDFlags) beforeSave() {}
-func (x *FDFlags) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.CloseOnExec)
+func (f *FDFlags) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.CloseOnExec)
}
-func (x *FDFlags) afterLoad() {}
+func (f *FDFlags) afterLoad() {}
-func (x *FDFlags) StateLoad(m state.Source) {
- m.Load(0, &x.CloseOnExec)
+func (f *FDFlags) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.CloseOnExec)
}
-func (x *descriptor) StateTypeName() string {
+func (d *descriptor) StateTypeName() string {
return "pkg/sentry/kernel.descriptor"
}
-func (x *descriptor) StateFields() []string {
+func (d *descriptor) StateFields() []string {
return []string{
"file",
"fileVFS2",
@@ -99,28 +99,28 @@ func (x *descriptor) StateFields() []string {
}
}
-func (x *descriptor) beforeSave() {}
+func (d *descriptor) beforeSave() {}
-func (x *descriptor) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.file)
- m.Save(1, &x.fileVFS2)
- m.Save(2, &x.flags)
+func (d *descriptor) StateSave(stateSinkObject state.Sink) {
+ d.beforeSave()
+ stateSinkObject.Save(0, &d.file)
+ stateSinkObject.Save(1, &d.fileVFS2)
+ stateSinkObject.Save(2, &d.flags)
}
-func (x *descriptor) afterLoad() {}
+func (d *descriptor) afterLoad() {}
-func (x *descriptor) StateLoad(m state.Source) {
- m.Load(0, &x.file)
- m.Load(1, &x.fileVFS2)
- m.Load(2, &x.flags)
+func (d *descriptor) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &d.file)
+ stateSourceObject.Load(1, &d.fileVFS2)
+ stateSourceObject.Load(2, &d.flags)
}
-func (x *FDTable) StateTypeName() string {
+func (f *FDTable) StateTypeName() string {
return "pkg/sentry/kernel.FDTable"
}
-func (x *FDTable) StateFields() []string {
+func (f *FDTable) StateFields() []string {
return []string{
"FDTableRefs",
"k",
@@ -130,56 +130,56 @@ func (x *FDTable) StateFields() []string {
}
}
-func (x *FDTable) beforeSave() {}
+func (f *FDTable) beforeSave() {}
-func (x *FDTable) StateSave(m state.Sink) {
- x.beforeSave()
- var descriptorTable map[int32]descriptor = x.saveDescriptorTable()
- m.SaveValue(4, descriptorTable)
- m.Save(0, &x.FDTableRefs)
- m.Save(1, &x.k)
- m.Save(2, &x.next)
- m.Save(3, &x.used)
+func (f *FDTable) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ var descriptorTableValue map[int32]descriptor = f.saveDescriptorTable()
+ stateSinkObject.SaveValue(4, descriptorTableValue)
+ stateSinkObject.Save(0, &f.FDTableRefs)
+ stateSinkObject.Save(1, &f.k)
+ stateSinkObject.Save(2, &f.next)
+ stateSinkObject.Save(3, &f.used)
}
-func (x *FDTable) afterLoad() {}
+func (f *FDTable) afterLoad() {}
-func (x *FDTable) StateLoad(m state.Source) {
- m.Load(0, &x.FDTableRefs)
- m.Load(1, &x.k)
- m.Load(2, &x.next)
- m.Load(3, &x.used)
- m.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { x.loadDescriptorTable(y.(map[int32]descriptor)) })
+func (f *FDTable) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.FDTableRefs)
+ stateSourceObject.Load(1, &f.k)
+ stateSourceObject.Load(2, &f.next)
+ stateSourceObject.Load(3, &f.used)
+ stateSourceObject.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { f.loadDescriptorTable(y.(map[int32]descriptor)) })
}
-func (x *FDTableRefs) StateTypeName() string {
+func (f *FDTableRefs) StateTypeName() string {
return "pkg/sentry/kernel.FDTableRefs"
}
-func (x *FDTableRefs) StateFields() []string {
+func (f *FDTableRefs) StateFields() []string {
return []string{
"refCount",
}
}
-func (x *FDTableRefs) beforeSave() {}
+func (f *FDTableRefs) beforeSave() {}
-func (x *FDTableRefs) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refCount)
+func (f *FDTableRefs) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.refCount)
}
-func (x *FDTableRefs) afterLoad() {}
+func (f *FDTableRefs) afterLoad() {}
-func (x *FDTableRefs) StateLoad(m state.Source) {
- m.Load(0, &x.refCount)
+func (f *FDTableRefs) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.refCount)
}
-func (x *FSContext) StateTypeName() string {
+func (f *FSContext) StateTypeName() string {
return "pkg/sentry/kernel.FSContext"
}
-func (x *FSContext) StateFields() []string {
+func (f *FSContext) StateFields() []string {
return []string{
"FSContextRefs",
"root",
@@ -190,57 +190,57 @@ func (x *FSContext) StateFields() []string {
}
}
-func (x *FSContext) beforeSave() {}
+func (f *FSContext) beforeSave() {}
-func (x *FSContext) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.FSContextRefs)
- m.Save(1, &x.root)
- m.Save(2, &x.rootVFS2)
- m.Save(3, &x.cwd)
- m.Save(4, &x.cwdVFS2)
- m.Save(5, &x.umask)
+func (f *FSContext) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.FSContextRefs)
+ stateSinkObject.Save(1, &f.root)
+ stateSinkObject.Save(2, &f.rootVFS2)
+ stateSinkObject.Save(3, &f.cwd)
+ stateSinkObject.Save(4, &f.cwdVFS2)
+ stateSinkObject.Save(5, &f.umask)
}
-func (x *FSContext) afterLoad() {}
+func (f *FSContext) afterLoad() {}
-func (x *FSContext) StateLoad(m state.Source) {
- m.Load(0, &x.FSContextRefs)
- m.Load(1, &x.root)
- m.Load(2, &x.rootVFS2)
- m.Load(3, &x.cwd)
- m.Load(4, &x.cwdVFS2)
- m.Load(5, &x.umask)
+func (f *FSContext) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.FSContextRefs)
+ stateSourceObject.Load(1, &f.root)
+ stateSourceObject.Load(2, &f.rootVFS2)
+ stateSourceObject.Load(3, &f.cwd)
+ stateSourceObject.Load(4, &f.cwdVFS2)
+ stateSourceObject.Load(5, &f.umask)
}
-func (x *FSContextRefs) StateTypeName() string {
+func (f *FSContextRefs) StateTypeName() string {
return "pkg/sentry/kernel.FSContextRefs"
}
-func (x *FSContextRefs) StateFields() []string {
+func (f *FSContextRefs) StateFields() []string {
return []string{
"refCount",
}
}
-func (x *FSContextRefs) beforeSave() {}
+func (f *FSContextRefs) beforeSave() {}
-func (x *FSContextRefs) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refCount)
+func (f *FSContextRefs) StateSave(stateSinkObject state.Sink) {
+ f.beforeSave()
+ stateSinkObject.Save(0, &f.refCount)
}
-func (x *FSContextRefs) afterLoad() {}
+func (f *FSContextRefs) afterLoad() {}
-func (x *FSContextRefs) StateLoad(m state.Source) {
- m.Load(0, &x.refCount)
+func (f *FSContextRefs) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &f.refCount)
}
-func (x *IPCNamespace) StateTypeName() string {
+func (i *IPCNamespace) StateTypeName() string {
return "pkg/sentry/kernel.IPCNamespace"
}
-func (x *IPCNamespace) StateFields() []string {
+func (i *IPCNamespace) StateFields() []string {
return []string{
"userNS",
"semaphores",
@@ -248,28 +248,28 @@ func (x *IPCNamespace) StateFields() []string {
}
}
-func (x *IPCNamespace) beforeSave() {}
+func (i *IPCNamespace) beforeSave() {}
-func (x *IPCNamespace) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.userNS)
- m.Save(1, &x.semaphores)
- m.Save(2, &x.shms)
+func (i *IPCNamespace) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.userNS)
+ stateSinkObject.Save(1, &i.semaphores)
+ stateSinkObject.Save(2, &i.shms)
}
-func (x *IPCNamespace) afterLoad() {}
+func (i *IPCNamespace) afterLoad() {}
-func (x *IPCNamespace) StateLoad(m state.Source) {
- m.Load(0, &x.userNS)
- m.Load(1, &x.semaphores)
- m.Load(2, &x.shms)
+func (i *IPCNamespace) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.userNS)
+ stateSourceObject.Load(1, &i.semaphores)
+ stateSourceObject.Load(2, &i.shms)
}
-func (x *Kernel) StateTypeName() string {
+func (k *Kernel) StateTypeName() string {
return "pkg/sentry/kernel.Kernel"
}
-func (x *Kernel) StateFields() []string {
+func (k *Kernel) StateFields() []string {
return []string{
"featureSet",
"timekeeper",
@@ -311,98 +311,98 @@ func (x *Kernel) StateFields() []string {
}
}
-func (x *Kernel) beforeSave() {}
-
-func (x *Kernel) StateSave(m state.Sink) {
- x.beforeSave()
- var danglingEndpoints []tcpip.Endpoint = x.saveDanglingEndpoints()
- m.SaveValue(24, danglingEndpoints)
- var deviceRegistry *device.Registry = x.saveDeviceRegistry()
- m.SaveValue(28, deviceRegistry)
- m.Save(0, &x.featureSet)
- m.Save(1, &x.timekeeper)
- m.Save(2, &x.tasks)
- m.Save(3, &x.rootUserNamespace)
- m.Save(4, &x.rootNetworkNamespace)
- m.Save(5, &x.applicationCores)
- m.Save(6, &x.useHostCores)
- m.Save(7, &x.extraAuxv)
- m.Save(8, &x.vdso)
- m.Save(9, &x.rootUTSNamespace)
- m.Save(10, &x.rootIPCNamespace)
- m.Save(11, &x.rootAbstractSocketNamespace)
- m.Save(12, &x.futexes)
- m.Save(13, &x.globalInit)
- m.Save(14, &x.realtimeClock)
- m.Save(15, &x.monotonicClock)
- m.Save(16, &x.syslog)
- m.Save(17, &x.runningTasks)
- m.Save(18, &x.cpuClock)
- m.Save(19, &x.cpuClockTickerDisabled)
- m.Save(20, &x.cpuClockTickerSetting)
- m.Save(21, &x.uniqueID)
- m.Save(22, &x.nextInotifyCookie)
- m.Save(23, &x.netlinkPorts)
- m.Save(25, &x.sockets)
- m.Save(26, &x.socketsVFS2)
- m.Save(27, &x.nextSocketRecord)
- m.Save(29, &x.DirentCacheLimiter)
- m.Save(30, &x.SpecialOpts)
- m.Save(31, &x.vfs)
- m.Save(32, &x.hostMount)
- m.Save(33, &x.pipeMount)
- m.Save(34, &x.shmMount)
- m.Save(35, &x.socketMount)
- m.Save(36, &x.SleepForAddressSpaceActivation)
-}
-
-func (x *Kernel) afterLoad() {}
-
-func (x *Kernel) StateLoad(m state.Source) {
- m.Load(0, &x.featureSet)
- m.Load(1, &x.timekeeper)
- m.Load(2, &x.tasks)
- m.Load(3, &x.rootUserNamespace)
- m.Load(4, &x.rootNetworkNamespace)
- m.Load(5, &x.applicationCores)
- m.Load(6, &x.useHostCores)
- m.Load(7, &x.extraAuxv)
- m.Load(8, &x.vdso)
- m.Load(9, &x.rootUTSNamespace)
- m.Load(10, &x.rootIPCNamespace)
- m.Load(11, &x.rootAbstractSocketNamespace)
- m.Load(12, &x.futexes)
- m.Load(13, &x.globalInit)
- m.Load(14, &x.realtimeClock)
- m.Load(15, &x.monotonicClock)
- m.Load(16, &x.syslog)
- m.Load(17, &x.runningTasks)
- m.Load(18, &x.cpuClock)
- m.Load(19, &x.cpuClockTickerDisabled)
- m.Load(20, &x.cpuClockTickerSetting)
- m.Load(21, &x.uniqueID)
- m.Load(22, &x.nextInotifyCookie)
- m.Load(23, &x.netlinkPorts)
- m.Load(25, &x.sockets)
- m.Load(26, &x.socketsVFS2)
- m.Load(27, &x.nextSocketRecord)
- m.Load(29, &x.DirentCacheLimiter)
- m.Load(30, &x.SpecialOpts)
- m.Load(31, &x.vfs)
- m.Load(32, &x.hostMount)
- m.Load(33, &x.pipeMount)
- m.Load(34, &x.shmMount)
- m.Load(35, &x.socketMount)
- m.Load(36, &x.SleepForAddressSpaceActivation)
- m.LoadValue(24, new([]tcpip.Endpoint), func(y interface{}) { x.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
- m.LoadValue(28, new(*device.Registry), func(y interface{}) { x.loadDeviceRegistry(y.(*device.Registry)) })
-}
-
-func (x *SocketRecord) StateTypeName() string {
+func (k *Kernel) beforeSave() {}
+
+func (k *Kernel) StateSave(stateSinkObject state.Sink) {
+ k.beforeSave()
+ var danglingEndpointsValue []tcpip.Endpoint = k.saveDanglingEndpoints()
+ stateSinkObject.SaveValue(24, danglingEndpointsValue)
+ var deviceRegistryValue *device.Registry = k.saveDeviceRegistry()
+ stateSinkObject.SaveValue(28, deviceRegistryValue)
+ stateSinkObject.Save(0, &k.featureSet)
+ stateSinkObject.Save(1, &k.timekeeper)
+ stateSinkObject.Save(2, &k.tasks)
+ stateSinkObject.Save(3, &k.rootUserNamespace)
+ stateSinkObject.Save(4, &k.rootNetworkNamespace)
+ stateSinkObject.Save(5, &k.applicationCores)
+ stateSinkObject.Save(6, &k.useHostCores)
+ stateSinkObject.Save(7, &k.extraAuxv)
+ stateSinkObject.Save(8, &k.vdso)
+ stateSinkObject.Save(9, &k.rootUTSNamespace)
+ stateSinkObject.Save(10, &k.rootIPCNamespace)
+ stateSinkObject.Save(11, &k.rootAbstractSocketNamespace)
+ stateSinkObject.Save(12, &k.futexes)
+ stateSinkObject.Save(13, &k.globalInit)
+ stateSinkObject.Save(14, &k.realtimeClock)
+ stateSinkObject.Save(15, &k.monotonicClock)
+ stateSinkObject.Save(16, &k.syslog)
+ stateSinkObject.Save(17, &k.runningTasks)
+ stateSinkObject.Save(18, &k.cpuClock)
+ stateSinkObject.Save(19, &k.cpuClockTickerDisabled)
+ stateSinkObject.Save(20, &k.cpuClockTickerSetting)
+ stateSinkObject.Save(21, &k.uniqueID)
+ stateSinkObject.Save(22, &k.nextInotifyCookie)
+ stateSinkObject.Save(23, &k.netlinkPorts)
+ stateSinkObject.Save(25, &k.sockets)
+ stateSinkObject.Save(26, &k.socketsVFS2)
+ stateSinkObject.Save(27, &k.nextSocketRecord)
+ stateSinkObject.Save(29, &k.DirentCacheLimiter)
+ stateSinkObject.Save(30, &k.SpecialOpts)
+ stateSinkObject.Save(31, &k.vfs)
+ stateSinkObject.Save(32, &k.hostMount)
+ stateSinkObject.Save(33, &k.pipeMount)
+ stateSinkObject.Save(34, &k.shmMount)
+ stateSinkObject.Save(35, &k.socketMount)
+ stateSinkObject.Save(36, &k.SleepForAddressSpaceActivation)
+}
+
+func (k *Kernel) afterLoad() {}
+
+func (k *Kernel) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &k.featureSet)
+ stateSourceObject.Load(1, &k.timekeeper)
+ stateSourceObject.Load(2, &k.tasks)
+ stateSourceObject.Load(3, &k.rootUserNamespace)
+ stateSourceObject.Load(4, &k.rootNetworkNamespace)
+ stateSourceObject.Load(5, &k.applicationCores)
+ stateSourceObject.Load(6, &k.useHostCores)
+ stateSourceObject.Load(7, &k.extraAuxv)
+ stateSourceObject.Load(8, &k.vdso)
+ stateSourceObject.Load(9, &k.rootUTSNamespace)
+ stateSourceObject.Load(10, &k.rootIPCNamespace)
+ stateSourceObject.Load(11, &k.rootAbstractSocketNamespace)
+ stateSourceObject.Load(12, &k.futexes)
+ stateSourceObject.Load(13, &k.globalInit)
+ stateSourceObject.Load(14, &k.realtimeClock)
+ stateSourceObject.Load(15, &k.monotonicClock)
+ stateSourceObject.Load(16, &k.syslog)
+ stateSourceObject.Load(17, &k.runningTasks)
+ stateSourceObject.Load(18, &k.cpuClock)
+ stateSourceObject.Load(19, &k.cpuClockTickerDisabled)
+ stateSourceObject.Load(20, &k.cpuClockTickerSetting)
+ stateSourceObject.Load(21, &k.uniqueID)
+ stateSourceObject.Load(22, &k.nextInotifyCookie)
+ stateSourceObject.Load(23, &k.netlinkPorts)
+ stateSourceObject.Load(25, &k.sockets)
+ stateSourceObject.Load(26, &k.socketsVFS2)
+ stateSourceObject.Load(27, &k.nextSocketRecord)
+ stateSourceObject.Load(29, &k.DirentCacheLimiter)
+ stateSourceObject.Load(30, &k.SpecialOpts)
+ stateSourceObject.Load(31, &k.vfs)
+ stateSourceObject.Load(32, &k.hostMount)
+ stateSourceObject.Load(33, &k.pipeMount)
+ stateSourceObject.Load(34, &k.shmMount)
+ stateSourceObject.Load(35, &k.socketMount)
+ stateSourceObject.Load(36, &k.SleepForAddressSpaceActivation)
+ stateSourceObject.LoadValue(24, new([]tcpip.Endpoint), func(y interface{}) { k.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
+ stateSourceObject.LoadValue(28, new(*device.Registry), func(y interface{}) { k.loadDeviceRegistry(y.(*device.Registry)) })
+}
+
+func (s *SocketRecord) StateTypeName() string {
return "pkg/sentry/kernel.SocketRecord"
}
-func (x *SocketRecord) StateFields() []string {
+func (s *SocketRecord) StateFields() []string {
return []string{
"k",
"Sock",
@@ -411,106 +411,106 @@ func (x *SocketRecord) StateFields() []string {
}
}
-func (x *SocketRecord) beforeSave() {}
+func (s *SocketRecord) beforeSave() {}
-func (x *SocketRecord) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.k)
- m.Save(1, &x.Sock)
- m.Save(2, &x.SockVFS2)
- m.Save(3, &x.ID)
+func (s *SocketRecord) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.k)
+ stateSinkObject.Save(1, &s.Sock)
+ stateSinkObject.Save(2, &s.SockVFS2)
+ stateSinkObject.Save(3, &s.ID)
}
-func (x *SocketRecord) afterLoad() {}
+func (s *SocketRecord) afterLoad() {}
-func (x *SocketRecord) StateLoad(m state.Source) {
- m.Load(0, &x.k)
- m.Load(1, &x.Sock)
- m.Load(2, &x.SockVFS2)
- m.Load(3, &x.ID)
+func (s *SocketRecord) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.k)
+ stateSourceObject.Load(1, &s.Sock)
+ stateSourceObject.Load(2, &s.SockVFS2)
+ stateSourceObject.Load(3, &s.ID)
}
-func (x *SocketRecordVFS1) StateTypeName() string {
+func (s *SocketRecordVFS1) StateTypeName() string {
return "pkg/sentry/kernel.SocketRecordVFS1"
}
-func (x *SocketRecordVFS1) StateFields() []string {
+func (s *SocketRecordVFS1) StateFields() []string {
return []string{
"socketEntry",
"SocketRecord",
}
}
-func (x *SocketRecordVFS1) beforeSave() {}
+func (s *SocketRecordVFS1) beforeSave() {}
-func (x *SocketRecordVFS1) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.socketEntry)
- m.Save(1, &x.SocketRecord)
+func (s *SocketRecordVFS1) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.socketEntry)
+ stateSinkObject.Save(1, &s.SocketRecord)
}
-func (x *SocketRecordVFS1) afterLoad() {}
+func (s *SocketRecordVFS1) afterLoad() {}
-func (x *SocketRecordVFS1) StateLoad(m state.Source) {
- m.Load(0, &x.socketEntry)
- m.Load(1, &x.SocketRecord)
+func (s *SocketRecordVFS1) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.socketEntry)
+ stateSourceObject.Load(1, &s.SocketRecord)
}
-func (x *pendingSignals) StateTypeName() string {
+func (p *pendingSignals) StateTypeName() string {
return "pkg/sentry/kernel.pendingSignals"
}
-func (x *pendingSignals) StateFields() []string {
+func (p *pendingSignals) StateFields() []string {
return []string{
"signals",
}
}
-func (x *pendingSignals) beforeSave() {}
+func (p *pendingSignals) beforeSave() {}
-func (x *pendingSignals) StateSave(m state.Sink) {
- x.beforeSave()
- var signals []savedPendingSignal = x.saveSignals()
- m.SaveValue(0, signals)
+func (p *pendingSignals) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ var signalsValue []savedPendingSignal = p.saveSignals()
+ stateSinkObject.SaveValue(0, signalsValue)
}
-func (x *pendingSignals) afterLoad() {}
+func (p *pendingSignals) afterLoad() {}
-func (x *pendingSignals) StateLoad(m state.Source) {
- m.LoadValue(0, new([]savedPendingSignal), func(y interface{}) { x.loadSignals(y.([]savedPendingSignal)) })
+func (p *pendingSignals) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadValue(0, new([]savedPendingSignal), func(y interface{}) { p.loadSignals(y.([]savedPendingSignal)) })
}
-func (x *pendingSignalQueue) StateTypeName() string {
+func (p *pendingSignalQueue) StateTypeName() string {
return "pkg/sentry/kernel.pendingSignalQueue"
}
-func (x *pendingSignalQueue) StateFields() []string {
+func (p *pendingSignalQueue) StateFields() []string {
return []string{
"pendingSignalList",
"length",
}
}
-func (x *pendingSignalQueue) beforeSave() {}
+func (p *pendingSignalQueue) beforeSave() {}
-func (x *pendingSignalQueue) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.pendingSignalList)
- m.Save(1, &x.length)
+func (p *pendingSignalQueue) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.pendingSignalList)
+ stateSinkObject.Save(1, &p.length)
}
-func (x *pendingSignalQueue) afterLoad() {}
+func (p *pendingSignalQueue) afterLoad() {}
-func (x *pendingSignalQueue) StateLoad(m state.Source) {
- m.Load(0, &x.pendingSignalList)
- m.Load(1, &x.length)
+func (p *pendingSignalQueue) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.pendingSignalList)
+ stateSourceObject.Load(1, &p.length)
}
-func (x *pendingSignal) StateTypeName() string {
+func (p *pendingSignal) StateTypeName() string {
return "pkg/sentry/kernel.pendingSignal"
}
-func (x *pendingSignal) StateFields() []string {
+func (p *pendingSignal) StateFields() []string {
return []string{
"pendingSignalEntry",
"SignalInfo",
@@ -518,106 +518,106 @@ func (x *pendingSignal) StateFields() []string {
}
}
-func (x *pendingSignal) beforeSave() {}
+func (p *pendingSignal) beforeSave() {}
-func (x *pendingSignal) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.pendingSignalEntry)
- m.Save(1, &x.SignalInfo)
- m.Save(2, &x.timer)
+func (p *pendingSignal) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.pendingSignalEntry)
+ stateSinkObject.Save(1, &p.SignalInfo)
+ stateSinkObject.Save(2, &p.timer)
}
-func (x *pendingSignal) afterLoad() {}
+func (p *pendingSignal) afterLoad() {}
-func (x *pendingSignal) StateLoad(m state.Source) {
- m.Load(0, &x.pendingSignalEntry)
- m.Load(1, &x.SignalInfo)
- m.Load(2, &x.timer)
+func (p *pendingSignal) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.pendingSignalEntry)
+ stateSourceObject.Load(1, &p.SignalInfo)
+ stateSourceObject.Load(2, &p.timer)
}
-func (x *pendingSignalList) StateTypeName() string {
+func (p *pendingSignalList) StateTypeName() string {
return "pkg/sentry/kernel.pendingSignalList"
}
-func (x *pendingSignalList) StateFields() []string {
+func (p *pendingSignalList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *pendingSignalList) beforeSave() {}
+func (p *pendingSignalList) beforeSave() {}
-func (x *pendingSignalList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (p *pendingSignalList) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.head)
+ stateSinkObject.Save(1, &p.tail)
}
-func (x *pendingSignalList) afterLoad() {}
+func (p *pendingSignalList) afterLoad() {}
-func (x *pendingSignalList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (p *pendingSignalList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.head)
+ stateSourceObject.Load(1, &p.tail)
}
-func (x *pendingSignalEntry) StateTypeName() string {
+func (p *pendingSignalEntry) StateTypeName() string {
return "pkg/sentry/kernel.pendingSignalEntry"
}
-func (x *pendingSignalEntry) StateFields() []string {
+func (p *pendingSignalEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *pendingSignalEntry) beforeSave() {}
+func (p *pendingSignalEntry) beforeSave() {}
-func (x *pendingSignalEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (p *pendingSignalEntry) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.next)
+ stateSinkObject.Save(1, &p.prev)
}
-func (x *pendingSignalEntry) afterLoad() {}
+func (p *pendingSignalEntry) afterLoad() {}
-func (x *pendingSignalEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (p *pendingSignalEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.next)
+ stateSourceObject.Load(1, &p.prev)
}
-func (x *savedPendingSignal) StateTypeName() string {
+func (s *savedPendingSignal) StateTypeName() string {
return "pkg/sentry/kernel.savedPendingSignal"
}
-func (x *savedPendingSignal) StateFields() []string {
+func (s *savedPendingSignal) StateFields() []string {
return []string{
"si",
"timer",
}
}
-func (x *savedPendingSignal) beforeSave() {}
+func (s *savedPendingSignal) beforeSave() {}
-func (x *savedPendingSignal) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.si)
- m.Save(1, &x.timer)
+func (s *savedPendingSignal) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.si)
+ stateSinkObject.Save(1, &s.timer)
}
-func (x *savedPendingSignal) afterLoad() {}
+func (s *savedPendingSignal) afterLoad() {}
-func (x *savedPendingSignal) StateLoad(m state.Source) {
- m.Load(0, &x.si)
- m.Load(1, &x.timer)
+func (s *savedPendingSignal) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.si)
+ stateSourceObject.Load(1, &s.timer)
}
-func (x *IntervalTimer) StateTypeName() string {
+func (i *IntervalTimer) StateTypeName() string {
return "pkg/sentry/kernel.IntervalTimer"
}
-func (x *IntervalTimer) StateFields() []string {
+func (i *IntervalTimer) StateFields() []string {
return []string{
"timer",
"target",
@@ -632,117 +632,117 @@ func (x *IntervalTimer) StateFields() []string {
}
}
-func (x *IntervalTimer) beforeSave() {}
+func (i *IntervalTimer) beforeSave() {}
-func (x *IntervalTimer) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.timer)
- m.Save(1, &x.target)
- m.Save(2, &x.signo)
- m.Save(3, &x.id)
- m.Save(4, &x.sigval)
- m.Save(5, &x.group)
- m.Save(6, &x.sigpending)
- m.Save(7, &x.sigorphan)
- m.Save(8, &x.overrunCur)
- m.Save(9, &x.overrunLast)
+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 (x *IntervalTimer) afterLoad() {}
+func (i *IntervalTimer) afterLoad() {}
-func (x *IntervalTimer) StateLoad(m state.Source) {
- m.Load(0, &x.timer)
- m.Load(1, &x.target)
- m.Load(2, &x.signo)
- m.Load(3, &x.id)
- m.Load(4, &x.sigval)
- m.Load(5, &x.group)
- m.Load(6, &x.sigpending)
- m.Load(7, &x.sigorphan)
- m.Load(8, &x.overrunCur)
- m.Load(9, &x.overrunLast)
+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 (x *processGroupList) StateTypeName() string {
+func (p *processGroupList) StateTypeName() string {
return "pkg/sentry/kernel.processGroupList"
}
-func (x *processGroupList) StateFields() []string {
+func (p *processGroupList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *processGroupList) beforeSave() {}
+func (p *processGroupList) beforeSave() {}
-func (x *processGroupList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (p *processGroupList) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.head)
+ stateSinkObject.Save(1, &p.tail)
}
-func (x *processGroupList) afterLoad() {}
+func (p *processGroupList) afterLoad() {}
-func (x *processGroupList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (p *processGroupList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.head)
+ stateSourceObject.Load(1, &p.tail)
}
-func (x *processGroupEntry) StateTypeName() string {
+func (p *processGroupEntry) StateTypeName() string {
return "pkg/sentry/kernel.processGroupEntry"
}
-func (x *processGroupEntry) StateFields() []string {
+func (p *processGroupEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *processGroupEntry) beforeSave() {}
+func (p *processGroupEntry) beforeSave() {}
-func (x *processGroupEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (p *processGroupEntry) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.next)
+ stateSinkObject.Save(1, &p.prev)
}
-func (x *processGroupEntry) afterLoad() {}
+func (p *processGroupEntry) afterLoad() {}
-func (x *processGroupEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (p *processGroupEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.next)
+ stateSourceObject.Load(1, &p.prev)
}
-func (x *ProcessGroupRefs) StateTypeName() string {
+func (p *ProcessGroupRefs) StateTypeName() string {
return "pkg/sentry/kernel.ProcessGroupRefs"
}
-func (x *ProcessGroupRefs) StateFields() []string {
+func (p *ProcessGroupRefs) StateFields() []string {
return []string{
"refCount",
}
}
-func (x *ProcessGroupRefs) beforeSave() {}
+func (p *ProcessGroupRefs) beforeSave() {}
-func (x *ProcessGroupRefs) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refCount)
+func (p *ProcessGroupRefs) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.refCount)
}
-func (x *ProcessGroupRefs) afterLoad() {}
+func (p *ProcessGroupRefs) afterLoad() {}
-func (x *ProcessGroupRefs) StateLoad(m state.Source) {
- m.Load(0, &x.refCount)
+func (p *ProcessGroupRefs) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.refCount)
}
-func (x *ptraceOptions) StateTypeName() string {
+func (p *ptraceOptions) StateTypeName() string {
return "pkg/sentry/kernel.ptraceOptions"
}
-func (x *ptraceOptions) StateFields() []string {
+func (p *ptraceOptions) StateFields() []string {
return []string{
"ExitKill",
"SysGood",
@@ -756,167 +756,167 @@ func (x *ptraceOptions) StateFields() []string {
}
}
-func (x *ptraceOptions) beforeSave() {}
+func (p *ptraceOptions) beforeSave() {}
-func (x *ptraceOptions) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ExitKill)
- m.Save(1, &x.SysGood)
- m.Save(2, &x.TraceClone)
- m.Save(3, &x.TraceExec)
- m.Save(4, &x.TraceExit)
- m.Save(5, &x.TraceFork)
- m.Save(6, &x.TraceSeccomp)
- m.Save(7, &x.TraceVfork)
- m.Save(8, &x.TraceVforkDone)
+func (p *ptraceOptions) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.ExitKill)
+ stateSinkObject.Save(1, &p.SysGood)
+ stateSinkObject.Save(2, &p.TraceClone)
+ stateSinkObject.Save(3, &p.TraceExec)
+ stateSinkObject.Save(4, &p.TraceExit)
+ stateSinkObject.Save(5, &p.TraceFork)
+ stateSinkObject.Save(6, &p.TraceSeccomp)
+ stateSinkObject.Save(7, &p.TraceVfork)
+ stateSinkObject.Save(8, &p.TraceVforkDone)
}
-func (x *ptraceOptions) afterLoad() {}
+func (p *ptraceOptions) afterLoad() {}
-func (x *ptraceOptions) StateLoad(m state.Source) {
- m.Load(0, &x.ExitKill)
- m.Load(1, &x.SysGood)
- m.Load(2, &x.TraceClone)
- m.Load(3, &x.TraceExec)
- m.Load(4, &x.TraceExit)
- m.Load(5, &x.TraceFork)
- m.Load(6, &x.TraceSeccomp)
- m.Load(7, &x.TraceVfork)
- m.Load(8, &x.TraceVforkDone)
+func (p *ptraceOptions) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.ExitKill)
+ stateSourceObject.Load(1, &p.SysGood)
+ stateSourceObject.Load(2, &p.TraceClone)
+ stateSourceObject.Load(3, &p.TraceExec)
+ stateSourceObject.Load(4, &p.TraceExit)
+ stateSourceObject.Load(5, &p.TraceFork)
+ stateSourceObject.Load(6, &p.TraceSeccomp)
+ stateSourceObject.Load(7, &p.TraceVfork)
+ stateSourceObject.Load(8, &p.TraceVforkDone)
}
-func (x *ptraceStop) StateTypeName() string {
+func (p *ptraceStop) StateTypeName() string {
return "pkg/sentry/kernel.ptraceStop"
}
-func (x *ptraceStop) StateFields() []string {
+func (p *ptraceStop) StateFields() []string {
return []string{
"frozen",
"listen",
}
}
-func (x *ptraceStop) beforeSave() {}
+func (p *ptraceStop) beforeSave() {}
-func (x *ptraceStop) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.frozen)
- m.Save(1, &x.listen)
+func (p *ptraceStop) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.frozen)
+ stateSinkObject.Save(1, &p.listen)
}
-func (x *ptraceStop) afterLoad() {}
+func (p *ptraceStop) afterLoad() {}
-func (x *ptraceStop) StateLoad(m state.Source) {
- m.Load(0, &x.frozen)
- m.Load(1, &x.listen)
+func (p *ptraceStop) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.frozen)
+ stateSourceObject.Load(1, &p.listen)
}
-func (x *OldRSeqCriticalRegion) StateTypeName() string {
+func (o *OldRSeqCriticalRegion) StateTypeName() string {
return "pkg/sentry/kernel.OldRSeqCriticalRegion"
}
-func (x *OldRSeqCriticalRegion) StateFields() []string {
+func (o *OldRSeqCriticalRegion) StateFields() []string {
return []string{
"CriticalSection",
"Restart",
}
}
-func (x *OldRSeqCriticalRegion) beforeSave() {}
+func (o *OldRSeqCriticalRegion) beforeSave() {}
-func (x *OldRSeqCriticalRegion) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.CriticalSection)
- m.Save(1, &x.Restart)
+func (o *OldRSeqCriticalRegion) StateSave(stateSinkObject state.Sink) {
+ o.beforeSave()
+ stateSinkObject.Save(0, &o.CriticalSection)
+ stateSinkObject.Save(1, &o.Restart)
}
-func (x *OldRSeqCriticalRegion) afterLoad() {}
+func (o *OldRSeqCriticalRegion) afterLoad() {}
-func (x *OldRSeqCriticalRegion) StateLoad(m state.Source) {
- m.Load(0, &x.CriticalSection)
- m.Load(1, &x.Restart)
+func (o *OldRSeqCriticalRegion) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &o.CriticalSection)
+ stateSourceObject.Load(1, &o.Restart)
}
-func (x *sessionList) StateTypeName() string {
+func (s *sessionList) StateTypeName() string {
return "pkg/sentry/kernel.sessionList"
}
-func (x *sessionList) StateFields() []string {
+func (s *sessionList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *sessionList) beforeSave() {}
+func (s *sessionList) beforeSave() {}
-func (x *sessionList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (s *sessionList) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.head)
+ stateSinkObject.Save(1, &s.tail)
}
-func (x *sessionList) afterLoad() {}
+func (s *sessionList) afterLoad() {}
-func (x *sessionList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (s *sessionList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.head)
+ stateSourceObject.Load(1, &s.tail)
}
-func (x *sessionEntry) StateTypeName() string {
+func (s *sessionEntry) StateTypeName() string {
return "pkg/sentry/kernel.sessionEntry"
}
-func (x *sessionEntry) StateFields() []string {
+func (s *sessionEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *sessionEntry) beforeSave() {}
+func (s *sessionEntry) beforeSave() {}
-func (x *sessionEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (s *sessionEntry) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.next)
+ stateSinkObject.Save(1, &s.prev)
}
-func (x *sessionEntry) afterLoad() {}
+func (s *sessionEntry) afterLoad() {}
-func (x *sessionEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (s *sessionEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.next)
+ stateSourceObject.Load(1, &s.prev)
}
-func (x *SessionRefs) StateTypeName() string {
+func (s *SessionRefs) StateTypeName() string {
return "pkg/sentry/kernel.SessionRefs"
}
-func (x *SessionRefs) StateFields() []string {
+func (s *SessionRefs) StateFields() []string {
return []string{
"refCount",
}
}
-func (x *SessionRefs) beforeSave() {}
+func (s *SessionRefs) beforeSave() {}
-func (x *SessionRefs) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refCount)
+func (s *SessionRefs) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.refCount)
}
-func (x *SessionRefs) afterLoad() {}
+func (s *SessionRefs) afterLoad() {}
-func (x *SessionRefs) StateLoad(m state.Source) {
- m.Load(0, &x.refCount)
+func (s *SessionRefs) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.refCount)
}
-func (x *Session) StateTypeName() string {
+func (s *Session) StateTypeName() string {
return "pkg/sentry/kernel.Session"
}
-func (x *Session) StateFields() []string {
+func (s *Session) StateFields() []string {
return []string{
"SessionRefs",
"leader",
@@ -927,34 +927,34 @@ func (x *Session) StateFields() []string {
}
}
-func (x *Session) beforeSave() {}
+func (s *Session) beforeSave() {}
-func (x *Session) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.SessionRefs)
- m.Save(1, &x.leader)
- m.Save(2, &x.id)
- m.Save(3, &x.foreground)
- m.Save(4, &x.processGroups)
- m.Save(5, &x.sessionEntry)
+func (s *Session) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.SessionRefs)
+ stateSinkObject.Save(1, &s.leader)
+ stateSinkObject.Save(2, &s.id)
+ stateSinkObject.Save(3, &s.foreground)
+ stateSinkObject.Save(4, &s.processGroups)
+ stateSinkObject.Save(5, &s.sessionEntry)
}
-func (x *Session) afterLoad() {}
+func (s *Session) afterLoad() {}
-func (x *Session) StateLoad(m state.Source) {
- m.Load(0, &x.SessionRefs)
- m.Load(1, &x.leader)
- m.Load(2, &x.id)
- m.Load(3, &x.foreground)
- m.Load(4, &x.processGroups)
- m.Load(5, &x.sessionEntry)
+func (s *Session) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.SessionRefs)
+ stateSourceObject.Load(1, &s.leader)
+ stateSourceObject.Load(2, &s.id)
+ stateSourceObject.Load(3, &s.foreground)
+ stateSourceObject.Load(4, &s.processGroups)
+ stateSourceObject.Load(5, &s.sessionEntry)
}
-func (x *ProcessGroup) StateTypeName() string {
+func (p *ProcessGroup) StateTypeName() string {
return "pkg/sentry/kernel.ProcessGroup"
}
-func (x *ProcessGroup) StateFields() []string {
+func (p *ProcessGroup) StateFields() []string {
return []string{
"refs",
"originator",
@@ -965,158 +965,158 @@ func (x *ProcessGroup) StateFields() []string {
}
}
-func (x *ProcessGroup) beforeSave() {}
+func (p *ProcessGroup) beforeSave() {}
-func (x *ProcessGroup) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refs)
- m.Save(1, &x.originator)
- m.Save(2, &x.id)
- m.Save(3, &x.session)
- m.Save(4, &x.ancestors)
- m.Save(5, &x.processGroupEntry)
+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 (x *ProcessGroup) afterLoad() {}
+func (p *ProcessGroup) afterLoad() {}
-func (x *ProcessGroup) StateLoad(m state.Source) {
- m.Load(0, &x.refs)
- m.Load(1, &x.originator)
- m.Load(2, &x.id)
- m.Load(3, &x.session)
- m.Load(4, &x.ancestors)
- m.Load(5, &x.processGroupEntry)
+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 (x *SignalHandlers) StateTypeName() string {
+func (s *SignalHandlers) StateTypeName() string {
return "pkg/sentry/kernel.SignalHandlers"
}
-func (x *SignalHandlers) StateFields() []string {
+func (s *SignalHandlers) StateFields() []string {
return []string{
"actions",
}
}
-func (x *SignalHandlers) beforeSave() {}
+func (s *SignalHandlers) beforeSave() {}
-func (x *SignalHandlers) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.actions)
+func (s *SignalHandlers) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.actions)
}
-func (x *SignalHandlers) afterLoad() {}
+func (s *SignalHandlers) afterLoad() {}
-func (x *SignalHandlers) StateLoad(m state.Source) {
- m.Load(0, &x.actions)
+func (s *SignalHandlers) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.actions)
}
-func (x *socketList) StateTypeName() string {
+func (s *socketList) StateTypeName() string {
return "pkg/sentry/kernel.socketList"
}
-func (x *socketList) StateFields() []string {
+func (s *socketList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *socketList) beforeSave() {}
+func (s *socketList) beforeSave() {}
-func (x *socketList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (s *socketList) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.head)
+ stateSinkObject.Save(1, &s.tail)
}
-func (x *socketList) afterLoad() {}
+func (s *socketList) afterLoad() {}
-func (x *socketList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (s *socketList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.head)
+ stateSourceObject.Load(1, &s.tail)
}
-func (x *socketEntry) StateTypeName() string {
+func (s *socketEntry) StateTypeName() string {
return "pkg/sentry/kernel.socketEntry"
}
-func (x *socketEntry) StateFields() []string {
+func (s *socketEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *socketEntry) beforeSave() {}
+func (s *socketEntry) beforeSave() {}
-func (x *socketEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (s *socketEntry) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.next)
+ stateSinkObject.Save(1, &s.prev)
}
-func (x *socketEntry) afterLoad() {}
+func (s *socketEntry) afterLoad() {}
-func (x *socketEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (s *socketEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.next)
+ stateSourceObject.Load(1, &s.prev)
}
-func (x *syscallTableInfo) StateTypeName() string {
+func (s *syscallTableInfo) StateTypeName() string {
return "pkg/sentry/kernel.syscallTableInfo"
}
-func (x *syscallTableInfo) StateFields() []string {
+func (s *syscallTableInfo) StateFields() []string {
return []string{
"OS",
"Arch",
}
}
-func (x *syscallTableInfo) beforeSave() {}
+func (s *syscallTableInfo) beforeSave() {}
-func (x *syscallTableInfo) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.OS)
- m.Save(1, &x.Arch)
+func (s *syscallTableInfo) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.OS)
+ stateSinkObject.Save(1, &s.Arch)
}
-func (x *syscallTableInfo) afterLoad() {}
+func (s *syscallTableInfo) afterLoad() {}
-func (x *syscallTableInfo) StateLoad(m state.Source) {
- m.Load(0, &x.OS)
- m.Load(1, &x.Arch)
+func (s *syscallTableInfo) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.OS)
+ stateSourceObject.Load(1, &s.Arch)
}
-func (x *syslog) StateTypeName() string {
+func (s *syslog) StateTypeName() string {
return "pkg/sentry/kernel.syslog"
}
-func (x *syslog) StateFields() []string {
+func (s *syslog) StateFields() []string {
return []string{
"msg",
}
}
-func (x *syslog) beforeSave() {}
+func (s *syslog) beforeSave() {}
-func (x *syslog) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.msg)
+func (s *syslog) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.msg)
}
-func (x *syslog) afterLoad() {}
+func (s *syslog) afterLoad() {}
-func (x *syslog) StateLoad(m state.Source) {
- m.Load(0, &x.msg)
+func (s *syslog) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.msg)
}
-func (x *Task) StateTypeName() string {
+func (t *Task) StateTypeName() string {
return "pkg/sentry/kernel.Task"
}
-func (x *Task) StateFields() []string {
+func (t *Task) StateFields() []string {
return []string{
"taskNode",
"runState",
@@ -1183,218 +1183,218 @@ func (x *Task) StateFields() []string {
}
}
-func (x *Task) beforeSave() {}
+func (t *Task) beforeSave() {}
-func (x *Task) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.signalQueue) {
- state.Failf("signalQueue is %#v, expected zero", &x.signalQueue)
+func (t *Task) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ if !state.IsZeroValue(&t.signalQueue) {
+ state.Failf("signalQueue is %#v, expected zero", &t.signalQueue)
}
- var ptraceTracer *Task = x.savePtraceTracer()
- m.SaveValue(31, ptraceTracer)
- var syscallFilters []bpf.Program = x.saveSyscallFilters()
- m.SaveValue(47, syscallFilters)
- m.Save(0, &x.taskNode)
- m.Save(1, &x.runState)
- m.Save(2, &x.taskWorkCount)
- m.Save(3, &x.taskWork)
- m.Save(4, &x.haveSyscallReturn)
- m.Save(5, &x.gosched)
- m.Save(6, &x.yieldCount)
- m.Save(7, &x.pendingSignals)
- m.Save(8, &x.signalMask)
- m.Save(9, &x.realSignalMask)
- m.Save(10, &x.haveSavedSignalMask)
- m.Save(11, &x.savedSignalMask)
- m.Save(12, &x.signalStack)
- m.Save(13, &x.groupStopPending)
- m.Save(14, &x.groupStopAcknowledged)
- m.Save(15, &x.trapStopPending)
- m.Save(16, &x.trapNotifyPending)
- m.Save(17, &x.stop)
- m.Save(18, &x.exitStatus)
- m.Save(19, &x.syscallRestartBlock)
- m.Save(20, &x.k)
- m.Save(21, &x.containerID)
- m.Save(22, &x.tc)
- m.Save(23, &x.fsContext)
- m.Save(24, &x.fdTable)
- m.Save(25, &x.vforkParent)
- m.Save(26, &x.exitState)
- m.Save(27, &x.exitTracerNotified)
- m.Save(28, &x.exitTracerAcked)
- m.Save(29, &x.exitParentNotified)
- m.Save(30, &x.exitParentAcked)
- m.Save(32, &x.ptraceTracees)
- m.Save(33, &x.ptraceSeized)
- m.Save(34, &x.ptraceOpts)
- m.Save(35, &x.ptraceSyscallMode)
- m.Save(36, &x.ptraceSinglestep)
- m.Save(37, &x.ptraceCode)
- m.Save(38, &x.ptraceSiginfo)
- m.Save(39, &x.ptraceEventMsg)
- m.Save(40, &x.ioUsage)
- m.Save(41, &x.creds)
- m.Save(42, &x.utsns)
- m.Save(43, &x.ipcns)
- m.Save(44, &x.abstractSockets)
- m.Save(45, &x.mountNamespaceVFS2)
- m.Save(46, &x.parentDeathSignal)
- m.Save(48, &x.cleartid)
- m.Save(49, &x.allowedCPUMask)
- m.Save(50, &x.cpu)
- m.Save(51, &x.niceness)
- m.Save(52, &x.numaPolicy)
- m.Save(53, &x.numaNodeMask)
- m.Save(54, &x.netns)
- m.Save(55, &x.rseqCPU)
- m.Save(56, &x.oldRSeqCPUAddr)
- m.Save(57, &x.rseqAddr)
- m.Save(58, &x.rseqSignature)
- m.Save(59, &x.robustList)
- m.Save(60, &x.startTime)
- m.Save(61, &x.kcov)
-}
-
-func (x *Task) StateLoad(m state.Source) {
- m.Load(0, &x.taskNode)
- m.Load(1, &x.runState)
- m.Load(2, &x.taskWorkCount)
- m.Load(3, &x.taskWork)
- m.Load(4, &x.haveSyscallReturn)
- m.Load(5, &x.gosched)
- m.Load(6, &x.yieldCount)
- m.Load(7, &x.pendingSignals)
- m.Load(8, &x.signalMask)
- m.Load(9, &x.realSignalMask)
- m.Load(10, &x.haveSavedSignalMask)
- m.Load(11, &x.savedSignalMask)
- m.Load(12, &x.signalStack)
- m.Load(13, &x.groupStopPending)
- m.Load(14, &x.groupStopAcknowledged)
- m.Load(15, &x.trapStopPending)
- m.Load(16, &x.trapNotifyPending)
- m.Load(17, &x.stop)
- m.Load(18, &x.exitStatus)
- m.Load(19, &x.syscallRestartBlock)
- m.Load(20, &x.k)
- m.Load(21, &x.containerID)
- m.Load(22, &x.tc)
- m.Load(23, &x.fsContext)
- m.Load(24, &x.fdTable)
- m.Load(25, &x.vforkParent)
- m.Load(26, &x.exitState)
- m.Load(27, &x.exitTracerNotified)
- m.Load(28, &x.exitTracerAcked)
- m.Load(29, &x.exitParentNotified)
- m.Load(30, &x.exitParentAcked)
- m.Load(32, &x.ptraceTracees)
- m.Load(33, &x.ptraceSeized)
- m.Load(34, &x.ptraceOpts)
- m.Load(35, &x.ptraceSyscallMode)
- m.Load(36, &x.ptraceSinglestep)
- m.Load(37, &x.ptraceCode)
- m.Load(38, &x.ptraceSiginfo)
- m.Load(39, &x.ptraceEventMsg)
- m.Load(40, &x.ioUsage)
- m.Load(41, &x.creds)
- m.Load(42, &x.utsns)
- m.Load(43, &x.ipcns)
- m.Load(44, &x.abstractSockets)
- m.Load(45, &x.mountNamespaceVFS2)
- m.Load(46, &x.parentDeathSignal)
- m.Load(48, &x.cleartid)
- m.Load(49, &x.allowedCPUMask)
- m.Load(50, &x.cpu)
- m.Load(51, &x.niceness)
- m.Load(52, &x.numaPolicy)
- m.Load(53, &x.numaNodeMask)
- m.Load(54, &x.netns)
- m.Load(55, &x.rseqCPU)
- m.Load(56, &x.oldRSeqCPUAddr)
- m.Load(57, &x.rseqAddr)
- m.Load(58, &x.rseqSignature)
- m.Load(59, &x.robustList)
- m.Load(60, &x.startTime)
- m.Load(61, &x.kcov)
- m.LoadValue(31, new(*Task), func(y interface{}) { x.loadPtraceTracer(y.(*Task)) })
- m.LoadValue(47, new([]bpf.Program), func(y interface{}) { x.loadSyscallFilters(y.([]bpf.Program)) })
- m.AfterLoad(x.afterLoad)
-}
-
-func (x *runSyscallAfterPtraceEventClone) StateTypeName() string {
+ var ptraceTracerValue *Task = t.savePtraceTracer()
+ stateSinkObject.SaveValue(31, ptraceTracerValue)
+ var syscallFiltersValue []bpf.Program = t.saveSyscallFilters()
+ stateSinkObject.SaveValue(47, syscallFiltersValue)
+ stateSinkObject.Save(0, &t.taskNode)
+ stateSinkObject.Save(1, &t.runState)
+ stateSinkObject.Save(2, &t.taskWorkCount)
+ stateSinkObject.Save(3, &t.taskWork)
+ stateSinkObject.Save(4, &t.haveSyscallReturn)
+ stateSinkObject.Save(5, &t.gosched)
+ stateSinkObject.Save(6, &t.yieldCount)
+ stateSinkObject.Save(7, &t.pendingSignals)
+ stateSinkObject.Save(8, &t.signalMask)
+ stateSinkObject.Save(9, &t.realSignalMask)
+ stateSinkObject.Save(10, &t.haveSavedSignalMask)
+ stateSinkObject.Save(11, &t.savedSignalMask)
+ stateSinkObject.Save(12, &t.signalStack)
+ stateSinkObject.Save(13, &t.groupStopPending)
+ stateSinkObject.Save(14, &t.groupStopAcknowledged)
+ stateSinkObject.Save(15, &t.trapStopPending)
+ stateSinkObject.Save(16, &t.trapNotifyPending)
+ stateSinkObject.Save(17, &t.stop)
+ stateSinkObject.Save(18, &t.exitStatus)
+ stateSinkObject.Save(19, &t.syscallRestartBlock)
+ stateSinkObject.Save(20, &t.k)
+ stateSinkObject.Save(21, &t.containerID)
+ stateSinkObject.Save(22, &t.tc)
+ stateSinkObject.Save(23, &t.fsContext)
+ stateSinkObject.Save(24, &t.fdTable)
+ stateSinkObject.Save(25, &t.vforkParent)
+ stateSinkObject.Save(26, &t.exitState)
+ stateSinkObject.Save(27, &t.exitTracerNotified)
+ stateSinkObject.Save(28, &t.exitTracerAcked)
+ stateSinkObject.Save(29, &t.exitParentNotified)
+ stateSinkObject.Save(30, &t.exitParentAcked)
+ stateSinkObject.Save(32, &t.ptraceTracees)
+ stateSinkObject.Save(33, &t.ptraceSeized)
+ stateSinkObject.Save(34, &t.ptraceOpts)
+ stateSinkObject.Save(35, &t.ptraceSyscallMode)
+ stateSinkObject.Save(36, &t.ptraceSinglestep)
+ stateSinkObject.Save(37, &t.ptraceCode)
+ stateSinkObject.Save(38, &t.ptraceSiginfo)
+ stateSinkObject.Save(39, &t.ptraceEventMsg)
+ stateSinkObject.Save(40, &t.ioUsage)
+ stateSinkObject.Save(41, &t.creds)
+ stateSinkObject.Save(42, &t.utsns)
+ stateSinkObject.Save(43, &t.ipcns)
+ stateSinkObject.Save(44, &t.abstractSockets)
+ stateSinkObject.Save(45, &t.mountNamespaceVFS2)
+ stateSinkObject.Save(46, &t.parentDeathSignal)
+ stateSinkObject.Save(48, &t.cleartid)
+ stateSinkObject.Save(49, &t.allowedCPUMask)
+ stateSinkObject.Save(50, &t.cpu)
+ stateSinkObject.Save(51, &t.niceness)
+ stateSinkObject.Save(52, &t.numaPolicy)
+ stateSinkObject.Save(53, &t.numaNodeMask)
+ stateSinkObject.Save(54, &t.netns)
+ stateSinkObject.Save(55, &t.rseqCPU)
+ stateSinkObject.Save(56, &t.oldRSeqCPUAddr)
+ stateSinkObject.Save(57, &t.rseqAddr)
+ stateSinkObject.Save(58, &t.rseqSignature)
+ stateSinkObject.Save(59, &t.robustList)
+ stateSinkObject.Save(60, &t.startTime)
+ stateSinkObject.Save(61, &t.kcov)
+}
+
+func (t *Task) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.taskNode)
+ stateSourceObject.Load(1, &t.runState)
+ stateSourceObject.Load(2, &t.taskWorkCount)
+ stateSourceObject.Load(3, &t.taskWork)
+ stateSourceObject.Load(4, &t.haveSyscallReturn)
+ stateSourceObject.Load(5, &t.gosched)
+ stateSourceObject.Load(6, &t.yieldCount)
+ stateSourceObject.Load(7, &t.pendingSignals)
+ stateSourceObject.Load(8, &t.signalMask)
+ stateSourceObject.Load(9, &t.realSignalMask)
+ stateSourceObject.Load(10, &t.haveSavedSignalMask)
+ stateSourceObject.Load(11, &t.savedSignalMask)
+ stateSourceObject.Load(12, &t.signalStack)
+ stateSourceObject.Load(13, &t.groupStopPending)
+ stateSourceObject.Load(14, &t.groupStopAcknowledged)
+ stateSourceObject.Load(15, &t.trapStopPending)
+ stateSourceObject.Load(16, &t.trapNotifyPending)
+ stateSourceObject.Load(17, &t.stop)
+ stateSourceObject.Load(18, &t.exitStatus)
+ stateSourceObject.Load(19, &t.syscallRestartBlock)
+ stateSourceObject.Load(20, &t.k)
+ stateSourceObject.Load(21, &t.containerID)
+ stateSourceObject.Load(22, &t.tc)
+ stateSourceObject.Load(23, &t.fsContext)
+ stateSourceObject.Load(24, &t.fdTable)
+ stateSourceObject.Load(25, &t.vforkParent)
+ stateSourceObject.Load(26, &t.exitState)
+ stateSourceObject.Load(27, &t.exitTracerNotified)
+ stateSourceObject.Load(28, &t.exitTracerAcked)
+ stateSourceObject.Load(29, &t.exitParentNotified)
+ stateSourceObject.Load(30, &t.exitParentAcked)
+ stateSourceObject.Load(32, &t.ptraceTracees)
+ stateSourceObject.Load(33, &t.ptraceSeized)
+ stateSourceObject.Load(34, &t.ptraceOpts)
+ stateSourceObject.Load(35, &t.ptraceSyscallMode)
+ stateSourceObject.Load(36, &t.ptraceSinglestep)
+ stateSourceObject.Load(37, &t.ptraceCode)
+ stateSourceObject.Load(38, &t.ptraceSiginfo)
+ stateSourceObject.Load(39, &t.ptraceEventMsg)
+ stateSourceObject.Load(40, &t.ioUsage)
+ stateSourceObject.Load(41, &t.creds)
+ stateSourceObject.Load(42, &t.utsns)
+ stateSourceObject.Load(43, &t.ipcns)
+ stateSourceObject.Load(44, &t.abstractSockets)
+ stateSourceObject.Load(45, &t.mountNamespaceVFS2)
+ stateSourceObject.Load(46, &t.parentDeathSignal)
+ stateSourceObject.Load(48, &t.cleartid)
+ stateSourceObject.Load(49, &t.allowedCPUMask)
+ stateSourceObject.Load(50, &t.cpu)
+ stateSourceObject.Load(51, &t.niceness)
+ stateSourceObject.Load(52, &t.numaPolicy)
+ stateSourceObject.Load(53, &t.numaNodeMask)
+ stateSourceObject.Load(54, &t.netns)
+ stateSourceObject.Load(55, &t.rseqCPU)
+ stateSourceObject.Load(56, &t.oldRSeqCPUAddr)
+ stateSourceObject.Load(57, &t.rseqAddr)
+ stateSourceObject.Load(58, &t.rseqSignature)
+ stateSourceObject.Load(59, &t.robustList)
+ stateSourceObject.Load(60, &t.startTime)
+ stateSourceObject.Load(61, &t.kcov)
+ stateSourceObject.LoadValue(31, new(*Task), func(y interface{}) { t.loadPtraceTracer(y.(*Task)) })
+ stateSourceObject.LoadValue(47, new([]bpf.Program), func(y interface{}) { t.loadSyscallFilters(y.([]bpf.Program)) })
+ stateSourceObject.AfterLoad(t.afterLoad)
+}
+
+func (r *runSyscallAfterPtraceEventClone) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallAfterPtraceEventClone"
}
-func (x *runSyscallAfterPtraceEventClone) StateFields() []string {
+func (r *runSyscallAfterPtraceEventClone) StateFields() []string {
return []string{
"vforkChild",
"vforkChildTID",
}
}
-func (x *runSyscallAfterPtraceEventClone) beforeSave() {}
+func (r *runSyscallAfterPtraceEventClone) beforeSave() {}
-func (x *runSyscallAfterPtraceEventClone) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.vforkChild)
- m.Save(1, &x.vforkChildTID)
+func (r *runSyscallAfterPtraceEventClone) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.vforkChild)
+ stateSinkObject.Save(1, &r.vforkChildTID)
}
-func (x *runSyscallAfterPtraceEventClone) afterLoad() {}
+func (r *runSyscallAfterPtraceEventClone) afterLoad() {}
-func (x *runSyscallAfterPtraceEventClone) StateLoad(m state.Source) {
- m.Load(0, &x.vforkChild)
- m.Load(1, &x.vforkChildTID)
+func (r *runSyscallAfterPtraceEventClone) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.vforkChild)
+ stateSourceObject.Load(1, &r.vforkChildTID)
}
-func (x *runSyscallAfterVforkStop) StateTypeName() string {
+func (r *runSyscallAfterVforkStop) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallAfterVforkStop"
}
-func (x *runSyscallAfterVforkStop) StateFields() []string {
+func (r *runSyscallAfterVforkStop) StateFields() []string {
return []string{
"childTID",
}
}
-func (x *runSyscallAfterVforkStop) beforeSave() {}
+func (r *runSyscallAfterVforkStop) beforeSave() {}
-func (x *runSyscallAfterVforkStop) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.childTID)
+func (r *runSyscallAfterVforkStop) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.childTID)
}
-func (x *runSyscallAfterVforkStop) afterLoad() {}
+func (r *runSyscallAfterVforkStop) afterLoad() {}
-func (x *runSyscallAfterVforkStop) StateLoad(m state.Source) {
- m.Load(0, &x.childTID)
+func (r *runSyscallAfterVforkStop) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.childTID)
}
-func (x *vforkStop) StateTypeName() string {
+func (v *vforkStop) StateTypeName() string {
return "pkg/sentry/kernel.vforkStop"
}
-func (x *vforkStop) StateFields() []string {
+func (v *vforkStop) StateFields() []string {
return []string{}
}
-func (x *vforkStop) beforeSave() {}
+func (v *vforkStop) beforeSave() {}
-func (x *vforkStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (v *vforkStop) StateSave(stateSinkObject state.Sink) {
+ v.beforeSave()
}
-func (x *vforkStop) afterLoad() {}
+func (v *vforkStop) afterLoad() {}
-func (x *vforkStop) StateLoad(m state.Source) {
+func (v *vforkStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *TaskContext) StateTypeName() string {
+func (t *TaskContext) StateTypeName() string {
return "pkg/sentry/kernel.TaskContext"
}
-func (x *TaskContext) StateFields() []string {
+func (t *TaskContext) StateFields() []string {
return []string{
"Name",
"Arch",
@@ -1404,229 +1404,229 @@ func (x *TaskContext) StateFields() []string {
}
}
-func (x *TaskContext) beforeSave() {}
+func (t *TaskContext) beforeSave() {}
-func (x *TaskContext) StateSave(m state.Sink) {
- x.beforeSave()
- var st syscallTableInfo = x.saveSt()
- m.SaveValue(4, st)
- m.Save(0, &x.Name)
- m.Save(1, &x.Arch)
- m.Save(2, &x.MemoryManager)
- m.Save(3, &x.fu)
+func (t *TaskContext) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ var stValue syscallTableInfo = t.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)
}
-func (x *TaskContext) afterLoad() {}
+func (t *TaskContext) afterLoad() {}
-func (x *TaskContext) StateLoad(m state.Source) {
- m.Load(0, &x.Name)
- m.Load(1, &x.Arch)
- m.Load(2, &x.MemoryManager)
- m.Load(3, &x.fu)
- m.LoadValue(4, new(syscallTableInfo), func(y interface{}) { x.loadSt(y.(syscallTableInfo)) })
+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 (x *execStop) StateTypeName() string {
+func (e *execStop) StateTypeName() string {
return "pkg/sentry/kernel.execStop"
}
-func (x *execStop) StateFields() []string {
+func (e *execStop) StateFields() []string {
return []string{}
}
-func (x *execStop) beforeSave() {}
+func (e *execStop) beforeSave() {}
-func (x *execStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (e *execStop) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
}
-func (x *execStop) afterLoad() {}
+func (e *execStop) afterLoad() {}
-func (x *execStop) StateLoad(m state.Source) {
+func (e *execStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *runSyscallAfterExecStop) StateTypeName() string {
+func (r *runSyscallAfterExecStop) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallAfterExecStop"
}
-func (x *runSyscallAfterExecStop) StateFields() []string {
+func (r *runSyscallAfterExecStop) StateFields() []string {
return []string{
"tc",
}
}
-func (x *runSyscallAfterExecStop) beforeSave() {}
+func (r *runSyscallAfterExecStop) beforeSave() {}
-func (x *runSyscallAfterExecStop) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.tc)
+func (r *runSyscallAfterExecStop) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.tc)
}
-func (x *runSyscallAfterExecStop) afterLoad() {}
+func (r *runSyscallAfterExecStop) afterLoad() {}
-func (x *runSyscallAfterExecStop) StateLoad(m state.Source) {
- m.Load(0, &x.tc)
+func (r *runSyscallAfterExecStop) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.tc)
}
-func (x *ExitStatus) StateTypeName() string {
+func (e *ExitStatus) StateTypeName() string {
return "pkg/sentry/kernel.ExitStatus"
}
-func (x *ExitStatus) StateFields() []string {
+func (e *ExitStatus) StateFields() []string {
return []string{
"Code",
"Signo",
}
}
-func (x *ExitStatus) beforeSave() {}
+func (e *ExitStatus) beforeSave() {}
-func (x *ExitStatus) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Code)
- m.Save(1, &x.Signo)
+func (e *ExitStatus) StateSave(stateSinkObject state.Sink) {
+ e.beforeSave()
+ stateSinkObject.Save(0, &e.Code)
+ stateSinkObject.Save(1, &e.Signo)
}
-func (x *ExitStatus) afterLoad() {}
+func (e *ExitStatus) afterLoad() {}
-func (x *ExitStatus) StateLoad(m state.Source) {
- m.Load(0, &x.Code)
- m.Load(1, &x.Signo)
+func (e *ExitStatus) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &e.Code)
+ stateSourceObject.Load(1, &e.Signo)
}
-func (x *runExit) StateTypeName() string {
+func (r *runExit) StateTypeName() string {
return "pkg/sentry/kernel.runExit"
}
-func (x *runExit) StateFields() []string {
+func (r *runExit) StateFields() []string {
return []string{}
}
-func (x *runExit) beforeSave() {}
+func (r *runExit) beforeSave() {}
-func (x *runExit) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runExit) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runExit) afterLoad() {}
+func (r *runExit) afterLoad() {}
-func (x *runExit) StateLoad(m state.Source) {
+func (r *runExit) StateLoad(stateSourceObject state.Source) {
}
-func (x *runExitMain) StateTypeName() string {
+func (r *runExitMain) StateTypeName() string {
return "pkg/sentry/kernel.runExitMain"
}
-func (x *runExitMain) StateFields() []string {
+func (r *runExitMain) StateFields() []string {
return []string{}
}
-func (x *runExitMain) beforeSave() {}
+func (r *runExitMain) beforeSave() {}
-func (x *runExitMain) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runExitMain) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runExitMain) afterLoad() {}
+func (r *runExitMain) afterLoad() {}
-func (x *runExitMain) StateLoad(m state.Source) {
+func (r *runExitMain) StateLoad(stateSourceObject state.Source) {
}
-func (x *runExitNotify) StateTypeName() string {
+func (r *runExitNotify) StateTypeName() string {
return "pkg/sentry/kernel.runExitNotify"
}
-func (x *runExitNotify) StateFields() []string {
+func (r *runExitNotify) StateFields() []string {
return []string{}
}
-func (x *runExitNotify) beforeSave() {}
+func (r *runExitNotify) beforeSave() {}
-func (x *runExitNotify) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runExitNotify) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runExitNotify) afterLoad() {}
+func (r *runExitNotify) afterLoad() {}
-func (x *runExitNotify) StateLoad(m state.Source) {
+func (r *runExitNotify) StateLoad(stateSourceObject state.Source) {
}
-func (x *taskList) StateTypeName() string {
+func (t *taskList) StateTypeName() string {
return "pkg/sentry/kernel.taskList"
}
-func (x *taskList) StateFields() []string {
+func (t *taskList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *taskList) beforeSave() {}
+func (t *taskList) beforeSave() {}
-func (x *taskList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (t *taskList) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.head)
+ stateSinkObject.Save(1, &t.tail)
}
-func (x *taskList) afterLoad() {}
+func (t *taskList) afterLoad() {}
-func (x *taskList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (t *taskList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.head)
+ stateSourceObject.Load(1, &t.tail)
}
-func (x *taskEntry) StateTypeName() string {
+func (t *taskEntry) StateTypeName() string {
return "pkg/sentry/kernel.taskEntry"
}
-func (x *taskEntry) StateFields() []string {
+func (t *taskEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *taskEntry) beforeSave() {}
+func (t *taskEntry) beforeSave() {}
-func (x *taskEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (t *taskEntry) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.next)
+ stateSinkObject.Save(1, &t.prev)
}
-func (x *taskEntry) afterLoad() {}
+func (t *taskEntry) afterLoad() {}
-func (x *taskEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (t *taskEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.next)
+ stateSourceObject.Load(1, &t.prev)
}
-func (x *runApp) StateTypeName() string {
+func (r *runApp) StateTypeName() string {
return "pkg/sentry/kernel.runApp"
}
-func (x *runApp) StateFields() []string {
+func (r *runApp) StateFields() []string {
return []string{}
}
-func (x *runApp) beforeSave() {}
+func (r *runApp) beforeSave() {}
-func (x *runApp) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runApp) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runApp) afterLoad() {}
+func (r *runApp) afterLoad() {}
-func (x *runApp) StateLoad(m state.Source) {
+func (r *runApp) StateLoad(stateSourceObject state.Source) {
}
-func (x *TaskGoroutineSchedInfo) StateTypeName() string {
+func (t *TaskGoroutineSchedInfo) StateTypeName() string {
return "pkg/sentry/kernel.TaskGoroutineSchedInfo"
}
-func (x *TaskGoroutineSchedInfo) StateFields() []string {
+func (t *TaskGoroutineSchedInfo) StateFields() []string {
return []string{
"Timestamp",
"State",
@@ -1635,215 +1635,215 @@ func (x *TaskGoroutineSchedInfo) StateFields() []string {
}
}
-func (x *TaskGoroutineSchedInfo) beforeSave() {}
+func (t *TaskGoroutineSchedInfo) beforeSave() {}
-func (x *TaskGoroutineSchedInfo) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Timestamp)
- m.Save(1, &x.State)
- m.Save(2, &x.UserTicks)
- m.Save(3, &x.SysTicks)
+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 (x *TaskGoroutineSchedInfo) afterLoad() {}
+func (t *TaskGoroutineSchedInfo) afterLoad() {}
-func (x *TaskGoroutineSchedInfo) StateLoad(m state.Source) {
- m.Load(0, &x.Timestamp)
- m.Load(1, &x.State)
- m.Load(2, &x.UserTicks)
- m.Load(3, &x.SysTicks)
+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 (x *taskClock) StateTypeName() string {
+func (t *taskClock) StateTypeName() string {
return "pkg/sentry/kernel.taskClock"
}
-func (x *taskClock) StateFields() []string {
+func (t *taskClock) StateFields() []string {
return []string{
"t",
"includeSys",
}
}
-func (x *taskClock) beforeSave() {}
+func (t *taskClock) beforeSave() {}
-func (x *taskClock) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.t)
- m.Save(1, &x.includeSys)
+func (t *taskClock) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.t)
+ stateSinkObject.Save(1, &t.includeSys)
}
-func (x *taskClock) afterLoad() {}
+func (t *taskClock) afterLoad() {}
-func (x *taskClock) StateLoad(m state.Source) {
- m.Load(0, &x.t)
- m.Load(1, &x.includeSys)
+func (t *taskClock) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.t)
+ stateSourceObject.Load(1, &t.includeSys)
}
-func (x *tgClock) StateTypeName() string {
+func (t *tgClock) StateTypeName() string {
return "pkg/sentry/kernel.tgClock"
}
-func (x *tgClock) StateFields() []string {
+func (t *tgClock) StateFields() []string {
return []string{
"tg",
"includeSys",
}
}
-func (x *tgClock) beforeSave() {}
+func (t *tgClock) beforeSave() {}
-func (x *tgClock) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.tg)
- m.Save(1, &x.includeSys)
+func (t *tgClock) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.tg)
+ stateSinkObject.Save(1, &t.includeSys)
}
-func (x *tgClock) afterLoad() {}
+func (t *tgClock) afterLoad() {}
-func (x *tgClock) StateLoad(m state.Source) {
- m.Load(0, &x.tg)
- m.Load(1, &x.includeSys)
+func (t *tgClock) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.tg)
+ stateSourceObject.Load(1, &t.includeSys)
}
-func (x *groupStop) StateTypeName() string {
+func (g *groupStop) StateTypeName() string {
return "pkg/sentry/kernel.groupStop"
}
-func (x *groupStop) StateFields() []string {
+func (g *groupStop) StateFields() []string {
return []string{}
}
-func (x *groupStop) beforeSave() {}
+func (g *groupStop) beforeSave() {}
-func (x *groupStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (g *groupStop) StateSave(stateSinkObject state.Sink) {
+ g.beforeSave()
}
-func (x *groupStop) afterLoad() {}
+func (g *groupStop) afterLoad() {}
-func (x *groupStop) StateLoad(m state.Source) {
+func (g *groupStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *runInterrupt) StateTypeName() string {
+func (r *runInterrupt) StateTypeName() string {
return "pkg/sentry/kernel.runInterrupt"
}
-func (x *runInterrupt) StateFields() []string {
+func (r *runInterrupt) StateFields() []string {
return []string{}
}
-func (x *runInterrupt) beforeSave() {}
+func (r *runInterrupt) beforeSave() {}
-func (x *runInterrupt) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runInterrupt) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runInterrupt) afterLoad() {}
+func (r *runInterrupt) afterLoad() {}
-func (x *runInterrupt) StateLoad(m state.Source) {
+func (r *runInterrupt) StateLoad(stateSourceObject state.Source) {
}
-func (x *runInterruptAfterSignalDeliveryStop) StateTypeName() string {
+func (r *runInterruptAfterSignalDeliveryStop) StateTypeName() string {
return "pkg/sentry/kernel.runInterruptAfterSignalDeliveryStop"
}
-func (x *runInterruptAfterSignalDeliveryStop) StateFields() []string {
+func (r *runInterruptAfterSignalDeliveryStop) StateFields() []string {
return []string{}
}
-func (x *runInterruptAfterSignalDeliveryStop) beforeSave() {}
+func (r *runInterruptAfterSignalDeliveryStop) beforeSave() {}
-func (x *runInterruptAfterSignalDeliveryStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runInterruptAfterSignalDeliveryStop) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runInterruptAfterSignalDeliveryStop) afterLoad() {}
+func (r *runInterruptAfterSignalDeliveryStop) afterLoad() {}
-func (x *runInterruptAfterSignalDeliveryStop) StateLoad(m state.Source) {
+func (r *runInterruptAfterSignalDeliveryStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *runSyscallAfterSyscallEnterStop) StateTypeName() string {
+func (r *runSyscallAfterSyscallEnterStop) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallAfterSyscallEnterStop"
}
-func (x *runSyscallAfterSyscallEnterStop) StateFields() []string {
+func (r *runSyscallAfterSyscallEnterStop) StateFields() []string {
return []string{}
}
-func (x *runSyscallAfterSyscallEnterStop) beforeSave() {}
+func (r *runSyscallAfterSyscallEnterStop) beforeSave() {}
-func (x *runSyscallAfterSyscallEnterStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runSyscallAfterSyscallEnterStop) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runSyscallAfterSyscallEnterStop) afterLoad() {}
+func (r *runSyscallAfterSyscallEnterStop) afterLoad() {}
-func (x *runSyscallAfterSyscallEnterStop) StateLoad(m state.Source) {
+func (r *runSyscallAfterSyscallEnterStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *runSyscallAfterSysemuStop) StateTypeName() string {
+func (r *runSyscallAfterSysemuStop) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallAfterSysemuStop"
}
-func (x *runSyscallAfterSysemuStop) StateFields() []string {
+func (r *runSyscallAfterSysemuStop) StateFields() []string {
return []string{}
}
-func (x *runSyscallAfterSysemuStop) beforeSave() {}
+func (r *runSyscallAfterSysemuStop) beforeSave() {}
-func (x *runSyscallAfterSysemuStop) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runSyscallAfterSysemuStop) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runSyscallAfterSysemuStop) afterLoad() {}
+func (r *runSyscallAfterSysemuStop) afterLoad() {}
-func (x *runSyscallAfterSysemuStop) StateLoad(m state.Source) {
+func (r *runSyscallAfterSysemuStop) StateLoad(stateSourceObject state.Source) {
}
-func (x *runSyscallReinvoke) StateTypeName() string {
+func (r *runSyscallReinvoke) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallReinvoke"
}
-func (x *runSyscallReinvoke) StateFields() []string {
+func (r *runSyscallReinvoke) StateFields() []string {
return []string{}
}
-func (x *runSyscallReinvoke) beforeSave() {}
+func (r *runSyscallReinvoke) beforeSave() {}
-func (x *runSyscallReinvoke) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runSyscallReinvoke) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runSyscallReinvoke) afterLoad() {}
+func (r *runSyscallReinvoke) afterLoad() {}
-func (x *runSyscallReinvoke) StateLoad(m state.Source) {
+func (r *runSyscallReinvoke) StateLoad(stateSourceObject state.Source) {
}
-func (x *runSyscallExit) StateTypeName() string {
+func (r *runSyscallExit) StateTypeName() string {
return "pkg/sentry/kernel.runSyscallExit"
}
-func (x *runSyscallExit) StateFields() []string {
+func (r *runSyscallExit) StateFields() []string {
return []string{}
}
-func (x *runSyscallExit) beforeSave() {}
+func (r *runSyscallExit) beforeSave() {}
-func (x *runSyscallExit) StateSave(m state.Sink) {
- x.beforeSave()
+func (r *runSyscallExit) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
}
-func (x *runSyscallExit) afterLoad() {}
+func (r *runSyscallExit) afterLoad() {}
-func (x *runSyscallExit) StateLoad(m state.Source) {
+func (r *runSyscallExit) StateLoad(stateSourceObject state.Source) {
}
-func (x *ThreadGroup) StateTypeName() string {
+func (t *ThreadGroup) StateTypeName() string {
return "pkg/sentry/kernel.ThreadGroup"
}
-func (x *ThreadGroup) StateFields() []string {
+func (t *ThreadGroup) StateFields() []string {
return []string{
"threadGroupNode",
"signalHandlers",
@@ -1881,138 +1881,138 @@ func (x *ThreadGroup) StateFields() []string {
}
}
-func (x *ThreadGroup) beforeSave() {}
-
-func (x *ThreadGroup) StateSave(m state.Sink) {
- x.beforeSave()
- var oldRSeqCritical *OldRSeqCriticalRegion = x.saveOldRSeqCritical()
- m.SaveValue(29, oldRSeqCritical)
- m.Save(0, &x.threadGroupNode)
- m.Save(1, &x.signalHandlers)
- m.Save(2, &x.pendingSignals)
- m.Save(3, &x.groupStopDequeued)
- m.Save(4, &x.groupStopSignal)
- m.Save(5, &x.groupStopPendingCount)
- m.Save(6, &x.groupStopComplete)
- m.Save(7, &x.groupStopWaitable)
- m.Save(8, &x.groupContNotify)
- m.Save(9, &x.groupContInterrupted)
- m.Save(10, &x.groupContWaitable)
- m.Save(11, &x.exiting)
- m.Save(12, &x.exitStatus)
- m.Save(13, &x.terminationSignal)
- m.Save(14, &x.itimerRealTimer)
- m.Save(15, &x.itimerVirtSetting)
- m.Save(16, &x.itimerProfSetting)
- m.Save(17, &x.rlimitCPUSoftSetting)
- m.Save(18, &x.cpuTimersEnabled)
- m.Save(19, &x.timers)
- m.Save(20, &x.nextTimerID)
- m.Save(21, &x.exitedCPUStats)
- m.Save(22, &x.childCPUStats)
- m.Save(23, &x.ioUsage)
- m.Save(24, &x.maxRSS)
- m.Save(25, &x.childMaxRSS)
- m.Save(26, &x.limits)
- m.Save(27, &x.processGroup)
- m.Save(28, &x.execed)
- m.Save(30, &x.mounts)
- m.Save(31, &x.tty)
- m.Save(32, &x.oomScoreAdj)
-}
-
-func (x *ThreadGroup) afterLoad() {}
-
-func (x *ThreadGroup) StateLoad(m state.Source) {
- m.Load(0, &x.threadGroupNode)
- m.Load(1, &x.signalHandlers)
- m.Load(2, &x.pendingSignals)
- m.Load(3, &x.groupStopDequeued)
- m.Load(4, &x.groupStopSignal)
- m.Load(5, &x.groupStopPendingCount)
- m.Load(6, &x.groupStopComplete)
- m.Load(7, &x.groupStopWaitable)
- m.Load(8, &x.groupContNotify)
- m.Load(9, &x.groupContInterrupted)
- m.Load(10, &x.groupContWaitable)
- m.Load(11, &x.exiting)
- m.Load(12, &x.exitStatus)
- m.Load(13, &x.terminationSignal)
- m.Load(14, &x.itimerRealTimer)
- m.Load(15, &x.itimerVirtSetting)
- m.Load(16, &x.itimerProfSetting)
- m.Load(17, &x.rlimitCPUSoftSetting)
- m.Load(18, &x.cpuTimersEnabled)
- m.Load(19, &x.timers)
- m.Load(20, &x.nextTimerID)
- m.Load(21, &x.exitedCPUStats)
- m.Load(22, &x.childCPUStats)
- m.Load(23, &x.ioUsage)
- m.Load(24, &x.maxRSS)
- m.Load(25, &x.childMaxRSS)
- m.Load(26, &x.limits)
- m.Load(27, &x.processGroup)
- m.Load(28, &x.execed)
- m.Load(30, &x.mounts)
- m.Load(31, &x.tty)
- m.Load(32, &x.oomScoreAdj)
- m.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { x.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
-}
-
-func (x *itimerRealListener) StateTypeName() string {
+func (t *ThreadGroup) beforeSave() {}
+
+func (t *ThreadGroup) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ var oldRSeqCriticalValue *OldRSeqCriticalRegion = t.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 {
return "pkg/sentry/kernel.itimerRealListener"
}
-func (x *itimerRealListener) StateFields() []string {
+func (i *itimerRealListener) StateFields() []string {
return []string{
"tg",
}
}
-func (x *itimerRealListener) beforeSave() {}
+func (i *itimerRealListener) beforeSave() {}
-func (x *itimerRealListener) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.tg)
+func (i *itimerRealListener) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.tg)
}
-func (x *itimerRealListener) afterLoad() {}
+func (i *itimerRealListener) afterLoad() {}
-func (x *itimerRealListener) StateLoad(m state.Source) {
- m.Load(0, &x.tg)
+func (i *itimerRealListener) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.tg)
}
-func (x *TaskSet) StateTypeName() string {
+func (t *TaskSet) StateTypeName() string {
return "pkg/sentry/kernel.TaskSet"
}
-func (x *TaskSet) StateFields() []string {
+func (t *TaskSet) StateFields() []string {
return []string{
"Root",
"sessions",
}
}
-func (x *TaskSet) beforeSave() {}
+func (t *TaskSet) beforeSave() {}
-func (x *TaskSet) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Root)
- m.Save(1, &x.sessions)
+func (t *TaskSet) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.Root)
+ stateSinkObject.Save(1, &t.sessions)
}
-func (x *TaskSet) afterLoad() {}
+func (t *TaskSet) afterLoad() {}
-func (x *TaskSet) StateLoad(m state.Source) {
- m.Load(0, &x.Root)
- m.Load(1, &x.sessions)
+func (t *TaskSet) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.Root)
+ stateSourceObject.Load(1, &t.sessions)
}
-func (x *PIDNamespace) StateTypeName() string {
+func (p *PIDNamespace) StateTypeName() string {
return "pkg/sentry/kernel.PIDNamespace"
}
-func (x *PIDNamespace) StateFields() []string {
+func (p *PIDNamespace) StateFields() []string {
return []string{
"owner",
"parent",
@@ -2029,46 +2029,46 @@ func (x *PIDNamespace) StateFields() []string {
}
}
-func (x *PIDNamespace) beforeSave() {}
-
-func (x *PIDNamespace) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.owner)
- m.Save(1, &x.parent)
- m.Save(2, &x.userns)
- m.Save(3, &x.last)
- m.Save(4, &x.tasks)
- m.Save(5, &x.tids)
- m.Save(6, &x.tgids)
- m.Save(7, &x.sessions)
- m.Save(8, &x.sids)
- m.Save(9, &x.processGroups)
- m.Save(10, &x.pgids)
- m.Save(11, &x.exiting)
-}
-
-func (x *PIDNamespace) afterLoad() {}
-
-func (x *PIDNamespace) StateLoad(m state.Source) {
- m.Load(0, &x.owner)
- m.Load(1, &x.parent)
- m.Load(2, &x.userns)
- m.Load(3, &x.last)
- m.Load(4, &x.tasks)
- m.Load(5, &x.tids)
- m.Load(6, &x.tgids)
- m.Load(7, &x.sessions)
- m.Load(8, &x.sids)
- m.Load(9, &x.processGroups)
- m.Load(10, &x.pgids)
- m.Load(11, &x.exiting)
-}
-
-func (x *threadGroupNode) StateTypeName() 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 (t *threadGroupNode) StateTypeName() string {
return "pkg/sentry/kernel.threadGroupNode"
}
-func (x *threadGroupNode) StateFields() []string {
+func (t *threadGroupNode) StateFields() []string {
return []string{
"pidns",
"leader",
@@ -2080,36 +2080,36 @@ func (x *threadGroupNode) StateFields() []string {
}
}
-func (x *threadGroupNode) beforeSave() {}
+func (t *threadGroupNode) beforeSave() {}
-func (x *threadGroupNode) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.pidns)
- m.Save(1, &x.leader)
- m.Save(2, &x.execing)
- m.Save(3, &x.tasks)
- m.Save(4, &x.tasksCount)
- m.Save(5, &x.liveTasks)
- m.Save(6, &x.activeTasks)
+func (t *threadGroupNode) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.pidns)
+ stateSinkObject.Save(1, &t.leader)
+ stateSinkObject.Save(2, &t.execing)
+ stateSinkObject.Save(3, &t.tasks)
+ stateSinkObject.Save(4, &t.tasksCount)
+ stateSinkObject.Save(5, &t.liveTasks)
+ stateSinkObject.Save(6, &t.activeTasks)
}
-func (x *threadGroupNode) afterLoad() {}
+func (t *threadGroupNode) afterLoad() {}
-func (x *threadGroupNode) StateLoad(m state.Source) {
- m.Load(0, &x.pidns)
- m.Load(1, &x.leader)
- m.Load(2, &x.execing)
- m.Load(3, &x.tasks)
- m.Load(4, &x.tasksCount)
- m.Load(5, &x.liveTasks)
- m.Load(6, &x.activeTasks)
+func (t *threadGroupNode) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.pidns)
+ stateSourceObject.Load(1, &t.leader)
+ stateSourceObject.Load(2, &t.execing)
+ stateSourceObject.Load(3, &t.tasks)
+ stateSourceObject.Load(4, &t.tasksCount)
+ stateSourceObject.Load(5, &t.liveTasks)
+ stateSourceObject.Load(6, &t.activeTasks)
}
-func (x *taskNode) StateTypeName() string {
+func (t *taskNode) StateTypeName() string {
return "pkg/sentry/kernel.taskNode"
}
-func (x *taskNode) StateFields() []string {
+func (t *taskNode) StateFields() []string {
return []string{
"tg",
"taskEntry",
@@ -2119,32 +2119,32 @@ func (x *taskNode) StateFields() []string {
}
}
-func (x *taskNode) beforeSave() {}
+func (t *taskNode) beforeSave() {}
-func (x *taskNode) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.tg)
- m.Save(1, &x.taskEntry)
- m.Save(2, &x.parent)
- m.Save(3, &x.children)
- m.Save(4, &x.childPIDNamespace)
+func (t *taskNode) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.tg)
+ stateSinkObject.Save(1, &t.taskEntry)
+ stateSinkObject.Save(2, &t.parent)
+ stateSinkObject.Save(3, &t.children)
+ stateSinkObject.Save(4, &t.childPIDNamespace)
}
-func (x *taskNode) afterLoad() {}
+func (t *taskNode) afterLoad() {}
-func (x *taskNode) StateLoad(m state.Source) {
- m.LoadWait(0, &x.tg)
- m.Load(1, &x.taskEntry)
- m.Load(2, &x.parent)
- m.Load(3, &x.children)
- m.Load(4, &x.childPIDNamespace)
+func (t *taskNode) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.LoadWait(0, &t.tg)
+ stateSourceObject.Load(1, &t.taskEntry)
+ stateSourceObject.Load(2, &t.parent)
+ stateSourceObject.Load(3, &t.children)
+ stateSourceObject.Load(4, &t.childPIDNamespace)
}
-func (x *Timekeeper) StateTypeName() string {
+func (t *Timekeeper) StateTypeName() string {
return "pkg/sentry/kernel.Timekeeper"
}
-func (x *Timekeeper) StateFields() []string {
+func (t *Timekeeper) StateFields() []string {
return []string{
"bootTime",
"saveMonotonic",
@@ -2153,79 +2153,79 @@ func (x *Timekeeper) StateFields() []string {
}
}
-func (x *Timekeeper) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.bootTime)
- m.Save(1, &x.saveMonotonic)
- m.Save(2, &x.saveRealtime)
- m.Save(3, &x.params)
+func (t *Timekeeper) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.bootTime)
+ stateSinkObject.Save(1, &t.saveMonotonic)
+ stateSinkObject.Save(2, &t.saveRealtime)
+ stateSinkObject.Save(3, &t.params)
}
-func (x *Timekeeper) StateLoad(m state.Source) {
- m.Load(0, &x.bootTime)
- m.Load(1, &x.saveMonotonic)
- m.Load(2, &x.saveRealtime)
- m.Load(3, &x.params)
- m.AfterLoad(x.afterLoad)
+func (t *Timekeeper) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.bootTime)
+ stateSourceObject.Load(1, &t.saveMonotonic)
+ stateSourceObject.Load(2, &t.saveRealtime)
+ stateSourceObject.Load(3, &t.params)
+ stateSourceObject.AfterLoad(t.afterLoad)
}
-func (x *timekeeperClock) StateTypeName() string {
+func (t *timekeeperClock) StateTypeName() string {
return "pkg/sentry/kernel.timekeeperClock"
}
-func (x *timekeeperClock) StateFields() []string {
+func (t *timekeeperClock) StateFields() []string {
return []string{
"tk",
"c",
}
}
-func (x *timekeeperClock) beforeSave() {}
+func (t *timekeeperClock) beforeSave() {}
-func (x *timekeeperClock) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.tk)
- m.Save(1, &x.c)
+func (t *timekeeperClock) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.tk)
+ stateSinkObject.Save(1, &t.c)
}
-func (x *timekeeperClock) afterLoad() {}
+func (t *timekeeperClock) afterLoad() {}
-func (x *timekeeperClock) StateLoad(m state.Source) {
- m.Load(0, &x.tk)
- m.Load(1, &x.c)
+func (t *timekeeperClock) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.tk)
+ stateSourceObject.Load(1, &t.c)
}
-func (x *TTY) StateTypeName() string {
+func (t *TTY) StateTypeName() string {
return "pkg/sentry/kernel.TTY"
}
-func (x *TTY) StateFields() []string {
+func (t *TTY) StateFields() []string {
return []string{
"Index",
"tg",
}
}
-func (x *TTY) beforeSave() {}
+func (t *TTY) beforeSave() {}
-func (x *TTY) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Index)
- m.Save(1, &x.tg)
+func (t *TTY) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.Index)
+ stateSinkObject.Save(1, &t.tg)
}
-func (x *TTY) afterLoad() {}
+func (t *TTY) afterLoad() {}
-func (x *TTY) StateLoad(m state.Source) {
- m.Load(0, &x.Index)
- m.Load(1, &x.tg)
+func (t *TTY) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.Index)
+ stateSourceObject.Load(1, &t.tg)
}
-func (x *UTSNamespace) StateTypeName() string {
+func (u *UTSNamespace) StateTypeName() string {
return "pkg/sentry/kernel.UTSNamespace"
}
-func (x *UTSNamespace) StateFields() []string {
+func (u *UTSNamespace) StateFields() []string {
return []string{
"hostName",
"domainName",
@@ -2233,28 +2233,28 @@ func (x *UTSNamespace) StateFields() []string {
}
}
-func (x *UTSNamespace) beforeSave() {}
+func (u *UTSNamespace) beforeSave() {}
-func (x *UTSNamespace) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.hostName)
- m.Save(1, &x.domainName)
- m.Save(2, &x.userns)
+func (u *UTSNamespace) StateSave(stateSinkObject state.Sink) {
+ u.beforeSave()
+ stateSinkObject.Save(0, &u.hostName)
+ stateSinkObject.Save(1, &u.domainName)
+ stateSinkObject.Save(2, &u.userns)
}
-func (x *UTSNamespace) afterLoad() {}
+func (u *UTSNamespace) afterLoad() {}
-func (x *UTSNamespace) StateLoad(m state.Source) {
- m.Load(0, &x.hostName)
- m.Load(1, &x.domainName)
- m.Load(2, &x.userns)
+func (u *UTSNamespace) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &u.hostName)
+ stateSourceObject.Load(1, &u.domainName)
+ stateSourceObject.Load(2, &u.userns)
}
-func (x *VDSOParamPage) StateTypeName() string {
+func (v *VDSOParamPage) StateTypeName() string {
return "pkg/sentry/kernel.VDSOParamPage"
}
-func (x *VDSOParamPage) StateFields() []string {
+func (v *VDSOParamPage) StateFields() []string {
return []string{
"mfp",
"fr",
@@ -2263,23 +2263,23 @@ func (x *VDSOParamPage) StateFields() []string {
}
}
-func (x *VDSOParamPage) beforeSave() {}
+func (v *VDSOParamPage) beforeSave() {}
-func (x *VDSOParamPage) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.mfp)
- m.Save(1, &x.fr)
- m.Save(2, &x.seq)
- m.Save(3, &x.copyScratchBuffer)
+func (v *VDSOParamPage) StateSave(stateSinkObject state.Sink) {
+ v.beforeSave()
+ stateSinkObject.Save(0, &v.mfp)
+ stateSinkObject.Save(1, &v.fr)
+ stateSinkObject.Save(2, &v.seq)
+ stateSinkObject.Save(3, &v.copyScratchBuffer)
}
-func (x *VDSOParamPage) afterLoad() {}
+func (v *VDSOParamPage) afterLoad() {}
-func (x *VDSOParamPage) StateLoad(m state.Source) {
- m.Load(0, &x.mfp)
- m.Load(1, &x.fr)
- m.Load(2, &x.seq)
- m.Load(3, &x.copyScratchBuffer)
+func (v *VDSOParamPage) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &v.mfp)
+ stateSourceObject.Load(1, &v.fr)
+ stateSourceObject.Load(2, &v.seq)
+ stateSourceObject.Load(3, &v.copyScratchBuffer)
}
func init() {
diff --git a/pkg/sentry/kernel/pipe/pipe_state_autogen.go b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
index df55abce6..031ea2cc2 100644
--- a/pkg/sentry/kernel/pipe/pipe_state_autogen.go
+++ b/pkg/sentry/kernel/pipe/pipe_state_autogen.go
@@ -6,37 +6,37 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *inodeOperations) StateTypeName() string {
+func (i *inodeOperations) StateTypeName() string {
return "pkg/sentry/kernel/pipe.inodeOperations"
}
-func (x *inodeOperations) StateFields() []string {
+func (i *inodeOperations) StateFields() []string {
return []string{
"InodeSimpleAttributes",
"p",
}
}
-func (x *inodeOperations) beforeSave() {}
+func (i *inodeOperations) beforeSave() {}
-func (x *inodeOperations) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.InodeSimpleAttributes)
- m.Save(1, &x.p)
+func (i *inodeOperations) StateSave(stateSinkObject state.Sink) {
+ i.beforeSave()
+ stateSinkObject.Save(0, &i.InodeSimpleAttributes)
+ stateSinkObject.Save(1, &i.p)
}
-func (x *inodeOperations) afterLoad() {}
+func (i *inodeOperations) afterLoad() {}
-func (x *inodeOperations) StateLoad(m state.Source) {
- m.Load(0, &x.InodeSimpleAttributes)
- m.Load(1, &x.p)
+func (i *inodeOperations) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &i.InodeSimpleAttributes)
+ stateSourceObject.Load(1, &i.p)
}
-func (x *Pipe) StateTypeName() string {
+func (p *Pipe) StateTypeName() string {
return "pkg/sentry/kernel/pipe.Pipe"
}
-func (x *Pipe) StateFields() []string {
+func (p *Pipe) StateFields() []string {
return []string{
"isNamed",
"atomicIOBytes",
@@ -48,98 +48,98 @@ func (x *Pipe) StateFields() []string {
}
}
-func (x *Pipe) beforeSave() {}
+func (p *Pipe) beforeSave() {}
-func (x *Pipe) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.isNamed)
- m.Save(1, &x.atomicIOBytes)
- m.Save(2, &x.readers)
- m.Save(3, &x.writers)
- m.Save(4, &x.view)
- m.Save(5, &x.max)
- m.Save(6, &x.hadWriter)
+func (p *Pipe) StateSave(stateSinkObject state.Sink) {
+ p.beforeSave()
+ stateSinkObject.Save(0, &p.isNamed)
+ stateSinkObject.Save(1, &p.atomicIOBytes)
+ stateSinkObject.Save(2, &p.readers)
+ stateSinkObject.Save(3, &p.writers)
+ stateSinkObject.Save(4, &p.view)
+ stateSinkObject.Save(5, &p.max)
+ stateSinkObject.Save(6, &p.hadWriter)
}
-func (x *Pipe) afterLoad() {}
+func (p *Pipe) afterLoad() {}
-func (x *Pipe) StateLoad(m state.Source) {
- m.Load(0, &x.isNamed)
- m.Load(1, &x.atomicIOBytes)
- m.Load(2, &x.readers)
- m.Load(3, &x.writers)
- m.Load(4, &x.view)
- m.Load(5, &x.max)
- m.Load(6, &x.hadWriter)
+func (p *Pipe) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &p.isNamed)
+ stateSourceObject.Load(1, &p.atomicIOBytes)
+ stateSourceObject.Load(2, &p.readers)
+ stateSourceObject.Load(3, &p.writers)
+ stateSourceObject.Load(4, &p.view)
+ stateSourceObject.Load(5, &p.max)
+ stateSourceObject.Load(6, &p.hadWriter)
}
-func (x *Reader) StateTypeName() string {
+func (r *Reader) StateTypeName() string {
return "pkg/sentry/kernel/pipe.Reader"
}
-func (x *Reader) StateFields() []string {
+func (r *Reader) StateFields() []string {
return []string{
"ReaderWriter",
}
}
-func (x *Reader) beforeSave() {}
+func (r *Reader) beforeSave() {}
-func (x *Reader) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ReaderWriter)
+func (r *Reader) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.ReaderWriter)
}
-func (x *Reader) afterLoad() {}
+func (r *Reader) afterLoad() {}
-func (x *Reader) StateLoad(m state.Source) {
- m.Load(0, &x.ReaderWriter)
+func (r *Reader) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.ReaderWriter)
}
-func (x *ReaderWriter) StateTypeName() string {
+func (r *ReaderWriter) StateTypeName() string {
return "pkg/sentry/kernel/pipe.ReaderWriter"
}
-func (x *ReaderWriter) StateFields() []string {
+func (r *ReaderWriter) StateFields() []string {
return []string{
"Pipe",
}
}
-func (x *ReaderWriter) beforeSave() {}
+func (r *ReaderWriter) beforeSave() {}
-func (x *ReaderWriter) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Pipe)
+func (r *ReaderWriter) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.Pipe)
}
-func (x *ReaderWriter) afterLoad() {}
+func (r *ReaderWriter) afterLoad() {}
-func (x *ReaderWriter) StateLoad(m state.Source) {
- m.Load(0, &x.Pipe)
+func (r *ReaderWriter) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.Pipe)
}
-func (x *Writer) StateTypeName() string {
+func (w *Writer) StateTypeName() string {
return "pkg/sentry/kernel/pipe.Writer"
}
-func (x *Writer) StateFields() []string {
+func (w *Writer) StateFields() []string {
return []string{
"ReaderWriter",
}
}
-func (x *Writer) beforeSave() {}
+func (w *Writer) beforeSave() {}
-func (x *Writer) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ReaderWriter)
+func (w *Writer) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.ReaderWriter)
}
-func (x *Writer) afterLoad() {}
+func (w *Writer) afterLoad() {}
-func (x *Writer) StateLoad(m state.Source) {
- m.Load(0, &x.ReaderWriter)
+func (w *Writer) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.ReaderWriter)
}
func init() {
diff --git a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
index fe5adfbee..80358c6e3 100644
--- a/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
+++ b/pkg/sentry/kernel/semaphore/semaphore_state_autogen.go
@@ -6,11 +6,11 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *Registry) StateTypeName() string {
+func (r *Registry) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.Registry"
}
-func (x *Registry) StateFields() []string {
+func (r *Registry) StateFields() []string {
return []string{
"userNS",
"semaphores",
@@ -18,28 +18,28 @@ func (x *Registry) StateFields() []string {
}
}
-func (x *Registry) beforeSave() {}
+func (r *Registry) beforeSave() {}
-func (x *Registry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.userNS)
- m.Save(1, &x.semaphores)
- m.Save(2, &x.lastIDUsed)
+func (r *Registry) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.userNS)
+ stateSinkObject.Save(1, &r.semaphores)
+ stateSinkObject.Save(2, &r.lastIDUsed)
}
-func (x *Registry) afterLoad() {}
+func (r *Registry) afterLoad() {}
-func (x *Registry) StateLoad(m state.Source) {
- m.Load(0, &x.userNS)
- m.Load(1, &x.semaphores)
- m.Load(2, &x.lastIDUsed)
+func (r *Registry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.userNS)
+ stateSourceObject.Load(1, &r.semaphores)
+ stateSourceObject.Load(2, &r.lastIDUsed)
}
-func (x *Set) StateTypeName() string {
+func (s *Set) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.Set"
}
-func (x *Set) StateFields() []string {
+func (s *Set) StateFields() []string {
return []string{
"registry",
"ID",
@@ -54,71 +54,71 @@ func (x *Set) StateFields() []string {
}
}
-func (x *Set) beforeSave() {}
+func (s *Set) beforeSave() {}
-func (x *Set) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.registry)
- m.Save(1, &x.ID)
- m.Save(2, &x.key)
- m.Save(3, &x.creator)
- m.Save(4, &x.owner)
- m.Save(5, &x.perms)
- m.Save(6, &x.opTime)
- m.Save(7, &x.changeTime)
- m.Save(8, &x.sems)
- m.Save(9, &x.dead)
+func (s *Set) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.registry)
+ stateSinkObject.Save(1, &s.ID)
+ stateSinkObject.Save(2, &s.key)
+ stateSinkObject.Save(3, &s.creator)
+ stateSinkObject.Save(4, &s.owner)
+ stateSinkObject.Save(5, &s.perms)
+ stateSinkObject.Save(6, &s.opTime)
+ stateSinkObject.Save(7, &s.changeTime)
+ stateSinkObject.Save(8, &s.sems)
+ stateSinkObject.Save(9, &s.dead)
}
-func (x *Set) afterLoad() {}
+func (s *Set) afterLoad() {}
-func (x *Set) StateLoad(m state.Source) {
- m.Load(0, &x.registry)
- m.Load(1, &x.ID)
- m.Load(2, &x.key)
- m.Load(3, &x.creator)
- m.Load(4, &x.owner)
- m.Load(5, &x.perms)
- m.Load(6, &x.opTime)
- m.Load(7, &x.changeTime)
- m.Load(8, &x.sems)
- m.Load(9, &x.dead)
+func (s *Set) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.registry)
+ stateSourceObject.Load(1, &s.ID)
+ stateSourceObject.Load(2, &s.key)
+ stateSourceObject.Load(3, &s.creator)
+ stateSourceObject.Load(4, &s.owner)
+ stateSourceObject.Load(5, &s.perms)
+ stateSourceObject.Load(6, &s.opTime)
+ stateSourceObject.Load(7, &s.changeTime)
+ stateSourceObject.Load(8, &s.sems)
+ stateSourceObject.Load(9, &s.dead)
}
-func (x *sem) StateTypeName() string {
+func (s *sem) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.sem"
}
-func (x *sem) StateFields() []string {
+func (s *sem) StateFields() []string {
return []string{
"value",
"pid",
}
}
-func (x *sem) beforeSave() {}
+func (s *sem) beforeSave() {}
-func (x *sem) StateSave(m state.Sink) {
- x.beforeSave()
- if !state.IsZeroValue(&x.waiters) {
- state.Failf("waiters is %#v, expected zero", &x.waiters)
+func (s *sem) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ if !state.IsZeroValue(&s.waiters) {
+ state.Failf("waiters is %#v, expected zero", &s.waiters)
}
- m.Save(0, &x.value)
- m.Save(1, &x.pid)
+ stateSinkObject.Save(0, &s.value)
+ stateSinkObject.Save(1, &s.pid)
}
-func (x *sem) afterLoad() {}
+func (s *sem) afterLoad() {}
-func (x *sem) StateLoad(m state.Source) {
- m.Load(0, &x.value)
- m.Load(1, &x.pid)
+func (s *sem) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.value)
+ stateSourceObject.Load(1, &s.pid)
}
-func (x *waiter) StateTypeName() string {
+func (w *waiter) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.waiter"
}
-func (x *waiter) StateFields() []string {
+func (w *waiter) StateFields() []string {
return []string{
"waiterEntry",
"value",
@@ -126,73 +126,73 @@ func (x *waiter) StateFields() []string {
}
}
-func (x *waiter) beforeSave() {}
+func (w *waiter) beforeSave() {}
-func (x *waiter) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.waiterEntry)
- m.Save(1, &x.value)
- m.Save(2, &x.ch)
+func (w *waiter) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.waiterEntry)
+ stateSinkObject.Save(1, &w.value)
+ stateSinkObject.Save(2, &w.ch)
}
-func (x *waiter) afterLoad() {}
+func (w *waiter) afterLoad() {}
-func (x *waiter) StateLoad(m state.Source) {
- m.Load(0, &x.waiterEntry)
- m.Load(1, &x.value)
- m.Load(2, &x.ch)
+func (w *waiter) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.waiterEntry)
+ stateSourceObject.Load(1, &w.value)
+ stateSourceObject.Load(2, &w.ch)
}
-func (x *waiterList) StateTypeName() string {
+func (w *waiterList) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.waiterList"
}
-func (x *waiterList) StateFields() []string {
+func (w *waiterList) StateFields() []string {
return []string{
"head",
"tail",
}
}
-func (x *waiterList) beforeSave() {}
+func (w *waiterList) beforeSave() {}
-func (x *waiterList) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.head)
- m.Save(1, &x.tail)
+func (w *waiterList) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.head)
+ stateSinkObject.Save(1, &w.tail)
}
-func (x *waiterList) afterLoad() {}
+func (w *waiterList) afterLoad() {}
-func (x *waiterList) StateLoad(m state.Source) {
- m.Load(0, &x.head)
- m.Load(1, &x.tail)
+func (w *waiterList) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.head)
+ stateSourceObject.Load(1, &w.tail)
}
-func (x *waiterEntry) StateTypeName() string {
+func (w *waiterEntry) StateTypeName() string {
return "pkg/sentry/kernel/semaphore.waiterEntry"
}
-func (x *waiterEntry) StateFields() []string {
+func (w *waiterEntry) StateFields() []string {
return []string{
"next",
"prev",
}
}
-func (x *waiterEntry) beforeSave() {}
+func (w *waiterEntry) beforeSave() {}
-func (x *waiterEntry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.next)
- m.Save(1, &x.prev)
+func (w *waiterEntry) StateSave(stateSinkObject state.Sink) {
+ w.beforeSave()
+ stateSinkObject.Save(0, &w.next)
+ stateSinkObject.Save(1, &w.prev)
}
-func (x *waiterEntry) afterLoad() {}
+func (w *waiterEntry) afterLoad() {}
-func (x *waiterEntry) StateLoad(m state.Source) {
- m.Load(0, &x.next)
- m.Load(1, &x.prev)
+func (w *waiterEntry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &w.next)
+ stateSourceObject.Load(1, &w.prev)
}
func init() {
diff --git a/pkg/sentry/kernel/shm/shm_state_autogen.go b/pkg/sentry/kernel/shm/shm_state_autogen.go
index fa80353b6..846cbc2d5 100644
--- a/pkg/sentry/kernel/shm/shm_state_autogen.go
+++ b/pkg/sentry/kernel/shm/shm_state_autogen.go
@@ -6,11 +6,11 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *Registry) StateTypeName() string {
+func (r *Registry) StateTypeName() string {
return "pkg/sentry/kernel/shm.Registry"
}
-func (x *Registry) StateFields() []string {
+func (r *Registry) StateFields() []string {
return []string{
"userNS",
"shms",
@@ -20,32 +20,32 @@ func (x *Registry) StateFields() []string {
}
}
-func (x *Registry) beforeSave() {}
+func (r *Registry) beforeSave() {}
-func (x *Registry) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.userNS)
- m.Save(1, &x.shms)
- m.Save(2, &x.keysToShms)
- m.Save(3, &x.totalPages)
- m.Save(4, &x.lastIDUsed)
+func (r *Registry) StateSave(stateSinkObject state.Sink) {
+ r.beforeSave()
+ stateSinkObject.Save(0, &r.userNS)
+ stateSinkObject.Save(1, &r.shms)
+ stateSinkObject.Save(2, &r.keysToShms)
+ stateSinkObject.Save(3, &r.totalPages)
+ stateSinkObject.Save(4, &r.lastIDUsed)
}
-func (x *Registry) afterLoad() {}
+func (r *Registry) afterLoad() {}
-func (x *Registry) StateLoad(m state.Source) {
- m.Load(0, &x.userNS)
- m.Load(1, &x.shms)
- m.Load(2, &x.keysToShms)
- m.Load(3, &x.totalPages)
- m.Load(4, &x.lastIDUsed)
+func (r *Registry) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &r.userNS)
+ stateSourceObject.Load(1, &r.shms)
+ stateSourceObject.Load(2, &r.keysToShms)
+ stateSourceObject.Load(3, &r.totalPages)
+ stateSourceObject.Load(4, &r.lastIDUsed)
}
-func (x *Shm) StateTypeName() string {
+func (s *Shm) StateTypeName() string {
return "pkg/sentry/kernel/shm.Shm"
}
-func (x *Shm) StateFields() []string {
+func (s *Shm) StateFields() []string {
return []string{
"ShmRefs",
"mfp",
@@ -67,72 +67,72 @@ func (x *Shm) StateFields() []string {
}
}
-func (x *Shm) beforeSave() {}
-
-func (x *Shm) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ShmRefs)
- m.Save(1, &x.mfp)
- m.Save(2, &x.registry)
- m.Save(3, &x.ID)
- m.Save(4, &x.creator)
- m.Save(5, &x.size)
- m.Save(6, &x.effectiveSize)
- m.Save(7, &x.fr)
- m.Save(8, &x.key)
- m.Save(9, &x.perms)
- m.Save(10, &x.owner)
- m.Save(11, &x.attachTime)
- m.Save(12, &x.detachTime)
- m.Save(13, &x.changeTime)
- m.Save(14, &x.creatorPID)
- m.Save(15, &x.lastAttachDetachPID)
- m.Save(16, &x.pendingDestruction)
+func (s *Shm) beforeSave() {}
+
+func (s *Shm) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.ShmRefs)
+ stateSinkObject.Save(1, &s.mfp)
+ stateSinkObject.Save(2, &s.registry)
+ stateSinkObject.Save(3, &s.ID)
+ stateSinkObject.Save(4, &s.creator)
+ stateSinkObject.Save(5, &s.size)
+ stateSinkObject.Save(6, &s.effectiveSize)
+ stateSinkObject.Save(7, &s.fr)
+ stateSinkObject.Save(8, &s.key)
+ stateSinkObject.Save(9, &s.perms)
+ stateSinkObject.Save(10, &s.owner)
+ stateSinkObject.Save(11, &s.attachTime)
+ stateSinkObject.Save(12, &s.detachTime)
+ stateSinkObject.Save(13, &s.changeTime)
+ stateSinkObject.Save(14, &s.creatorPID)
+ stateSinkObject.Save(15, &s.lastAttachDetachPID)
+ stateSinkObject.Save(16, &s.pendingDestruction)
}
-func (x *Shm) afterLoad() {}
-
-func (x *Shm) StateLoad(m state.Source) {
- m.Load(0, &x.ShmRefs)
- m.Load(1, &x.mfp)
- m.Load(2, &x.registry)
- m.Load(3, &x.ID)
- m.Load(4, &x.creator)
- m.Load(5, &x.size)
- m.Load(6, &x.effectiveSize)
- m.Load(7, &x.fr)
- m.Load(8, &x.key)
- m.Load(9, &x.perms)
- m.Load(10, &x.owner)
- m.Load(11, &x.attachTime)
- m.Load(12, &x.detachTime)
- m.Load(13, &x.changeTime)
- m.Load(14, &x.creatorPID)
- m.Load(15, &x.lastAttachDetachPID)
- m.Load(16, &x.pendingDestruction)
+func (s *Shm) afterLoad() {}
+
+func (s *Shm) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.ShmRefs)
+ stateSourceObject.Load(1, &s.mfp)
+ stateSourceObject.Load(2, &s.registry)
+ stateSourceObject.Load(3, &s.ID)
+ stateSourceObject.Load(4, &s.creator)
+ stateSourceObject.Load(5, &s.size)
+ stateSourceObject.Load(6, &s.effectiveSize)
+ stateSourceObject.Load(7, &s.fr)
+ stateSourceObject.Load(8, &s.key)
+ stateSourceObject.Load(9, &s.perms)
+ stateSourceObject.Load(10, &s.owner)
+ stateSourceObject.Load(11, &s.attachTime)
+ stateSourceObject.Load(12, &s.detachTime)
+ stateSourceObject.Load(13, &s.changeTime)
+ stateSourceObject.Load(14, &s.creatorPID)
+ stateSourceObject.Load(15, &s.lastAttachDetachPID)
+ stateSourceObject.Load(16, &s.pendingDestruction)
}
-func (x *ShmRefs) StateTypeName() string {
+func (s *ShmRefs) StateTypeName() string {
return "pkg/sentry/kernel/shm.ShmRefs"
}
-func (x *ShmRefs) StateFields() []string {
+func (s *ShmRefs) StateFields() []string {
return []string{
"refCount",
}
}
-func (x *ShmRefs) beforeSave() {}
+func (s *ShmRefs) beforeSave() {}
-func (x *ShmRefs) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.refCount)
+func (s *ShmRefs) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.refCount)
}
-func (x *ShmRefs) afterLoad() {}
+func (s *ShmRefs) afterLoad() {}
-func (x *ShmRefs) StateLoad(m state.Source) {
- m.Load(0, &x.refCount)
+func (s *ShmRefs) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.refCount)
}
func init() {
diff --git a/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go b/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
index 089a35b60..6c608aaa4 100644
--- a/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
+++ b/pkg/sentry/kernel/signalfd/signalfd_state_autogen.go
@@ -6,30 +6,30 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *SignalOperations) StateTypeName() string {
+func (s *SignalOperations) StateTypeName() string {
return "pkg/sentry/kernel/signalfd.SignalOperations"
}
-func (x *SignalOperations) StateFields() []string {
+func (s *SignalOperations) StateFields() []string {
return []string{
"target",
"mask",
}
}
-func (x *SignalOperations) beforeSave() {}
+func (s *SignalOperations) beforeSave() {}
-func (x *SignalOperations) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.target)
- m.Save(1, &x.mask)
+func (s *SignalOperations) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.target)
+ stateSinkObject.Save(1, &s.mask)
}
-func (x *SignalOperations) afterLoad() {}
+func (s *SignalOperations) afterLoad() {}
-func (x *SignalOperations) StateLoad(m state.Source) {
- m.Load(0, &x.target)
- m.Load(1, &x.mask)
+func (s *SignalOperations) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.target)
+ stateSourceObject.Load(1, &s.mask)
}
func init() {
diff --git a/pkg/sentry/kernel/time/time_state_autogen.go b/pkg/sentry/kernel/time/time_state_autogen.go
index 4fb37df9a..1a30539f0 100644
--- a/pkg/sentry/kernel/time/time_state_autogen.go
+++ b/pkg/sentry/kernel/time/time_state_autogen.go
@@ -6,34 +6,34 @@ import (
"gvisor.dev/gvisor/pkg/state"
)
-func (x *Time) StateTypeName() string {
+func (t *Time) StateTypeName() string {
return "pkg/sentry/kernel/time.Time"
}
-func (x *Time) StateFields() []string {
+func (t *Time) StateFields() []string {
return []string{
"ns",
}
}
-func (x *Time) beforeSave() {}
+func (t *Time) beforeSave() {}
-func (x *Time) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.ns)
+func (t *Time) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.ns)
}
-func (x *Time) afterLoad() {}
+func (t *Time) afterLoad() {}
-func (x *Time) StateLoad(m state.Source) {
- m.Load(0, &x.ns)
+func (t *Time) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.ns)
}
-func (x *Setting) StateTypeName() string {
+func (s *Setting) StateTypeName() string {
return "pkg/sentry/kernel/time.Setting"
}
-func (x *Setting) StateFields() []string {
+func (s *Setting) StateFields() []string {
return []string{
"Enabled",
"Next",
@@ -41,28 +41,28 @@ func (x *Setting) StateFields() []string {
}
}
-func (x *Setting) beforeSave() {}
+func (s *Setting) beforeSave() {}
-func (x *Setting) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.Enabled)
- m.Save(1, &x.Next)
- m.Save(2, &x.Period)
+func (s *Setting) StateSave(stateSinkObject state.Sink) {
+ s.beforeSave()
+ stateSinkObject.Save(0, &s.Enabled)
+ stateSinkObject.Save(1, &s.Next)
+ stateSinkObject.Save(2, &s.Period)
}
-func (x *Setting) afterLoad() {}
+func (s *Setting) afterLoad() {}
-func (x *Setting) StateLoad(m state.Source) {
- m.Load(0, &x.Enabled)
- m.Load(1, &x.Next)
- m.Load(2, &x.Period)
+func (s *Setting) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &s.Enabled)
+ stateSourceObject.Load(1, &s.Next)
+ stateSourceObject.Load(2, &s.Period)
}
-func (x *Timer) StateTypeName() string {
+func (t *Timer) StateTypeName() string {
return "pkg/sentry/kernel/time.Timer"
}
-func (x *Timer) StateFields() []string {
+func (t *Timer) StateFields() []string {
return []string{
"clock",
"listener",
@@ -71,23 +71,23 @@ func (x *Timer) StateFields() []string {
}
}
-func (x *Timer) beforeSave() {}
+func (t *Timer) beforeSave() {}
-func (x *Timer) StateSave(m state.Sink) {
- x.beforeSave()
- m.Save(0, &x.clock)
- m.Save(1, &x.listener)
- m.Save(2, &x.setting)
- m.Save(3, &x.paused)
+func (t *Timer) StateSave(stateSinkObject state.Sink) {
+ t.beforeSave()
+ stateSinkObject.Save(0, &t.clock)
+ stateSinkObject.Save(1, &t.listener)
+ stateSinkObject.Save(2, &t.setting)
+ stateSinkObject.Save(3, &t.paused)
}
-func (x *Timer) afterLoad() {}
+func (t *Timer) afterLoad() {}
-func (x *Timer) StateLoad(m state.Source) {
- m.Load(0, &x.clock)
- m.Load(1, &x.listener)
- m.Load(2, &x.setting)
- m.Load(3, &x.paused)
+func (t *Timer) StateLoad(stateSourceObject state.Source) {
+ stateSourceObject.Load(0, &t.clock)
+ stateSourceObject.Load(1, &t.listener)
+ stateSourceObject.Load(2, &t.setting)
+ stateSourceObject.Load(3, &t.paused)
}
func init() {
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-28 00:05:57 +0000